def test_assemble_hodge(self): p_dual = (self.p[0] - 1, self.p[1] - 1) func_space_lob_0 = FunctionSpace(self.mesh, '0-lobatto', self.p) func_space_extgauss_0 = FunctionSpace(self.mesh, '0-ext_gauss', p_dual) func_space_lob_2 = FunctionSpace(self.mesh, '2-lobatto', self.p) func_space_extgauss_2 = FunctionSpace(self.mesh, '2-ext_gauss', p_dual) func_space_lob_1 = FunctionSpace(self.mesh, '1-lobatto', self.p) func_space_extgauss_1 = FunctionSpace(self.mesh, '1-ext_gauss', p_dual) hodge_20_ext = hodge(func_space_extgauss_0) hodge_11_lob = hodge(func_space_lob_1) hodge_02_lob = hodge(func_space_lob_2) hodge_assembled_ref = assemble_slow( self.mesh, hodge_20_ext, func_space_lob_2.dof_map.dof_map, func_space_extgauss_0.dof_map.dof_map_internal) hodge_assembled = assemble( hodge_20_ext, (func_space_lob_2, func_space_extgauss_0)).toarray() npt.assert_array_almost_equal(hodge_assembled_ref, hodge_assembled) hodge_assembled_ref = assemble_slow( self.mesh, hodge_11_lob, func_space_extgauss_1.dof_map.dof_map_internal, func_space_lob_1.dof_map.dof_map) hodge_assembled = assemble( hodge_11_lob, (func_space_extgauss_1, func_space_lob_1)).toarray() npt.assert_array_almost_equal(hodge_assembled_ref, hodge_assembled) hodge_assembled_ref = assemble_slow( self.mesh, hodge_02_lob, func_space_extgauss_0.dof_map.dof_map_internal, func_space_lob_2.dof_map.dof_map) hodge_assembled = assemble( hodge_02_lob, (func_space_extgauss_0, func_space_lob_2)).toarray() npt.assert_array_almost_equal(hodge_assembled_ref, hodge_assembled)
def solver(p, n, c): print("\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^") print("Start curl curl solver @ p=", p) print(" @ n=", n) print(" @ c=", c) px = py = p nx = n ny = n mesh = CrazyMesh(2, (nx, ny), ((-1, 1), (-1, 1)), c) xi = eta = np.linspace(-1, 1, np.ceil(500 / (nx * ny)) + 1) # %% exact p(0) func_space_gl0 = FunctionSpace(mesh, '0-lobatto', (px + 1, py + 1), is_inner=False) p0_exact = Form(func_space_gl0) 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 lobatto 0-form, p0') plt.colorbar() plt.show() # %% p(0) func_space_gl0 = FunctionSpace(mesh, '0-lobatto', (px + 1, py + 1), is_inner=False) p0 = Form(func_space_gl0) # %% func_space_gl1 = FunctionSpace(mesh, '1-lobatto', (px + 1, py + 1), is_inner=False) uo = Form(func_space_gl1) # %% func_space_eg1 = FunctionSpace(mesh, '1-ext_gauss', (px, py)) ui = Form(func_space_eg1) # %% func_space_eg2 = FunctionSpace(mesh, '2-ext_gauss', (px, py)) f2 = Form(func_space_eg2) f2_exact = Form(func_space_eg2) f2_exact.discretize(ffun) # f2_exact.reconstruct(xi, eta) # (x, y), data = f2_exact.export_to_plot() # plt.contourf(x, y, data) # plt.title('exact extended-gauss 2-form, f2') # plt.colorbar() # plt.show() # %% E10 = d(func_space_gl0) # E10_assembled = assemble(mesh, E10, uo.function_space.dof_map.dof_map,p0.function_space.dof_map.dof_map, mode='replace') E10_assembled = assemble(E10, (uo.function_space, p0.function_space)) H = hodge(func_space_gl1) # H_assembled = assemble(mesh, H , ui.function_space.dof_map.dof_map_internal, uo.function_space.dof_map.dof_map) H_assembled = assemble(H, (ui.function_space, uo.function_space)) #H_assembled = np.linalg.inv(H_assembled) E21 = d(func_space_eg1) # E21_assembled = assemble(mesh, E21, f2.function_space.dof_map.dof_map, ui.function_space.dof_map.dof_map, mode = 'replace') E21_assembled = assemble(E21, (f2.function_space, ui.function_space)) # %% # uo.cochain = E10_assembled.dot(p0_exact.cochain) # uo.reconstruct(xi, eta) # (x, y), data_dx, data_dy = uo.export_to_plot() # plt.contourf(x, y, data_dx) # plt.title('exact lobatto 1-form dx') # plt.colorbar() # plt.show() # print('uo_dx max:', np.max(data_dx)) # print('uo_dx min:', np.min(data_dx)) # # plt.contourf(x, y, data_dy) # plt.title('exact lobatto 1-form dy') # plt.colorbar() # plt.show() # print('uo_dy max:', np.max(data_dy)) # print('uo_dy min:', np.min(data_dy)) # # ui_internal_cochain = H_assembled.dot(uo.cochain) # ui.cochain = np.concatenate((ui_internal_cochain, np.zeros( # ui.function_space.num_dof - ui.basis.num_basis * ui.mesh.num_elements)), axis=0) # ui.reconstruct(xi, eta) # (x, y), data_dx, data_dy = ui.export_to_plot() # plt.contourf(x, y, data_dx) # plt.title('ext_gauss 1-form dx') # plt.colorbar() # plt.show() # print('ui_dx max:', np.max(data_dx)) # print('ui_dy min:', np.min(data_dx)) # # plt.contourf(x, y, data_dy) # plt.title('ext_gauss 1-form dy') # plt.colorbar() # plt.show() # print('ui_dy max:', np.max(data_dy)) # print('ui_dy min:', np.min(data_dy)) # def UBC(mesh, s, p, position): # def pullbackedfun_dx(xi, eta): # x, y = mesh.mapping(xi, eta, s) # return ui_dx(x, y) # # def pullbackedfun_dy(xi, eta): # x, y = mesh.mapping(xi, eta, s) # return ui_dy(x, y) # # def fun2bint_dxi(xi, eta): # return pullbackedfun_dx(xi, eta) * mesh.dx_dxi(xi, eta, s) + pullbackedfun_dy(xi, eta) * mesh.dy_dxi(xi, eta, s) # # def fun2bint_deta(xi, eta): # return pullbackedfun_dx(xi, eta) * mesh.dx_deta(xi, eta, s) + pullbackedfun_dy(xi, eta) * mesh.dy_deta(xi, eta, s) # # UBC_s = np.zeros(shape = (p+1)) # extended_gauss_nodes, _ = extended_gauss_quad(p-1) # if position == 'Left': # for i in range(p+1): # # print("hello, Left world") # def fun2bint_deta_BC(eta): # return fun2bint_deta(-1, eta) # UBC_s[i] = quad(fun2bint_deta_BC, extended_gauss_nodes[i], extended_gauss_nodes[i+1] )[0] # elif position == 'Right': # for i in range(p+1): # # print("hello, Right world") # def fun2bint_deta_BC(eta): # return fun2bint_deta(+1, eta) # UBC_s[i] = quad(fun2bint_deta_BC, extended_gauss_nodes[i], extended_gauss_nodes[i+1] )[0] # elif position == 'Bottom': # for i in range(p+1): # # print("hello, Bottom world") # def fun2bint_dxi_BC(xi): # return fun2bint_dxi(xi, -1) # UBC_s[i] = quad(fun2bint_dxi_BC, extended_gauss_nodes[i], extended_gauss_nodes[i+1] )[0] # elif position == 'Top': # for i in range(p+1): # # print("hello, Top world") # def fun2bint_dxi_BC(xi): # return fun2bint_dxi(xi, +1) # UBC_s[i] = quad(fun2bint_dxi_BC, extended_gauss_nodes[i], extended_gauss_nodes[i+1] )[0] # return UBC_s # # def extended_gauss1_general_boundary_edges(mesh, p, gathering_matrix): # p+=1 # nx = mesh.n_x # ny = mesh.n_y # # Left = np.zeros( shape = (ny*(p+1)), dtype=np.int32 ) # Right = np.zeros( shape = (ny*(p+1)), dtype=np.int32 ) # Bottom = np.zeros( shape = (nx*(p+1)), dtype=np.int32 ) # Top = np.zeros( shape = (nx*(p+1)), dtype=np.int32 ) # # M = 2 * p * (p+1) # N = p+1 # # UBC_L = UBC_R = UBC_B = UBC_T = 0 # # for J in range(ny): # eleidLeft = J # Left[ J*N : J*N + N ] = gathering_matrix[ eleidLeft , M +2*N : M +3*N ] # UBC_s=UBC(mesh, eleidLeft, p, "Left") # if UBC_L is 0: # UBC_L= UBC_s # else: # UBC_L = np.hstack((UBC_L, UBC_s)) # # eleidRight = (nx-1)*ny + J # Right[ J*N : J*N + N ] = gathering_matrix[ eleidRight, M +3*N : M +4*N ] # UBC_s=UBC(mesh, eleidRight, p, "Right") # if UBC_R is 0: # UBC_R= UBC_s # else: # UBC_R = np.hstack((UBC_R, UBC_s)) # # for I in range(nx): # eleidBottom = I*ny # Bottom[ I*N : I*N + N ] = gathering_matrix[ eleidBottom, M : M + N ] # UBC_s=UBC(mesh, eleidBottom, p, "Bottom") # if UBC_B is 0: # UBC_B= UBC_s # else: # UBC_B = np.hstack((UBC_B, UBC_s)) # # eleidTop = I*ny + ny -1 # Top[ I*N : I*N + N ] = gathering_matrix[ eleidTop , M + N : M + 2*N ] # UBC_s=UBC(mesh, eleidTop, p, "Top") # if UBC_T is 0: # UBC_T= UBC_s # else: # UBC_T = np.hstack((UBC_T, UBC_s)) # # return np.vstack((Left, UBC_L)), np.vstack((Right, UBC_R)), np.vstack((Bottom, UBC_B)), np.vstack((Top, UBC_T)) # # Left, Right, Bottom, Top = extended_gauss1_general_boundary_edges(mesh, px, ui.function_space.dof_map.dof_map) # Boundaryedgs = np.hstack( (Left, Right, Bottom, Top) ) # for i in range(np.shape(Boundaryedgs)[1]): # ui.cochain[int(Boundaryedgs[0, i])] =Boundaryedgs[1, i] # # f2.cochain = E21_assembled.dot(ui.cochain) # f2.reconstruct(xi, eta) # (x, y), data = f2.export_to_plot() # plt.contourf(x, y, data) # plt.title('exact extended-gauss 2-form, f2') # plt.colorbar() # plt.show() # %% # system: # | I -H 0 | | ui | | 0 | # | | | | | | # | 0 I -E10 | * | uo | = | 0 | # | | | | | | # | E21 0 0 | | p | | f | ui_num_dof_internal = ui.basis.num_basis * ui.mesh.num_elements ui_num_dof_external = ui.function_space.num_dof - ui_num_dof_internal # LHS1 = np.hstack(( np.eye(ui_num_dof_internal) , # np.zeros((ui_num_dof_internal, ui_num_dof_external)), # -H_assembled , # np.zeros((ui_num_dof_internal, p0.function_space.num_dof)) )) LHS1 = sparse.hstack( (sparse.eye(ui_num_dof_internal), sparse.csc_matrix( (ui_num_dof_internal, ui_num_dof_external)), -H_assembled, sparse.csc_matrix((ui_num_dof_internal, p0.function_space.num_dof)))) # LHS2 = np.hstack(( np.zeros((uo.function_space.num_dof, ui.function_space.num_dof )) , # np.eye(uo.function_space.num_dof) , # -E10_assembled )) LHS2 = sparse.hstack( (sparse.csc_matrix( (uo.function_space.num_dof, ui.function_space.num_dof)), sparse.eye(uo.function_space.num_dof), -E10_assembled)) # LHS3 = np.hstack(( E21_assembled , # np.zeros((f2.function_space.num_dof, uo.function_space.num_dof )) , # np.zeros((f2.function_space.num_dof, f2.function_space.num_dof )) )) LHS3 = sparse.hstack( (E21_assembled, sparse.csc_matrix( (f2.function_space.num_dof, uo.function_space.num_dof)), sparse.csc_matrix( (f2.function_space.num_dof, f2.function_space.num_dof)))) RHS1 = np.zeros((ui_num_dof_internal, 1)) RHS2 = np.zeros((uo.function_space.num_dof, 1)) RHS3 = f2_exact.cochain.reshape((f2_exact.function_space.num_dof, 1)) # %% boundary edges # def UBC(mesh, s, p, position): # def pullbackedfun_dx(xi, eta): # x, y = mesh.mapping(xi, eta, s) # return ufun_u(x, y) # # def pullbackedfun_dy(xi, eta): # x, y = mesh.mapping(xi, eta, s) # return ufun_v(x, y) # # def fun2bint_dxi(xi, eta): # return pullbackedfun_dx(xi, eta) * mesh.dx_dxi(xi, eta, s) + pullbackedfun_dy(xi, eta) * mesh.dy_dxi(xi, eta, s) # # def fun2bint_deta(xi, eta): # return pullbackedfun_dx(xi, eta) * mesh.dx_deta(xi, eta, s) + pullbackedfun_dy(xi, eta) * mesh.dy_deta(xi, eta, s) # # UBC_s = np.zeros(shape = (p+1)) # extended_gauss_nodes, _ = extended_gauss_quad(p-1) # if position == 'Left': # for i in range(p+1): # # print("hello, Left world") # def fun2bint_deta_BC(eta): # return fun2bint_deta(-1, eta) # UBC_s[i] = quad(fun2bint_deta_BC, extended_gauss_nodes[i], extended_gauss_nodes[i+1] )[0] # elif position == 'Right': # for i in range(p+1): # # print("hello, Right world") # def fun2bint_deta_BC(eta): # return fun2bint_deta(+1, eta) # UBC_s[i] = quad(fun2bint_deta_BC, extended_gauss_nodes[i], extended_gauss_nodes[i+1] )[0] # elif position == 'Bottom': # for i in range(p+1): # # print("hello, Bottom world") # def fun2bint_dxi_BC(xi): # return fun2bint_dxi(xi, -1) # UBC_s[i] = quad(fun2bint_dxi_BC, extended_gauss_nodes[i], extended_gauss_nodes[i+1] )[0] # elif position == 'Top': # for i in range(p+1): # # print("hello, Top world") # def fun2bint_dxi_BC(xi): # return fun2bint_dxi(xi, +1) # UBC_s[i] = quad(fun2bint_dxi_BC, extended_gauss_nodes[i], extended_gauss_nodes[i+1] )[0] # return UBC_s # # def extended_gauss1_general_boundary_edges(mesh, p, gathering_matrix): # p+=1 # nx = mesh.n_x # ny = mesh.n_y # # Left = np.zeros( shape = (ny*(p+1)), dtype=np.int32 ) # Right = np.zeros( shape = (ny*(p+1)), dtype=np.int32 ) # Bottom = np.zeros( shape = (nx*(p+1)), dtype=np.int32 ) # Top = np.zeros( shape = (nx*(p+1)), dtype=np.int32 ) # # M = 2 * p * (p+1) # N = p+1 # # UBC_L = UBC_R = UBC_B = UBC_T = 0 # # for J in range(ny): # eleidLeft = J # Left[ J*N : J*N + N ] = gathering_matrix[ eleidLeft , M +2*N : M +3*N ] # UBC_s=UBC(mesh, eleidLeft, p, "Left") # if UBC_L is 0: # UBC_L= UBC_s # else: # UBC_L = np.hstack((UBC_L, UBC_s)) # # eleidRight = (nx-1)*ny + J # Right[ J*N : J*N + N ] = gathering_matrix[ eleidRight, M +3*N : M +4*N ] # UBC_s=UBC(mesh, eleidRight, p, "Right") # if UBC_R is 0: # UBC_R= UBC_s # else: # UBC_R = np.hstack((UBC_R, UBC_s)) # # for I in range(nx): # eleidBottom = I*ny # Bottom[ I*N : I*N + N ] = gathering_matrix[ eleidBottom, M : M + N ] # UBC_s=UBC(mesh, eleidBottom, p, "Bottom") # if UBC_B is 0: # UBC_B= UBC_s # else: # UBC_B = np.hstack((UBC_B, UBC_s)) # # eleidTop = I*ny + ny -1 # Top[ I*N : I*N + N ] = gathering_matrix[ eleidTop , M + N : M + 2*N ] # UBC_s=UBC(mesh, eleidTop, p, "Top") # if UBC_T is 0: # UBC_T= UBC_s # else: # UBC_T = np.hstack((UBC_T, UBC_s)) # # return np.vstack((Left, UBC_L)), np.vstack((Right, UBC_R)), np.vstack((Bottom, UBC_B)), np.vstack((Top, UBC_T)) # # Left, Right, Bottom, Top = extended_gauss1_general_boundary_edges(mesh, px, ui.function_space.dof_map.dof_map) # Boundaryedgs = np.hstack( (Left, Right, Bottom, Top) ) # ## LBC = np.zeros( shape = ( np.shape(Boundaryedgs)[1], ui.function_space.num_dof+ uo.function_space.num_dof + p0.function_space.num_dof ) ) # LBC = sparse.lil_matrix( ( np.shape(Boundaryedgs)[1], ui.function_space.num_dof+ uo.function_space.num_dof + p0.function_space.num_dof ) ) # # RBC = np.zeros( shape = ( np.shape(Boundaryedgs)[1], 1) ) # for i in range(np.shape(Boundaryedgs)[1]): # if i == 0 : # LBC[0, ui.function_space.num_dof+ uo.function_space.num_dof] = 1 # RBC[0] = p0_exact.cochain[0] # else: # LBC[i, int(Boundaryedgs[0, i])] =1 # RBC[i] = Boundaryedgs[1, i] # %% def PBC(p, nx, ny, gathering_matrix, gathering_matrix_edge): p += 1 Left = np.zeros(shape=(ny * (p + 1), 4), dtype=np.int32) Right = np.zeros(shape=(ny * (p + 1), 4), dtype=np.int32) Bottom = np.zeros(shape=(nx * (p + 1), 4), dtype=np.int32) Top = np.zeros(shape=(nx * (p + 1), 4), dtype=np.int32) N = p + 1 P = 2 * p * (p + 1) Q = (p + 1) for J in range(ny): eleidLeft = J Left[J * N:J * N + N, 0] = gathering_matrix[eleidLeft, :N] if eleidLeft == 0: # left-bottom corner element Left[0, 0] = -1 # left - bottom corner point Left[0, 1] = gathering_matrix_edge[0, P + 2 * Q] Left[0, 2] = gathering_matrix_edge[0, P] if eleidLeft == ny - 1: # left-top corner element Left[-1, 0] = -3 # left _- top corner point Left[-1, 1] = gathering_matrix_edge[eleidLeft, P + Q] Left[-1, 2] = gathering_matrix_edge[eleidLeft, P + 3 * Q - 1] if eleidLeft >= 0 and eleidLeft < ny - 1: Left[J * N + N - 1, 0] = -2 # left Left[J * N + N - 1, 1] = gathering_matrix_edge[eleidLeft, P + 3 * Q - 1] Left[J * N + N - 1, 2] = gathering_matrix_edge[eleidLeft, P + Q] Left[J * N + N - 1, 3] = gathering_matrix_edge[eleidLeft + 1, P + 2 * Q] eleidRight = (nx - 1) * ny + J Right[J * N:J * N + N, 0] = gathering_matrix[eleidRight, -N:] if eleidRight == nx * ny - ny: # right bottom element Right[0, 0] = -4 Right[0, 1] = gathering_matrix_edge[eleidRight, P + Q - 1] Right[0, 2] = gathering_matrix_edge[eleidRight, P + 3 * Q] if eleidRight == nx * ny - 1: # right top element Right[-1, 0] = -5 Right[-1, 1] = gathering_matrix_edge[eleidRight, P + 2 * Q - 1] Right[-1, 2] = gathering_matrix_edge[eleidRight, -1] if eleidRight >= nx * ny - ny and eleidRight < nx * ny - 1: # right elements Right[J * N + N - 1, 0] = -6 Right[J * N + N - 1, 1] = gathering_matrix_edge[eleidRight, -1] Right[J * N + N - 1, 2] = gathering_matrix_edge[eleidRight, P + 2 * Q - 1] Right[J * N + N - 1, 3] = gathering_matrix_edge[eleidRight + 1, P + 3 * Q] for I in range(nx): eleidBottom = I * ny Bottom[I * N:I * N + N, 0] = gathering_matrix[eleidBottom, 0:N**2:N] if eleidBottom >= 0 and eleidBottom < nx * ny - ny: # bottom elements Bottom[I * N + N - 1, 0] = -7 Bottom[I * N + N - 1, 1] = gathering_matrix_edge[eleidBottom, P + Q - 1] Bottom[I * N + N - 1, 2] = gathering_matrix_edge[eleidBottom, P + 3 * Q] Bottom[I * N + N - 1, 3] = gathering_matrix_edge[eleidBottom + ny, P] eleidTop = I * ny + ny - 1 Top[I * N:I * N + N, 0] = gathering_matrix[eleidTop, N - 1:N**2:N] if eleidTop >= 0 and eleidTop < nx * ny - 1: # bottom elements Top[I * N + N - 1, 0] = -8 Top[I * N + N - 1, 1] = gathering_matrix_edge[eleidTop, P + 2 * Q - 1] Top[I * N + N - 1, 2] = gathering_matrix_edge[eleidTop, -1] Top[I * N + N - 1, 3] = gathering_matrix_edge[eleidTop + ny, P + Q] return Left, Right, Bottom, Top Left, Right, Bottom, Top = PBC(p, nx, ny, p0_exact.function_space.dof_map.dof_map, ui.function_space.dof_map.dof_map) Boundarypoints = np.vstack((Left, Right, Bottom, Top)) LBC = sparse.lil_matrix( (np.shape(Boundarypoints)[0], ui.function_space.num_dof + uo.function_space.num_dof + p0.function_space.num_dof)) RBC = np.zeros(shape=(np.shape(Boundarypoints)[0], 1)) for i in range(np.shape(Boundarypoints)[0]): if Boundarypoints[i, 0] == -1: LBC[i, Boundarypoints[i, 1]] = +1 LBC[i, Boundarypoints[i, 2]] = +1 RBC[i] = 0 elif Boundarypoints[i, 0] == -2: LBC[i, Boundarypoints[i, 1]] = -2 LBC[i, Boundarypoints[i, 2]] = +1 LBC[i, Boundarypoints[i, 3]] = +1 RBC[i] = 0 elif Boundarypoints[i, 0] == -3: LBC[i, Boundarypoints[i, 1]] = +1 LBC[i, Boundarypoints[i, 2]] = -1 RBC[i] = 0 elif Boundarypoints[i, 0] == -4: LBC[i, Boundarypoints[i, 1]] = +1 LBC[i, Boundarypoints[i, 2]] = -1 RBC[i] = 0 elif Boundarypoints[i, 0] == -5: LBC[i, Boundarypoints[i, 1]] = +1 LBC[i, Boundarypoints[i, 2]] = +1 RBC[i] = 0 elif Boundarypoints[i, 0] == -6: LBC[i, Boundarypoints[i, 1]] = +1 LBC[i, Boundarypoints[i, 2]] = +1 LBC[i, Boundarypoints[i, 3]] = -2 RBC[i] = 0 elif Boundarypoints[i, 0] == -7: LBC[i, Boundarypoints[i, 1]] = -2 LBC[i, Boundarypoints[i, 2]] = +1 LBC[i, Boundarypoints[i, 3]] = +1 RBC[i] = 0 elif Boundarypoints[i, 0] == -8: LBC[i, Boundarypoints[i, 1]] = +1 LBC[i, Boundarypoints[i, 2]] = +1 LBC[i, Boundarypoints[i, 3]] = -2 RBC[i] = 0 else: LBC[i, ui.function_space.num_dof + uo.function_space.num_dof + int(Boundarypoints[i, 0])] = 1 RBC[i] = p0_exact.cochain[Boundarypoints[i, 0]] # %% def dof_map_crazy_lobatto_point_pair(mesh, p, global_numbering, global_numbering_edges): nx, ny = mesh.n_x, mesh.n_y N = p + 1 interface_point_pair = np.zeros( (((nx - 1) * ny + nx * (ny - 1)) * N, 4), dtype=np.int32) n = 0 P = 2 * p * (p + 1) Q = (p + 1) for i in range(nx - 1): for j in range(ny): s1 = j + i * ny s2 = j + (i + 1) * ny # print(s1, s2) for m in range(N): interface_point_pair[n, 0] = global_numbering[s1, N * p + m] interface_point_pair[n, 1] = global_numbering[s2, m] if j < ny - 1 and m == N - 1: s3 = s2 + 1 interface_point_pair[n, 0] = global_numbering_edges[s1, P + 2 * Q - 1] interface_point_pair[n, 1] = global_numbering_edges[s1, -1] interface_point_pair[n, 2] = global_numbering_edges[s2, P + Q] interface_point_pair[n, 3] = global_numbering_edges[s3, P + 2 * Q] n += 1 for i in range(nx): for j in range(ny - 1): s1 = j + i * ny s2 = j + 1 + i * ny # print(s1, s2) for m in range(N): interface_point_pair[n, 0] = global_numbering[s1, (m + 1) * N - 1] interface_point_pair[n, 1] = global_numbering[s2, m * N] n += 1 return interface_point_pair interface_point_pair = dof_map_crazy_lobatto_point_pair( mesh, px + 1, p0.function_space.dof_map.dof_map, ui.function_space.dof_map.dof_map) # Lintface = np.zeros( shape = ( np.shape( interface_point_pair )[0], ui.function_space.num_dof+ uo.function_space.num_dof + p0.function_space.num_dof ) ) Lintface = sparse.lil_matrix( (np.shape(interface_point_pair)[0], ui.function_space.num_dof + uo.function_space.num_dof + p0.function_space.num_dof)) #Rintface = np.zeros( shape = ( np.shape( interface_point_pair )[0]-(nx-1)*(ny-1), 1) ) Rintface = np.zeros(shape=(np.shape(interface_point_pair)[0], 1)) for i in range(np.shape(interface_point_pair)[0]): if interface_point_pair[i, 2] != 0 and interface_point_pair[i, 3] != 0: Lintface[i, interface_point_pair[i, 0]] = 1 Lintface[i, interface_point_pair[i, 1]] = 1 Lintface[i, interface_point_pair[i, 2]] = -1 Lintface[i, interface_point_pair[i, 3]] = -1 else: Lintface[i, ui.function_space.num_dof + uo.function_space.num_dof + interface_point_pair[i, 0]] = 1 Lintface[i, ui.function_space.num_dof + uo.function_space.num_dof + interface_point_pair[i, 1]] = -1 # Lintface = sparse.csr_matrix(Lintface) # %% #Lintface=Lintface[~np.all(Lintface == 0, axis=1)] LHS = sparse.vstack((LHS1, LHS2, LHS3, Lintface, LBC)) RHS = np.vstack((RHS1, RHS2, RHS3, Rintface, RBC)) #rrefLHS = np.array(Matrix(LHS).rref()[0]).astype(None) #print(rrefLHS) print("----------------------------------------------------") print("LHS shape:", np.shape(LHS)) print("------ solve the square sparse system:......") LHS = sparse.csr_matrix(LHS) Res = sparse.linalg.spsolve(LHS, RHS) # # print("------ solve the singular square sparse system:......") # solution = sparse.linalg.lsqr(LHS,RHS, atol=1e-20, btol=1e-20) # Res = solution[0].reshape((np.size(solution[0]),1)) # residual = np.sum(np.abs(LHS.dot(Res) - RHS)) # print("------ least square solution error =",residual) # print("++++++ solve the singular square full system:......") # solution= np.linalg.lstsq(LHS,RHS) # %% eigen values and eigen vector # w, v = sp.linalg.eig(LHS.todense()) # %% ui.cochain = Res[0:ui.function_space.num_dof].reshape( ui.function_space.num_dof) uo.cochain = Res[ui.function_space. num_dof:-p0.function_space.num_dof].reshape( uo.function_space.num_dof) p0.cochain = Res[-p0.function_space.num_dof:].reshape( p0.function_space.num_dof) # %% view the result p0.reconstruct(xi, eta) (x, y), data = p0.export_to_plot() plt.contourf(x, y, data) plt.title('solution lobatto 0-form, p0') plt.colorbar() plt.show() print('p0 max:', np.max(data)) print('p0 min:', np.min(data)) uo.reconstruct(xi, eta) (x, y), data_dx, data_dy = uo.export_to_plot() plt.contourf(x, y, data_dx) plt.title('solution lobatto 1-form dx') plt.colorbar() plt.show() print('uo max:', np.max(data_dx)) print('uo min:', np.min(data_dx)) plt.contourf(x, y, data_dy) plt.title('solution lobatto 1-form dy') plt.colorbar() plt.show() print('uo max:', np.max(data_dy)) print('uo min:', np.min(data_dy)) # # ui.reconstruct(xi, eta) (x, y), data_dx, data_dy = ui.export_to_plot() plt.contourf(x, y, data_dx) plt.title('solution extended_gauss 1-form dx') plt.colorbar() plt.show() print('ui max:', np.max(data_dx)) print('ui min:', np.min(data_dx)) plt.contourf(x, y, data_dy) plt.title('solution extended_gauss 1-form dy') plt.colorbar() plt.show() print('ui max:', np.max(data_dy)) print('ui min:', np.min(data_dy)) f2_exact.reconstruct(xi, eta) (x, y), data = f2_exact.export_to_plot() plt.contourf(x, y, data) plt.title('exact extended-gauss 2-form, f2') plt.colorbar() plt.show() # %% error L2_error_p0 = p0.l_2_norm(pfun, ('gauss', 10))[0] print("------ L2_error_psi0 =", L2_error_p0) L2_error_ui = ui.l_2_norm((ui_dx, ui_dy), ('gauss', 5))[0] print("------ L2_error_ui =", L2_error_ui) print("vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv\n") # %% return return L2_error_p0, L2_error_ui
def solver(p, n, c): 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), ((0, 1), (0, 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_eg1 = FunctionSpace(mesh, '1-ext_gauss', (px, py)) ui = Form(func_space_eg1) func_space_gl1 = FunctionSpace(mesh, '1-lobatto', (px + 1, py + 1), is_inner=False) uo = Form(func_space_gl1) func_space_gl2 = FunctionSpace(mesh, '2-lobatto', (px + 1, py + 1), is_inner=False) f2 = Form(func_space_gl2) f2.discretize(ffun, ('gauss', px + 5)) # f2.reconstruct(xi, eta) # (x, y), data = f2.export_to_plot() # plt.contourf(x, y, data) # plt.title('exact lobatto 2-form, f2') # plt.colorbar() # plt.show() # %% E10 = d(func_space_eg0)[0:ui.basis.num_basis] # E10 = d(func_space_eg0) H = hodge(func_space_gl1) E21 = d(func_space_gl1) # print(np.shape(uo.function_space.dof_map.dof_map)) # print(np.shape(ui.function_space.dof_map.dof_map_internal)) # E10_assembled = assemble_(mesh, E10, ui.function_space.dof_map.dof_map_internal, # p0.function_space.dof_map.dof_map, mode='replace') E10_assembled = assemble(E10, (ui.function_space, p0.function_space)) # H_assembled = assemble_(mesh, H, uo.function_space.dof_map.dof_map, # ui.function_space.dof_map.dof_map_internal) # E21_assembled = assemble_(mesh, E21, f2.function_space.dof_map.dof_map, # uo.function_space.dof_map.dof_map, mode='replace') E21_assembled = assemble(E21, (f2.function_space, uo.function_space)) #print(E21_assembled) # E10_assembled = assemble(E10, ui.function_space, p0.function_space) H_assembled = -assemble(H, ui.function_space, uo.function_space) # E21_assembled = assemble(E21, f2.function_space, uo.function_space) # %% test the assembled matrices # ui_cochian_internal = E10_assembled.dot(p0_exact.cochain) # ui.cochain = np.concatenate((ui_cochian_internal, np.zeros( # ui.function_space.num_dof - ui.basis.num_basis * ui.mesh.num_elements)), axis=0) # ui.reconstruct(xi, eta) # (x, y), data_dx, data_dy = ui.export_to_plot() ## plt.contourf(x, y, data_dx) ## plt.title('exact extended_gauss 1-form dx') ## plt.colorbar() ## plt.show() # # plt.contourf(x, y, data_dy) # plt.title('exact extended_gauss 1-form dy') # plt.colorbar() # plt.show() # # uo.cochain = H_assembled.dot( ui_cochian_internal) # uo.reconstruct(xi, eta) # (x, y), data_dx, data_dy = uo.export_to_plot() # plt.contourf(x, y, data_dx) # plt.title('exact lobbat 1-form dx') # plt.colorbar() # plt.show() # plt.contourf(x, y, data_dy) # plt.title('exact lobbat 1-form dy') # plt.colorbar() # plt.show() # %% # system: # | H E10 | | uo | | 0 | # | | | | | | # | | * | | = | | # | | | | | | # | E21 0 | | p | | f | ui_num_dof_internal = ui.basis.num_basis * ui.mesh.num_elements # LHS1 = np.hstack((np.eye(ui_num_dof_internal), # np.zeros((ui_num_dof_internal, uo.function_space.num_dof)), # -E10_assembled)) # # LHS2 = np.hstack((-H_assembled, # np.eye(uo.function_space.num_dof), # np.zeros((uo.function_space.num_dof, p0.function_space.num_dof)))) # # LHS3 = np.hstack((np.zeros((f2.function_space.num_dof, ui_num_dof_internal)), # E21_assembled, # np.zeros((f2.function_space.num_dof, p0.function_space.num_dof)))) LHS1 = sparse.hstack((H_assembled, E10_assembled)) LHS2 = sparse.hstack( (E21_assembled, sparse.csc_matrix( (f2.function_space.num_dof, p0.function_space.num_dof)))) RHS1 = np.zeros(shape=(uo.function_space.num_dof, 1)) RHS2 = f2.cochain.reshape((f2.function_space.num_dof, 1)) # %% def dof_map_crazy_lobatto_edges(mesh, p): nx, ny = mesh.n_x, mesh.n_y global_numbering = np.zeros((nx * ny, 2 * p * (p + 1)), dtype=np.int32) local_numbering = np.array([int(i) for i in range(2 * p * (p + 1))]) for i in range(nx): for j in range(ny): s = j + i * ny global_numbering[s, :] = local_numbering + 2 * p * (p + 1) * s interface_edge_pair = np.zeros( (((nx - 1) * ny + nx * (ny - 1)) * p, 2), dtype=np.int32) n = 0 for i in range(nx - 1): for j in range(ny): s1 = j + i * ny s2 = j + (i + 1) * ny for m in range(p): interface_edge_pair[n, 0] = global_numbering[s1, p * (p + 1) + p**2 + m] interface_edge_pair[n, 1] = global_numbering[s2, p * (p + 1) + m] n += 1 for i in range(nx): for j in range(ny - 1): s1 = j + i * ny s2 = j + 1 + i * ny for m in range(p): interface_edge_pair[n, 0] = global_numbering[s1, (m + 1) * (p + 1) - 1] interface_edge_pair[n, 1] = global_numbering[s2, m * (p + 1)] n += 1 return interface_edge_pair interface_edge_pair = dof_map_crazy_lobatto_edges(mesh, px + 1) LItFuo = sparse.lil_matrix( (np.shape(interface_edge_pair)[0], uo.function_space.num_dof + p0.function_space.num_dof)) RItFuo = np.zeros(shape=(np.shape(interface_edge_pair)[0], 1)) for i in range(np.shape(interface_edge_pair)[0]): LItFuo[i, interface_edge_pair[i, 0]] = 1 LItFuo[i, interface_edge_pair[i, 1]] = -1 # %% def CrazyMesh_2d_extended_gauss0_general_boundary_nodes( mesh, p, gathering_matrix): p += 1 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 Left, Right, Bottom, Top = CrazyMesh_2d_extended_gauss0_general_boundary_nodes( mesh, px, p0.function_space.dof_map.dof_map) Boundarypoint = np.hstack((Left, Right, Bottom, Top)) # LBCphi = np.zeros(shape=(np.size(Boundarypoint), ui_num_dof_internal + # uo.function_space.num_dof + p0.function_space.num_dof)) LBCphi = sparse.lil_matrix( (np.size(Boundarypoint), uo.function_space.num_dof + p0.function_space.num_dof)) RBCphi = np.zeros(shape=(np.size(Boundarypoint), 1)) for i in range(np.size(Boundarypoint)): LBCphi[i, uo.function_space.num_dof + Boundarypoint[i]] = 1 RBCphi[i] = p0_exact.cochain[Boundarypoint[i]] # %% LHS and RHS and solve it LHS = sparse.vstack((LHS1, LHS2, LItFuo, LBCphi)) RHS = np.vstack((RHS1, RHS2, RItFuo, RBCphi)) print("----------------------------------------------------") print("LHS shape:", np.shape(LHS)) # LHS = sparse.csr_matrix(LHS) print("------ solve the square sparse system:......") Res = sparse.linalg.spsolve(LHS, RHS) # Res = sparse.linalg.lsqr(LHS,RHS, atol=1e-20, btol=1e-20)[0] # print("++++++ solve the singular square full system:......") # Res = np.linalg.solve(LHS, RHS) # %% split into pieces uo.cochain = Res[:uo.function_space.num_dof].reshape( uo.function_space.num_dof) p0.cochain = Res[-p0.function_space.num_dof:].reshape( p0.function_space.num_dof) # %% view the result p0.reconstruct(xi, eta) (x, y), data = p0.export_to_plot() plt.contourf(x, y, data) plt.title('solution extended gauss 0-form, p0') plt.colorbar() plt.show() # # uo.reconstruct(xi, eta) # (x, y), data_dx, data_dy = uo.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() #f2.reconstruct(xi, eta) #(x, y), data = f2.export_to_plot() #plt.contourf(x, y, data) #plt.title('exact lobatto 2-form, f2') #plt.colorbar() #plt.show() # %% L2_error L2_error_p0 = p0.l_2_norm(pfun, ('gauss', px + 5))[0] L2_error_uo = uo.l_2_norm((uo_dx, uo_dy), ('lobatto', px + 5))[0] print("------ L2_error_p0 =", L2_error_p0) print("------ L2_error_uo =", L2_error_uo) return L2_error_p0, L2_error_uo print("vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv\n")
def solver(p,n,c): # %% define px = py = p nx = n ny = n mesh = CrazyMesh(2, (nx, ny), ((-1, 1), (-1, 1)), c) xi = eta = np.linspace(-1, 1, np.ceil(1000 / (nx * ny)) + 1) # %% exact p(0) func_space_gl0 = FunctionSpace(mesh, '0-lobatto', (px + 1, py + 1), is_inner=False) # p0_exact = Form(func_space_gl0) # 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 lobatto 0-form, p0') # plt.colorbar() # plt.show() # %% p(0) func_space_gl0 = FunctionSpace(mesh, '0-lobatto', (px + 1, py + 1), is_inner=False) p0 = Form(func_space_gl0) # %% func_space_gl1 = FunctionSpace(mesh, '1-lobatto', (px + 1, py + 1), is_inner=False) uo = Form(func_space_gl1) # %% func_space_eg1 = FunctionSpace(mesh, '1-ext_gauss', (px, py)) ui = Form(func_space_eg1) # %% func_space_eg2 = FunctionSpace(mesh, '2-ext_gauss', (px, py)) f2 = Form(func_space_eg2) f2_exact = Form(func_space_eg2) f2_exact.discretize(ffun) # f2_exact.reconstruct(xi, eta) # (x, y), data = f2_exact.export_to_plot() # plt.contourf(x, y, data) # plt.title('exact extended-gauss 2-form, f2') # plt.colorbar() # plt.show() # %% E10 = d(func_space_gl0) E10_assembled = assemble(mesh, E10, uo.function_space.dof_map.dof_map, p0.function_space.dof_map.dof_map, mode='replace') H = hodge(func_space_gl1) H_assembled = assemble(mesh, H , ui.function_space.dof_map.dof_map_internal, uo.function_space.dof_map.dof_map) #H_assembled = np.linalg.inv(H_assembled) E21 = d(func_space_eg1) E21_assembled = assemble(mesh, E21, f2.function_space.dof_map.dof_map, ui.function_space.dof_map.dof_map, mode = 'replace') # %% #uo.cochain = E10_assembled.dot(p0_exact.cochain) #uo.reconstruct(xi, eta) #(x, y), data_dx, data_dy = uo.export_to_plot() #plt.contourf(x, y, data_dx) #plt.title('test lobatto outer 1-form dx') #plt.colorbar() #plt.show() # #plt.contourf(x, y, data_dy) #plt.title('test lobatto outer 1-form dy') #plt.colorbar() #plt.show() # #cochain_internal = H_assembled.dot(uo.cochain) #ui.cochain = np.concatenate((cochain_internal, np.zeros(ui.function_space.num_dof - ui.basis.num_basis * ui.mesh.num_elements )), axis=0) #ui.reconstruct(xi, eta) #(x, y), data_dx, data_dy = ui.export_to_plot() #plt.contourf(x, y, data_dx) #plt.title('test extended gauss inner 1-form dx') #plt.colorbar() #plt.show() # #plt.contourf(x, y, data_dy) #plt.title('test extended gauss inner 1-form dy') #plt.colorbar() #plt.show() # %% # system: # | I H*E10 | | ui | | 0 | # | | | | = | | # | E21 0 | | p | | f | ui_num_dof_internal = ui.basis.num_basis * ui.mesh.num_elements ui_num_dof_external = ui.function_space.num_dof - ui_num_dof_internal LHS1 = np.hstack(( np.eye(ui_num_dof_internal) , np.zeros((ui_num_dof_internal, ui_num_dof_external)), -H_assembled.dot(E10_assembled) )) LHS3 = np.hstack(( E21_assembled , np.zeros((f2.function_space.num_dof, p0.function_space.num_dof )) )) RHS1 = np.zeros((ui_num_dof_internal, 1 )) RHS3 = f2_exact.cochain.reshape( (f2_exact.function_space.num_dof,1) ) LHS3[-1,:] = 0 LHS3[-1,-1] = 1 RHS3[-1,0] = 0 # %% boundary edges def UBC(mesh, s, p, position): def pullbackedfun_dx(xi, eta): x, y = mesh.mapping(xi, eta, s) return ufun_u(x, y) def pullbackedfun_dy(xi, eta): x, y = mesh.mapping(xi, eta, s) return ufun_v(x, y) def fun2bint_dxi(xi, eta): return pullbackedfun_dx(xi, eta) * mesh.dx_dxi(xi, eta, s) + pullbackedfun_dy(xi, eta) * mesh.dy_dxi(xi, eta, s) def fun2bint_deta(xi, eta): return pullbackedfun_dx(xi, eta) * mesh.dx_deta(xi, eta, s) + pullbackedfun_dy(xi, eta) * mesh.dy_deta(xi, eta, s) UBC_s = np.zeros(shape = (p+1)) extended_gauss_nodes, _ = extended_gauss_quad(p-1) if position == 'Left': for i in range(p+1): # print("hello, Left world") def fun2bint_deta_BC(eta): return fun2bint_deta(-1, eta) UBC_s[i] = quad(fun2bint_deta_BC, extended_gauss_nodes[i], extended_gauss_nodes[i+1] )[0] elif position == 'Right': for i in range(p+1): # print("hello, Right world") def fun2bint_deta_BC(eta): return fun2bint_deta(+1, eta) UBC_s[i] = quad(fun2bint_deta_BC, extended_gauss_nodes[i], extended_gauss_nodes[i+1] )[0] elif position == 'Bottom': for i in range(p+1): # print("hello, Bottom world") def fun2bint_dxi_BC(xi): return fun2bint_dxi(xi, -1) UBC_s[i] = quad(fun2bint_dxi_BC, extended_gauss_nodes[i], extended_gauss_nodes[i+1] )[0] elif position == 'Top': for i in range(p+1): # print("hello, Top world") def fun2bint_dxi_BC(xi): return fun2bint_dxi(xi, +1) UBC_s[i] = quad(fun2bint_dxi_BC, extended_gauss_nodes[i], extended_gauss_nodes[i+1] )[0] return UBC_s def extended_gauss1_general_boundary_edges(mesh, p, gathering_matrix): p+=1 nx = mesh.n_x ny = mesh.n_y Left = np.zeros( shape = (ny*(p+1)), dtype=np.int32 ) Right = np.zeros( shape = (ny*(p+1)), dtype=np.int32 ) Bottom = np.zeros( shape = (nx*(p+1)), dtype=np.int32 ) Top = np.zeros( shape = (nx*(p+1)), dtype=np.int32 ) M = 2 * p * (p+1) N = p+1 UBC_L = UBC_R = UBC_B = UBC_T = 0 for J in range(ny): eleidLeft = J Left[ J*N : J*N + N ] = gathering_matrix[ eleidLeft , M +2*N : M +3*N ] UBC_s=UBC(mesh, eleidLeft, p, "Left") if UBC_L is 0: UBC_L= UBC_s else: UBC_L = np.hstack((UBC_L, UBC_s)) eleidRight = (nx-1)*ny + J Right[ J*N : J*N + N ] = gathering_matrix[ eleidRight, M +3*N : M +4*N ] UBC_s=UBC(mesh, eleidRight, p, "Right") if UBC_R is 0: UBC_R= UBC_s else: UBC_R = np.hstack((UBC_R, UBC_s)) for I in range(nx): eleidBottom = I*ny Bottom[ I*N : I*N + N ] = gathering_matrix[ eleidBottom, M : M + N ] UBC_s=UBC(mesh, eleidBottom, p, "Bottom") if UBC_B is 0: UBC_B= UBC_s else: UBC_B = np.hstack((UBC_B, UBC_s)) eleidTop = I*ny + ny -1 Top[ I*N : I*N + N ] = gathering_matrix[ eleidTop , M + N : M + 2*N ] UBC_s=UBC(mesh, eleidTop, p, "Top") if UBC_T is 0: UBC_T= UBC_s else: UBC_T = np.hstack((UBC_T, UBC_s)) return np.vstack((Left, UBC_L)), np.vstack((Right, UBC_R)), np.vstack((Bottom, UBC_B)), np.vstack((Top, UBC_T)) Left, Right, Bottom, Top = extended_gauss1_general_boundary_edges(mesh, px, ui.function_space.dof_map.dof_map) Boundaryedgs = np.hstack( (Left, Right, Bottom, Top) ) LBC = np.zeros( shape = ( np.shape(Boundaryedgs)[1], ui.function_space.num_dof + p0.function_space.num_dof ) ) RBC = np.zeros( shape = ( np.shape(Boundaryedgs)[1], 1) ) for i in range(np.shape(Boundaryedgs)[1]): LBC[i, int(Boundaryedgs[0, i])] =1 RBC[i] = Boundaryedgs[1, i] #ui.cochain = np.concatenate((cochain_internal, Bottom[1,:], Top[1,:], Left[1,:], Right[1,:])) #f2.cochain = E21_assembled.dot(ui.cochain) #f2.discretize(ffun) #f2.reconstruct(xi, eta) #(x, y), data = f2.export_to_plot() #plt.contourf(x, y, data) #plt.title('test extended-gauss 2-form, f2') #plt.colorbar() #plt.show() #size_Left = np.size( Left ) /2 # %% def dof_map_crazy_lobatto_point_pair(mesh, p, global_numbering): nx, ny = mesh.n_x, mesh.n_y N = p+1 interface_point_pair = np.zeros( ( ( (nx - 1) * ny + nx * (ny - 1) ) * N, 2 ), dtype=np.int32 ) n = 0 for i in range(nx - 1): for j in range(ny): s1 = j + i * ny s2 = j + (i + 1) * ny # print(s1, s2) for m in range(N): interface_point_pair[n, 0] = global_numbering[s1, N * p + m] interface_point_pair[n, 1] = global_numbering[s2, m] # if j < ny-1 and m == N-1: # interface_point_pair[n, 0] = interface_point_pair[n, 1] = 0 n += 1 for i in range(nx): for j in range(ny - 1): s1 = j + i * ny s2 = j + 1 + i * ny # print(s1, s2) for m in range(N): interface_point_pair[n, 0] = global_numbering[s1, (m+1)*N -1] interface_point_pair[n, 1] = global_numbering[s2, m*N] n += 1 return interface_point_pair interface_point_pair = dof_map_crazy_lobatto_point_pair(mesh, px+1, p0.function_space.dof_map.dof_map) Lintface = np.zeros( shape = ( np.shape( interface_point_pair )[0], ui.function_space.num_dof + p0.function_space.num_dof ) ) #Rintface = np.zeros( shape = ( np.shape( interface_point_pair )[0]-(nx-1)*(ny-1), 1) ) Rintface = np.zeros( shape = ( np.shape( interface_point_pair )[0], 1) ) for i in range( np.shape( interface_point_pair )[0] ): if interface_point_pair[i, 0] == interface_point_pair[i, 1] == 0: pass else: Lintface[i, ui.function_space.num_dof + interface_point_pair[i, 0]] = 1 Lintface[i, ui.function_space.num_dof + interface_point_pair[i, 1]] = -1 # %% #Lintface=Lintface[~np.all(Lintface == 0, axis=1)] LHS = np.vstack( (LHS1, LHS3, Lintface, LBC) ) RHS = np.vstack( (RHS1, RHS3, Rintface, RBC) ) #rrefLHS = np.array(Matrix(LHS).rref()[0]).astype(None) #print(rrefLHS) # solution= np.linalg.lstsq(LHS,RHS) sLHS = sparse.csr_matrix(LHS) solution = sparse.linalg.lsqr(sLHS,RHS) Res = solution[0].reshape((np.size(solution[0]),1)) residual = np.sum(np.abs(LHS.dot(Res) - RHS)) print("residual=",residual) # %% ui.cochain = Res[0:ui.function_space.num_dof].reshape(ui.function_space.num_dof) p0.cochain = Res[-p0.function_space.num_dof:].reshape(p0.function_space.num_dof) # %% view the result p0.reconstruct(xi, eta) (x, y), data = p0.export_to_plot() plt.contourf(x, y, data) plt.title('solution lobatto 0-form, p0') plt.colorbar() plt.show() print('p0 max:', np.max(data)) print('p0 min:', np.min(data)) # # ui.reconstruct(xi, eta) (x, y), data_dx, data_dy = ui.export_to_plot() plt.contourf(x, y, data_dx) plt.title('solution extended_gauss 1-form dx') plt.colorbar() plt.show() print('ui max:', np.max(data_dx)) print('ui min:', np.min(data_dx)) plt.contourf(x, y, data_dy) plt.title('solution extended_gauss 1-form dy') plt.colorbar() plt.show() print('ui max:', np.max(data_dy)) print('ui min:', np.min(data_dy)) L2_error_p0 = p0.l_2_norm(pfun, ('gauss', 40))[0] print(L2_error_p0) L2_error_ui = ui.l_2_norm((ufun_u, ufun_v), ('lobatto', 40))[0] print(L2_error_ui) return L2_error_p0, L2_error_ui
glE21 = d_21_lobatto_outer((px + 1, py + 1)) #glE21 = d(func_space_gl1) glE21_assembled = assemble(glE21, (func_space_gl2, func_space_gl1)) fn = Form(func_space_gl2) fn.cochain = glE21_assembled.dot(un1.cochain) #fo2 = d(uo1) #fn.reconstruct(xi, eta) #(x, y), data = fn.export_to_plot() #plt.contourf(x, y, data) #plt.title('2). lobatto f^{(n)} dx \wedge dy') #plt.colorbar() #plt.show() # %% H02gl = hodge(func_space_gl2) H02gl_assembled = assemble(H02gl, (func_space_eg0, func_space_gl2)) f0 = Form(func_space_eg0) f0_cochain_internal = H02gl_assembled.dot(fn.cochain) f0.cochain = np.concatenate( (f0_cochain_internal, np.zeros(f0.function_space.num_dof - f0.basis.num_basis * f0.mesh.num_elements)), axis=0) #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()