def test_weighted_metric(self): # TODO: figure out why if the metric tensor is set to ones the result is very different """Compare weighted and unweighted metric terms with K set to identity.""" mesh = CrazyMesh(2, (1, 1), ((-1, 1), (-1, 1)), curvature=0.2) K = MeshFunction(mesh) func_space = FunctionSpace(mesh, '1-lobatto', (3, 3)) basis = BasisForm(func_space) K.continous_tensor = [diff_tens_11, diff_tens_12, diff_tens_22] xi = eta = np.linspace(-1, 1, 5) xi, eta = np.meshgrid(xi, eta) g_11_k, g_12_k, g_22_k = basis.weighted_metric_tensor(xi.ravel('F'), eta.ravel('F'), K) g_11, g_12, g_22 = mesh.metric_tensor(xi.ravel('F'), eta.ravel('F')) npt.assert_array_almost_equal(g_11, g_11_k)
def test_discretize_lobatto(self): """Test the discretize method of the 2 - forms.""" my_mesh = CrazyMesh(2, (2, 2), ((-1, 1), (-1, 1)), curvature=0) p_int_0 = 2 for p in range(3, 8): filename = 'discrete_2_form_p' + \ str(p) + '_p_int' + str(p_int_0) + '.dat' directory = os.getcwd() + '/src/tests/test_discrete_2_form/' func_space = FunctionSpace(my_mesh, '2-lobatto', p) form = Form(func_space) form.discretize(paraboloid, ('gauss', p_int_0)) cochain_ref = np.loadtxt(directory + filename, delimiter=',') npt.assert_array_almost_equal(form.cochain_local, cochain_ref, decimal=4) p = 5 for p_int in range(2, 6): filename = 'discrete_2_form_p' + \ str(p) + '_p_int' + str(p_int_0) + '.dat' directory = os.getcwd() + '/src/tests/test_discrete_2_form/' func_space = FunctionSpace(my_mesh, '2-lobatto', p) form = Form(func_space) form.discretize(paraboloid, ('gauss', p_int_0)) cochain_ref = np.loadtxt(directory + filename, delimiter=',') npt.assert_array_almost_equal(form.cochain_local, cochain_ref, decimal=4) p = 6 p_int = 5 filename_1 = 'discrete_2_form_p' + \ str(p) + '_p_int' + str(p_int) + '_el_57.dat' directory = os.getcwd() + '/src/tests/test_discrete_2_form/' mesh_1 = CrazyMesh(2, (5, 7), ((-1, 1), (-1, 1)), curvature=0) func_space = FunctionSpace(mesh_1, '2-lobatto', p) form = Form(func_space) form.discretize(paraboloid, ('gauss', p_int)) cochain_ref_1 = np.loadtxt(directory + filename_1, delimiter=',') npt.assert_array_almost_equal(form.cochain_local, cochain_ref_1) mesh_2 = CrazyMesh(2, (5, 7), ((-1, 1), (-1, 1)), curvature=0.2) filename_2 = 'discrete_2_form_p' + \ str(p) + '_p_int' + str(p_int) + '_el_57_cc2.dat' directory = os.getcwd() + '/src/tests/test_discrete_2_form/' func_space = FunctionSpace(mesh_2, '2-lobatto', p) form = Form(func_space) form.discretize(paraboloid, ('gauss', p_int)) cochain_ref_2 = np.loadtxt(directory + filename_2, delimiter=',') npt.assert_array_almost_equal(form.cochain_local, cochain_ref_2)
def test_visulalization_extended_gauss_e10_inner(self): def pfun(x, y): return np.sin(np.pi * x) * np.sin(np.pi * y) p = (10, 10) n = (20, 20) mesh = CrazyMesh(2, n, ((-1, 1), (-1, 1)), 0.3) func_space_extGau = FunctionSpace(mesh, '0-ext_gauss', p) form_0_extG = Form(func_space_extGau) form_0_extG.discretize(self.pfun) xi = eta = np.linspace(-1, 1, 10) form_0_extG.reconstruct(xi, eta) (x, y), data = form_0_extG.export_to_plot() plt.contourf(x, y, data) plt.title('reduced extended_gauss 0-form') plt.colorbar() plt.show() form_1 = d(form_0_extG) form_1.reconstruct(xi, eta) (x, y), data_dx, data_dy = form_1.export_to_plot() ufun_x, ufun_y = self.ufun() plt.contourf(x, y, data_dx) plt.title('extended_gauss 1-form dx') plt.colorbar() plt.show() # plt.contourf(x, y, data_dy) plt.title('extended_gauss 1-form dy') plt.colorbar() plt.show() print(np.min(data_dy))
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_visulization_lobato_e10_inner(self): def pfun(x, y): return np.sin(np.pi * x) * np.sin(np.pi * y) p = (20, 20) n = (2, 2) mesh = CrazyMesh(2, n, ((-1, 1), (-1, 1)), 0.2) xi = eta = np.linspace(-1, 1, 100) func_space = FunctionSpace(mesh, '0-lobatto', p) form_0 = Form(func_space) form_0.discretize(pfun) form_0.reconstruct(xi, eta) (x, y), data = form_0.export_to_plot() plt.contourf(x, y, data) plt.title('reduced lobatto 0-form') plt.colorbar() plt.show() form_1 = d(form_0) form_1.reconstruct(xi, eta) (x, y), data_dx, data_dy = form_1.export_to_plot() plt.contourf(x, y, data_dx) plt.title('lobatto 1-form dx') plt.colorbar() # plt.show() plt.contourf(x, y, data_dy) plt.title('lobatto 1-form dy') plt.colorbar() # plt.show() print(np.min(data_dy))
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 test_project_lobatto(self): directory = 'src/tests/test_form_2/' x_ref = np.loadtxt(directory + 'x_lobatto_n3-2_p20-20_c3_xieta_30.dat', delimiter=',') y_ref = np.loadtxt(directory + 'y_lobatto_n3-2_p20-20_c3_xieta_30.dat', delimiter=',') data_ref = np.loadtxt(directory + 'data_lobatto_n3-2_p20-20_c3_xieta_30.dat', delimiter=',') def ffun(x, y): return np.sin(np.pi * x) * np.sin(np.pi * y) p = (20, 20) n = (3, 2) mesh = CrazyMesh(2, n, ((-1, 1), (-1, 1)), 0.3) xi = eta = np.linspace(-1, 1, 30) func_space = FunctionSpace(mesh, '2-lobatto', p) form_2 = Form(func_space) form_2.discretize(ffun) form_2.reconstruct(xi, eta) (x, y), data = form_2.export_to_plot() npt.assert_array_almost_equal(x_ref, x) npt.assert_array_almost_equal(y_ref, y) npt.assert_array_almost_equal(data_ref, data)
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_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 test_dual_space(self): """Test the generation of the dual space.""" p = 3, 3 mesh = CrazyMesh(2, (1, 1), ((-1, 1), (-1, 1)), curvature=0.2) func_space = FunctionSpace(mesh, '0-lobatto', p) dual_space_ref = FunctionSpace(mesh, '2-gauss', (p[0] - 1, p[1] - 1)) dual_space = DualSpace(func_space, extend=False) self.assertEqual(dual_space_ref.form_type, dual_space.form_type, msg="Form type is different") self.assertEqual(dual_space_ref.p, dual_space.p) func_space = FunctionSpace(mesh, '2-gauss', p) dual_space_ref = FunctionSpace(mesh, '0-lobatto', (p[0] + 1, p[1] + 1)) dual_space = DualSpace(func_space, extend=False) self.assertEqual(dual_space_ref.form_type, dual_space.form_type, msg="Form type is different") self.assertEqual(dual_space_ref.p, dual_space.p) func_space = FunctionSpace(mesh, '0-gauss', p) dual_space_ref = FunctionSpace(mesh, '2-lobatto', (p[0] + 1, p[1] + 1)) dual_space = DualSpace(func_space, extend=False) self.assertEqual(dual_space_ref.form_type, dual_space.form_type, msg="Form type is different") self.assertEqual(dual_space_ref.p, dual_space.p) func_space = FunctionSpace(mesh, '2-lobatto', p) dual_space_ref = FunctionSpace(mesh, '0-gauss', (p[0] - 1, p[1] - 1)) dual_space = DualSpace(func_space, extend=False) self.assertEqual(dual_space_ref.form_type, dual_space.form_type, msg="Form type is different") self.assertEqual(dual_space_ref.p, dual_space.p) func_space = FunctionSpace(mesh, '1-lobatto', p) dual_space_ref = FunctionSpace(mesh, '1-ext_gauss', (p[0] - 1, p[1] - 1)) dual_space = DualSpace(func_space, extend=True) self.assertEqual(dual_space_ref.form_type, dual_space.form_type, msg="Form type is different") self.assertEqual(dual_space_ref.p, dual_space.p) func_space = FunctionSpace(mesh, '1-ext_gauss', p) dual_space_ref = FunctionSpace(mesh, '1-lobatto', (p[0] + 1, p[1] + 1)) dual_space = DualSpace(func_space, extend=True) self.assertEqual(dual_space_ref.form_type, dual_space.form_type, msg="Form type is different") self.assertEqual(dual_space_ref.p, dual_space.p) func_space = FunctionSpace(mesh, '1-lobatto', p) dual_space_ref = FunctionSpace(mesh, '1-gauss', (p[0] - 1, p[1] - 1)) dual_space = DualSpace(func_space, extend=False) self.assertEqual(dual_space_ref.form_type, dual_space.form_type, msg="Form type is different") self.assertEqual(dual_space_ref.p, dual_space.p) func_space = FunctionSpace(mesh, '1-gauss', p) dual_space_ref = FunctionSpace(mesh, '1-lobatto', (p[0] + 1, p[1] + 1)) dual_space = DualSpace(func_space, extend=False) self.assertEqual(dual_space_ref.form_type, dual_space.form_type, msg="Form type is different") self.assertEqual(dual_space_ref.p, dual_space.p)
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_local_to_global_cochain(self): # TODO: currently not supported px != py """Test local to global mapping of cochians.""" mesh = CrazyMesh(2, (2, 2), ((-1, 1), (-1, 1)), curvature=0.3) cases = ['2-lobatto', '2-gauss'] p = 2, 3 for form_case in cases: func_space = FunctionSpace(mesh, form_case, p) form_2 = Form(func_space) form_2.discretize(paraboloid)
def test_ext_gauss_projection(self): p = (10, 10) n = (5, 6) mesh = CrazyMesh(2, n, ((-1, 1), (-1, 1)), 0.3) func_space_extGau = FunctionSpace(mesh, '0-ext_gauss', p) form_0_extG = ExtGaussForm_0(func_space_extGau) form_0_extG.discretize(self.pfun) xi = eta = np.linspace(-1, 1, 20) form_0_extG.reconstruct(xi, eta) (x, y), data = form_0_extG.export_to_plot() npt.assert_array_almost_equal(self.pfun(x, y), data)
def test_lobatto_projection(self): p = (10, 10) n = (5, 6) mesh = CrazyMesh(2, n, ((-1, 1), (-1, 1)), 0.3) func_space = FunctionSpace(mesh, '0-lobatto', p) form_0 = Form(func_space) form_0.discretize(self.pfun) xi = eta = np.linspace(-1, 1, 20) form_0.reconstruct(xi, eta) (x, y), data = form_0.export_to_plot() npt.assert_array_almost_equal(self.pfun(x, y), data)
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_l2_norm(self): p = (10, 10) n = (10, 10) mesh = CrazyMesh(2, n, ((0, 1), (0, 1)), 0.1) func_space = FunctionSpace(mesh, '1-lobatto', p) form_1 = Form(func_space) form_1.discretize((self.ufun_x, self.ufun_y)) # print("chochain : \n", form_1.chochain) error_global, error_local = form_1.l_2_norm((self.ufun_x, self.ufun_y)) self.assertLess(error_global, 4 * 10**(-12)) self.assertLess(error_local, 4 * 10**(-10))
def test_discretize_simple(self): """Simple discretization of 0 forms.""" p_s = [(2, 2)] n = (2, 2) for p in p_s: mesh = CrazyMesh(2, n, ((-1, 1), (-1, 1)), 0.0) func_space = FunctionSpace(mesh, '0-lobatto', p) form_0 = Form(func_space) form_0.discretize(self.pfun) # values at x = +- 0.5 and y = +- 0.5 ref_value = np.array((1, -1, -1, 1)) npt.assert_array_almost_equal(ref_value, form_0.cochain_local[4])
def test_projection_gauss(self): p = (10, 10) n = (5, 6) mesh = CrazyMesh(2, n, ((-1, 1), (-1, 1)), 0.1) func_space = FunctionSpace(mesh, '1-gauss', p) form_1 = Form(func_space) form_1.discretize((self.ufun_x, self.ufun_y)) xi = eta = np.linspace(-1, 1, 40) form_1.reconstruct(xi, eta) (x, y), data_dx, data_dy = form_1.export_to_plot() npt.assert_array_almost_equal(self.ufun_x(x, y), data_dx, decimal=4) npt.assert_array_almost_equal(self.ufun_y(x, y), data_dy, decimal=4)
def test_projection_gauss(self): def ffun(x, y): return np.sin(np.pi * x) * np.sin(np.pi * y) p = (20, 20) n = (3, 3) mesh = CrazyMesh(2, n, ((-1, 1), (-1, 1)), 0.3) func_space = FunctionSpace(mesh, '2-ext_gauss', p) f2eg = Form(func_space) f2eg.discretize(ffun) xi = eta = np.linspace(-1, 1, 50) f2eg.reconstruct(xi, eta) (x, y), data = f2eg.export_to_plot() npt.assert_array_almost_equal(ffun(x, y), data)
def test_exceptions(self): p = 2 mesh = CrazyMesh(2, (2, 2), ((-1, 1), (-1, 1))) func_space = FunctionSpace(mesh, '1-lobatto', p) basis = BasisForm(func_space) basis_1 = BasisForm(func_space) quad_cases = [(None, 'gauss'), (None, None), ('gauss', None), ('lobatto', 'gauss')] for case in quad_cases: if None in case: with self.assertRaises(UnboundLocalError): basis.quad_grid = case[0] basis_1.quad_grid = case[1] else: basis.quad_grid = case[0] basis_1.quad_grid = case[1] self.assertRaises(QuadratureError, inner, basis, basis_1)
def test_reconstruct_lobatto(self): """Test the reconstructin of lobatto forms.""" p = (20, 20) n = (3, 2) mesh = CrazyMesh(2, n, ((-1, 1), (-1, 1)), 0.3) xi = eta = np.linspace(-1, 1, 30) func_space = FunctionSpace(mesh, '2-lobatto', p) form_2 = Form(func_space) cochain = np.loadtxt( 'src/tests/test_form_2/cochain_lobatto_n3-2_p20-20_c3.dat', delimiter=',') ref_reconstructed = np.loadtxt( 'src/tests/test_form_2/reconstructed_lobatto_n3-2_p20-20_c3_xieta_30.dat', delimiter=',') form_2.cochain = cochain form_2.reconstruct(xi, eta) npt.assert_array_almost_equal(ref_reconstructed, form_2.reconstructed)
def test_reduction_visualization_extended_gauss_2form(self): def ffun(x, y): return np.sin(np.pi * x) * np.sin(np.pi * y) p = (20, 20) n = (3, 3) mesh = CrazyMesh(2, n, ((-1, 1), (-1, 1)), 0.3) func_space = FunctionSpace(mesh, '2-ext_gauss', p) f2eg = Form(func_space) f2eg.discretize(ffun) xi = eta = np.linspace(-1, 1, 50) f2eg.reconstruct(xi, eta) (x, y), data = f2eg.export_to_plot() plt.contourf(x, y, data) plt.title('reduced extened_gauss 2-form') plt.colorbar() plt.show()
def test_discretize_lobatto(self): def func_x(x, y): return np.ones(np.shape(x)) def func_y(x, y): return np.ones(np.shape(x)) * 2 mesh = CrazyMesh(2, (2, 2), ((-1, 1), (-1, 1)), 0.3) func_space = FunctionSpace(mesh, '1-lobatto', (3, 3)) form_1 = Form(func_space) form_1.discretize((func_x, func_y)) cochain_local_ref = np.loadtxt( 'src/tests/test_discrete_1_form/discrete_1_form_dx_1_dy_2.csv', delimiter=',') npt.assert_array_almost_equal(form_1.cochain_local, cochain_local_ref, decimal=3)
def test_coboundary_lobatto_e10_inner(self): """Test of the coundary 0->1 for lobatto form inner oriented.""" p = (20, 20) n = (6, 6) mesh = CrazyMesh(2, n, ((-1, 1), (-1, 1)), 0.1) xi = eta = np.linspace(-1, 1, 100) func_space = FunctionSpace(mesh, '0-lobatto', p) form_0 = Form(func_space) form_0.discretize(self.pfun) form_1 = d(form_0) form_1.reconstruct(xi, eta) (x, y), data_dx, data_dy = form_1.export_to_plot() ufun_x, ufun_y = self.ufun() npt.assert_array_almost_equal(ufun_x(x, y), data_dx) npt.assert_array_almost_equal(ufun_y(x, y), data_dy)
def test_reduction_visualization_lobatto_2form(self): def ffun(x, y): return np.sin(np.pi * x) * np.sin(np.pi * y) p = (20, 20) n = (2, 2) mesh = CrazyMesh(2, n, ((-1.25, 1), (-1.25, 1)), 0.3) xi = eta = np.linspace(-1, 1, 30) func_space = FunctionSpace(mesh, '2-lobatto', p) form_2 = Form(func_space) form_2.discretize(ffun) # np.savetxt('cochain_lobatto_n3-2_p20-20_c3.dat', form_2.cochain, delimiter=',') form_2.reconstruct(xi, eta) (x, y), data = form_2.export_to_plot() plt.contourf(x, y, data) plt.title('our reduced lobatto 2-form') plt.colorbar() plt.show()
def test_metric(self): def gamma1(s): return 2 * s - 1, -1 * np.ones(np.shape(s)) def gamma2(t): return 1 * np.ones(np.shape(t)), 2 * t - 1 def gamma3(s): return 2 * s - 1, 1 * np.ones(np.shape(s)) def gamma4(t): return -1 * np.ones(np.shape(t)), 2 * t - 1 def dgamma1(s): return 2 * np.ones(np.shape(s)), 0 * np.ones(np.shape(s)) def dgamma2(t): return 0 * np.ones(np.shape(t)), 2 * np.ones(np.shape(t)) def dgamma3(s): return 2 * np.ones(np.shape(s)), 0 * np.ones(np.shape(s)) def dgamma4(t): return 0 * np.ones(np.shape(t)), 2 * np.ones(np.shape(t)) gamma = (gamma1, gamma2, gamma3, gamma4) dgamma = (dgamma1, dgamma2, dgamma3, dgamma4) sand_shale_mesh = TransfiniteMesh(2, (1, 1), gamma, dgamma) crazy_mesh = CrazyMesh(2, (1, 1), ((-1, 1), (-1, 1))) xi = eta = np.linspace(-1, 1, 5) npt.assert_array_almost_equal(crazy_mesh.dx_dxi(xi, eta), sand_shale_mesh.dx_dxi(xi, eta)) npt.assert_array_almost_equal(crazy_mesh.dx_deta(xi, eta), sand_shale_mesh.dx_deta(xi, eta)) npt.assert_array_almost_equal(crazy_mesh.dy_dxi(xi, eta), sand_shale_mesh.dy_dxi(xi, eta)) npt.assert_array_almost_equal(crazy_mesh.dy_deta(xi, eta), sand_shale_mesh.dy_deta(xi, eta)) npt.assert_array_almost_equal(crazy_mesh.g(xi, eta), sand_shale_mesh.g(xi, eta))
def test_coboundary_extended_gauss_e10_inner(self): def pfun(x, y): return np.sin(np.pi * x) * np.sin(np.pi * y) p = (10, 10) n = (20, 20) mesh = CrazyMesh(2, n, ((-1, 1), (-1, 1)), 0.3) func_space_extGau = FunctionSpace(mesh, '0-ext_gauss', p) form_0_extG = Form(func_space_extGau) form_0_extG.discretize(self.pfun) xi = eta = np.linspace(-1, 1, 10) form_0_extG.reconstruct(xi, eta) form_1 = d(form_0_extG) form_1.reconstruct(xi, eta) (x, y), data_dx, data_dy = form_1.export_to_plot() ufun_x, ufun_y = self.ufun() npt.assert_array_almost_equal(ufun_x(x, y), data_dx) npt.assert_array_almost_equal(ufun_y(x, y), data_dy) print(np.min(data_dy))
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])
def test_reduction_visualization_lobatto_1form(self): """Simple discretization of 1 forms.""" p_s = [(10, 10)] n = (2, 2) for p in p_s: mesh = CrazyMesh(2, n, ((-1, 1), (-1, 1)), 0) func_space = FunctionSpace(mesh, '1-lobatto', p) form_1 = Form(func_space) form_1.discretize((self.ufun_x, self.ufun_y)) print(form_1.function_space.dof_map.dof_map) xi = eta = np.linspace(-1, 1, 40) form_1.reconstruct(xi, eta) (x, y), data_dx, data_dy = form_1.export_to_plot() plt.contourf(x, y, data_dx) plt.title('projected lobatto 1-form dx') plt.colorbar() plt.show() plt.contourf(x, y, data_dy) plt.title('projected lobatto 1-form dy') plt.colorbar() plt.show() print(np.min(data_dy))
def ffun(x, y): return -2 * np.pi**2 * np.sin(np.pi * x) * np.sin(np.pi * y) # %% define p = 0 n = 2 c = 0.0 px = py = p nx = ny = n print("\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^") print("Start div grad solver @ p=", px) print(" @ n=", nx) print(" @ c=", c) mesh = CrazyMesh(2, (nx, ny), ((-1, 1), (-1, 1)), c) xi = eta = np.linspace(-1, 1, np.ceil(500 / (nx * ny)) + 1) # %% function spaces func_space_eg0 = FunctionSpace(mesh, '0-ext_gauss', (px, py)) p0 = Form(func_space_eg0) p0_exact = Form(func_space_eg0) p0_exact.discretize(pfun) #p0_exact.reconstruct(xi, eta) #(x, y), data = p0_exact.export_to_plot() #plt.contourf(x, y, data) #plt.title('exact extended gauss 0-form, p0') #plt.colorbar() #plt.show() #func_space_g0 = FunctionSpace(mesh, '0-gauss', (px, py)) # %% func_space_eg1 = FunctionSpace(mesh, '1-ext_gauss', (px, py))