def test_unique_vertices_average_loc_unique_vert(self): """ get values based on triangle lists. """ #Create basic mesh points, vertices, boundary = rectangular(1, 3) #Create shallow water domain domain = Domain(points, vertices, boundary) domain.build_tagged_elements_dictionary({'bottom':[0,1], 'top':[4,5], 'not_bottom':[2,3,4,5]}) #Set friction domain.set_quantity('friction', add_x_y) av_bottom = 2.0/3.0 add = 60.0 calc_frict = av_bottom + add domain.set_tag_region(Add_value_to_region('bottom', 'friction', add, initial_quantity='friction', location='unique vertices', average=True )) #print domain.quantities['friction'].get_values() frict_points = domain.quantities['friction'].get_values() assert num.allclose(frict_points[0],\ [ calc_frict, calc_frict, calc_frict]) assert num.allclose(frict_points[1],\ [ calc_frict, calc_frict, calc_frict]) assert num.allclose(frict_points[2],\ [ calc_frict, 1.0 + 2.0/3.0, calc_frict]) assert num.allclose(frict_points[3],\ [ 2.0/3.0,calc_frict, 1.0 + 2.0/3.0])
def test_bigger(self): """test_bigger test larger mesh """ points, vertices, boundary = rectangular(4, 4, 1, 1) mesh = Mesh(points, vertices, boundary) #Test that points are arranged in a counter clock wise order mesh.check_integrity() root = MeshQuadtree(mesh) root.set_last_triangle() for x in [[0.6, 0.3], [0.1, 0.2], [0.7,0.7], [0.1,0.9], [0.4,0.6], [0.9,0.1], [10, 3]]: found, s0, s1, s2, k = root.search_fast(ensure_numeric(x)) if k >= 0: V = mesh.get_vertex_coordinates(k) # nodes for triangle k assert is_inside_polygon(x, V) assert found is True #print k, x else: assert found is False
def test_unique_verticesII(self): """ get values based on triangle lists. """ #Create basic mesh points, vertices, boundary = rectangular(1, 3) #Create shallow water domain domain = Domain(points, vertices, boundary) domain.build_tagged_elements_dictionary({'bottom':[0,1], 'top':[4,5], 'all':[0,1,2,3,4,5]}) #Set friction manning = 0.07 domain.set_quantity('friction', manning) domain.set_tag_region(Add_value_to_region('bottom', 'friction', 1.0,initial_quantity='friction', location = 'unique vertices')) #print domain.quantities['friction'].get_values() assert num.allclose(domain.quantities['friction'].get_values(),\ [[ 1.07, 1.07, 1.07], [ 1.07, 1.07, 1.07], [ 1.07, 0.07, 1.07], [ 0.07, 1.07, 0.07], [ 0.07, 0.07, 0.07], [ 0.07, 0.07, 0.07]])
def test_get_edge_midpoint_coordinates_triangle_id(self): """test_get_vertex_coordinates_triangle_id Test that vertices for one triangle can be returned. """ from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular #Create basic mesh nodes, triangles, _ = rectangular(1, 3) domain = General_mesh(nodes, triangles) assert num.allclose(domain.get_nodes(), nodes) M = domain.number_of_triangles for i in range(M): E = domain.get_edge_midpoint_coordinates(triangle_id=i) assert E.shape[0] == 3 k0 = triangles[i, 0] #Index of vertex 0 in triangle i k1 = triangles[i, 1] #Index of vertex 0 in triangle i k2 = triangles[i, 2] #Index of vertex 0 in triangle i assert num.allclose(E[0, :], 0.5 * (nodes[k1] + nodes[k2])) assert num.allclose(E[1, :], 0.5 * (nodes[k0] + nodes[k2])) assert num.allclose(E[2, :], 0.5 * (nodes[k1] + nodes[k0])) E0 = domain.get_edge_midpoint_coordinate(i, 0) E1 = domain.get_edge_midpoint_coordinate(i, 1) E2 = domain.get_edge_midpoint_coordinate(i, 2) assert num.allclose(E0, 0.5 * (nodes[k1] + nodes[k2])) assert num.allclose(E1, 0.5 * (nodes[k0] + nodes[k2])) assert num.allclose(E2, 0.5 * (nodes[k1] + nodes[k0]))
def test_advection_example(self): #Test that system can evolve from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular points, vertices, boundary = rectangular(6, 6) #Create advection domain with direction (1,-1) domain = Advection_Domain(points, vertices, boundary, velocity=[1.0, -1.0]) # Initial condition is zero by default #Boundaries T = Transmissive_boundary(domain) D = Dirichlet_boundary(num.array([3.1415])) domain.set_boundary( {'left': D, 'right': T, 'bottom': T, 'top': T} ) domain.check_integrity() #Check that the boundary value gets propagated to all elements for t in domain.evolve(yieldstep = 0.05, finaltime = 10): if num.allclose(domain.quantities['stage'].centroid_values, 3.1415): break assert num.allclose(domain.quantities['stage'].centroid_values, 3.1415)
def test_large(self): """test_larger mesh and different quad trees """ points, vertices, boundary = rectangular(10, 12, 1, 1) mesh = Mesh(points, vertices, boundary) #Test that points are arranged in a counter clock wise order mesh.check_integrity() root = MeshQuadtree(mesh) root.set_last_triangle() #print m, root.show() for x in [[0.6, 0.3], [0.1, 0.2], [0.7,0.7], [0.1,0.9], [0.4,0.6], [0.9,0.1], [10, 3]]: found, s0, s1, s2, k = root.search_fast(x) if k >= 0: V = mesh.get_vertex_coordinates(k) # nodes for triangle k assert is_inside_triangle(x, V, closed=True) assert is_inside_polygon(x, V) assert found is True else: assert found is False if k == 0: return
def test_unique_verticesII(self): """ get values based on triangle lists. """ #Create basic mesh points, vertices, boundary = rectangular(1, 3) #Create shallow water domain domain = Domain(points, vertices, boundary) domain.build_tagged_elements_dictionary({ 'bottom': [0, 1], 'top': [4, 5], 'all': [0, 1, 2, 3, 4, 5] }) #Set friction manning = 0.07 domain.set_quantity('friction', manning) domain.set_tag_region( Add_value_to_region('bottom', 'friction', 1.0, initial_quantity='friction', location='unique vertices')) #print domain.quantities['friction'].get_values() assert num.allclose(domain.quantities['friction'].get_values(),\ [[ 1.07, 1.07, 1.07], [ 1.07, 1.07, 1.07], [ 1.07, 0.07, 1.07], [ 0.07, 1.07, 0.07], [ 0.07, 0.07, 0.07], [ 0.07, 0.07, 0.07]])
def test_vertex_value_indices(self): """Check that structures are correct. """ from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular a = [0.0, 0.0] b = [0.0, 2.0] c = [2.0, 0.0] d = [0.0, 4.0] e = [2.0, 2.0] f = [4.0, 0.0] nodes = num.array([a, b, c, d, e, f]) #bac, bce, ecf, dbe, daf, dae triangles = num.array([[1, 0, 2], [1, 2, 4], [4, 2, 5], [3, 1, 4]]) domain1 = General_mesh(nodes, triangles) #Create larger mesh nodes, triangles, _ = rectangular(3, 6) domain2 = General_mesh(nodes, triangles) # Test both meshes for domain in [domain1, domain2]: assert sum(domain.number_of_triangles_per_node) ==\ len(domain.vertex_value_indices) # Check number of triangles per node count = [0] * domain.number_of_nodes for triangle in domain.triangles: for i in triangle: count[i] += 1 #print count # assert num.allclose(count, domain.number_of_triangles_per_node) # Check indices current_node = 0 k = 0 # Track triangles touching on node for index in domain.vertex_value_indices: k += 1 triangle = old_div(index, 3) vertex = index % 3 assert domain.triangles[triangle, vertex] == current_node if domain.number_of_triangles_per_node[current_node] == k: # Move on to next node k = 0 current_node += 1
def test_vertex_value_indices(self): """Check that structures are correct. """ from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular a = [0.0, 0.0] b = [0.0, 2.0] c = [2.0, 0.0] d = [0.0, 4.0] e = [2.0, 2.0] f = [4.0, 0.0] nodes = num.array([a, b, c, d, e, f]) #bac, bce, ecf, dbe, daf, dae triangles = num.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]]) domain1 = General_mesh(nodes, triangles) #Create larger mesh nodes, triangles, _ = rectangular(3, 6) domain2 = General_mesh(nodes, triangles) # Test both meshes for domain in [domain1, domain2]: assert sum(domain.number_of_triangles_per_node) ==\ len(domain.vertex_value_indices) # Check number of triangles per node count = [0]*domain.number_of_nodes for triangle in domain.triangles: for i in triangle: count[i] += 1 #print count # assert num.allclose(count, domain.number_of_triangles_per_node) # Check indices current_node = 0 k = 0 # Track triangles touching on node for index in domain.vertex_value_indices: k += 1 triangle = index / 3 vertex = index % 3 assert domain.triangles[triangle, vertex] == current_node if domain.number_of_triangles_per_node[current_node] == k: # Move on to next node k = 0 current_node += 1
def test_region_indices(self): """create region based on triangle lists.""" #Create basic mesh points, vertices, boundary = rectangular(1, 3) #Create shallow water domain domain = Domain(points, vertices, boundary) region = Region(domain, indices=[0, 2, 3]) expected_indices = [0, 2, 3] assert num.allclose(region.indices, expected_indices)
def test_get_unique_vertex_values(self): """ get unique_vertex based on triangle lists. """ #Create basic mesh points, vertices, boundary = rectangular(1, 3) domain = General_mesh(points, vertices) assert domain.get_unique_vertices() == [0, 1, 2, 3, 4, 5, 6, 7] unique_vertices = domain.get_unique_vertices([0, 1, 4]) assert unique_vertices == [0, 1, 2, 4, 5, 6, 7] unique_vertices = domain.get_unique_vertices([0, 4]) assert unique_vertices == [0, 2, 4, 5, 6, 7]
def test_region_polygon_expanded(self): """create region based on triangle lists.""" #Create basic mesh points, vertices, boundary = rectangular(1, 3) #Create shallow water domain domain = Domain(points, vertices, boundary) region = Region(domain, polygon=[[0.0, 0.0], [0.5, 0.0], [0.5, 0.5]], expand_polygon=True) expected_indices = [0, 1, 2, 3] assert num.allclose(region.indices, expected_indices)
def test_region_polygon(self): """create region based on triangle lists.""" #Create basic mesh points, vertices, boundary = rectangular(1, 3) #Create shallow water domain domain = Domain(points, vertices, boundary) poly = [[0.0, 0.0], [0.5, 0.0], [0.5, 0.5]] #print poly region = Region(domain, polygon=poly) expected_indices = [1] assert num.allclose(region.indices, expected_indices)
def test_small(self): """test_small: Two triangles """ points, vertices, boundary = rectangular(1, 1, 1, 1) mesh = Mesh(points, vertices, boundary) #Test that points are arranged in a counter clock wise order mesh.check_integrity() root = MeshQuadtree(mesh) root.set_last_triangle() x = [0.2, 0.7] found, s0, s1, s2, k = root.search_fast(x) assert k == 1 # Triangle one assert found is True
def test_get_unique_vertex_values(self): """ get unique_vertex based on triangle lists. """ #Create basic mesh points, vertices, boundary = rectangular(1, 3) domain = General_mesh(points, vertices) assert domain.get_unique_vertices() == [0,1,2,3,4,5,6,7] unique_vertices = domain.get_unique_vertices([0,1,4]) unique_vertices.sort() assert unique_vertices == [0,1,2,4,5,6,7] unique_vertices = domain.get_unique_vertices([0,4]) unique_vertices.sort() assert unique_vertices == [0,2,4,5,6,7]
def test_get_vertex_coordinates(self): from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular #Create basic mesh nodes, triangles, _ = rectangular(1, 3) domain = General_mesh(nodes, triangles) assert num.allclose(domain.get_nodes(), nodes) M = domain.number_of_triangles V = domain.get_vertex_coordinates() assert V.shape[0] == 3 * M for i in range(M): for j in range(3): k = triangles[i, j] #Index of vertex j in triangle i assert num.allclose(V[3 * i + j, :], nodes[k])
def test_off_and_boundary(self): """test_off: Test a point off the mesh """ points, vertices, boundary = rectangular(1, 1, 1, 1) mesh = Mesh(points, vertices, boundary) #Test that points are arranged in a counter clock wise order mesh.check_integrity() root = MeshQuadtree(mesh) root.set_last_triangle() found, s0, s1, s2, k = root.search_fast([-0.2, 10.7]) assert found is False found, s0, s1, s2, k = root.search_fast([0, 0]) assert found is True
def test_get_vertex_values(self): """Get connectivity based on triangle lists. """ from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular #Create basic mesh nodes, triangles, _ = rectangular(1, 3) domain = General_mesh(nodes, triangles) msg = ("domain.get_triangles()=\n%s\nshould be the same as " "'triangles'=\n%s" % (str(domain.get_triangles()), str(triangles))) assert num.allclose(domain.get_triangles(), triangles), msg msg = ("domain.get_triangles([0,4])=\n%s\nshould be the same as " "'[triangles[0], triangles[4]]' which is\n%s" % (str(domain.get_triangles( [0, 4])), str([triangles[0], triangles[4]]))) assert num.allclose(domain.get_triangles([0, 4]), [triangles[0], triangles[4]]), msg
def test_get_vertex_values(self): """Get connectivity based on triangle lists. """ from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular #Create basic mesh nodes, triangles, _ = rectangular(1, 3) domain = General_mesh(nodes, triangles) msg = ("domain.get_triangles()=\n%s\nshould be the same as " "'triangles'=\n%s" % (str(domain.get_triangles()), str(triangles))) assert num.allclose(domain.get_triangles(), triangles), msg msg = ("domain.get_triangles([0,4])=\n%s\nshould be the same as " "'[triangles[0], triangles[4]]' which is\n%s" % (str(domain.get_triangles([0,4])), str([triangles[0], triangles[4]]))) assert num.allclose(domain.get_triangles([0,4]), [triangles[0], triangles[4]]), msg
def test_underlying_function(self): """test_larger mesh and different quad trees """ return points, vertices, boundary = rectangular(2, 2, 1, 1) mesh = Mesh(points, vertices, boundary) root = MeshQuadtree(mesh) root.set_last_triangle() # One point x = ensure_numeric([0.5, 0.5]) found, sigma0, sigma1, sigma2, k = \ root._search_triangles_of_vertices(root.search(x), x) if k >= 0: V = mesh.get_vertex_coordinates(k) # nodes for triangle k assert is_inside_polygon(x, V) assert found is True else: assert found is False # More points for x in [[0.6, 0.3], [0.1, 0.2], [0.7,0.7], [0.1,0.9], [0.4,0.6], [0.9,0.1], [10, 3]]: triangles = root.search(x) #print x, candidate_vertices found, sigma0, sigma1, sigma2, k = \ root._search_triangles_of_vertices(triangles, ensure_numeric(x)) if k >= 0: V = mesh.get_vertex_coordinates(k) # nodes for triangle k assert is_inside_polygon(x, V) assert found is True else: assert found is False
def test_get_vertex_coordinates(self): from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular #Create basic mesh nodes, triangles, _ = rectangular(1, 3) domain = General_mesh(nodes, triangles) assert num.allclose(domain.get_nodes(), nodes) M = domain.number_of_triangles V = domain.get_vertex_coordinates() assert V.shape[0] == 3*M for i in range(M): for j in range(3): k = triangles[i,j] #Index of vertex j in triangle i assert num.allclose(V[3*i+j,:], nodes[k])
def test_unique_vertices_average_loc_unique_vert_1_5(self): """ get values based on triangle lists. """ #Create basic mesh points, vertices, boundary = rectangular(1, 3) #Create shallow water domain domain = Domain(points, vertices, boundary) domain.set_flow_algorithm('1_5') domain.build_tagged_elements_dictionary({ 'bottom': [0, 1], 'top': [4, 5], 'not_bottom': [2, 3, 4, 5] }) #Set friction domain.set_quantity('friction', add_x_y) av_bottom = 2.0 / 3.0 add = 60.0 calc_frict = av_bottom + add domain.set_tag_region( Add_value_to_region('bottom', 'friction', add, initial_quantity='friction', location='unique vertices', average=True)) #print domain.quantities['friction'].get_values() frict_points = domain.quantities['friction'].get_values() assert num.allclose(frict_points[0],\ [ calc_frict, calc_frict, calc_frict]) assert num.allclose(frict_points[1],\ [ calc_frict, calc_frict, calc_frict]) assert num.allclose(frict_points[2],\ [ calc_frict, 1.0 + 2.0/3.0, calc_frict]) assert num.allclose(frict_points[3],\ [ 2.0/3.0,calc_frict, 1.0 + 2.0/3.0])
def test_get_vertex_coordinates_triangle_id(self): """test_get_vertex_coordinates_triangle_id Test that vertices for one triangle can be returned. """ from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular #Create basic mesh nodes, triangles, _ = rectangular(1, 3) domain = General_mesh(nodes, triangles) assert num.allclose(domain.get_nodes(), nodes) M = domain.number_of_triangles for i in range(M): V = domain.get_vertex_coordinates(triangle_id=i) assert V.shape[0] == 3 for j in range(3): k = triangles[i, j] #Index of vertex j in triangle i assert num.allclose(V[j, :], nodes[k])
def test_unique_vertices_average_loc_unique_vert_de0(self): """ get values based on triangle lists. """ #Create basic mesh points, vertices, boundary = rectangular(1, 3) #Create shallow water domain domain = Domain(points, vertices, boundary) domain.build_tagged_elements_dictionary({ 'bottom': [0, 1], 'top': [4, 5], 'not_bottom': [2, 3, 4, 5] }) #Set friction domain.set_quantity('friction', add_x_y) av_bottom = 2.0 / 3.0 add = 60.0 calc_frict = av_bottom + add domain.set_tag_region( Add_value_to_region('bottom', 'friction', add, initial_quantity='friction', location='unique vertices', average=True)) #print domain.quantities['friction'].get_values() frict_points = domain.quantities['friction'].get_values() expected0 = [60.77777778, 60.77777778, 60.77777778] expected1 = [60.77777778, 60.77777778, 60.77777778] expected2 = [60.77777778, 1.66666667, 60.77777778] expected3 = [0.66666667, 60.77777778, 1.66666667] assert num.allclose(frict_points[0], expected0) assert num.allclose(frict_points[1], expected1) assert num.allclose(frict_points[2], expected2) assert num.allclose(frict_points[3], expected3)
def test_get_edge_midpoint_coordinates(self): from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular #Create basic mesh nodes, triangles, _ = rectangular(1, 3) domain = General_mesh(nodes, triangles) assert num.allclose(domain.get_nodes(), nodes) M = domain.number_of_triangles E = domain.get_edge_midpoint_coordinates() assert E.shape[0] == 3 * M for i in range(M): k0 = triangles[i, 0] #Index of vertex 0 in triangle i k1 = triangles[i, 1] #Index of vertex 1 in triangle i k2 = triangles[i, 2] #Index of vertex 2 in triangle i assert num.allclose(E[3 * i + 0, :], 0.5 * (nodes[k1] + nodes[k2])) assert num.allclose(E[3 * i + 1, :], 0.5 * (nodes[k0] + nodes[k2])) assert num.allclose(E[3 * i + 2, :], 0.5 * (nodes[k1] + nodes[k0]))
def test_get_vertex_coordinates_triangle_id(self): """test_get_vertex_coordinates_triangle_id Test that vertices for one triangle can be returned. """ from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular #Create basic mesh nodes, triangles, _ = rectangular(1, 3) domain = General_mesh(nodes, triangles) assert num.allclose(domain.get_nodes(), nodes) M = domain.number_of_triangles for i in range(M): V = domain.get_vertex_coordinates(triangle_id=i) assert V.shape[0] == 3 for j in range(3): k = triangles[i,j] #Index of vertex j in triangle i assert num.allclose(V[j,:], nodes[k])
def test_unique_vertices_average_loc_vert(self): """Get values based on triangle lists.""" #Create basic mesh points, vertices, boundary = rectangular(1, 3) #Create shallow water domain domain = Domain(points, vertices, boundary) domain.build_tagged_elements_dictionary({ 'bottom': [0, 1], 'top': [4, 5], 'not_bottom': [2, 3, 4, 5] }) #Set friction domain.set_quantity('friction', add_x_y) av_bottom = 2.0 / 3.0 add = 60.0 calc_frict = av_bottom + add domain.set_tag_region( Add_value_to_region('bottom', 'friction', add, initial_quantity='friction', location='vertices', average=True)) frict_points = domain.quantities['friction'].get_values() expected = [calc_frict, calc_frict, calc_frict] msg = ('frict_points[0]=%s\nexpected=%s' % (str(frict_points[0]), str(expected))) assert num.allclose(frict_points[0], expected), msg msg = ('frict_points[1]=%s\nexpected=%s' % (str(frict_points[1]), str(expected))) assert num.allclose(frict_points[1], expected), msg
def test_get_edge_midpoint_coordinates_triangle_id(self): """test_get_vertex_coordinates_triangle_id Test that vertices for one triangle can be returned. """ from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular #Create basic mesh nodes, triangles, _ = rectangular(1, 3) domain = General_mesh(nodes, triangles) assert num.allclose(domain.get_nodes(), nodes) M = domain.number_of_triangles for i in range(M): E = domain.get_edge_midpoint_coordinates(triangle_id=i) assert E.shape[0] == 3 k0 = triangles[i,0] #Index of vertex 0 in triangle i k1 = triangles[i,1] #Index of vertex 0 in triangle i k2 = triangles[i,2] #Index of vertex 0 in triangle i assert num.allclose(E[0,:], 0.5*(nodes[k1]+nodes[k2])) assert num.allclose(E[1,:], 0.5*(nodes[k0]+nodes[k2])) assert num.allclose(E[2,:], 0.5*(nodes[k1]+nodes[k0])) E0 = domain.get_edge_midpoint_coordinate(i, 0 ) E1 = domain.get_edge_midpoint_coordinate(i, 1 ) E2 = domain.get_edge_midpoint_coordinate(i, 2 ) assert num.allclose(E0, 0.5*(nodes[k1]+nodes[k2])) assert num.allclose(E1, 0.5*(nodes[k0]+nodes[k2])) assert num.allclose(E2, 0.5*(nodes[k1]+nodes[k0]))
def test_get_edge_midpoint_coordinates(self): from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular #Create basic mesh nodes, triangles, _ = rectangular(1, 3) domain = General_mesh(nodes, triangles) assert num.allclose(domain.get_nodes(), nodes) M = domain.number_of_triangles E = domain.get_edge_midpoint_coordinates() assert E.shape[0] == 3*M for i in range(M): k0 = triangles[i,0] #Index of vertex 0 in triangle i k1 = triangles[i,1] #Index of vertex 1 in triangle i k2 = triangles[i,2] #Index of vertex 2 in triangle i assert num.allclose(E[3*i+0,:], 0.5*(nodes[k1]+nodes[k2]) ) assert num.allclose(E[3*i+1,:], 0.5*(nodes[k0]+nodes[k2]) ) assert num.allclose(E[3*i+2,:], 0.5*(nodes[k1]+nodes[k0]) )
def test_merge_swwfiles(self): from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular, \ rectangular_cross from anuga.shallow_water.shallow_water_domain import Domain from anuga.file.sww import SWW_file from anuga.abstract_2d_finite_volumes.generic_boundary_conditions import \ Dirichlet_boundary Bd = Dirichlet_boundary([0.5, 0., 0.]) # Create shallow water domain domain = Domain(*rectangular_cross(2, 2)) domain.set_name('test1') domain.set_quantity('elevation', 2) domain.set_quantity('stage', 5) domain.set_boundary({'left': Bd, 'right': Bd, 'top': Bd, 'bottom': Bd}) for t in domain.evolve(yieldstep=0.5, finaltime=1): pass domain = Domain(*rectangular(3, 3)) domain.set_name('test2') domain.set_quantity('elevation', 3) domain.set_quantity('stage', 50) domain.set_boundary({'left': Bd, 'right': Bd, 'top': Bd, 'bottom': Bd}) for t in domain.evolve(yieldstep=0.5, finaltime=1): pass outfile = 'test_out.sww' _sww_merge(['test1.sww', 'test2.sww'], outfile) self.assertTrue(os.access(outfile, os.F_OK)) # remove temp files if not sys.platform == 'win32': os.remove('test1.sww') os.remove('test2.sww') os.remove(outfile)
def test_get_mesh_and_quantities_from_de0_sww_file(self): """test_get_mesh_and_quantities_from_sww_file(self): """ # Generate a test sww file with non trivial georeference import time, os # Setup #from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular # Create basic mesh (100m x 5m) width = 5 length = 50 t_end = 10 points, vertices, boundary = rectangular(length, width, 50, 5) # Create shallow water domain domain = Domain(points, vertices, boundary, geo_reference = Geo_reference(56,308500,6189000)) domain.set_name('test_get_mesh_and_quantities_from_sww_file') swwfile = domain.get_name() + '.sww' domain.set_datadir('.') domain.set_flow_algorithm('DE0') Br = Reflective_boundary(domain) # Side walls Bd = Dirichlet_boundary([1, 0, 0]) # inflow domain.set_boundary( {'left': Bd, 'right': Bd, 'top': Br, 'bottom': Br}) for t in domain.evolve(yieldstep=1, finaltime = t_end): pass # Read it # Get mesh and quantities from sww file X = get_mesh_and_quantities_from_file(swwfile, quantities=['elevation', 'stage', 'xmomentum', 'ymomentum'], verbose=False) mesh, quantities, time = X # Check that mesh has been recovered assert num.alltrue(mesh.triangles == domain.get_triangles()) assert num.allclose(mesh.nodes, domain.get_nodes()) # Check that time has been recovered assert num.allclose(time, range(t_end+1)) # Check that quantities have been recovered # (sww files use single precision) z=domain.get_quantity('elevation').get_values(location='unique vertices') assert num.allclose(quantities['elevation'], z) for q in ['stage', 'xmomentum', 'ymomentum']: # Get quantity at last timestep q_ref=domain.get_quantity(q).get_values(location='unique vertices') #print q,quantities[q] q_sww=quantities[q][-1,:] msg = 'Quantity %s failed to be recovered' %q assert num.allclose(q_ref, q_sww, atol=1.0e-2), msg
def test_get_energy_through_cross_section(self): """test_get_energy_through_cross_section(self): Test that the specific and total energy through a cross section can be correctly obtained from an sww file. This test creates a flat bed with a known flow through it and tests that the function correctly returns the expected energies. The specifics are u = 2 m/s h = 1 m w = 3 m (width of channel) q = u*h*w = 6 m^3/s Es = h + 0.5*v*v/g # Specific energy head [m] Et = w + 0.5*v*v/g # Total energy head [m] This test uses georeferencing """ import time, os from anuga.file.netcdf import NetCDFFile # Setup #from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular # Create basic mesh (20m x 3m) width = 3 length = 20 t_end = 1 points, vertices, boundary = rectangular(length, width, length, width) # Create shallow water domain domain = Domain(points, vertices, boundary, geo_reference = Geo_reference(56,308500,6189000)) domain.default_order = 2 domain.set_minimum_storable_height(0.01) domain.set_name('flowtest') swwfile = domain.get_name() + '.sww' domain.set_datadir('.') domain.format = 'sww' domain.smooth = True e = -1.0 w = 1.0 h = w-e u = 2.0 uh = u*h Br = Reflective_boundary(domain) # Side walls Bd = Dirichlet_boundary([w, uh, 0]) # 2 m/s across the 3 m inlet: domain.set_quantity('elevation', e) domain.set_quantity('stage', w) domain.set_quantity('xmomentum', uh) domain.set_boundary( {'left': Bd, 'right': Bd, 'top': Br, 'bottom': Br}) for t in domain.evolve(yieldstep=1, finaltime = t_end): pass # Check that momentum is as it should be in the interior I = [[0, width/2.], [length/2., width/2.], [length, width/2.]] I = domain.geo_reference.get_absolute(I) f = file_function(swwfile, quantities=['stage', 'xmomentum', 'ymomentum'], interpolation_points=I, verbose=False) for t in range(t_end+1): for i in range(3): #print i, t, f(t, i) assert num.allclose(f(t, i), [w, uh, 0], atol=1.0e-6) # Check energies through the middle for i in range(5): x = length/2. + i*0.23674563 # Arbitrary cross_section = [[x, 0], [x, width]] cross_section = domain.geo_reference.get_absolute(cross_section) time, Es = get_energy_through_cross_section(swwfile, cross_section, kind='specific', verbose=False) assert num.allclose(Es, h + 0.5*u*u/g) time, Et = get_energy_through_cross_section(swwfile, cross_section, kind='total', verbose=False) assert num.allclose(Et, w + 0.5*u*u/g)
def test_sww2domain1(self): ################################################ #Create a test domain, and evolve and save it. ################################################ #from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular #Create basic mesh yiel=0.01 points, vertices, boundary = rectangular(10,10) #print "=============== boundary rect =======================" #print boundary #Create shallow water domain domain = Domain(points, vertices, boundary) domain.geo_reference = Geo_reference(56,11,11) domain.smooth = False domain.store = True domain.set_name('bedslope') domain.default_order=2 #Bed-slope and friction domain.set_quantity('elevation', lambda x,y: -x/3) domain.set_quantity('friction', 0.1) # Boundary conditions from math import sin, pi Br = Reflective_boundary(domain) Bt = Transmissive_boundary(domain) Bd = Dirichlet_boundary([0.2,0.,0.]) Bw = Time_boundary(domain=domain,function=lambda t: [(0.1*sin(t*2*pi)), 0.0, 0.0]) #domain.set_boundary({'left': Bd, 'right': Br, 'top': Br, 'bottom': Br}) domain.set_boundary({'left': Bd, 'right': Bd, 'top': Bd, 'bottom': Bd}) domain.quantities_to_be_stored['xmomentum'] = 2 domain.quantities_to_be_stored['ymomentum'] = 2 #Initial condition h = 0.05 elevation = domain.quantities['elevation'].vertex_values domain.set_quantity('stage', elevation + h) domain.check_integrity() #Evolution #domain.tight_slope_limiters = 1 for t in domain.evolve(yieldstep = yiel, finaltime = 0.05): #domain.write_time() pass #print boundary filename = domain.datadir + os.sep + domain.get_name() + '.sww' domain2 = load_sww_as_domain(filename, None, fail_if_NaN=False, verbose=self.verbose) # Unfortunately we loss the boundaries top, bottom, left and right, # they are now all lumped into "exterior" #print "=============== boundary domain2 =======================" #print domain2.boundary #print domain2.get_boundary_tags() #points, vertices, boundary = rectangular(15,15) #domain2.boundary = boundary ################### ##NOW TEST IT!!! ################### os.remove(filename) bits = ['vertex_coordinates'] for quantity in ['stage']: bits.append('get_quantity("%s").get_integral()' % quantity) bits.append('get_quantity("%s").get_values()' % quantity) for bit in bits: #print 'testing that domain.'+bit+' has been restored' #print bit #print 'done' #print eval('domain.'+bit) #print eval('domain2.'+bit) assert num.allclose(eval('domain.'+bit),eval('domain2.'+bit)) ###################################### #Now evolve them both, just to be sure ######################################x from time import sleep final = .1 domain.set_quantity('friction', 0.1) domain.store = False domain.set_boundary({'exterior': Bd, 'left' : Bd, 'right': Bd, 'top': Bd, 'bottom': Bd}) for t in domain.evolve(yieldstep = yiel, finaltime = final): #domain.write_time() pass #BUT since domain2 gets time hacked back to 0: # Load_sww_as_domain sets starttime for domain2 to the last time in the # sww file (which is the value of time+domain.starttime final2 = final - domain2.get_starttime() domain2.smooth = False domain2.store = False domain2.default_order=2 domain2.set_quantity('friction', 0.1) #Bed-slope and friction # Boundary conditions Bd2=Dirichlet_boundary([0.2,0.,0.]) domain2.boundary = domain.boundary #print 'domain2.boundary' #print domain2.boundary domain2.set_boundary({'exterior': Bd, 'left' : Bd, 'right': Bd, 'top': Bd, 'bottom': Bd}) #domain2.set_boundary({'exterior': Bd}) domain2.check_integrity() for t in domain2.evolve(yieldstep = yiel, finaltime = final2): #domain2.write_time() pass ################### ##NOW TEST IT!!! ################## bits = ['vertex_coordinates'] for quantity in ['elevation','stage', 'ymomentum','xmomentum']: bits.append('get_quantity("%s").get_integral()' %quantity) bits.append('get_quantity("%s").get_values()' %quantity) #print bits for bit in bits: #print bit #print eval('domain.'+bit) #print eval('domain2.'+bit) #print eval('domain.'+bit+'-domain2.'+bit) msg = 'Values in the two domains are different for ' + bit assert num.allclose(eval('domain.'+bit),eval('domain2.'+bit), rtol=5.e-2, atol=5.e-2), msg
def test_get_maximum_inundation_de0(self): """Test that sww information can be converted correctly to maximum runup elevation and location (without and with georeferencing) This test creates a slope and a runup which is maximal (~11m) at around 10s and levels out to the boundary condition (1m) at about 30s. """ import time, os from anuga.file.netcdf import NetCDFFile #Setup #from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular # Create basic mesh (100m x 100m) points, vertices, boundary = rectangular(20, 5, 100, 50) # Create shallow water domain domain = Domain(points, vertices, boundary) domain.default_order = 2 domain.set_minimum_storable_height(0.01) filename = 'runup_test_3' domain.set_name(filename) swwfile = domain.get_name() + '.sww' domain.set_datadir('.') domain.format = 'sww' domain.smooth = True # FIXME (Ole): Backwards compatibility # Look at sww file and see what happens when # domain.tight_slope_limiters = 1 domain.tight_slope_limiters = 0 domain.use_centroid_velocities = 0 # Backwards compatibility (7/5/8) Br = Reflective_boundary(domain) Bd = Dirichlet_boundary([1.0,0,0]) #---------- First run without geo referencing domain.set_quantity('elevation', lambda x,y: -0.2*x + 14) # Slope domain.set_quantity('stage', -6) domain.set_boundary( {'left': Br, 'right': Bd, 'top': Br, 'bottom': Br}) for t in domain.evolve(yieldstep=1, finaltime = 50): pass # Check maximal runup runup = get_maximum_inundation_elevation(swwfile) location = get_maximum_inundation_location(swwfile) #print 'Runup, location', runup, location assert num.allclose(runup, 4.66666666667) assert num.allclose(location[0], 46.666668) # Check final runup runup = get_maximum_inundation_elevation(swwfile, time_interval=[45,50]) location = get_maximum_inundation_location(swwfile, time_interval=[45,50]) #print 'Runup, location:',runup, location assert num.allclose(runup, 3.81481488546) assert num.allclose(location[0], 51.666668) # Check runup restricted to a polygon p = [[50,1], [99,1], [99,49], [50,49]] runup = get_maximum_inundation_elevation(swwfile, polygon=p) location = get_maximum_inundation_location(swwfile, polygon=p) #print runup, location assert num.allclose(runup, 3.81481488546) assert num.allclose(location[0], 51.6666666) # Check that mimimum_storable_height works fid = NetCDFFile(swwfile, netcdf_mode_r) # Open existing file stage = fid.variables['stage_c'][:] z = fid.variables['elevation_c'][:] xmomentum = fid.variables['xmomentum_c'][:] ymomentum = fid.variables['ymomentum_c'][:] for i in range(stage.shape[0]): h = stage[i]-z # depth vector at time step i # Check every node location for j in range(stage.shape[1]): # Depth being either exactly zero implies # momentum being zero. # Or else depth must be greater than or equal to # the minimal storable height if h[j] == 0.0: assert xmomentum[i,j] == 0.0 assert ymomentum[i,j] == 0.0 else: assert h[j] >= 0.0 fid.close() # Cleanup os.remove(swwfile) #------------- Now the same with georeferencing domain.time=0.0 E = 308500 N = 6189000 #E = N = 0 domain.geo_reference = Geo_reference(56, E, N) domain.set_quantity('elevation', lambda x,y: -0.2*x + 14) # Slope domain.set_quantity('stage', -6) domain.set_boundary( {'left': Br, 'right': Bd, 'top': Br, 'bottom': Br}) for t in domain.evolve(yieldstep=1, finaltime = 50): pass # Check maximal runup runup = get_maximum_inundation_elevation(swwfile) location = get_maximum_inundation_location(swwfile) #print runup, location assert num.allclose(runup,4.66666666667) assert num.allclose(location[0], 308546.66) # Check final runup runup = get_maximum_inundation_elevation(swwfile, time_interval=[45,50]) location = get_maximum_inundation_location(swwfile, time_interval=[45,50]) #print runup, location #1.66666666667 [308561.66, 6189006.5] assert num.allclose(runup, 3.81481488546) assert num.allclose(location[0], 308551.66) # Check runup restricted to a polygon p = num.array([[50,1], [99,1], [99,49], [50,49]], num.int) + num.array([E, N], num.int) #array default# runup = get_maximum_inundation_elevation(swwfile, polygon=p) location = get_maximum_inundation_location(swwfile, polygon=p) #print runup, location assert num.allclose(runup, 3.81481488546) assert num.allclose(location[0], 308551.66) # Cleanup os.remove(swwfile)
def test_get_flow_through_cross_section_stored_uniquely(self): """test_get_flow_through_cross_section_stored_uniquely(self): Test that the total flow through a cross section can be correctly obtained from an sww file. This test creates a flat bed with a known flow through it and tests that the function correctly returns the expected flow. The specifics are u = 2 m/s h = 1 m w = 3 m (width of channel) q = u*h*w = 6 m^3/s """ import time, os from anuga.file.netcdf import NetCDFFile # Setup #from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular # Create basic mesh (20m x 3m) width = 3 length = 20 t_end = 3 points, vertices, boundary = rectangular(length, width, length, width) # Create shallow water domain domain = Domain(points, vertices, boundary) domain.default_order = 2 domain.set_minimum_storable_height(0.01) domain.set_name('flowtest_uniquely') swwfile = domain.get_name() + '.sww' domain.set_store_vertices_uniquely() domain.set_datadir('.') domain.format = 'sww' domain.smooth = True h = 1.0 u = 2.0 uh = u*h Br = Reflective_boundary(domain) # Side walls Bd = Dirichlet_boundary([h, uh, 0]) # 2 m/s across the 3 m inlet: domain.set_quantity('elevation', 0.0) domain.set_quantity('stage', h) domain.set_quantity('xmomentum', uh) domain.set_boundary( {'left': Bd, 'right': Bd, 'top': Br, 'bottom': Br}) for t in domain.evolve(yieldstep=1, finaltime = t_end): pass # Check that momentum is as it should be in the interior I = [[0, width/2.], [length/2., width/2.], [length, width/2.]] f = file_function(swwfile, quantities=['stage', 'xmomentum', 'ymomentum'], interpolation_points=I, verbose=False) for t in range(t_end+1): for i in range(3): assert num.allclose(f(t, i), [1, 2, 0], atol=1.0e-6) # Check flows through the middle for i in range(5): x = length/2. + i*0.23674563 # Arbitrary cross_section = [[x, 0], [x, width]] time, Q = get_flow_through_cross_section(swwfile, cross_section, verbose=False) assert num.allclose(Q, uh*width) # Try the same with partial lines x = length/2. for i in range(5): start_point = [length/2., i*width/5.] #print start_point cross_section = [start_point, [length/2., width]] time, Q = get_flow_through_cross_section(swwfile, cross_section, verbose=False) #print i, Q, (width-start_point[1]) assert num.allclose(Q, uh*(width-start_point[1])) # Verify no flow when line is parallel to flow cross_section = [[length/2.-10, width/2.], [length/2.+10, width/2.]] time, Q = get_flow_through_cross_section(swwfile, cross_section, verbose=False) #print i, Q assert num.allclose(Q, 0, atol=1.0e-5) # Try with lines on an angle (all flow still runs through here) cross_section = [[length/2., 0], [length/2.+width, width]] time, Q = get_flow_through_cross_section(swwfile, cross_section, verbose=False) assert num.allclose(Q, uh*width)
############################################## # Change min_depth and see how larger values aggravate the problem yieldstep = 0.1 finaltime = 10.0 #min_depth = 1.0e-4 min_depth = 1.0e-2 from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular from anuga.shallow_water import Domain, Reflective_boundary #Create shallow water domain points, vertices, boundary = rectangular(50, 50, len1=500, len2=500) domain = Domain(points, vertices, boundary) domain.smooth = False domain.visualise = True domain.default_order = 1 domain.minimum_allowed_height = min_depth print 'Extent', domain.get_extent() # Set initial condition class Set_IC: """Set an initial condition with a constant value, for x0<x<x1 """ def __init__(self, x0=0.25, x1=0.5, h=1.0): self.x0 = x0 self.x1 = x1
def test_get_flow_through_cross_section_with_geo(self): """test_get_flow_through_cross_section(self): Test that the total flow through a cross section can be correctly obtained at run-time from the ANUGA domain. This test creates a flat bed with a known flow through it and tests that the function correctly returns the expected flow. The specifics are e = -1 m u = 2 m/s h = 2 m w = 3 m (width of channel) q = u*h*w = 12 m^3/s This run tries it with georeferencing and with elevation = -1 """ # Create basic mesh (20m x 3m) width = 3 length = 20 t_end = 1 points, vertices, boundary = rectangular(length, width, length, width) # Create shallow water domain domain = Domain(points, vertices, boundary, geo_reference=Geo_reference(56, 308500, 6189000)) domain.default_order = 2 domain.set_quantities_to_be_stored(None) e = -1.0 w = 1.0 h = w-e u = 2.0 uh = u*h Br = Reflective_boundary(domain) # Side walls Bd = Dirichlet_boundary([w, uh, 0]) # 2 m/s across the 3 m inlet: # Initial conditions domain.set_quantity('elevation', e) domain.set_quantity('stage', w) domain.set_quantity('xmomentum', uh) domain.set_boundary({'left': Bd, 'right': Bd, 'top': Br, 'bottom': Br}) # Interpolation points down the middle I = [[0, width/2.], [length/2., width/2.], [length, width/2.]] interpolation_points = domain.geo_reference.get_absolute(I) for t in domain.evolve(yieldstep=0.1, finaltime=0.5): # Shortcuts to quantites stage = domain.get_quantity('stage') xmomentum = domain.get_quantity('xmomentum') ymomentum = domain.get_quantity('ymomentum') # Check that quantities are they should be in the interior w_t = stage.get_values(interpolation_points) uh_t = xmomentum.get_values(interpolation_points) vh_t = ymomentum.get_values(interpolation_points) assert num.allclose(w_t, w) assert num.allclose(uh_t, uh) assert num.allclose(vh_t, 0.0, atol=1.0e-6) # Check flows through the middle for i in range(5): x = length/2. + i*0.23674563 # Arbitrary cross_section = [[x, 0], [x, width]] cross_section = domain.geo_reference.get_absolute(cross_section) Q = domain.get_flow_through_cross_section(cross_section, verbose=False) assert num.allclose(Q, uh*width) import cPickle cPickle.dump(domain, open('domain_pickle.pickle', 'w')) domain_restored = cPickle.load(open('domain_pickle.pickle')) for t in domain_restored.evolve(yieldstep=0.1, finaltime=1.0): # Shortcuts to quantites stage = domain_restored.get_quantity('stage') xmomentum = domain_restored.get_quantity('xmomentum') ymomentum = domain_restored.get_quantity('ymomentum') # Check that quantities are they should be in the interior w_t = stage.get_values(interpolation_points) uh_t = xmomentum.get_values(interpolation_points) vh_t = ymomentum.get_values(interpolation_points) assert num.allclose(w_t, w) assert num.allclose(uh_t, uh) assert num.allclose(vh_t, 0.0, atol=1.0e-6) # Check flows through the middle for i in range(5): x = length/2. + i*0.23674563 # Arbitrary cross_section = [[x, 0], [x, width]] cross_section = domain_restored.geo_reference.get_absolute(cross_section) Q = domain_restored.get_flow_through_cross_section(cross_section, verbose=False) assert num.allclose(Q, uh*width)
# # ######################################################### ############################################## # Change min_depth and see how larger values aggravate the problem yieldstep = 0.1 finaltime = 10.0 #min_depth = 1.0e-4 min_depth = 1.0e-2 from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular from anuga.shallow_water import Domain, Reflective_boundary #Create shallow water domain points, vertices, boundary = rectangular(50, 50, len1=500, len2=500) domain = Domain(points, vertices, boundary) domain.smooth = False domain.visualise = True domain.default_order = 1 domain.minimum_allowed_height = min_depth print 'Extent', domain.get_extent() # Set initial condition class Set_IC: """Set an initial condition with a constant value, for x0<x<x1 """ def __init__(self, x0=0.25, x1=0.5, h=1.0): self.x0 = x0 self.x1 = x1
def test_get_flow_through_cross_section_stored_uniquely(self): """test_get_flow_through_cross_section_stored_uniquely(self): Test that the total flow through a cross section can be correctly obtained from an sww file. This test creates a flat bed with a known flow through it and tests that the function correctly returns the expected flow. The specifics are u = 2 m/s h = 1 m w = 3 m (width of channel) q = u*h*w = 6 m^3/s """ import time, os from anuga.file.netcdf import NetCDFFile # Setup #from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular # Create basic mesh (20m x 3m) width = 3 length = 20 t_end = 3 points, vertices, boundary = rectangular(length, width, length, width) # Create shallow water domain domain = Domain(points, vertices, boundary) domain.default_order = 2 domain.set_minimum_storable_height(0.01) domain.set_name('flowtest_uniquely') swwfile = domain.get_name() + '.sww' domain.set_store_vertices_uniquely() domain.set_datadir('.') domain.format = 'sww' domain.smooth = True h = 1.0 u = 2.0 uh = u * h Br = Reflective_boundary(domain) # Side walls Bd = Dirichlet_boundary([h, uh, 0]) # 2 m/s across the 3 m inlet: domain.set_quantity('elevation', 0.0) domain.set_quantity('stage', h) domain.set_quantity('xmomentum', uh) domain.set_boundary({'left': Bd, 'right': Bd, 'top': Br, 'bottom': Br}) for t in domain.evolve(yieldstep=1, finaltime=t_end): pass # Check that momentum is as it should be in the interior I = [[0, width / 2.], [length / 2., width / 2.], [length, width / 2.]] f = file_function(swwfile, quantities=['stage', 'xmomentum', 'ymomentum'], interpolation_points=I, verbose=False) for t in range(t_end + 1): for i in range(3): assert num.allclose(f(t, i), [1, 2, 0], atol=1.0e-6) # Check flows through the middle for i in range(5): x = length / 2. + i * 0.23674563 # Arbitrary cross_section = [[x, 0], [x, width]] time, Q = get_flow_through_cross_section(swwfile, cross_section, verbose=False) assert num.allclose(Q, uh * width) # Try the same with partial lines x = length / 2. for i in range(5): start_point = [length / 2., i * width / 5.] #print start_point cross_section = [start_point, [length / 2., width]] time, Q = get_flow_through_cross_section(swwfile, cross_section, verbose=False) #print i, Q, (width-start_point[1]) assert num.allclose(Q, uh * (width - start_point[1])) # Verify no flow when line is parallel to flow cross_section = [[length / 2. - 10, width / 2.], [length / 2. + 10, width / 2.]] time, Q = get_flow_through_cross_section(swwfile, cross_section, verbose=False) #print i, Q assert num.allclose(Q, 0, atol=1.0e-5) # Try with lines on an angle (all flow still runs through here) cross_section = [[length / 2., 0], [length / 2. + width, width]] time, Q = get_flow_through_cross_section(swwfile, cross_section, verbose=False) assert num.allclose(Q, uh * width)
def test_region_tags(self): """get values based on triangle lists.""" #Create basic mesh points, vertices, boundary = rectangular(1, 3) #Create shallow water domain domain = Domain(points, vertices, boundary) domain.build_tagged_elements_dictionary({'bottom': [0,1], 'top': [4,5], 'all': [0,1,2,3,4,5]}) #Set friction manning = 0.07 domain.set_quantity('friction', manning) a = Set_tag_region('bottom', 'friction', 0.09) b = Set_tag_region('top', 'friction', 1.0) domain.set_tag_region([a, b]) expected = [[ 0.09, 0.09, 0.09], [ 0.09, 0.09, 0.09], [ 0.07, 0.07, 0.07], [ 0.07, 0.07, 0.07], [ 1.0, 1.0, 1.0], [ 1.0, 1.0, 1.0]] msg = ("\ndomain.quantities['friction']=%s\nexpected value=%s" % (str(domain.quantities['friction'].get_values()), str(expected))) assert num.allclose(domain.quantities['friction'].get_values(), expected), msg #c = Add_Value_To_region('all', 'friction', 10.0) domain.set_tag_region(Add_value_to_region('all', 'friction', 10.0)) #print domain.quantities['friction'].get_values() assert num.allclose(domain.quantities['friction'].get_values(), [[ 10.09, 10.09, 10.09], [ 10.09, 10.09, 10.09], [ 10.07, 10.07, 10.07], [ 10.07, 10.07, 10.07], [ 11.0, 11.0, 11.0], [ 11.0, 11.0, 11.0]]) # trying a function domain.set_tag_region(Set_tag_region('top', 'friction', add_x_y)) #print domain.quantities['friction'].get_values() assert num.allclose(domain.quantities['friction'].get_values(), [[ 10.09, 10.09, 10.09], [ 10.09, 10.09, 10.09], [ 10.07, 10.07, 10.07], [ 10.07, 10.07, 10.07], [ 5./3, 2.0, 2./3], [ 1.0, 2./3, 2.0]]) domain.set_quantity('elevation', 10.0) domain.set_quantity('stage', 10.0) domain.set_tag_region(Add_value_to_region('top', 'stage', 1.0,initial_quantity='elevation')) #print domain.quantities['stage'].get_values() assert num.allclose(domain.quantities['stage'].get_values(), [[ 10., 10., 10.], [ 10., 10., 10.], [ 10., 10., 10.], [ 10., 10., 10.], [ 11.0, 11.0, 11.0], [ 11.0, 11.0, 11.0]]) domain.set_quantity('elevation', 10.0) domain.set_quantity('stage', give_me_23) #this works as well, (is cleaner, but doesn't work for regions) #domain.set_quantity('stage', # domain.quantities['stage'].vertex_values+ \ # domain.quantities['elevation'].vertex_values) domain.set_tag_region(Add_quantities('top', 'elevation','stage')) #print domain.quantities['stage'].get_values() assert num.allclose(domain.quantities['elevation'].get_values(), [[ 10., 10., 10.], [ 10., 10., 10.], [ 10., 10., 10.], [ 10., 10., 10.], [ 33., 33.0, 33.], [ 33.0, 33., 33.]])
def test_areas(self): #Create basic mesh points, vertices, boundary = rectangular(1, 3) domain = General_mesh(points, vertices) assert domain.get_area() == 1.0
Transmissive_boundary, Time_boundary from anuga.shallow_water.shallow_water_domain import Weir_simple as Weir import anuga.utilities.log as log from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular ###################### # Domain # N = 12 log.critical('Creating domain') #Create basic mesh points, vertices, boundary = rectangular(N, N/2, len1=1.2,len2=0.6, origin=(-0.07, 0)) log.critical('Number of elements=%d' % len(vertices)) #Create shallow water domain domain = Domain(points, vertices, boundary) domain.smooth = False domain.default_order = 2 domain.set_name('show_balanced_limiters') domain.store = True domain.format = 'sww' #Native netcdf visualisation format #Set bed-slope and friction inflow_stage = 0.1 manning = 0.1 Z = Weir(inflow_stage)
def test_get_flow_through_cross_section_with_geo(self): """test_get_flow_through_cross_section(self): Test that the total flow through a cross section can be correctly obtained at run-time from the ANUGA domain. This test creates a flat bed with a known flow through it and tests that the function correctly returns the expected flow. The specifics are e = -1 m u = 2 m/s h = 2 m w = 3 m (width of channel) q = u*h*w = 12 m^3/s This run tries it with georeferencing and with elevation = -1 """ # Create basic mesh (20m x 3m) width = 3 length = 20 t_end = 1 points, vertices, boundary = rectangular(length, width, length, width) # Create shallow water domain domain = Domain(points, vertices, boundary, geo_reference=Geo_reference(56, 308500, 6189000)) domain.default_order = 2 domain.set_quantities_to_be_stored(None) e = -1.0 w = 1.0 h = w - e u = 2.0 uh = u * h Br = Reflective_boundary(domain) # Side walls Bd = Dirichlet_boundary([w, uh, 0]) # 2 m/s across the 3 m inlet: # Initial conditions domain.set_quantity('elevation', e) domain.set_quantity('stage', w) domain.set_quantity('xmomentum', uh) domain.set_boundary({'left': Bd, 'right': Bd, 'top': Br, 'bottom': Br}) # Interpolation points down the middle I = [[0, width / 2.], [length / 2., width / 2.], [length, width / 2.]] interpolation_points = domain.geo_reference.get_absolute(I) for t in domain.evolve(yieldstep=0.1, finaltime=0.5): # Shortcuts to quantites stage = domain.get_quantity('stage') xmomentum = domain.get_quantity('xmomentum') ymomentum = domain.get_quantity('ymomentum') # Check that quantities are they should be in the interior w_t = stage.get_values(interpolation_points) uh_t = xmomentum.get_values(interpolation_points) vh_t = ymomentum.get_values(interpolation_points) assert num.allclose(w_t, w) assert num.allclose(uh_t, uh) assert num.allclose(vh_t, 0.0, atol=1.0e-6) # Check flows through the middle for i in range(5): x = length / 2. + i * 0.23674563 # Arbitrary cross_section = [[x, 0], [x, width]] cross_section = domain.geo_reference.get_absolute( cross_section) Q = domain.get_flow_through_cross_section(cross_section, verbose=False) assert num.allclose(Q, uh * width) import cPickle cPickle.dump(domain, open('domain_pickle.pickle', 'w')) domain_restored = cPickle.load(open('domain_pickle.pickle')) for t in domain_restored.evolve(yieldstep=0.1, finaltime=1.0): # Shortcuts to quantites stage = domain_restored.get_quantity('stage') xmomentum = domain_restored.get_quantity('xmomentum') ymomentum = domain_restored.get_quantity('ymomentum') # Check that quantities are they should be in the interior w_t = stage.get_values(interpolation_points) uh_t = xmomentum.get_values(interpolation_points) vh_t = ymomentum.get_values(interpolation_points) assert num.allclose(w_t, w) assert num.allclose(uh_t, uh) assert num.allclose(vh_t, 0.0, atol=1.0e-6) # Check flows through the middle for i in range(5): x = length / 2. + i * 0.23674563 # Arbitrary cross_section = [[x, 0], [x, width]] cross_section = domain_restored.geo_reference.get_absolute( cross_section) Q = domain_restored.get_flow_through_cross_section( cross_section, verbose=False) assert num.allclose(Q, uh * width)
def test_get_mesh_and_quantities_from_unique_vertices_DE0_sww_file(self): """test_get_mesh_and_quantities_from_unique_vertices_sww_file(self): """ # Generate a test sww file with non trivial georeference import time, os # Setup #from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular # Create basic mesh (100m x 5m) width = 5 length = 50 t_end = 10 points, vertices, boundary = rectangular(10, 1, length, width) # Create shallow water domain domain = Domain(points, vertices, boundary, geo_reference = Geo_reference(56,308500,6189000)) domain.set_name('test_get_mesh_and_quantities_from_unique_vertices_sww_file') swwfile = domain.get_name() + '.sww' domain.set_datadir('.') domain.set_flow_algorithm('DE0') domain.set_store_vertices_uniquely() Br = Reflective_boundary(domain) # Side walls Bd = Dirichlet_boundary([1, 0, 0]) # inflow domain.set_boundary( {'left': Bd, 'right': Bd, 'top': Br, 'bottom': Br}) for t in domain.evolve(yieldstep=1, finaltime = t_end): pass # Read it # Get mesh and quantities from sww file X = get_mesh_and_quantities_from_file(swwfile, quantities=['elevation', 'stage', 'xmomentum', 'ymomentum'], verbose=False) mesh, quantities, time = X #print quantities #print time dhash = domain.get_nodes()[:,0]*10+domain.get_nodes()[:,1] mhash = mesh.nodes[:,0]*10+mesh.nodes[:,1] #print 'd_nodes',len(dhash) #print 'm_nodes',len(mhash) di = num.argsort(dhash) mi = num.argsort(mhash) minv = num.argsort(mi) dinv = num.argsort(di) #print 'd_tri',len(domain.get_triangles()) #print 'm_tri',len(mesh.triangles) # Check that mesh has been recovered # triangle order should be ok assert num.allclose(mesh.nodes[mi,:],domain.get_nodes()[di,:]) assert num.alltrue(minv[mesh.triangles] == dinv[domain.get_triangles()]) # Check that time has been recovered assert num.allclose(time, range(t_end+1)) z=domain.get_quantity('elevation').get_values(location='vertices').flatten() assert num.allclose(quantities['elevation'], z) for q in ['stage', 'xmomentum', 'ymomentum']: # Get quantity at last timestep q_ref=domain.get_quantity(q).get_values(location='vertices').flatten() #print q,quantities[q] q_sww=quantities[q][-1,:] msg = 'Quantity %s failed to be recovered' %q assert num.allclose(q_ref, q_sww, atol=1.0e-6), msg
def test_sww2pts_centroids_de0(self): """Test that sww information can be converted correctly to pts data at specified coordinates - in this case, the centroids. """ import time, os from anuga.file.netcdf import NetCDFFile # Used for points that lie outside mesh NODATA_value = 1758323 # Setup from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular # Create shallow water domain domain = Domain(*rectangular(2, 2)) B = Transmissive_boundary(domain) domain.set_boundary( {'left': B, 'right': B, 'top': B, 'bottom': B}) domain.set_name('datatest_de0') ptsfile = domain.get_name() + '_elevation.pts' swwfile = domain.get_name() + '.sww' domain.set_datadir('.') domain.format = 'sww' domain.set_quantity('elevation', lambda x,y: -x-y) domain.geo_reference = Geo_reference(56,308500,6189000) sww = SWW_file(domain) sww.store_connectivity() sww.store_timestep() #self.domain.tight_slope_limiters = 1 domain.evolve_to_end(finaltime = 0.01) sww.store_timestep() # Check contents in NetCDF fid = NetCDFFile(sww.filename, netcdf_mode_r) # Get the variables x = fid.variables['x'][:] y = fid.variables['y'][:] elevation = fid.variables['elevation'][:] time = fid.variables['time'][:] stage = fid.variables['stage'][:] volumes = fid.variables['volumes'][:] # Invoke interpolation for vertex points points = num.concatenate( (x[:,num.newaxis],y[:,num.newaxis]), axis=1 ) points = num.ascontiguousarray(points) sww2pts(domain.get_name() + '.sww', quantity = 'elevation', data_points = points, NODATA_value = NODATA_value) ref_point_values = elevation point_values = Geospatial_data(ptsfile).get_attributes() #print 'P', point_values #print 'Ref', ref_point_values assert num.allclose(point_values, ref_point_values) # Invoke interpolation for centroids points = domain.get_centroid_coordinates() #print points sww2pts(domain.get_name() + '.sww', quantity = 'elevation', data_points = points, NODATA_value = NODATA_value) #ref_point_values = [-0.5, -0.5, -1, -1, -1, -1, -1.5, -1.5] #At centroids ref_point_values = [-0.77777777, -0.77777777, -0.99999998, -0.99999998, -0.99999998, -0.99999998, -1.22222221, -1.22222221] point_values = Geospatial_data(ptsfile).get_attributes() #print 'P', point_values #print 'Ref', ref_point_values assert num.allclose(point_values, ref_point_values) fid.close() #Cleanup os.remove(sww.filename) os.remove(ptsfile)
def test_get_maximum_inundation_de0(self): """Test that sww information can be converted correctly to maximum runup elevation and location (without and with georeferencing) This test creates a slope and a runup which is maximal (~11m) at around 10s and levels out to the boundary condition (1m) at about 30s. """ import time, os from anuga.file.netcdf import NetCDFFile verbose = False #Setup #from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular # Create basic mesh (100m x 100m) points, vertices, boundary = rectangular(20, 5, 100, 50) # Create shallow water domain domain = Domain(points, vertices, boundary) domain.set_flow_algorithm('DE0') domain.set_low_froude(0) domain.set_minimum_storable_height(0.01) filename = 'runup_test_3' domain.set_name(filename) swwfile = domain.get_name() + '.sww' domain.set_datadir('.') domain.format = 'sww' domain.smooth = True # FIXME (Ole): Backwards compatibility # Look at sww file and see what happens when # domain.tight_slope_limiters = 1 domain.tight_slope_limiters = 0 domain.use_centroid_velocities = 0 # Backwards compatibility (7/5/8) Br = Reflective_boundary(domain) Bd = Dirichlet_boundary([1.0, 0, 0]) #---------- First run without geo referencing domain.set_quantity('elevation', lambda x, y: -0.2 * x + 14) # Slope domain.set_quantity('stage', -6) domain.set_boundary({'left': Br, 'right': Bd, 'top': Br, 'bottom': Br}) for t in domain.evolve(yieldstep=1, finaltime=50): pass # Check maximal runup runup, location, max_time = get_maximum_inundation_data( swwfile, return_time=True) if verbose: print('Runup, location', runup, location, max_time) assert num.allclose(runup, 3.33333325386) assert num.allclose(location, [53.333332, 43.333332]) assert num.allclose(max_time, 10.0) # Check runup in restricted time interval runup, location, max_time = get_maximum_inundation_data( swwfile, time_interval=[0, 9], return_time=True) if verbose: print('Runup, location:', runup, location, max_time) assert num.allclose(runup, 2.66666674614) assert num.allclose(location, [56.666668, 16.666666]) assert num.allclose(max_time, 9.0) # Check final runup runup, location = get_maximum_inundation_data(swwfile, time_interval=[45, 50]) if verbose: print('Runup, location:', runup, location, max_time) assert num.allclose(runup, 3.33333325386) assert num.allclose(location, [53.333332, 33.333332]) #assert num.allclose(max_time, 45.0) # Check runup restricted to a polygon p = [[50, 1], [99, 1], [99, 40], [50, 40]] runup, location = get_maximum_inundation_data(swwfile, polygon=p) #runup = get_maximum_inundation_elevation(swwfile, polygon=p) #location = get_maximum_inundation_location(swwfile, polygon=p) #print runup, location, max_time assert num.allclose(runup, 3.33333325386) assert num.allclose(location, [53.333332, 33.333332]) #assert num.allclose(max_time, 11.0) # Check that mimimum_storable_height works fid = NetCDFFile(swwfile, netcdf_mode_r) # Open existing file stage = fid.variables['stage_c'][:] z = fid.variables['elevation_c'][:] xmomentum = fid.variables['xmomentum_c'][:] ymomentum = fid.variables['ymomentum_c'][:] for i in range(stage.shape[0]): h = stage[i] - z # depth vector at time step i # Check every node location for j in range(stage.shape[1]): # Depth being either exactly zero implies # momentum being zero. # Or else depth must be greater than or equal to # the minimal storable height if h[j] == 0.0: assert xmomentum[i, j] == 0.0 assert ymomentum[i, j] == 0.0 else: assert h[j] >= 0.0 fid.close() # Cleanup os.remove(swwfile) #------------- Now the same with georeferencing domain.time = 0.0 E = 308500 N = 6189000 #E = N = 0 domain.geo_reference = Geo_reference(56, E, N) domain.set_quantity('elevation', lambda x, y: -0.2 * x + 14) # Slope domain.set_quantity('stage', -6) domain.set_boundary({'left': Br, 'right': Bd, 'top': Br, 'bottom': Br}) for t in domain.evolve(yieldstep=1, finaltime=50): pass # Check maximal runup runup, location = get_maximum_inundation_data(swwfile) #print 'Runup, location', runup, location, max_time assert num.allclose(runup, 3.33333325386) assert num.allclose(location, [53.333332 + E, 43.333332 + N]) #assert num.allclose(max_time, 10.0) # Check runup in restricted time interval runup, location = get_maximum_inundation_data(swwfile, time_interval=[0, 9]) #print 'Runup, location:',runup, location, max_time assert num.allclose(runup, 2.66666674614) assert num.allclose(location, [56.666668 + E, 16.666666 + N]) #assert num.allclose(max_time, 9.0) # Check final runup runup, location = get_maximum_inundation_data(swwfile, time_interval=[45, 50]) #print 'Runup, location:',runup, location, max_time assert num.allclose(runup, 3.33333325386) assert num.allclose(location, [53.333332 + E, 33.333332 + N]) #assert num.allclose(max_time, 45.0) # Check runup restricted to a polygon p = num.array([[50, 1], [99, 1], [99, 40], [50, 40]], num.int) + num.array([E, N], num.int) runup, location = get_maximum_inundation_data(swwfile, polygon=p) #print runup, location, max_time assert num.allclose(runup, 3.33333325386) assert num.allclose(location, [53.333332 + E, 33.333332 + N]) #assert num.allclose(max_time, 11.0) # Cleanup os.remove(swwfile)
def test_region_tags(self): """get values based on triangle lists.""" #Create basic mesh points, vertices, boundary = rectangular(1, 3) #Create shallow water domain domain = Domain(points, vertices, boundary) domain.build_tagged_elements_dictionary({ 'bottom': [0, 1], 'top': [4, 5], 'all': [0, 1, 2, 3, 4, 5] }) #Set friction manning = 0.07 domain.set_quantity('friction', manning) a = Set_tag_region('bottom', 'friction', 0.09) b = Set_tag_region('top', 'friction', 1.0) domain.set_tag_region([a, b]) expected = [[0.09, 0.09, 0.09], [0.09, 0.09, 0.09], [0.07, 0.07, 0.07], [0.07, 0.07, 0.07], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]] msg = ( "\ndomain.quantities['friction']=%s\nexpected value=%s" % (str(domain.quantities['friction'].get_values()), str(expected))) assert num.allclose(domain.quantities['friction'].get_values(), expected), msg #c = Add_Value_To_region('all', 'friction', 10.0) domain.set_tag_region(Add_value_to_region('all', 'friction', 10.0)) #print domain.quantities['friction'].get_values() assert num.allclose(domain.quantities['friction'].get_values(), [[10.09, 10.09, 10.09], [10.09, 10.09, 10.09], [10.07, 10.07, 10.07], [10.07, 10.07, 10.07], [11.0, 11.0, 11.0], [11.0, 11.0, 11.0]]) # trying a function domain.set_tag_region(Set_tag_region('top', 'friction', add_x_y)) #print domain.quantities['friction'].get_values() assert num.allclose(domain.quantities['friction'].get_values(), [[10.09, 10.09, 10.09], [10.09, 10.09, 10.09], [10.07, 10.07, 10.07], [10.07, 10.07, 10.07], [5. / 3, 2.0, 2. / 3], [1.0, 2. / 3, 2.0]]) domain.set_quantity('elevation', 10.0) domain.set_quantity('stage', 10.0) domain.set_tag_region( Add_value_to_region('top', 'stage', 1.0, initial_quantity='elevation')) #print domain.quantities['stage'].get_values() assert num.allclose( domain.quantities['stage'].get_values(), [[10., 10., 10.], [10., 10., 10.], [10., 10., 10.], [10., 10., 10.], [11.0, 11.0, 11.0], [11.0, 11.0, 11.0]]) domain.set_quantity('elevation', 10.0) domain.set_quantity('stage', give_me_23) #this works as well, (is cleaner, but doesn't work for regions) #domain.set_quantity('stage', # domain.quantities['stage'].vertex_values+ \ # domain.quantities['elevation'].vertex_values) domain.set_tag_region(Add_quantities('top', 'elevation', 'stage')) #print domain.quantities['stage'].get_values() assert num.allclose( domain.quantities['elevation'].get_values(), [[10., 10., 10.], [10., 10., 10.], [10., 10., 10.], [10., 10., 10.], [33., 33.0, 33.], [33.0, 33., 33.]])
def test_get_energy_through_cross_section(self): """test_get_energy_through_cross_section(self): Test that the specific and total energy through a cross section can be correctly obtained from an sww file. This test creates a flat bed with a known flow through it and tests that the function correctly returns the expected energies. The specifics are u = 2 m/s h = 1 m w = 3 m (width of channel) q = u*h*w = 6 m^3/s Es = h + 0.5*v*v/g # Specific energy head [m] Et = w + 0.5*v*v/g # Total energy head [m] This test uses georeferencing """ import time, os from anuga.file.netcdf import NetCDFFile # Setup #from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular # Create basic mesh (20m x 3m) width = 3 length = 20 t_end = 1 points, vertices, boundary = rectangular(length, width, length, width) # Create shallow water domain domain = Domain(points, vertices, boundary, geo_reference=Geo_reference(56, 308500, 6189000)) domain.default_order = 2 domain.set_minimum_storable_height(0.01) domain.set_name('flowtest') swwfile = domain.get_name() + '.sww' domain.set_datadir('.') domain.format = 'sww' domain.smooth = True e = -1.0 w = 1.0 h = w - e u = 2.0 uh = u * h Br = Reflective_boundary(domain) # Side walls Bd = Dirichlet_boundary([w, uh, 0]) # 2 m/s across the 3 m inlet: domain.set_quantity('elevation', e) domain.set_quantity('stage', w) domain.set_quantity('xmomentum', uh) domain.set_boundary({'left': Bd, 'right': Bd, 'top': Br, 'bottom': Br}) for t in domain.evolve(yieldstep=1, finaltime=t_end): pass # Check that momentum is as it should be in the interior I = [[0, width / 2.], [length / 2., width / 2.], [length, width / 2.]] I = domain.geo_reference.get_absolute(I) f = file_function(swwfile, quantities=['stage', 'xmomentum', 'ymomentum'], interpolation_points=I, verbose=False) for t in range(t_end + 1): for i in range(3): #print i, t, f(t, i) assert num.allclose(f(t, i), [w, uh, 0], atol=1.0e-6) # Check energies through the middle for i in range(5): x = length / 2. + i * 0.23674563 # Arbitrary cross_section = [[x, 0], [x, width]] cross_section = domain.geo_reference.get_absolute(cross_section) time, Es = get_energy_through_cross_section(swwfile, cross_section, kind='specific', verbose=False) assert num.allclose(Es, h + 0.5 * u * u / g) time, Et = get_energy_through_cross_section(swwfile, cross_section, kind='total', verbose=False) assert num.allclose(Et, w + 0.5 * u * u / g)
def test_sww2pts_centroids_de0(self): """Test that sww information can be converted correctly to pts data at specified coordinates - in this case, the centroids. """ import time, os from anuga.file.netcdf import NetCDFFile # Used for points that lie outside mesh NODATA_value = 1758323 # Setup from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular # Create shallow water domain domain = Domain(*rectangular(2, 2)) B = Transmissive_boundary(domain) domain.set_boundary({'left': B, 'right': B, 'top': B, 'bottom': B}) domain.set_name('datatest_de0') ptsfile = domain.get_name() + '_elevation.pts' swwfile = domain.get_name() + '.sww' domain.set_datadir('.') domain.format = 'sww' domain.set_quantity('elevation', lambda x, y: -x - y) domain.geo_reference = Geo_reference(56, 308500, 6189000) sww = SWW_file(domain) sww.store_connectivity() sww.store_timestep() #self.domain.tight_slope_limiters = 1 domain.evolve_to_end(finaltime=0.01) sww.store_timestep() # Check contents in NetCDF fid = NetCDFFile(sww.filename, netcdf_mode_r) # Get the variables x = fid.variables['x'][:] y = fid.variables['y'][:] elevation = fid.variables['elevation'][:] time = fid.variables['time'][:] stage = fid.variables['stage'][:] volumes = fid.variables['volumes'][:] # Invoke interpolation for vertex points points = num.concatenate((x[:, num.newaxis], y[:, num.newaxis]), axis=1) points = num.ascontiguousarray(points) sww2pts(domain.get_name() + '.sww', quantity='elevation', data_points=points, NODATA_value=NODATA_value) ref_point_values = elevation point_values = Geospatial_data(ptsfile).get_attributes() #print 'P', point_values #print 'Ref', ref_point_values assert num.allclose(point_values, ref_point_values) # Invoke interpolation for centroids points = domain.get_centroid_coordinates() #print points sww2pts(domain.get_name() + '.sww', quantity='elevation', data_points=points, NODATA_value=NODATA_value) #ref_point_values = [-0.5, -0.5, -1, -1, -1, -1, -1.5, -1.5] #At centroids ref_point_values = [ -0.77777777, -0.77777777, -0.99999998, -0.99999998, -0.99999998, -0.99999998, -1.22222221, -1.22222221 ] point_values = Geospatial_data(ptsfile).get_attributes() #print 'P', point_values #print 'Ref', ref_point_values assert num.allclose(point_values, ref_point_values) fid.close() #Cleanup os.remove(sww.filename) os.remove(ptsfile)
def setUp(self): import time self.verbose = Test_File_Conversion.verbose # Create basic mesh points, vertices, boundary = rectangular(2, 2) # Create shallow water domain domain = Domain(points, vertices, boundary) domain.default_order = 2 # Set some field values domain.set_quantity('elevation', lambda x, y: -x) domain.set_quantity('friction', 0.03) ###################### # Boundary conditions B = Transmissive_boundary(domain) domain.set_boundary({'left': B, 'right': B, 'top': B, 'bottom': B}) ###################### #Initial condition - with jumps bed = domain.quantities['elevation'].vertex_values stage = num.zeros(bed.shape, num.float) h = 0.3 for i in range(stage.shape[0]): if i % 2 == 0: stage[i, :] = bed[i, :] + h else: stage[i, :] = bed[i, :] domain.set_quantity('stage', stage) domain.distribute_to_vertices_and_edges() self.initial_stage = copy.copy( domain.quantities['stage'].vertex_values) self.domain = domain C = domain.get_vertex_coordinates() self.X = C[:, 0:6:2].copy() self.Y = C[:, 1:6:2].copy() self.F = bed #Write A testfile (not realistic. Values aren't realistic) self.test_MOST_file = 'most_small' longitudes = [150.66667, 150.83334, 151., 151.16667] latitudes = [-34.5, -34.33333, -34.16667, -34] long_name = 'LON' lat_name = 'LAT' nx = 4 ny = 4 six = 6 for ext in ['_ha.nc', '_ua.nc', '_va.nc', '_e.nc']: fid = NetCDFFile(self.test_MOST_file + ext, netcdf_mode_w) fid.createDimension(long_name, nx) fid.createVariable(long_name, netcdf_float, (long_name, )) fid.variables[long_name].point_spacing = 'uneven' fid.variables[long_name].units = 'degrees_east' fid.variables[long_name][:] = longitudes fid.createDimension(lat_name, ny) fid.createVariable(lat_name, netcdf_float, (lat_name, )) fid.variables[lat_name].point_spacing = 'uneven' fid.variables[lat_name].units = 'degrees_north' fid.variables[lat_name][:] = latitudes fid.createDimension('TIME', six) fid.createVariable('TIME', netcdf_float, ('TIME', )) fid.variables['TIME'].point_spacing = 'uneven' fid.variables['TIME'].units = 'seconds' fid.variables['TIME'][:] = [0.0, 0.1, 0.6, 1.1, 1.6, 2.1] name = ext[1:3].upper() if name == 'E.': name = 'ELEVATION' fid.createVariable(name, netcdf_float, ('TIME', lat_name, long_name)) fid.variables[name].units = 'CENTIMETERS' fid.variables[name].missing_value = -1.e+034 fid.variables[name][:] = [ [[0.3400644, 0, -46.63519, -6.50198], [-0.1214216, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], [[0.3400644, 2.291054e-005, -23.33335, -6.50198], [-0.1213987, 4.581959e-005, -1.594838e-007, 1.421085e-012], [2.291054e-005, 4.582107e-005, 4.581715e-005, 1.854517e-009], [0, 2.291054e-005, 2.291054e-005, 0]], [[0.3400644, 0.0001374632, -23.31503, -6.50198], [-0.1212842, 0.0002756907, 0.006325484, 1.380492e-006], [0.0001374632, 0.0002749264, 0.0002742863, 6.665601e-008], [0, 0.0001374632, 0.0001374632, 0]], [[0.3400644, 0.0002520159, -23.29672, -6.50198], [-0.1211696, 0.0005075303, 0.01264618, 6.208276e-006], [0.0002520159, 0.0005040318, 0.0005027961, 2.23865e-007], [0, 0.0002520159, 0.0002520159, 0]], [[0.3400644, 0.0003665686, -23.27842, -6.50198], [-0.1210551, 0.0007413362, 0.01896192, 1.447638e-005], [0.0003665686, 0.0007331371, 0.0007313463, 4.734126e-007], [0, 0.0003665686, 0.0003665686, 0]], [[0.3400644, 0.0004811212, -23.26012, -6.50198], [-0.1209405, 0.0009771062, 0.02527271, 2.617787e-005], [0.0004811212, 0.0009622425, 0.0009599366, 8.152277e-007], [0, 0.0004811212, 0.0004811212, 0]] ] fid.close()
def setUp(self): import time self.verbose = Test_File_Conversion.verbose # Create basic mesh points, vertices, boundary = rectangular(2, 2) # Create shallow water domain domain = Domain(points, vertices, boundary) domain.default_order = 2 # Set some field values domain.set_quantity('elevation', lambda x,y: -x) domain.set_quantity('friction', 0.03) ###################### # Boundary conditions B = Transmissive_boundary(domain) domain.set_boundary( {'left': B, 'right': B, 'top': B, 'bottom': B}) ###################### #Initial condition - with jumps bed = domain.quantities['elevation'].vertex_values stage = num.zeros(bed.shape, num.float) h = 0.3 for i in range(stage.shape[0]): if i % 2 == 0: stage[i,:] = bed[i,:] + h else: stage[i,:] = bed[i,:] domain.set_quantity('stage', stage) domain.distribute_to_vertices_and_edges() self.initial_stage = copy.copy(domain.quantities['stage'].vertex_values) self.domain = domain C = domain.get_vertex_coordinates() self.X = C[:,0:6:2].copy() self.Y = C[:,1:6:2].copy() self.F = bed #Write A testfile (not realistic. Values aren't realistic) self.test_MOST_file = 'most_small' longitudes = [150.66667, 150.83334, 151., 151.16667] latitudes = [-34.5, -34.33333, -34.16667, -34] long_name = 'LON' lat_name = 'LAT' nx = 4 ny = 4 six = 6 for ext in ['_ha.nc', '_ua.nc', '_va.nc', '_e.nc']: fid = NetCDFFile(self.test_MOST_file + ext, netcdf_mode_w) fid.createDimension(long_name,nx) fid.createVariable(long_name,netcdf_float,(long_name,)) fid.variables[long_name].point_spacing='uneven' fid.variables[long_name].units='degrees_east' fid.variables[long_name][:] = longitudes fid.createDimension(lat_name,ny) fid.createVariable(lat_name,netcdf_float,(lat_name,)) fid.variables[lat_name].point_spacing='uneven' fid.variables[lat_name].units='degrees_north' fid.variables[lat_name][:] = latitudes fid.createDimension('TIME',six) fid.createVariable('TIME',netcdf_float,('TIME',)) fid.variables['TIME'].point_spacing='uneven' fid.variables['TIME'].units='seconds' fid.variables['TIME'][:] = [0.0, 0.1, 0.6, 1.1, 1.6, 2.1] name = ext[1:3].upper() if name == 'E.': name = 'ELEVATION' fid.createVariable(name,netcdf_float,('TIME', lat_name, long_name)) fid.variables[name].units='CENTIMETERS' fid.variables[name].missing_value=-1.e+034 fid.variables[name][:] = [[[0.3400644, 0, -46.63519, -6.50198], [-0.1214216, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], [[0.3400644, 2.291054e-005, -23.33335, -6.50198], [-0.1213987, 4.581959e-005, -1.594838e-007, 1.421085e-012], [2.291054e-005, 4.582107e-005, 4.581715e-005, 1.854517e-009], [0, 2.291054e-005, 2.291054e-005, 0]], [[0.3400644, 0.0001374632, -23.31503, -6.50198], [-0.1212842, 0.0002756907, 0.006325484, 1.380492e-006], [0.0001374632, 0.0002749264, 0.0002742863, 6.665601e-008], [0, 0.0001374632, 0.0001374632, 0]], [[0.3400644, 0.0002520159, -23.29672, -6.50198], [-0.1211696, 0.0005075303, 0.01264618, 6.208276e-006], [0.0002520159, 0.0005040318, 0.0005027961, 2.23865e-007], [0, 0.0002520159, 0.0002520159, 0]], [[0.3400644, 0.0003665686, -23.27842, -6.50198], [-0.1210551, 0.0007413362, 0.01896192, 1.447638e-005], [0.0003665686, 0.0007331371, 0.0007313463, 4.734126e-007], [0, 0.0003665686, 0.0003665686, 0]], [[0.3400644, 0.0004811212, -23.26012, -6.50198], [-0.1209405, 0.0009771062, 0.02527271, 2.617787e-005], [0.0004811212, 0.0009622425, 0.0009599366, 8.152277e-007], [0, 0.0004811212, 0.0004811212, 0]]] fid.close()