def darcy_dual_hybridVEM_example3(**kwargs): ####################### # Simple 3d Darcy problem with known exact solution ####################### Nx = Ny = Nz = 7 g = structured.CartGrid([Nx, Ny, Nz], [1, 1, 1]) g.compute_geometry() kxx = np.ones(g.num_cells) perm = tensor.SecondOrder(g.dim, kxx) def funP_ex(pt): return np.sin(2*np.pi*pt[0])*np.sin(2*np.pi*pt[1])\ * np.sin(2*np.pi*pt[2]) def funU_ex(pt): return [-2*np.pi*np.cos(2*np.pi*pt[0])\ * np.sin(2*np.pi*pt[1])*np.sin(2*np.pi*pt[2]), -2*np.pi*np.sin(2*np.pi*pt[0])\ * np.cos(2*np.pi*pt[1])*np.sin(2*np.pi*pt[2]), -2*np.pi*np.sin(2*np.pi*pt[0])\ * np.sin(2*np.pi*pt[1])*np.cos(2*np.pi*pt[2])] def fun(pt): return 12 * np.pi**2 * funP_ex(pt) f = np.array([fun(pt) for pt in g.cell_centers.T]) b_faces = g.get_boundary_faces() bnd = bc.BoundaryCondition(g, b_faces, ['dir'] * b_faces.size) bnd_val = np.zeros(g.num_faces) bnd_val[b_faces] = funP_ex(g.face_centers[:, b_faces]) solver = hybrid.HybridDualVEM() data = {'perm': perm, 'source': f, 'bc': bnd, 'bc_val': bnd_val} H, rhs = solver.matrix_rhs(g, data) l = sps.linalg.spsolve(H, rhs) u, p = solver.compute_up(g, l, data) P0u = dual.DualVEM().project_u(g, u) if kwargs['visualize']: plot_grid(g, p, P0u) p_ex = error.interpolate(g, funP_ex) u_ex = error.interpolate(g, funU_ex) np.set_printoptions(linewidth=999999) np.set_printoptions(precision=16) errors = np.array( [error.error_L2(g, p, p_ex), error.error_L2(g, P0u, u_ex)]) errors_known = np.array([0.1010936831876412, 0.0680593765009036]) assert np.allclose(errors, errors_known)
def darcy_dual_hybridVEM_example2(**kwargs): ####################### # Simple 2d Darcy problem on a surface with known exact solution ####################### Nx = Ny = 25 g = simplex.StructuredTriangleGrid([Nx, Ny], [1, 1]) R = cg.rot(np.pi / 6., [0, 1, 1]) g.nodes = np.dot(R, g.nodes) g.compute_geometry(is_embedded=True) T = cg.tangent_matrix(g.nodes) kxx = np.ones(g.num_cells) perm = tensor.SecondOrder(g.dim, kxx) def funP_ex(pt): return np.pi * pt[0] - 6 * pt[1] + np.exp(1) * pt[2] - 4 def funU_ex(pt): return np.dot(T, [-np.pi, 6, -np.exp(1)]) def fun(pt): return 0 f = np.array([fun(pt) for pt in g.cell_centers.T]) b_faces = g.get_boundary_faces() bnd = bc.BoundaryCondition(g, b_faces, ['dir'] * b_faces.size) bnd_val = np.zeros(g.num_faces) bnd_val[b_faces] = funP_ex(g.face_centers[:, b_faces]) solver = hybrid.HybridDualVEM() data = {'perm': perm, 'source': f, 'bc': bnd, 'bc_val': bnd_val} H, rhs = solver.matrix_rhs(g, data) l = sps.linalg.spsolve(H, rhs) u, p = solver.compute_up(g, l, data) P0u = dual.DualVEM().project_u(g, u) if kwargs['visualize']: plot_grid(g, p, P0u) p_ex = error.interpolate(g, funP_ex) u_ex = error.interpolate(g, funU_ex) errors = np.array( [error.error_L2(g, p, p_ex), error.error_L2(g, P0u, u_ex)]) errors_known = np.array([0, 0]) assert np.allclose(errors, errors_known)
def darcy_dualVEM_example1(**kwargs): ####################### # Simple 2d Darcy problem with known exact solution ####################### Nx = Ny = 25 g = structured.CartGrid([Nx, Ny], [1, 1]) g.compute_geometry() kxx = np.ones(g.num_cells) perm = tensor.SecondOrder(g.dim, kxx) def funP_ex(pt): return np.sin(2 * np.pi * pt[0]) * np.sin(2 * np.pi * pt[1]) def funU_ex(pt): return [ -2 * np.pi * np.cos(2 * np.pi * pt[0]) * np.sin(2 * np.pi * pt[1]), -2 * np.pi * np.sin(2 * np.pi * pt[0]) * np.cos(2 * np.pi * pt[1]), 0 ] def fun(pt): return 8 * np.pi**2 * funP_ex(pt) f = np.array([fun(pt) for pt in g.cell_centers.T]) b_faces = g.get_boundary_faces() bnd = bc.BoundaryCondition(g, b_faces, ['dir'] * b_faces.size) bnd_val = np.zeros(g.num_faces) bnd_val[b_faces] = funP_ex(g.face_centers[:, b_faces]) solver = dual.DualVEM() data = {'perm': perm, 'source': f, 'bc': bnd, 'bc_val': bnd_val} D, rhs = solver.matrix_rhs(g, data) up = sps.linalg.spsolve(D, rhs) u, p = solver.extract_u(g, up), solver.extract_p(g, up) P0u = solver.project_u(g, u) if kwargs['visualize']: plot_grid(g, p, P0u) p_ex = error.interpolate(g, funP_ex) u_ex = error.interpolate(g, funU_ex) errors = np.array( [error.error_L2(g, p, p_ex), error.error_L2(g, P0u, u_ex)]) errors_known = np.array([0.0210718223032, 0.00526933885613]) assert np.allclose(errors, errors_known)
def gb_error(gb, v1, v2, norm='L2'): gb.add_node_props(['error_1', 'error_2']) has_splitter.split(gb, 'error_1', v1) has_splitter.split(gb, 'error_2', v2) e = gb.apply_function_to_nodes( lambda g, d: error_L2(g, d['error_1'], d['error_2'], relative=False)) return e
def test_1d_elimination_3d_2d_1d(self): """ 3d case with a single 1d grid. """ f1 = np.array([[0, 1, 1, 0], [0, 0, 1, 1], [.5, .5, .5, .5]]) f2 = np.array([[.5, .5, .5, .5], [0, 1, 1, 0], [0, 0, 1, 1]]) gb = meshing.cart_grid([f1, f2], [2, 2, 2], **{'physdims': [1, 1, 1]}) gb.compute_geometry() gb.assign_node_ordering() tol = 1e-3 solver = tpfa.Tpfa() gb.add_node_props(['param']) a = 1e-2 for g, d in gb: param = Parameters(g) aperture = np.ones(g.num_cells) * np.power(a, gb.dim_max() - g.dim) param.set_aperture(aperture) p = tensor.SecondOrder( 3, np.ones(g.num_cells) * np.power(1e3, g.dim < gb.dim_max())) param.set_tensor('flow', p) bound_faces = g.get_boundary_faces() bound_face_centers = g.face_centers[:, bound_faces] left = bound_face_centers[0, :] > 1 - tol right = bound_face_centers[0, :] < tol labels = np.array(['neu'] * bound_faces.size) labels[np.logical_or(left, right)] = ['dir'] bc_val = np.zeros(g.num_faces) bc_dir = bound_faces[np.logical_or(left, right)] bc_val[bc_dir] = g.face_centers[0, bc_dir] param.set_bc(solver, bc.BoundaryCondition(g, bound_faces, labels)) param.set_bc_val(solver, bc_val) d['param'] = param coupling_conditions = tpfa.TpfaCoupling(solver) solver_coupler = coupler.Coupler(solver, coupling_conditions) A, rhs = solver_coupler.matrix_rhs(gb) p = sps.linalg.spsolve(A, rhs) p_cond, _, _, _ = condensation.solve_static_condensation(\ A, rhs, gb, dim=1) solver_coupler.split(gb, "pressure", p) solver_coupler.split(gb, "p_cond", p_cond) tol = 1e-5 assert ((np.amax(np.absolute(p - p_cond))) < tol) assert (np.sum( error.error_L2(g, d['pressure'], d['p_cond']) for g, d in gb) < tol)
def test_1d_elimination_2d_1d(self): """ Simplest case possible: 2d case with two fractures intersecting in a single 0d grid at the center of the domain. """ f1 = np.array([[0, 1], [.5, .5]]) gb = meshing.cart_grid([f1], [2, 2], **{'physdims': [1, 1]}) gb.compute_geometry() gb.assign_node_ordering() tol = 1e-3 solver = tpfa.Tpfa() gb.add_node_props(['param']) a = 1e-2 for g, d in gb: param = Parameters(g) a_dim = np.power(a, gb.dim_max() - g.dim) aperture = np.ones(g.num_cells) * a_dim param.set_aperture(aperture) kxx = np.ones(g.num_cells) * np.power(1e3, g.dim < gb.dim_max()) #print(kxx, 'dim', g.dim) p = tensor.SecondOrder(3, kxx, kyy=kxx, kzz=kxx) #print(p.perm) param.set_tensor('flow', p) bound_faces = g.get_boundary_faces() bound_face_centers = g.face_centers[:, bound_faces] right = bound_face_centers[0, :] > 1 - tol left = bound_face_centers[0, :] < tol labels = np.array(['neu'] * bound_faces.size) labels[right] = ['dir'] bc_val = np.zeros(g.num_faces) bc_dir = bound_faces[right] bc_neu = bound_faces[left] bc_val[bc_dir] = g.face_centers[0, bc_dir] bc_val[bc_neu] = -g.face_areas[bc_neu] * a_dim param.set_bc(solver, bc.BoundaryCondition(g, bound_faces, labels)) param.set_bc_val(solver, bc_val) d['param'] = param coupling_conditions = tpfa.TpfaCoupling(solver) solver_coupler = coupler.Coupler(solver, coupling_conditions) A, rhs = solver_coupler.matrix_rhs(gb) p = sps.linalg.spsolve(A, rhs) p_cond, _, _, _ = condensation.solve_static_condensation(\ A, rhs, gb, dim=1) solver_coupler.split(gb, "pressure", p) solver_coupler.split(gb, "p_cond", p_cond) tol = 1e-10 assert ((np.amax(np.absolute(p - p_cond))) < tol) assert (np.sum( error.error_L2(g, d['pressure'], d['p_cond']) for g, d in gb) < tol)
def test_tpfa_fluxes_2d_1d_cross_with_elimination(self): f1 = np.array([[0, 1], [.5, .5]]) f2 = np.array([[.5, .5], [0, 1]]) domain = {'xmin': 0, 'ymin': 0, 'xmax': 1, 'ymax': 1} mesh_size = 0.4 mesh_kwargs = {} mesh_kwargs['mesh_size'] = { 'mode': 'constant', 'value': mesh_size, 'bound_value': mesh_size } gb = meshing.cart_grid([f1, f2], [2, 2], **{'physdims': [1, 1]}) #gb = meshing.simplex_grid( [f1, f2],domain,**mesh_kwargs) gb.compute_geometry() gb.assign_node_ordering() # Enforce node orderning because of Python 3.5 and 2.7. # Don't do it in general. cell_centers_1 = np.array([[7.50000000e-01, 2.500000000e-01], [5.00000000e-01, 5.00000000e-01], [-5.55111512e-17, 5.55111512e-17]]) cell_centers_2 = np.array([[5.00000000e-01, 5.00000000e-01], [7.50000000e-01, 2.500000000e-01], [-5.55111512e-17, 5.55111512e-17]]) for g, d in gb: if g.dim == 1: if np.allclose(g.cell_centers, cell_centers_1): d['node_number'] = 1 elif np.allclose(g.cell_centers, cell_centers_2): d['node_number'] = 2 else: raise ValueError('Grid not found') tol = 1e-3 solver = tpfa.TpfaMixedDim('flow') gb.add_node_props(['param']) a = 1e-2 for g, d in gb: param = Parameters(g) a_dim = np.power(a, gb.dim_max() - g.dim) aperture = np.ones(g.num_cells) * a_dim param.set_aperture(aperture) kxx = np.ones(g.num_cells) * np.power(1e3, g.dim < gb.dim_max()) p = tensor.SecondOrder(3, kxx, kyy=kxx, kzz=kxx) param.set_tensor('flow', p) bound_faces = g.get_boundary_faces() bound_face_centers = g.face_centers[:, bound_faces] right = bound_face_centers[0, :] > 1 - tol left = bound_face_centers[0, :] < tol labels = np.array(['neu'] * bound_faces.size) labels[right] = ['dir'] bc_val = np.zeros(g.num_faces) bc_dir = bound_faces[right] bc_neu = bound_faces[left] bc_val[bc_dir] = g.face_centers[0, bc_dir] bc_val[bc_neu] = -g.face_areas[bc_neu] * a_dim param.set_bc('flow', bc.BoundaryCondition(g, bound_faces, labels)) param.set_bc_val('flow', bc_val) d['param'] = param gb.add_edge_prop('param') for e, d in gb.edges_props(): g_h = gb.sorted_nodes_of_edge(e)[1] d['param'] = Parameters(g_h) A, rhs = solver.matrix_rhs(gb) p = sps.linalg.spsolve(A, rhs) p = sps.linalg.spsolve(A, rhs) p_cond, p_red, _, _ = condensation.solve_static_condensation(\ A, rhs, gb, dim=0) solver.split(gb, "p_cond", p_cond) solver.split(gb, "pressure", p) # Make a copy of the grid bucket without the 0d grid dim_to_remove = 0 gb_r, elimination_data = gb.duplicate_without_dimension(dim_to_remove) # Compute the flux discretization on the new edges condensation.compute_elimination_fluxes(gb, gb_r, elimination_data) # Compute the discharges from the flux discretizations and computed pressures solver.split(gb_r, "pressure", p_red) fvutils.compute_discharges(gb) fvutils.compute_discharges(gb_r) # Known discharges d_0, d_1, d_2 = fluxes_2d_1d_cross_with_elimination() # Check node fluxes, ... rtol = 1e-6 atol = rtol for g, d in gb: if d['node_number'] == 0: assert np.allclose(d['discharge'], d_0, rtol, atol) if d['node_number'] == 1: assert np.allclose(d['discharge'], d_1, rtol, atol) if d['node_number'] == 2: assert np.allclose(d['discharge'], d_2, rtol, atol) for g, d in gb_r: if d['node_number'] == 0: assert np.allclose(d['discharge'], d_0, rtol, atol) if d['node_number'] == 1: assert np.allclose(d['discharge'], d_1, rtol, atol) if d['node_number'] == 2: assert np.allclose(d['discharge'], d_2, rtol, atol) # ... edge fluxes ... d_01, d_10, d_02, d_20, d_13, d_23 = coupling_fluxes_2d_1d_cross_no_el( ) for e, data in gb.edges_props(): g1, g2 = gb.sorted_nodes_of_edge(e) pa = data['param'] node_numbers = gb.nodes_prop([g2, g1], 'node_number') if pa is not None: if node_numbers == (0, 1): assert np.allclose( data['discharge'], d_01, rtol, atol) or \ np.allclose( data['discharge'], d_10, rtol, atol) if node_numbers == (0, 2): assert np.allclose( data['discharge'], d_02, rtol, atol) or \ np.allclose( data['discharge'], d_20, rtol, atol) if node_numbers == (1, 3): assert np.allclose(data['discharge'], d_13, rtol, atol) if node_numbers == (2, 3): assert np.allclose(data['discharge'], d_23, rtol, atol) d_11, d_21, d_22 = coupling_fluxes_2d_1d_cross_with_el() for e, data in gb_r.edges_props(): g1, g2 = gb_r.sorted_nodes_of_edge(e) pa = data['param'] node_numbers = gb_r.nodes_prop([g2, g1], 'node_number') if pa is not None: if node_numbers == (0, 1): assert np.allclose( data['discharge'], d_01, rtol, atol) or \ np.allclose( data['discharge'], d_10, rtol, atol) if node_numbers == (0, 2): assert np.allclose( data['discharge'], d_02, rtol, atol) or \ np.allclose( data['discharge'], d_20, rtol, atol) if node_numbers == (1, 1): assert np.allclose(data['discharge'], d_11, rtol, atol) if node_numbers == (2, 1): assert np.allclose(data['discharge'], d_21, rtol, atol) if node_numbers == (2, 2): assert np.allclose(data['discharge'], d_22, rtol, atol) # ... and pressures tol = 1e-10 assert ((np.amax(np.absolute(p - p_cond))) < tol) assert (np.sum( error.error_L2(g, d['pressure'], d['p_cond']) for g, d in gb) < tol)