def plot_function_2d(mesh, f, result_path): n = mesh.num_vertices() d = mesh.geometry().dim() # Create the triangulation mesh_coordinates = mesh.coordinates().reshape((n, d)) triangles = np.asarray([cell.entities(0) for cell in cells(mesh)]) triangulation = tri.Triangulation(mesh_coordinates[:, 0], mesh_coordinates[:, 1], triangles) # Get the z values as face colors for each triangle(midpoint) plt.figure() zfaces = np.asarray([f(cell.midpoint()) for cell in cells(mesh)]) plt.tripcolor(triangulation, facecolors=zfaces, edgecolors='k') fig = plt.gcf() fig.savefig(result_path + "-faces.eps") # Get the z values for each vertex plt.figure() z = np.asarray([f(point) for point in mesh_coordinates]) plt.tripcolor(triangulation, z, edgecolors='k') plt.xlabel('x') plt.ylabel('u') fig = plt.gcf() fig.savefig(result_path + "-vertices.eps")
def bulk_marking(mesh, distr, theta): marking = CellFunction("bool", mesh) distr_0 = sorted(distr, reverse=True)[int(len(distr) * theta)] for cell in cells(mesh): marking[cell] = distr[cell.index()] > distr_0 return marking
def estimate(self, solution): mesh = solution.function_space().mesh() # Define cell and facet residuals R_T = -(self.rhs_f + div(grad(solution))) n = FacetNormal(mesh) R_dT = dot(grad(solution), n) # Will use space of constants to localize indicator form Constants = FunctionSpace(mesh, "DG", 0) w = TestFunction(Constants) h = CellSize(mesh) # Define form for assembling error indicators form = (h ** 2 * R_T ** 2 * w * dx + avg(h) * avg(R_dT) ** 2 * 2 * avg(w) * dS) # + h * R_dT ** 2 * w * ds) # Assemble error indicators indicators = assemble(form) # Calculate error error_estimate = sqrt(sum(i for i in indicators.array())) # Take sqrt of indicators indicators = np.array([sqrt(i) for i in indicators]) # Mark cells for refinement based on maximal marking strategy largest_error = max(indicators) cell_markers = MeshFunction("bool", mesh, mesh.topology().dim()) for c in cells(mesh): cell_markers[c] = indicators[c.index()] > (self.fraction * largest_error) return error_estimate, cell_markers
def averaged_marking(mesh, distr): cells_num = mesh.num_cells() marking = CellFunction("bool", mesh) distr_aver = sum(distr) / cells_num for c in cells(mesh): marking[c] = distr[c.index()] >= distr_aver return marking
def error_majorant_distribution_nd(mesh, dim, ed_var, md_var, mf_var, V_exact): cell_num = mesh.num_cells() ed_distr = allocate_array_1d(cell_num) md_distr = allocate_array_1d(cell_num) maj_distr = allocate_array_1d(cell_num) md = project(md_var, V_exact) mf = project(mf_var, V_exact) ed = project(ed_var, V_exact) scheme_order = 4 gauss = integrators.SpaceIntegrator(scheme_order, dim) for c in cells(mesh): # Obtaining the coordinates of the vertices in the cell verts = c.get_vertex_coordinates().reshape(dim + 1, dim) x_n_transpose = verts.T # Calculating the area of the cell matrix = postprocess.allocate_array_2d(dim + 1, dim + 1) matrix[0:dim, 0:dim + 1] = x_n_transpose matrix[dim, 0:dim + 1] = numpy.array([1.0 for i in range(dim + 1)]) meas = float(1.0 / math.factorial(dim)) * abs(numpy.linalg.det(matrix)) ed_distr[c.index()] = gauss.integrate(ed, meas, x_n_transpose) md_distr[c.index()] = gauss.integrate(md, meas, x_n_transpose) maj_distr[c.index()] = gauss.integrate(mf, meas, x_n_transpose) print "ed_distr int total = %8.2e" % numpy.sum(ed_distr) print "md_distr int total = %8.2e" % numpy.sum(md_distr) print "maj_distr int total = %8.2e\n" % numpy.sum(maj_distr) return ed_distr, md_distr, maj_distr, ed, md, mf
def plot_carpet_2d(mesh, f, result_path): num_vert = mesh.num_vertices() num_cells = mesh.num_cells() d = mesh.geometry().dim() # Create the triangulation mesh_coordinates = mesh.coordinates().reshape((num_vert, d)) triangles = numpy.asarray([cell.entities(0) for cell in cells(mesh)]) triangulation = tri.Triangulation(mesh_coordinates[:, 0], mesh_coordinates[:, 1], triangles) fig = plt.figure() # add labels plt.figure() plt.xlabel('x') plt.ylabel('y') # change the font matplotlib.rcParams.update({'font.size': 16, 'font.family': 'serif'}) z = numpy.asarray([f(point) for point in mesh_coordinates]) plt.tripcolor(triangulation, z, cmap=cm.coolwarm, edgecolors='k') fig = plt.gcf() fig.savefig(result_path + "-cells-%d-vertices-%d.eps" % (num_cells, num_vert))
def get_2d_slice_of_3d_function_on_Oz(mesh, u, T, dim, v_degree): # create a boundary mesh bmesh = BoundaryMesh(mesh, "exterior") cell_func = CellFunction('size_t', bmesh, 0) coordinates = bmesh.coordinates() z_indeces = postprocess.allocate_array(dim) for cell in cells(bmesh): indx = 0 for vertex in vertices(cell): z_indeces[indx] = coordinates[vertex.index()][dim - 1] indx += 1 #print "Vertex index with coordinates", vertex.index(), coordinates[vertex.index()][dim-1] if (dim == 3 and near(z_indeces[0], T) and near(z_indeces[1], T) and near(z_indeces[2], T)) or (dim == 2 and near( z_indeces[0], T) and near(z_indeces[1], T)): #print "right cell", cell.index() cell_func[cell] = 1 submesh = SubMesh(bmesh, cell_func, 1) # create a FunctionSpace on the submesh- Vs = FunctionSpace(submesh, "Lagrange", v_degree) us = interpolate(u, Vs) return us, submesh
def plot_carpet_2d(mesh, f, result_path): num_vert = mesh.num_vertices() num_cells = mesh.num_cells() d = mesh.geometry().dim() # Create the triangulation mesh_coordinates = mesh.coordinates().reshape((num_vert, d)) triangles = numpy.asarray([cell.entities(0) for cell in cells(mesh)]) triangulation = tri.Triangulation(mesh_coordinates[:, 0], mesh_coordinates[:, 1], triangles) # Get the z values as face colors for each triangle(midpoint) fig = plt.figure() # Get the z values for each vertex plt.figure() plt.xlabel('x') plt.ylabel('y') z = numpy.asarray([f(point) for point in mesh_coordinates]) plt.tripcolor(triangulation, z, cmap=cm.coolwarm, edgecolors='k') fig = plt.gcf() fig.savefig(result_path + "-cells-%d-vertices-%d.eps" % (num_cells, num_vert)) plt.close('all')
def construct_A_from_mesh_functions(dim, A_expr, mesh): if dim == 2: a01 = MeshFunction("double", mesh, dim) a11 = MeshFunction("double", mesh, dim) A1 = A_expr[0] A2 = A_expr[1] a00 = MeshFunction("double", mesh, dim) for cell in cells(mesh): if cell.midpoint().x() < 0.5: if dim == 2: a00[cell] = A1[0][0] a11[cell] = A1[1][1] a01[cell] = A1[0][1] else: if dim == 2: a00[cell] = A2[0][0] a11[cell] = A2[1][1] a01[cell] = A2[0][1] # Code for C++ evaluation of conductivity conductivity_code = """ class Conductivity : public Expression { public: // Create expression with 3 components Conductivity() : Expression(3) {} // Function for evaluating expression on each cell void eval(Array<double>& values, const Array<double>& x, const ufc::cell& cell) const { const uint D = cell.topological_dimension; const uint cell_index = cell.index; values[0] = (*a00)[cell_index]; values[1] = (*a01)[cell_index]; values[2] = (*a11)[cell_index]; } // The data stored in mesh functions std::shared_ptr<MeshFunction<double> > a00; std::shared_ptr<MeshFunction<double> > a01; std::shared_ptr<MeshFunction<double> > a11; }; """ a = Expression(cppcode=conductivity_code) a.a00 = a00 a.a01 = a01 a.a11 = a11 A = as_matrix(((a[0], a[1]), (a[1], a[2]))) return A
def error_majorant_distribution_nd(mesh, domain, dim, u_e, grad_u_e, u, V_exact, y, f, lmbd, beta): cell_num = mesh.num_cells() #e_distr = postprocess.allocate_array(cell_num) #m_distr = postprocess.allocate_array(cell_num) ed_distr = postprocess.allocate_array(cell_num) md_distr = postprocess.allocate_array(cell_num) # Define error and residuals r_d = abs(Grad(u, dim) - y) r_f = abs(f + Div(y, dim) - lmbd * u) #C_FD = calculate_CF_of_domain(domain, dim) u_ve = interpolate(u, V_exact) u_exact_ve = interpolate(u_e, V_exact) e = u_ve - u_exact_ve #w_opt = (C_FD ** 2) * (1 + beta) / (beta + (C_FD ** 2) * (1 + beta) * lmbd) # Project UFL forms on the high-order functional space to obtain functions #ed = project(sqrt(inner(Grad(e, dim), Grad(e, dim))), V_exact) #md = project(sqrt(inner(r_d, r_d)), V_exact) ed = project(inner(Grad(e, dim), Grad(e, dim)), V_exact) md = project(inner(r_d, r_d), V_exact) #ed_test = assemble(sqrt(inner(Grad(e, dim), Grad(e, dim))) * dx) #md_test = assemble(sqrt(inner(r_d, r_d)) * dx) #e = project(sqrt(inner(Grad(e, dim), Grad(e, dim)) + lmbd * inner(e, e)), V_exact) #m = project(sqrt((1 + beta) * inner(r_d, r_d) + w_opt * inner(r_f, r_f)), V_exact) dofmap = V_exact.dofmap() scheme_order = 4 gauss = integration.SpaceIntegrator(scheme_order, dim) for c in cells(mesh): verts = dofmap.tabulate_coordinates(c) x_n = verts[0:dim + 1, :] x_n_transpose = x_n.transpose() matrix = postprocess.allocate_array_2d(dim + 1, dim + 1) matrix[0:dim, 0:dim + 1] = x_n_transpose matrix[dim, 0:dim + 1] = numpy.array([1.0 for i in range(dim + 1)]) meas = abs(numpy.linalg.det(matrix)) ed_distr[c.index()] = gauss.integrate(ed, meas, x_n_transpose) md_distr[c.index()] = gauss.integrate(md, meas, x_n_transpose) #e_distr[c.index()] = gauss.integrate(e, meas, x_n_transpose) #m_distr[c.index()] = gauss.integrate(m, meas, x_n_transpose) print 'sum of m_cells', numpy.sum(md_distr) print 'sum of e_cells', numpy.sum(ed_distr) return ed_distr, md_distr
def smoothness_distribution(u, mesh, dim): cell_num = mesh.num_cells() smoothness = postprocess.allocate_array(cell_num) for c in cells(mesh): # vert: num of vertices # horiz: dimension verts = c.get_vertex_coordinates().reshape(dim + 1, dim) u_inf_norm = l_inf_norm(u, verts, dim) h = c.h() denominator = h / 2 * assemble_local(inner( grad(u), grad(u)) * dx, c) + 2 / h * assemble_local(u * u * dx, c) F_c = u_inf_norm**2 / denominator smoothness[c.index()] = F_c return smoothness
def plot_function_3d(mesh, f, result_path): from mpl_toolkits.mplot3d import Axes3D from matplotlib import cm num_vert = mesh.num_vertices() num_cells = mesh.num_cells() d = mesh.geometry().dim() mesh_coordinates = mesh.coordinates().reshape((num_vert, d)) triangles = numpy.asarray([cell.entities(0) for cell in cells(mesh)]) triangulation = tri.Triangulation(mesh_coordinates[:, 0], mesh_coordinates[:, 1], triangles) z = numpy.asarray([f(point) for point in mesh_coordinates]) # change the font matplotlib.rcParams.update({'font.size': 10, 'font.family': 'serif'}) fig = plt.figure() ax = fig.gca(projection='3d') ''' # customize ticks on the axises start, end = ax.get_zlim() ax.zaxis.set_ticks(numpy.arange(start, end, (end - start) / 3)) ax.zaxis.set_major_formatter(ticker.FormatStrFormatter('%0.2f')) start, end = ax.get_xlim() ax.xaxis.set_ticks(numpy.arange(start, end, (end - start) / 3)) ax.xaxis.set_major_formatter(ticker.FormatStrFormatter('%0.2f')) start, end = ax.get_ylim() ax.yaxis.set_ticks(numpy.arange(start, end, (end - start) / 3)) ax.yaxis.set_major_formatter(ticker.FormatStrFormatter('%0.2f')) ''' # add labels ax.set_xlabel('x') ax.set_ylabel('y') ax.set_zlabel('u') # ax.plot_trisurf(triangulation, z, cmap=cm.gray, linewidth=0.2) RdGy ax.plot_trisurf(triangulation, z, cmap=cm.BrBG, linewidth=0.2) # ax.plot_trisurf(triangulation, z, cmap=cm.jet, linewidth=0.2) fig.savefig(result_path + '-cells-%d-vertices-%d.eps' % (num_cells, num_vert)) plt.close('all')
def error_majorant_distribution_nd(mesh, dim, V_exact, var_grad_e, var_delta_e, var_m_d, var_m_f_w_opt, beta, C_FD): cell_num = mesh.num_cells() ed_distr = postprocess.allocate_array(cell_num) delta_e_distr = postprocess.allocate_array(cell_num) md_distr = postprocess.allocate_array(cell_num) maj_distr = postprocess.allocate_array(cell_num) # Project UFL forms on the high-order functional space to obtain functions ed = project((var_grad_e), V_exact) delta_e = project(var_delta_e, V_exact) md = project((var_m_d), V_exact) mf_wopt = project(var_m_f_w_opt, V_exact) scheme_order = 4 gauss = integration.SpaceIntegrator(scheme_order, dim) for c in cells(mesh): # Obtaining the coordinates of the vertices in the cell verts = c.get_vertex_coordinates().reshape(dim + 1, dim) x_n_transpose = verts.T # Calculating the area of the cell matrix = postprocess.allocate_array_2d(dim + 1, dim + 1) matrix[0:dim, 0:dim + 1] = x_n_transpose matrix[dim, 0:dim + 1] = numpy.array([1.0 for i in range(dim + 1)]) # print "matrix = ", matrix meas = abs(numpy.linalg.det(matrix)) # Integrating over the cell ed_distr[c.index()] = gauss.integrate(ed, meas, x_n_transpose) delta_e_distr[c.index()] = gauss.integrate(delta_e, meas, x_n_transpose) md_distr[c.index()] = gauss.integrate(md, meas, x_n_transpose) #maj_distr[c.index()] = gauss.integrate(mdf, meas, x_n_transpose) #print 'num md_cells', md_distr #print 'ed_cells', ed_distr #print 'delta_e_cells', delta_e_distr #print 'maj_cells', maj_distr #print 'e_cells', e_distr print '\nmd = Sum_K md_K = %8.2e' % sum(md_distr) print 'ed = Sum_K ed_K = %8.2e' % sum(ed_distr) return ed_distr, md_distr, maj_distr
def predefined_amount_of_elements_marking(mesh, distr, theta): cells_num = mesh.num_cells() marking = CellFunction("bool", mesh) marking.set_all(False) i_cut = int(math.floor(theta * cells_num)) index_sorted = sorted(range(len(distr)), key=lambda k: distr[k], reverse=True) cells_indices_to_refine = index_sorted[0:i_cut] for cell in cells(mesh): if cell.index() in cells_indices_to_refine: marking[cell] = True return marking
def plot_function_3d(mesh, f, result_path): from matplotlib import cm n_vert = mesh.num_vertices() n_cells = mesh.num_cells() d = mesh.geometry().dim() mesh_coordinates = mesh.coordinates().reshape((n_vert, d)) triangles = np.asarray([cell.entities(0) for cell in cells(mesh)]) triangulation = tri.Triangulation(mesh_coordinates[:, 0], mesh_coordinates[:, 1], triangles) z = np.asarray([f(point) for point in mesh_coordinates]) fig = plt.figure() ax = fig.gca(projection='3d') ax.plot_trisurf(triangulation, z, cmap=cm.coolwarm, linewidth=0.2) fig.savefig(result_path + "-cells-%d-vertices-%d.eps" % (n_cells, n_vert))
def construct_from_mesh_functions(dim, A_expr, mesh): """ :param dim: geometrical dimension :param A_expr: expression defining diffusion matrix :param mesh: mesh-discretization of the domain :return: cell-wise function """ # Define scalar cell-wise function for dim = 1 a00 = MeshFunction("double", mesh, dim) # Define function expression from the problem data (depending on how many of the conditions are discussed ) A1 = A_expr[0] A2 = A_expr[1] # Case for dimension higher then one (symmetric case) if dim >= 2: a01 = MeshFunction("double", mesh, dim) a11 = MeshFunction("double", mesh, dim) # Case for dimension higher then two (symmetric case) if dim >= 3: a02 = MeshFunction("double", mesh, dim) a12 = MeshFunction("double", mesh, dim) a22 = MeshFunction("double", mesh, dim) for cell in cells(mesh): if cell.midpoint().x( ) < 0.5: # this condition checks whethe the elements on the left part of the domain A = A_expr[0] else: A = A_expr[1] a00[cell] = A[0][0] if dim >= 2: a11[cell] = A[1][1] a01[cell] = A[0][1] if dim >= 3: a02[cell] = A[0][2] a12[cell] = A[1][2] a22[cell] = A[2][2] # Code for C++ evaluation of conductivity conductivity_code = """ class Conductivity : public Expression { public: // Create expression with 3 components Conductivity() : Expression(3) {} // Function for evaluating expression on each cell void eval(Array<double>& values, const Array<double>& x, const ufc::cell& cell) const { const uint D = cell.topological_dimension; const uint cell_index = cell.index; values[0] = (*a00)[cell_index]; values[1] = (*a01)[cell_index]; values[2] = (*a11)[cell_index]; } // The data stored in mesh functions std::shared_ptr<MeshFunction<double> > a00; std::shared_ptr<MeshFunction<double> > a01; std::shared_ptr<MeshFunction<double> > a11; }; """ # Define expression via C++ code a = Expression(cppcode=conductivity_code) a.a00 = a00 if dim >= 2: a.a01 = a01 a.a11 = a11 if dim >= 3: a.a02 = a02 a.a12 = a12 a.a22 = a22 # Define matrix depending on the dimension if dim == 1: A = a[0] elif dim == 2: # A = |a[0] a[1]| # |a[1] a[2]| A = as_matrix(((a[0], a[1]), (a[1], a[2]))) elif dim == 3: # A = |a[0] a[1] a[2]| # |a[1] a[3] a[4]| # |a[2] a[4] a[5]| A = as_matrix( ((a[0], a[1], a[2]), (a[1], a[3], a[4]), (a[2], a[3], a[5]))) return A
def error_majorant_distribution_nd(mesh, dim, V_exact, var_grad_e, var_delta_e, var_m_d, var_m_f_w_opt, beta): # Allocate arrays for error and majorant distributions cell_num = mesh.num_cells() ed_distr = postprocess.allocate_array(cell_num) delta_e_distr = postprocess.allocate_array(cell_num) md_distr = postprocess.allocate_array(cell_num) mf_distr = postprocess.allocate_array(cell_num) # Project UFL forms on the high-order functional space to obtain functions ed = project(var_grad_e, V_exact) delta_e = project(var_delta_e, V_exact) md = project(var_m_d, V_exact) mf_wopt = project(var_m_f_w_opt, V_exact) # Obtained the mapping #dofmap = V_exact #mesh_coordimates = dofmap. # Define integration scheme order and assign the integrator scheme_order = 4 gauss = integration.SpaceIntegrator(scheme_order, dim) # Iterate over cells of the mesh and obtain local value of the majorant for c in cells(mesh): # Obtaining the coordinates of the vertices in the cell verts = c.get_vertex_coordinates().reshape(dim + 1, dim) x_n_transpose = verts.T # Calculating the area of the cell matrix = postprocess.allocate_array_2d(dim + 1, dim + 1) matrix[0:dim, 0:dim + 1] = x_n_transpose matrix[dim, 0:dim + 1] = numpy.array([1.0 for i in range(dim + 1)]) #print "matrix = ", matrix meas = abs(numpy.linalg.det(matrix)) # Integrating over the cell ed_distr[c.index()] = gauss.integrate(ed, meas, x_n_transpose) delta_e_distr[c.index()] = gauss.integrate(delta_e, meas, x_n_transpose) md_distr[c.index()] = gauss.integrate(md, meas, x_n_transpose) mf_distr[c.index()] = gauss.integrate(mf_wopt, meas, x_n_transpose) # Calculate majorant based on the parameter value if sum(mf_distr) <= DOLFIN_EPS: maj_distr = md_distr else: if sum(md_distr) <= DOLFIN_EPS: maj_distr = mf_distr else: maj_distr = ( 1.0 + beta ) * md_distr + mf_distr # here (1 + 1/beta) weight is ommited since it is included into the optimal mf_wopt e_distr = ed_distr + delta_e_distr #print 'md_cells', md_distr #print 'ed_cells', ed_distr print 'sum md_cells', sum(md_distr) print 'sum maj_cells', sum(maj_distr) print 'sum e_cells', sum(e_distr) return ed_distr, delta_e_distr, e_distr, md_distr, mf_distr, maj_distr, ed, md