def test_assembly_inner_product_2_forms(self): """Test the assembly of 1-forms inner products.""" func_space_lob = FunctionSpace(self.mesh, '2-lobatto', self.p) func_space_gauss = FunctionSpace(self.mesh, '2-gauss', self.p) func_space_extgauss = FunctionSpace(self.mesh, '2-ext_gauss', self.p) basis_lob = BasisForm(func_space_lob) basis_lob.quad_grid = 'gauss' M_lob = inner(basis_lob, basis_lob) basis_gauss = BasisForm(func_space_gauss) basis_gauss.quad_grid = 'lobatto' M_gauss = inner(basis_gauss, basis_gauss) basis_ext_gauss = BasisForm(func_space_extgauss) print(basis_ext_gauss.num_basis) basis_ext_gauss.quad_grid = 'lobatto' M_extgauss = inner(basis_ext_gauss, basis_ext_gauss) M_lob_ass_ref = assemble_slow(self.mesh, M_lob, func_space_lob.dof_map.dof_map, func_space_lob.dof_map.dof_map) M_gauss_ass_ref = assemble_slow(self.mesh, M_gauss, func_space_gauss.dof_map.dof_map, func_space_gauss.dof_map.dof_map) M_extgauss_ass_ref = assemble_slow( self.mesh, M_extgauss, func_space_extgauss.dof_map.dof_map_internal, func_space_extgauss.dof_map.dof_map_internal) M_lob_ass = assemble(M_lob, func_space_lob, func_space_lob).toarray() M_gauss_ass = assemble(M_gauss, func_space_gauss, func_space_gauss).toarray() M_extgauss_ass = assemble(M_extgauss, func_space_extgauss, func_space_extgauss).toarray() npt.assert_array_almost_equal(M_lob_ass_ref, M_lob_ass) npt.assert_array_almost_equal(M_gauss_ass_ref, M_gauss_ass) npt.assert_array_almost_equal(M_extgauss_ass_ref, M_extgauss_ass)
def test_basis_input(self): """Test the coboundary operator with some basis as inputs.""" p_x, p_y = 2, 2 func_space_0 = FunctionSpace(self.mesh, '0-lobatto', (p_x, p_y), is_inner=False) func_space_1 = FunctionSpace(self.mesh, '1-lobatto', (p_x, p_y), is_inner=False) func_space_2 = FunctionSpace(self.mesh, '2-lobatto', (p_x, p_y), is_inner=False) basis_0_ref = BasisForm(func_space_0) basis_1_ref = BasisForm(func_space_1) basis_0_ref.quad_grid = 'lobatto' basis_1_ref.quad_grid = 'gauss' basis_2_ref = BasisForm(func_space_2) basis_2_ref.quad_grid = 'lobatto' e_21_ref = d_21_lobatto_outer((p_x, p_y)) e_10_ref = d_10_lobatto_outer((p_x, p_y)) basis_1, e_10 = d(basis_0_ref) basis_1.quad_grid = 'gauss' basis_2, e_21 = d(basis_1_ref) basis_2.quad_grid = 'lobatto' M_1 = inner(basis_1, basis_1) M_1_ref = inner(basis_1_ref, basis_1_ref) npt.assert_array_almost_equal(M_1_ref, M_1) M_2 = inner(basis_2, basis_2) M_2_ref = inner(basis_2_ref, basis_2_ref) npt.assert_array_almost_equal(M_2_ref, M_2) npt.assert_array_equal(e_21_ref, e_21) npt.assert_array_equal(e_10_ref, e_10)
def test_basis_inner(self): """Test inner product with basis functions.""" p_x, p_y = 2, 2 func_space_0 = FunctionSpace(self.mesh, '0-lobatto', (p_x, p_y)) func_space_1 = FunctionSpace(self.mesh, '1-lobatto', (p_x, p_y)) basis_0 = BasisForm(func_space_0) basis_1 = BasisForm(func_space_1) basis_1.quad_grid = 'lobatto' basis_0.quad_grid = 'lobatto' M_1 = inner(basis_1, basis_1) e_10 = d(func_space_0) inner_prod_ref = np.tensordot(e_10, M_1, axes=((0), (0))) # inner_prod = inner(d(basis_0), basis_1) npt.assert_array_almost_equal(inner_prod_ref, inner_prod) # inner_prod_1_ref = np.rollaxis( np.tensordot(M_1, e_10, axes=((0), (0))), 2) inner_prod_1 = inner(basis_1, d(basis_0)) npt.assert_array_almost_equal(inner_prod_1_ref, inner_prod_1) # inner_prod_2_ref = np.tensordot(e_10, np.tensordot(e_10, M_1, axes=((0), (0))), axes=((0), (1))) inner_prod_2 = inner(d(basis_0), d(basis_0)) # npt.assert_array_almost_equal(inner_prod_2_ref, inner_prod_2)
def test_multiple_elements(self): """Test the anysotropic case in multiple element.""" p = (6, 6) is_inner = False crazy_mesh = CrazyMesh(2, (8, 5), ((-1, 1), (-1, 1)), curvature=0.1) func_space_2_lobatto = FunctionSpace(crazy_mesh, '2-lobatto', p, is_inner) func_space_1_lobatto = FunctionSpace(crazy_mesh, '1-lobatto', p, is_inner) func_space_1_lobatto.dof_map.continous_dof = True def diffusion_11(x, y): return 4 * np.ones(np.shape(x)) def diffusion_12(x, y): return 3 * np.ones(np.shape(x)) def diffusion_22(x, y): return 5 * np.ones(np.shape(x)) def source(x, y): return -36 * np.pi ** 2 * np.sin(2 * np.pi * x) * np.sin(2 * np.pi * y) + 24 * np.pi ** 2 * np.cos(2 * np.pi * x) * np.cos(2 * np.pi * y) # mesh function to inject the anisotropic tensor mesh_k = MeshFunction(crazy_mesh) mesh_k.continous_tensor = [diffusion_11, diffusion_12, diffusion_22] # definition of the basis functions basis_1 = BasisForm(func_space_1_lobatto) basis_1.quad_grid = 'gauss' basis_2 = BasisForm(func_space_2_lobatto) basis_2.quad_grid = 'gauss' # solution form phi_2 = Form(func_space_2_lobatto) phi_2.basis.quad_grid = 'gauss' form_source = Form(func_space_2_lobatto) form_source.discretize(source, ('gauss', 30)) # find inner product M_1k = inner(basis_1, basis_1, mesh_k) N_2 = inner(d(basis_1), basis_2) M_2 = inner(basis_2, basis_2) # assemble M_1k = assemble(M_1k, func_space_1_lobatto) N_2 = assemble(N_2, (func_space_1_lobatto, func_space_2_lobatto)) M_2 = assemble(M_2, func_space_2_lobatto) lhs = sparse.bmat([[M_1k, N_2], [N_2.transpose(), None]]).tocsc() rhs_source = (form_source.cochain @ M_2)[:, np.newaxis] rhs_zeros = np.zeros(lhs.shape[0] - np.size(rhs_source))[:, np.newaxis] rhs = np.vstack((rhs_zeros, rhs_source)) solution = sparse.linalg.spsolve(lhs, rhs) phi_2.cochain = solution[-func_space_2_lobatto.num_dof:] # sample the solution xi = eta = np.linspace(-1, 1, 200) phi_2.reconstruct(xi, eta) (x, y), data = phi_2.export_to_plot() plt.contourf(x, y, data) plt.show() print("max value {0} \nmin value {1}" .format(np.max(data), np.min(data))) npt.assert_array_almost_equal(self.solution(x, y), data, decimal=2)
def test_single_element(self): """Test the anysotropic case in a single element.""" dim = 2 elements_layout = (1, 1) bounds_domain = ((-1, 1), (-1, 1)) curvature = 0.1 p = (20, 20) is_inner = False crazy_mesh = CrazyMesh(dim, elements_layout, bounds_domain, curvature) func_space_2_lobatto = FunctionSpace(crazy_mesh, '2-lobatto', p, is_inner) func_space_1_lobatto = FunctionSpace(crazy_mesh, '1-lobatto', p, is_inner) def diffusion_11(x, y): return 4 * np.ones(np.shape(x)) def diffusion_12(x, y): return 3 * np.ones(np.shape(x)) def diffusion_22(x, y): return 5 * np.ones(np.shape(x)) mesh_k = MeshFunction(crazy_mesh) mesh_k.continous_tensor = [diffusion_11, diffusion_12, diffusion_22] basis_1 = BasisForm(func_space_1_lobatto) basis_1.quad_grid = 'gauss' basis_2 = BasisForm(func_space_2_lobatto) basis_2.quad_grid = 'gauss' phi_2 = Form(func_space_2_lobatto) phi_2.basis.quad_grid = 'gauss' M_1k = inner(basis_1, basis_1, mesh_k) N_2 = inner(basis_2, d(basis_1)) def source(x, y): return -36 * np.pi ** 2 * np.sin(2 * np.pi * x) * np.sin(2 * np.pi * y) + 24 * np.pi ** 2 * np.cos(2 * np.pi * x) * np.cos(2 * np.pi * y) form_source = Form(func_space_2_lobatto) form_source.discretize(source) M_2 = inner(basis_2, basis_2) lhs = np.vstack((np.hstack((M_1k[:, :, 0], N_2[:, :, 0])), np.hstack( (np.transpose(N_2[:, :, 0]), np.zeros((np.shape(N_2)[1], np.shape(N_2)[1])))))) rhs = np.zeros((np.shape(lhs)[0], 1)) rhs[-np.shape(M_2)[0]:] = form_source.cochain @ M_2 phi_2.cochain = np.linalg.solve(lhs, rhs)[-phi_2.basis.num_basis:].flatten() xi = eta = np.linspace(-1, 1, 200) phi_2.reconstruct(xi, eta) (x, y), data = phi_2.export_to_plot() print("max value {0} \nmin value {1}" .format(np.max(data), np.min(data))) npt.assert_array_almost_equal(self.solution(x, y), data, decimal=2)
def test_weighted_inner_continous(self): """Test for weighted inner product.""" mesh = CrazyMesh(2, (2, 2), ((-1, 1), (-1, 1)), curvature=0.2) func_space = FunctionSpace(mesh, '1-lobatto', (3, 4)) basis = BasisForm(func_space) basis.quad_grid = 'gauss' K = MeshFunction(mesh) K.continous_tensor = [diff_tens_11, diff_tens_12, diff_tens_22] M_1_weighted = inner(basis, basis, K) M_1 = inner(basis, basis) npt.assert_array_almost_equal(M_1, M_1_weighted)
def test_inner(self): list_cases = [ 'p2_n2-2', 'p2_n3-2', 'p5_n1-10', 'p10_n2-2', 'p13_n12-8' ] p = [2, 2, 5, 10, 13] n = [(2, 2), (3, 2), (1, 10), (2, 2), (12, 8)] curvature = [0.1, 0.1, 0.1, 0.1, 0.1] for i, case in enumerate(list_cases[:-1]): print("Test case n : ", i) # basis = basis_forms. # print("theo size ", (p[i] + 1)**2 * # (p[i] + 1)**2 * n[i][0] * n[i][1]) M_2_ref = np.loadtxt( os.getcwd() + '/src/tests/test_M_2/M_2_' + case + '.dat', delimiter=',').reshape((p[i])**2, n[i][0] * n[i][1], (p[i])**2) # print("actual size ", np.size(M_0_ref)) # print(np.shape(M_0_ref)) my_mesh = CrazyMesh(2, n[i], ((-1, 1), (-1, 1)), curvature=curvature[i]) function_space = FunctionSpace(my_mesh, '2-lobatto', p[i]) basis_0 = BasisForm(function_space) basis_0.quad_grid = 'lobatto' basis_1 = BasisForm(function_space) basis_1.quad_grid = 'lobatto' M_2 = inner(basis_0, basis_1) # print("REF ------------------ \n", M_2_ref[:, 0, :]) # print("CALCULATED _----------------\n", M_2[:, :, 0]) for el in range(n[i][0] * n[i][1]): npt.assert_array_almost_equal(M_2_ref[:, el, :], M_2[:, :, el], decimal=7)
def multiple_element(): mesh = CrazyMesh(2, (5, 7), ((-1, 1), (-1, 1)), curvature=0.3) p = 10, 10 func_space_vort = FunctionSpace(mesh, '0-ext_gauss', (p[0] - 1, p[1] - 1), is_inner=False) func_space_outer_vel = FunctionSpace( mesh, '1-total_ext_gauss', (p[0], p[1]), is_inner=False) # func_space_outer_vel = FunctionSpace( # mesh, '1-gauss', (p[0], p[1]), is_inner=False) func_space_inner_vel = FunctionSpace(mesh, '1-lobatto', p, is_inner=True) func_space_inner_vel.dof_map.continous_dof = True func_space_source = FunctionSpace(mesh, '2-lobatto', p, is_inner=True) basis_vort = BasisForm(func_space_vort) basis_vel_in = BasisForm(func_space_inner_vel) basis_vel_in.quad_grid = 'lobatto' basis_vel_out = BasisForm(func_space_outer_vel) basis_vel_out.quad_grid = 'lobatto' basis_2 = BasisForm(func_space_source) psi = Form(func_space_vort) u_in = Form(func_space_inner_vel) source = Form(func_space_source) source.discretize(ffun) M_1 = inner(basis_vel_in, basis_vel_in) E_21_in = d(func_space_inner_vel) W_02 = basis_2.wedged(basis_vort) W_02_E21 = np.transpose(W_02 @ E_21_in) M_1 = assemble(M_1, (func_space_inner_vel, func_space_inner_vel)) print(np.shape(M_1)) W_02_E21 = assemble(W_02_E21, (func_space_inner_vel, func_space_vort)) print(np.shape(W_02_E21)) W_02 = assemble(W_02, (func_space_source, func_space_vort)) lhs = spr.bmat([[M_1, W_02_E21], [W_02_E21.transpose(), None]]) print(np.shape(lhs)) rhs = np.zeros(np.shape(lhs)[0]) rhs[-func_space_source.num_dof:] = W_02 @ source.cochain solution = spr.linalg.spsolve(lhs.tocsc(), rhs) u_in.cochain = solution[:func_space_inner_vel.num_dof] cochian_psi = np.zeros(func_space_vort.num_dof) cochian_psi[:func_space_vort.num_internal_dof] = solution[-func_space_vort.num_internal_dof:] psi.cochain = cochian_psi xi = eta = np.linspace(-1, 1, 40) u_in.reconstruct(xi, eta) (x, y), u_x, u_y = u_in.export_to_plot() plt.contourf(x, y, u_x) plt.colorbar() plt.title("u_x inner") plt.show() psi.reconstruct(xi, eta) (x, y), psi_value = psi.export_to_plot() plt.contourf(x, y, psi_value) plt.title("psi outer" ) plt.colorbar() plt.show()
def test_inner(self): list_cases = [ 'p2_n2-2', 'p2_n3-2', 'p5_n1-10', 'p10_n2-2', 'p18_n14-14' ] p = [2, 2, 5, 10, 18] n = [(2, 2), (3, 2), (1, 10), (2, 2), (14, 10)] curvature = [0.2, 0.1, 0.2, 0.2, 0.2] for i, case in enumerate(list_cases[:-1]): print("Test case n : ", i) # basis = basis_forms. # print("theo size ", (p[i] + 1)**2 * # (p[i] + 1)**2 * n[i][0] * n[i][1]) M_0_ref = np.loadtxt( os.getcwd() + '/src/tests/test_M_0/M_0_' + case + '.dat', delimiter=',').reshape((p[i] + 1)**2, n[i][0] * n[i][1], (p[i] + 1)**2) # print(np.shape(M_0_ref)) my_mesh = CrazyMesh(2, n[i], ((-1, 1), (-1, 1)), curvature=curvature[i]) function_space = FunctionSpace(my_mesh, '0-lobatto', p[i]) basis = BasisForm(function_space) basis.quad_grid = 'lobatto' basis_1 = BasisForm(function_space) basis_1.quad_grid = 'lobatto' M_0 = inner(basis, basis_1) for el in range(n[i][0] * n[i][1]): npt.assert_array_almost_equal(M_0_ref[:, el, :], M_0[:, :, el], decimal=4)
def hodge_from_func_space(function_space, extend): """Calculate the hodge matrix from the function space.""" dual_space = DualSpace(function_space, extend) dual_form = Form(dual_space) form = Form(function_space) wedge_prod = form.basis.wedged(dual_form.basis) inner_prod = inner(dual_form.basis, dual_form.basis) inverse_inner = inv(np.rollaxis(inner_prod, 2, 0)) hodge_matrix = np.tensordot(inverse_inner, wedge_prod, axes=((2), (0))) hodge_matrix = np.moveaxis(hodge_matrix, 0, -1) return hodge_matrix
def hodge_from_form(form, extend): """Calculate the hodge matrix and resulting form.""" dual_space = DualSpace(form.function_space, extend) dual_form = Form(dual_space) wedge_prod = form.basis.wedged(dual_form.basis) inner_prod = inner(dual_form.basis, dual_form.basis) inverse_inner = inv(np.rollaxis(inner_prod, 2, 0)) hodge_matrix = np.tensordot(inverse_inner, wedge_prod, axes=((2), (0))) dual_form.cochain_local = np.einsum('kij,jk->ik', hodge_matrix, form.cochain_local) hodge_matrix = np.moveaxis(hodge_matrix, 0, -1) return dual_form, hodge_matrix
def test_inner(self): """Test inner product of one forms.""" list_cases = ['p2_n2-2', 'p2_n3-2', 'p5_n1-10', 'p10_n2-2', 'p13_n12-8'] p = [2, 2, 5, 10, 13] n = [(2, 2), (3, 2), (1, 10), (2, 2), (12, 8)] curvature = [0.1, 0.1, 0.1, 0.1, 0.1] for i, case in enumerate(list_cases[:-1]): M_1_ref = np.loadtxt( os.getcwd() + '/src/tests/test_M_1/M_1k_' + case + '.dat', delimiter=',').reshape(2 * p[i] * (p[i] + 1), n[i][0] * n[i][1], 2 * p[i] * (p[i] + 1)) my_mesh = CrazyMesh( 2, n[i], ((-1, 1), (-1, 1)), curvature=curvature[i]) function_space = FunctionSpace(my_mesh, '1-lobatto', p[i]) form = BasisForm(function_space) form.quad_grid = 'gauss' form_1 = BasisForm(function_space) form_1.quad_grid = 'gauss' K = MeshFunction(my_mesh) K.continous_tensor = [diff_tens_11, diff_tens_12, diff_tens_22] M_1 = inner(form, form_1, K) for el in range(n[i][0] * n[i][1]): npt.assert_array_almost_equal( M_1_ref[:, el, :], M_1[:, :, el])
for j in range(px): vol_id = px**2 + j edge_id = px * (px + 1) + j virtual_E21[vol_id - px**2, edge_id] = 1 virtual_E21[vol_id - px**2 + px, edge_id + px**2] = -1 for i in range(px): vol_id = px**2 + 2 * px + i edge_id = (px + 1) * i virtual_E21[vol_id - px**2, edge_id] = 1 virtual_E21[vol_id - px**2 + px, edge_id + px] = -1 # define the mass and wedge matrices M_1 = inner(basis_1, basis_1) M1_assembled = assemble(M_1, (func_space_1_lobatto, func_space_1_lobatto)) W_i_2 = basis_2.wedged(basis_0) Wi_2_E_21 = np.dot(W_i_2, E21) lhs = sparse.bmat( [[M1_assembled, Wi_2_E_21.transpose(), virtual_E21.transpose()], [Wi_2_E_21, None, None], [virtual_E21, None, None]]).tolil() rhs_1 = np.zeros(2 * px * (px + 1)) rhs_2 = np.dot(W_i_2, source_form.cochain) rhs_3 = np.zeros(4 * px) rhs = np.hstack((rhs_1, rhs_2, rhs_3))
for j in range(px): vol_id = px**2 + j edge_id = px * (px + 1) + j virtual_E21[vol_id - px**2, edge_id] = 1 virtual_E21[vol_id - px**2 + px, edge_id + px**2] = -1 for i in range(px): vol_id = px**2 + 2 * px + i edge_id = (px + 1) * i virtual_E21[vol_id - px**2, edge_id] = 1 virtual_E21[vol_id - px**2 + px, edge_id + px] = -1 # define the mass and wedge matrices # anisotropic_tensor = M_1 = inner(basis_1, basis_1, anisotropic_tensor) M1_assembled = assemble(M_1, (func_space_1_lobatto, func_space_1_lobatto)) W_i_2 = basis_2.wedged(basis_0) Wi_2_E_21 = np.dot(W_i_2, E21) lhs = sparse.bmat([[M1_assembled, Wi_2_E_21.transpose(), virtual_E21.transpose()], [ Wi_2_E_21, None, None], [virtual_E21, None, None]]).tolil() rhs_1 = np.zeros(2 * px * (px + 1)) rhs_2 = np.dot(W_i_2, source_form.cochain) rhs_3 = np.zeros(4 * px) rhs = np.hstack((rhs_1, rhs_2, rhs_3)) # implementing BC's
#Wn0_assembled = assemble_(mesh, Wn0, f2.function_space.dof_map.dof_map, # p0.function_space.dof_map.dof_map_internal,mode='add') # #Mn = inner ( f2.basis, f2.basis) #Mn_assembled = assemble(Mn, f2.function_space, f2.function_space) # #M0 = inner ( p0.basis , p0.basis) #M0_assembled = assemble(M0, p0.function_space, p0.function_space) # #H11 = hodge (func_space_gl1) #H11_assembled = -assemble(H11, ui.function_space,uo.function_space) #ui_num_dof_internal = ui.basis.num_basis * ui.mesh.num_elements p0_num_dof_internal = p0.basis.num_basis * ui.mesh.num_elements # %% LHS 11 Mnm1 = inner(uo.basis, uo.basis) Mnm1_assembled = assemble(Mnm1, uo.function_space, uo.function_space) # %% LHS 21 W0n = f2.basis.wedged(p0.basis) W0n_assembled = assemble_(mesh, W0n, p0.function_space.dof_map.dof_map_internal, f2.function_space.dof_map.dof_map, mode='add') E21 = d(func_space_gl1) #E21_assembled = assemble_(mesh, E21, f2.function_space.dof_map.dof_map, # uo.function_space.dof_map.dof_map, mode='replace') LHS21_local = W0n.dot(E21)
def multiple_element_v1(): mesh = CrazyMesh(2, (1, 1), ((-1, 1), (-1, 1)), curvature=0.0) p = 4, 4 func_space_vort = FunctionSpace(mesh, '0-lobatto', p, is_inner=False) func_space_outer_vel = FunctionSpace( mesh, '1-lobatto', p, is_inner=False) func_space_outer_vel.dof_map.continous_dof = True # func_space_outer_vel = FunctionSpace( # mesh, '1-gauss', (p[0], p[1]), is_inner=False) func_space_inner_vel = FunctionSpace( mesh, '1-gauss', (p[0], p[1]), is_inner=True) print('dof gauss :', func_space_inner_vel.num_dof) func_space_inner_vel.dof_map.continous_dof = False func_space_source = FunctionSpace(mesh, '2-gauss', (p[0] + 1, p[1] + 1), is_inner=True) print("dof source :", func_space_source.num_dof) basis_vort = BasisForm(func_space_vort) basis_vel_in = BasisForm(func_space_inner_vel) basis_vel_in.quad_grid = 'lobatto' basis_vel_out = BasisForm(func_space_outer_vel) basis_vel_out.quad_grid = 'lobatto' basis_2 = BasisForm(func_space_source) psi = Form(func_space_vort) u_in = Form(func_space_inner_vel) source = Form(func_space_source) source.discretize(ffun) M_1 = inner(basis_vel_in, basis_vel_in) # E_21_in = d(func_space_inner_vel) W_02 = basis_2.wedged(basis_vort) W_11 = basis_vel_in.wedged(basis_vel_out) E_10_out = d(func_space_vort) print(np.shape(W_11), np.shape(E_10_out)) W_E = W_11 @ E_10_out W_11_inv = basis_vel_out.wedged(basis_vel_in) E_W = np.transpose(E_10_out) @ W_11_inv print("shape ew : ", np.shape(W_E)) print(np.shape(W_02)) M_1 = assemble(M_1, (func_space_inner_vel, func_space_inner_vel)) print(func_space_source.num_local_dof) W_E = assemble(W_E, (func_space_outer_vel, func_space_vort)) E_W = assemble(E_W, (func_space_vort, func_space_outer_vel)) W_02 = assemble(W_02, (func_space_vort, func_space_source)) lhs = spr.bmat([[M_1, W_E], [W_E.transpose(), None]]) rhs = np.zeros(np.shape(lhs)[0]) rhs[-func_space_source.num_dof:] = W_02 @ source.cochain solution = spr.linalg.spsolve(lhs.tocsc(), rhs) u_in.cochain = solution[:func_space_inner_vel.num_dof] psi.cochain = solution[-func_space_vort.num_dof:] xi = eta = np.linspace(-1, 1, 40) u_in.reconstruct(xi, eta) (x, y), u_x, u_y = u_in.export_to_plot() plt.contourf(x, y, u_x) plt.colorbar() plt.title("u_x inner") plt.show() psi.reconstruct(xi, eta) (x, y), psi_value = psi.export_to_plot() plt.contourf(x, y, psi_value) plt.title("psi outer") plt.colorbar() plt.show()
def solver(p, n, c): print("----------------------------------------------------") print('p=', p, ';n=', n, ';c=', c, ':') px = py = p nx = ny = n mesh = CrazyMesh(2, (nx, ny), ((0, 1), (0, 1)), c) # xi = eta = np.linspace( -1, 1, np.ceil(100 / (nx * ny)) + 1 ) # %% define function space # func_space_g0 = FunctionSpace(mesh, '0-gauss' , (px + 1, py + 1), is_inner=False) # func_space_g1 = FunctionSpace(mesh, '1-gauss' , (px + 1, py + 1), is_inner=False) func_space_gl0 = FunctionSpace(mesh, '0-lobatto', (px + 1, py + 1), is_inner=False, separated_dof=False) func_space_gl1 = FunctionSpace(mesh, '1-lobatto', (px + 1, py + 1), is_inner=False) func_space_gl2 = FunctionSpace(mesh, '2-lobatto', (px + 1, py + 1), is_inner=False) func_space_eg0 = FunctionSpace(mesh, '0-ext_gauss', (px, py)) # func_space_eg1 = FunctionSpace(mesh, '1-ext_gauss', (px, py)) # func_space_eg2 = FunctionSpace(mesh, '2-ext_gauss', (px, py)) # %% un1 = Form(func_space_gl1) f0 = Form(func_space_eg0) fn = Form(func_space_gl2) wn2 = Form(func_space_gl0) #wn2 = Form(func_space_g0) un1_exact = Form(func_space_gl1) un1_exact.discretize((v, u)) rn1 = Form(func_space_gl1) rn1.discretize((r_v, r_u)) # %% LHS 24 and LHS 42 def d_21_lobatto_outer(p): px, py = p total_vol = px * py total_edges = px * (py + 1) + py * (px + 1) E21 = np.zeros((total_vol, total_edges)) for i in range(px): for j in range(py): volij = i * py + j edge_bottom = i * (py + 1) + j edge_top = i * (py + 1) + j + 1 edge_left = (py + 1) * px + i * py + j edge_right = (py + 1) * px + (i + 1) * py + j E21[volij, edge_left] = -1 E21[volij, edge_right] = +1 E21[volij, edge_bottom] = +1 E21[volij, edge_top] = -1 return E21 glE21 = d_21_lobatto_outer((px + 1, py + 1)) W0n = fn.basis.wedged(f0.basis) LHS13_local = W0n.dot(glE21) LHS31_local = LHS13_local.T Wb = integral1d_(1, ('lobatto_edge', p + 1), ('gauss_node', p + 1), ('gauss', p + 1)) LHS31_add = sparse.lil_matrix((2 * (p + 1) * (p + 2), 4 * (p + 1))) M = (p + 1) * (p + 2) N = p + 1 E = p + 2 for i in range(N): for j in range(N): # left LHS31_add[M + i, j] = +Wb[i, j] # right LHS31_add[-N + i, N + j] = -Wb[i, j] # bottom LHS31_add[i * E, 2 * N + j] = -Wb[i, j] # # top LHS31_add[(i + 1) * E - 1, 3 * N + j] = +Wb[i, j] LHS31_local = sparse.hstack((LHS31_local, LHS31_add)) LHS31 = assemble(LHS31_local.toarray(), (un1.function_space, f0.function_space)) LHS13_local = sparse.vstack((LHS13_local, LHS31_add.T)) LHS13 = sparse.lil_matrix( assemble(LHS13_local.toarray(), (f0.function_space, un1.function_space))) # %% LHS 11 f0.basis.quad_grid = ('gauss', px + 1) egM0 = inner(f0.basis, f0.basis) LHS11 = assemble(egM0, (func_space_eg0, func_space_eg0)) temp = sparse.lil_matrix( (f0.function_space.num_dof, f0.function_space.num_dof)) temp[0:f0.function_space.num_internal_dof, 0:f0.function_space.num_internal_dof] = LHS11 LHS11 = temp # %% LHS 22 wn2.basis.quad_grid = ('lobatto', px + 1) glMn2 = inner(wn2.basis, wn2.basis) LHS22 = assemble(glMn2, (func_space_gl0, func_space_gl0)) #wn2.basis.quad_grid = ( 'gauss', px+1 ) #glMn2 = inner(wn2.basis, wn2.basis) #LHS22 = assemble(glMn2, (func_space_g0, func_space_g0)) # %% LHS 23 , 32 def d_10_lobatto_outer(p): px, py = p total_edges = px * (py + 1) + py * (px + 1) total_nodes = (px + 1) * (py + 1) E10 = np.zeros((total_edges, total_nodes)) for i in range(px): for j in range(py + 1): edgeij = i * (py + 1) + j node_1 = i * (py + 1) + j node_2 = (i + 1) * (py + 1) + j E10[edgeij, node_1] = +1 E10[edgeij, node_2] = -1 for i in range(px + 1): for j in range(py): edgeij = px * (py + 1) + py * i + j node_1 = i * (py + 1) + j node_2 = i * (py + 1) + j + 1 E10[edgeij, node_1] = +1 E10[edgeij, node_2] = -1 return -E10 glE10 = d_10_lobatto_outer((px + 1, py + 1)) glE10 = assemble(glE10, (func_space_gl1, func_space_gl0)) glMn1 = inner(un1.basis, un1.basis) glMn1 = assemble(glMn1, (func_space_gl1, func_space_gl1)) LHS32 = glMn1.dot(glE10) LHS23 = LHS32.T #def d_10_gauss_outer(p): # px, py = p # total_edges = px * (py + 1) + py * (px + 1) # total_nodes = (px + 1) * (py + 1) # E10 = np.zeros((total_edges, total_nodes)) # # for i in range(px): # for j in range(py + 1): # edgeij = i * (py + 1) + j # node_1 = i * (py + 1) + j # node_2 = (i + 1) * (py + 1) + j # # E10[edgeij, node_1] = +1 # E10[edgeij, node_2] = -1 # # for i in range(px + 1): # for j in range(py): # edgeij = px * (py + 1) + py * i + j # node_1 = i * (py + 1) + j # node_2 = i * (py + 1) + j + 1 # # E10[edgeij, node_1] = +1 # E10[edgeij, node_2] = -1 # # return -E10 # #glE10 = d_10_gauss_outer((px+1, py+1)) #glE10 = assemble(glE10, (func_space_g1, func_space_g0)) # #glMn1 = inner(un1.basis, Form(func_space_g1).basis ) #glMn1 = assemble(glMn1, (func_space_gl1, func_space_g1)) #LHS32 = glMn1.dot(glE10) #LHS23 = LHS32.T # %% boundary edges def lobatto_boundary_edges(mesh, p, gathering_matrix): nx = mesh.n_x ny = mesh.n_y Left = np.zeros(shape=(ny * (p)), dtype=np.int32) Right = np.zeros(shape=(ny * (p)), dtype=np.int32) Bottom = np.zeros(shape=(nx * (p)), dtype=np.int32) Top = np.zeros(shape=(nx * (p)), dtype=np.int32) M = p * (p + 1) N = p for J in range(ny): eleidLeft = J Left[J * N:J * N + N] = gathering_matrix[eleidLeft, M:M + N] eleidRight = (nx - 1) * ny + J Right[J * N:J * N + N] = gathering_matrix[eleidRight, -N:] for I in range(nx): eleidBottom = I * ny Bottom[I * N:I * N + N] = gathering_matrix[eleidBottom, 0:M:N + 1] eleidTop = I * ny + ny - 1 Top[I * N:I * N + N] = gathering_matrix[eleidTop, N:M:N + 1] return Left, Right, Bottom, Top eLeft, eRight, eBottom, eTop = lobatto_boundary_edges( mesh, p + 1, un1.function_space.dof_map.dof_map) def ext_gauss_boundary_points(mesh, p, gathering_matrix): nx = mesh.n_x ny = mesh.n_y Left = np.zeros(shape=(ny * p), dtype=np.int16) Right = np.zeros(shape=(ny * p), dtype=np.int16) Bottom = np.zeros(shape=(nx * p), dtype=np.int16) Top = np.zeros(shape=(nx * p), dtype=np.int16) for J in range(ny): eleidLeft = J Left[J * p:J * p + p] = gathering_matrix[eleidLeft, p**2:p**2 + p] eleidRight = (nx - 1) * ny + J Right[J * p:J * p + p] = gathering_matrix[eleidRight, p**2 + p:p**2 + 2 * p] for I in range(nx): eleidBottom = I * ny Bottom[I * p:I * p + p] = gathering_matrix[eleidBottom, p**2 + 2 * p:p**2 + 3 * p] eleidTop = I * ny + ny - 1 Top[I * p:I * p + p] = gathering_matrix[eleidTop, p**2 + 3 * p:p**2 + 4 * p] return Left, Right, Bottom, Top nLeft, nRight, nBottom, nTop = ext_gauss_boundary_points( mesh, p + 1, f0.function_space.dof_map.dof_map) RHS1 = np.zeros(shape=(f0.function_space.num_dof, 1)) for i in range(np.size(nLeft)): LHS13[nLeft[i], :] = 0 LHS13[nLeft[i], eLeft[i]] = 1 RHS1[nLeft[i]] = un1_exact.cochain[eLeft[i]] LHS13[nRight[i], :] = 0 LHS13[nRight[i], eRight[i]] = 1 RHS1[nRight[i]] = un1_exact.cochain[eRight[i]] LHS13[nBottom[i], :] = 0 LHS13[nBottom[i], eBottom[i]] = 1 RHS1[nBottom[i]] = un1_exact.cochain[eBottom[i]] LHS13[nTop[i], :] = 0 LHS13[nTop[i], eTop[i]] = 1 RHS1[nTop[i]] = un1_exact.cochain[eTop[i]] # %% LHS = sparse.bmat([[ LHS11, sparse.csc_matrix( (f0.function_space.num_dof, wn2.function_space.num_dof)), LHS13 ], [ sparse.csc_matrix((wn2.function_space.num_dof, f0.function_space.num_dof)), LHS22, -LHS23 ], [ LHS31, -LHS32, sparse.csc_matrix((un1.function_space.num_dof, un1.function_space.num_dof)) ]]) # %% RHS2 RHS2 = np.zeros(shape=(wn2.function_space.num_dof, 1)) # %% RHS3 RHS3 = glMn1.dot(rn1.cochain) RHS3 = np.expand_dims(RHS3, axis=1) #%% solve it RHS = np.vstack((RHS1, RHS2, RHS3)) print("LHS shape:", np.shape(LHS)) # LHS = sparse.csr_matrix(LHS) print("------ solve the square sparse system:......") Res = sparse.linalg.spsolve(LHS, RHS) # %% split the Res f0.cochain = Res[:f0.function_space.num_dof].reshape( f0.function_space.num_dof) wn2.cochain = Res[f0.function_space. num_dof:-un1.function_space.num_dof].reshape( wn2.function_space.num_dof) un1.cochain = Res[-un1.function_space.num_dof:].reshape( un1.function_space.num_dof) # %% #f0.reconstruct(xi, eta) #(x, y), data = f0.export_to_plot() #plt.contourf(x, y, data) #plt.title("3). ext_gauss \\tilde{f}^{(0)}") #plt.colorbar() #plt.show() # #wn2.reconstruct(xi, eta) #(x, y), data = wn2.export_to_plot() #plt.contourf(x, y, data) #plt.title('8). lobatto w^{(n-2)}') #plt.colorbar() #plt.show() # #un1.reconstruct(xi, eta) #(x, y), data_dx, data_dy = un1.export_to_plot() #plt.contourf(x, y, data_dx) #plt.title('1.1). lobatto u^{(n-1)} dx') #plt.colorbar() #plt.show() # #plt.contourf(x, y, data_dy) #plt.title('1.2). lobatto u^{(n-1)} dy') #plt.colorbar() #plt.show() # %% L2_error_un1 = un1.l_2_norm((v, u), ('lobatto', p + 5))[0] def wn2_fun(x, y): return 0 * x * y L2_error_wn2 = wn2.l_2_norm(wn2_fun, ('lobatto', p + 5))[0] def f0_fun(x, y): return 4 * np.pi * np.sin(2 * np.pi * x) * np.sin(2 * np.pi * y) L2_error_f0 = f0.l_2_norm(f0_fun, ('gauss', p + 5))[0] print("------ L2_error_un1 =", L2_error_un1) print("------ L2_error_wn2 =", L2_error_wn2) print("------ L2_error_f0 =", L2_error_f0) return L2_error_un1, L2_error_wn2, L2_error_f0
# -*- coding: utf-8 -*- """ (SHORT NAME EXPLANATION) """ from mesh import CrazyMesh from function_space import FunctionSpace from forms import Form from inner_product import inner mesh = CrazyMesh(2, (2, 2), ((-1, 1), (-1, 1)), 0.1) func_space_eg0 = FunctionSpace(mesh, '0-ext_gauss', (5, 5)) f0 = Form(func_space_eg0) #f0.basis.quad_grid = ('gauss',6) egM0 = inner(f0.basis, f0.basis)
def single_element(): mesh = CrazyMesh(2, (1, 1), ((-1, 1), (-1, 1)), curvature=0.1) p = 20, 20 func_space_vort = FunctionSpace(mesh, '0-ext_gauss', (p[0] - 1, p[1] - 1), is_inner=False) func_space_outer_vel = FunctionSpace( mesh, '1-ext_gauss', (p[0] - 2, p[1] - 2), is_inner=False) func_space_inner_vel = FunctionSpace(mesh, '1-lobatto', p, is_inner=True) func_space_source = FunctionSpace(mesh, '2-lobatto', p, is_inner=True) basis_vort = BasisForm(func_space_vort) basis_vel_in = BasisForm(func_space_inner_vel) basis_vel_out = BasisForm(func_space_outer_vel) basis_2 = BasisForm(func_space_source) psi = Form(func_space_vort) u_in = Form(func_space_inner_vel) source = Form(func_space_source) source.discretize(ffun) M_1 = inner(basis_vel_in, basis_vel_in) W_11 = basis_vel_out.wedged(basis_vel_in) E_10_ext = d(func_space_vort) E_21_in = d(func_space_inner_vel) W_02 = basis_vort.wedged(basis_2) print("shapes : \n \ M_1 : {0} \n \ W_11 : {1} \n \ E_10 : {2} \n \ E_21_in : {3} \n \ W_02 : {4} \n" .format(np.shape(M_1), np.shape(W_11), np.shape(E_10_ext), np.shape(E_21_in), np.shape(W_02))) # one element # print(func_space_inner_vel.num_dof, func_space_vort.num_dof) lhs_0 = np.hstack((M_1[:, :, 0], np.transpose(W_02 @ E_21_in))) col_size_0 = np.shape(lhs_0)[1] eW = W_02 @ E_21_in col_zeros = col_size_0 - np.shape(eW)[1] lhs_1 = np.hstack((eW, np.zeros( (func_space_source.num_dof, col_zeros)))) lhs = np.vstack((lhs_0, lhs_1)) rhs_source = (source.cochain @ W_02)[:, np.newaxis] rhs_zeros = np.zeros((np.shape(lhs)[0] - func_space_source.num_dof, 1)) rhs = np.vstack((rhs_zeros, rhs_source)) print(np.shape(lhs)) solution = np.linalg.solve(lhs, rhs).flatten() print(np.shape(solution)) print(func_space_vort.num_dof) u_in.cochain = solution[:func_space_inner_vel.num_dof] psi_zeros = np.zeros((func_space_vort.num_dof - func_space_vort.num_internal_local_dof)) psi.cochain = np.append(solution[func_space_inner_vel.num_dof:], np.zeros((func_space_vort.num_dof - func_space_vort.num_internal_local_dof))) xi = eta = np.linspace(-1, 1, 40) u_in.reconstruct(xi, eta) (x, y), u_x, u_y = u_in.export_to_plot() plt.contourf(x, y, u_x) plt.colorbar() plt.title("u_x inner") plt.show() psi.reconstruct(xi, eta) (x, y), psi_value = psi.export_to_plot() plt.contourf(x, y, psi_value) plt.title("psi outer" ) plt.colorbar() plt.show()
from scipy.integrate import quad from sympy import Matrix import scipy.io from scipy import sparse import scipy as sp from inner_product import inner # %% exact solution define # u^{(1)} = { u, v }^T def u(x,y): return +np.cos(np.pi*x) * np.sin(np.pi*y) def v(x,y): return -np.sin(np.pi*x) * np.cos(np.pi*y) def r_u(x,y): return -2* np.pi**2 * np.cos(np.pi*x) * np.sin(np.pi*y) def r_v(x,y): return 2* np.pi**2 * np.sin(np.pi*x) * np.cos(np.pi*y) # %% define the mesh mesh = CrazyMesh( 2, (2, 2), ((-1, 1), (-1, 1)), 0.05 ) func_space_gauss1 = FunctionSpace(mesh, '1-gauss', (5, 5), is_inner=False) func_space_lobatto1 = FunctionSpace(mesh, '1-lobatto', (5, 5), is_inner=False) form_1_gauss = Form(func_space_gauss1) form_1_lobatto = Form(func_space_lobatto1) M = inner(form_1_lobatto.basis,form_1_gauss.basis)
# # # solution = sparse.linalg.spsolve(lhs, rhs) # # phi_2.cochain = solution[-func_space_2_lobatto.num_dof:] # # # # # sample the solution # # xi = eta = np.linspace(-1, 1, 200) # # phi_2.reconstruct(xi, eta) # # (x, y), data = phi_2.export_to_plot() # # plt.contourf(x, y, data) # # plt.show() # # # # solve for unknowns M_1k = inner(basis_1, basis_1, anisotropic_tensor) N_2 = inner(basis_2, d(basis_1)) M_2 = inner(basis_2, basis_2) # assemble inner products M_1k = assemble(M_1k, func_space_1_lobatto) N_2 = assemble(N_2, (func_space_2_lobatto, func_space_1_lobatto)) M_2 = assemble(M_2, func_space_2_lobatto) lhs = sparse.bmat([[M_1k, N_2.transpose()], [N_2, None]]).tolil() rhs_source = (form_source.cochain @ M_2)[:, np.newaxis] rhs_zeros = np.zeros(lhs.shape[0] - np.size(rhs_source))[:, np.newaxis] rhs = np.vstack((rhs_zeros, rhs_source)) # print(func_space_1_lobatto.dof_map.dof_map_boundary) bottom, top, left, right = func_space_1_lobatto.dof_map.dof_map_boundary # flux = 0 lhs[bottom] = 0
def main(el, poly_degree): dim = 2 element_layout = (el + 1, el + 1) # print(element_layout) """define polynomial degree and inner/outer orientation""" pp = (poly_degree + 1, poly_degree + 1) # polynomial degree - primal mesh pd = (pp[0] - 1, pp[1] - 1) # polynomial degree - dual mesh orientation_inner = True outer = False # is_inner = False # orientation of primal mesh """define mesh""" bounds_domain = ((0, 1), (0, 1)) curvature = 0.0 mesh1 = CrazyMesh(dim, element_layout, bounds_domain, curvature) # gamma = (gamma1, gamma2, gamma3, gamma4) # dgamma = (dgamma1, dgamma2, dgamma3, dgamma4) # mesh1 = TransfiniteMesh(dim, element_layout, gamma, dgamma) """define function spaces used in problem""" fs_2_lobatto = FunctionSpace(mesh1, '2-lobatto', pp, outer) fs_1_lobatto = FunctionSpace(mesh1, '1-lobatto', pp, outer) fs_0_gauss = FunctionSpace(mesh1, '0-gauss', pd, inner) fs_1_lobatto.dof_map.continous_dof = True # continuous elements """define forms and quad grid""" """define (n) - source form""" f_source = Form(fs_2_lobatto) # form for source term f_source.discretize(source) f_source.basis.quad_grid = 'gauss' """define (n-1) - q form""" f_flux = Form(fs_1_lobatto) # form for flux terms f_flux.basis.quad_grid = 'lobatto' """define exact 0 - \phi form""" f_phi_exact = Form(fs_0_gauss) f_phi_exact.discretize(manufactured_solution) f_phi_exact.basis.quad_grid = 'gauss' """define unkown 0 - \phi form""" f_phi = Form(fs_0_gauss) f_phi.basis.quad_grid = 'gauss' """define anisotropic tensor as a mesh property""" # anisotropic_tensor = MeshFunction(mesh1) # anisotropic_tensor.discrete_tensor = [ # k_11(element_layout), k_12(element_layout), k_22(element_layout)] # mesh function to inject the anisotropic tensor anisotropic_tensor = MeshFunction(mesh1) anisotropic_tensor.continous_tensor = [k_11, k_12, k_22] # mesh_k = MeshFunction(crazy_mesh) # mesh_k.continous_tensor = [diffusion_11, diffusion_12, diffusion_22] """define basis functions""" basis_2 = BasisForm(fs_2_lobatto) basis_1 = BasisForm(fs_1_lobatto) basis_0 = BasisForm(fs_0_gauss) basis_2.quad_grid = 'gauss' basis_1.quad_grid = 'lobatto' basis_0.quad_grid = 'gauss' """general variables used frequently""" num_total_elements = element_layout[0] * element_layout[1] num_total_edges = fs_1_lobatto.num_dof num_total_faces = fs_2_lobatto.num_dof num_local_surfaces = fs_2_lobatto.num_local_dof dof_map_lobatto_faces = fs_2_lobatto.dof_map.dof_map """define 1-form mass matrix""" M1 = inner(basis_1, basis_1, anisotropic_tensor) M1_assembled = assemble(M1, (fs_1_lobatto, fs_1_lobatto)) """define the wedge product""" E21 = d_21_lobatto_outer(pp) W1 = basis_2.wedged(basis_0) W1_E21 = np.dot(W1, E21) W1_E21_local = np.repeat(W1_E21[:, :, np.newaxis], num_total_elements, axis=2) W1_E21_assembled = assemble(W1_E21_local, (fs_0_gauss, fs_1_lobatto)) """assemble lhs""" lhs = sparse.bmat([[M1_assembled, W1_E21_assembled.transpose()], [W1_E21_assembled, None]]).tolil() # A = np.linalg.det(lhs.todense()) # print(A) """assemble rhs""" rhs1 = np.zeros(num_total_edges)[:, np.newaxis] f_cochain_local = f_source.cochain_local[:, np.newaxis] W1_f_local = np.tensordot(W1, f_cochain_local, axes=1) rhs2 = assemble_cochain2(W1_f_local, dof_map_lobatto_faces, num_total_faces) rhs = np.vstack((rhs1, rhs2)) # print(time.time() - start_time) """implement boundary conditions""" """neuman boundary condition""" """dirichlet boundary condition""" """solve linear system of equations""" solution = sparse.linalg.spsolve(lhs.tocsc(), rhs) end_time = time.time() print("The total time taken by the program is : ", end_time - start_time) """l2 error""" """post processing / reconstruction""" eta_plot = xi_plot = xi = eta = np.linspace(-1, 1, 30) """reconstruct fluxes""" f_flux.cochain = solution[:fs_1_lobatto.num_dof] f_flux.reconstruct(xi, eta) (x_plot, y_plot), flux_x_plot, flux_y_plot = f_flux.export_to_plot() flux_x_plot, flux_y_plot = flux_y_plot, flux_x_plot """reconstruct potential""" f_phi.cochain = solution[fs_1_lobatto.num_dof:] f_phi.reconstruct(xi, eta) (x_plot, y_plot), phi_plot = f_phi.export_to_plot() phi_exact_plot = np.sin(2 * np.pi * x_plot) * np.sin(2 * np.pi * y_plot) """l2 - error in (div u -f)""" div_u_sum = np.zeros(num_total_elements) for ele_num in range(num_total_elements): l2_div_u = np.dot(E21, f_flux.cochain_local[:, ele_num] )[:, np.newaxis] - f_cochain_local[:, :, ele_num] div_u_sum[ele_num] = np.sum(l2_div_u) l2_err_div_u = np.linalg.norm(div_u_sum) l_inf_err_div_u = np.max(div_u_sum) """l2 - error in phi and flux """ l2_err_phi = f_phi.l_2_norm(phi_exact) l2_err_flux = f_flux.l_2_norm((flux_y_exact, flux_x_exact)) error = l2_err_phi, l2_err_flux, l2_err_div_u, l_inf_err_div_u print(l2_err_phi[0]) print(l2_err_flux[0]) # return error # plt.figure(1) plt.contourf(x_plot, y_plot, flux_x_plot) plt.colorbar() # # plt.figure(2) # plt.contourf(x_plot, y_plot, flux_x_exact_plot) # plt.colorbar() # print(np.max(flux_x_exact_plot), np.min(flux_x_exact_plot)) # print(np.max(flux_x_plot), np.min(flux_x_plot)) # plt.figure(3) plt.contourf(x_plot, y_plot, flux_y_plot) plt.colorbar() # # plt.figure(4) # plt.contourf(x_plot, y_plot, flux_y_exact_plot) # plt.colorbar() # print(np.max(flux_y_exact_plot), np.min(flux_y_exact_plot)) # print(np.max(flux_y_plot), np.min(flux_y_plot)) # plt.figure(5) plt.contourf(x_plot, y_plot, phi_plot) plt.colorbar() # plt.figure(6) # plt.contourf(x_plot, y_plot, phi_exact_plot) # plt.colorbar() # print(np.max(phi_exact_plot), np.min(phi_exact_plot)) # print(np.max(phi_plot), np.min(phi_plot)) plt.show()