def construct_sleeve_geometry( t_wall=None, t_gap=None, t_sleeve=None, L_wall=None, L_sleeve=None, refinement_parameter=16, ): # # Define the domain as a polygon mesh = Mesh() domain = Polygon([ dolfin.Point(0.0, 0.0), dolfin.Point(L_wall, 0.0), dolfin.Point(L_wall, t_wall), dolfin.Point((L_wall - L_sleeve), t_wall), dolfin.Point((L_wall - L_sleeve), (t_wall + t_gap)), dolfin.Point(L_wall, (t_wall + t_gap)), dolfin.Point(L_wall, (t_sleeve + t_wall + t_gap)), dolfin.Point((L_wall - L_sleeve), (t_sleeve + t_wall + t_gap)), dolfin.Point((L_wall - L_sleeve - t_sleeve - t_gap), t_wall), dolfin.Point(0.0, t_wall), ], ) # # Define weld region weld_subdomain = Polygon([ dolfin.Point((L_wall - L_sleeve - t_sleeve - t_gap), t_wall), dolfin.Point((L_wall - L_sleeve), t_wall), dolfin.Point((L_wall - L_sleeve), (t_wall + t_sleeve + t_gap)), ]) domain.set_subdomain(1, weld_subdomain) # # Mesh mesh = generate_mesh(domain, refinement_parameter) # # Refine in the weld cell_markers = CellFunction("bool", mesh) cell_markers.set_all(False) c = is_in_weld_region( t_wall=t_wall, t_gap=t_gap, t_sleeve=t_sleeve, L_wall=L_wall, L_sleeve=L_sleeve, ) class MyDomain(SubDomain): def inside(self, x, on_boundary): return c(x) my_domain = MyDomain() my_domain.mark(cell_markers, True) mesh = refine(mesh, cell_markers) # # Define the upper and lower boundaries class Upper(SubDomain): def inside(self, x, on_boundary): # # Define relevant points xb1 = (L_wall - L_sleeve - t_sleeve - t_gap) xb2 = (L_wall - L_sleeve) yb1 = t_wall yb2 = (t_wall + t_sleeve + t_gap) # # Define params for assessing if on a line between points dx_line = xb2 - xb1 dy_line = yb2 - yb1 dx = x[0] - xb1 dy = x[1] - yb1 zero = dx * dy_line - dx_line * dy # is_upper_region_one = x[0] <= xb1 and near(x[1], yb1) is_upper_region_two = x[0] >= xb1 and x[0] <= xb2 and near(zero, 0) is_upper_region_three = x[0] >= xb2 and near(x[1], yb2) # return is_upper_region_one or is_upper_region_two or is_upper_region_three class Lower(SubDomain): def inside(self, x, on_boundary): return near(x[1], 0) # # Set boundaries upper = Upper() lower = Lower() boundaries = FacetFunction("size_t", mesh) boundaries.set_all(0) upper.mark(boundaries, 1) lower.mark(boundaries, 2) # return (mesh, boundaries)
def get_circle(): filename = inspect.getframeinfo(inspect.currentframe()).filename home = os.path.dirname(os.path.abspath(filename)) mesh = Mesh(home + '/test/circle.xml') mesh.coordinates()[:, 2] /= 1000.0 return mesh
# This script illustrates how the Xd-1d mesh could be makde from 1d from dolfin import Mesh, MeshFunction, Timer from mesh_around_1d import mesh_around_1d from meshconvert import convert2xml import subprocess, os import numpy as np timer = Timer('Meshing') timer.start() path = 'vasc_mesh.xml.gz' geo, _ = mesh_around_1d(path, size=1.) data = MeshFunction('int', Mesh(path), 'widths.xml.gz') out = subprocess.check_output(['gmsh', '--version'], stderr=subprocess.STDOUT) assert out.split('.')[0] == '3', 'Gmsh 3+ is required' ccall = 'gmsh -3 -optimize %s' % geo subprocess.call(ccall, shell=True) # Convert xml_file = 'vasc_GMSH.xml' msh_file = 'vacs_GMSH.msh' convert2xml(msh_file, xml_file) # Throw away the line function as it is expensive to store all the edges meshXd = Mesh(xml_file) # Make sure that the assumption of correspondence hold assert np.linalg.norm(mesh.coordinates() - meshXd.coordinates()[:mesh.num_vertices()]) < 1E-13
beta = (rk2.dot(zk2)) / (rk.dot(zk)) y1 = beta * pk pk = (zk2 + y1).copy() rk = rk2.copy() zk = zk2.copy() res4 = residual(Ah, bh, xk) print('residual after', ite + 1, 'iterations of CG is:', res4 / r0) return xk # =============================================================== # Read the meshes. Vspace = [] mesh = Mesh("./level_1.xml") V = VectorFunctionSpace(mesh, 'P', 1) Vspace.append(V) mesh1 = Mesh("./level_2.xml") V1 = VectorFunctionSpace(mesh1, 'P', 1) Vspace.append(V1) mesh2 = Mesh("./level_3.xml") V2 = VectorFunctionSpace(mesh2, 'P', 1) Vspace.append(V2) mesh3 = Mesh("./level_4.xml") V3 = VectorFunctionSpace(mesh3, 'P', 1) Vspace.append(V3)
def get_greenland_2D_1H(): filename = inspect.getframeinfo(inspect.currentframe()).filename home = os.path.dirname(os.path.abspath(filename)) mesh = Mesh(home + '/greenland/greenland_2D_1H_mesh.xml') return mesh
def create_submesh(mesh, markers, marker): "This function allows for a SubMesh-equivalent to be created in parallel" # Build mesh submesh = Mesh() mesh_editor = MeshEditor() mesh_editor.open(submesh, mesh.ufl_cell().cellname(), mesh.ufl_cell().topological_dimension(), mesh.ufl_cell().geometric_dimension()) # Return empty mesh if no matching markers if MPI.sum(mpi_comm_world(), int(marker in markers.array())) == 0: cbc_warning( "Unable to find matching markers in meshfunction. Submesh is empty." ) mesh_editor.close() return submesh base_cell_indices = np.where(markers.array() == marker)[0] base_cells = mesh.cells()[base_cell_indices] base_vertex_indices = np.unique(base_cells.flatten()) base_global_vertex_indices = sorted( [mesh.topology().global_indices(0)[vi] for vi in base_vertex_indices]) gi = mesh.topology().global_indices(0) shared_local_indices = set(base_vertex_indices).intersection( set(mesh.topology().shared_entities(0).keys())) shared_global_indices = [gi[vi] for vi in shared_local_indices] unshared_global_indices = list( set(base_global_vertex_indices) - set(shared_global_indices)) unshared_vertices_dist = distribution(len(unshared_global_indices)) # Number unshared vertices on separate process idx = sum(unshared_vertices_dist[:MPI.rank(mpi_comm_world())]) base_to_sub_global_indices = {} for gi in unshared_global_indices: base_to_sub_global_indices[gi] = idx idx += 1 # Gather all shared process on process 0 and assign global index all_shared_global_indices = gather(shared_global_indices, on_process=0, flatten=True) all_shared_global_indices = np.unique(all_shared_global_indices) shared_base_to_sub_global_indices = {} idx = int( MPI.max(mpi_comm_world(), float(max(base_to_sub_global_indices.values() + [-1e16]))) + 1) if MPI.rank(mpi_comm_world()) == 0: for gi in all_shared_global_indices: shared_base_to_sub_global_indices[int(gi)] = idx idx += 1 # Broadcast global numbering of all shared vertices shared_base_to_sub_global_indices = dict( zip(broadcast(shared_base_to_sub_global_indices.keys(), 0), broadcast(shared_base_to_sub_global_indices.values(), 0))) # Join shared and unshared numbering in one dict base_to_sub_global_indices = dict( base_to_sub_global_indices.items() + shared_base_to_sub_global_indices.items()) # Create mapping of local indices base_to_sub_local_indices = dict( zip(base_vertex_indices, range(len(base_vertex_indices)))) # Define sub-cells sub_cells = [None] * len(base_cells) for i, c in enumerate(base_cells): sub_cells[i] = [base_to_sub_local_indices[j] for j in c] # Store vertices as sub_vertices[local_index] = (global_index, coordinates) sub_vertices = {} for base_local, sub_local in base_to_sub_local_indices.items(): sub_vertices[sub_local] = (base_to_sub_global_indices[ mesh.topology().global_indices(0)[base_local]], mesh.coordinates()[base_local]) ## Done with base mesh # Distribute meshdata on (if any) empty processes sub_cells, sub_vertices = distribute_meshdata(sub_cells, sub_vertices) global_cell_distribution = distribution(len(sub_cells)) #global_vertex_distribution = distribution(len(sub_vertices)) global_num_cells = MPI.sum(mpi_comm_world(), len(sub_cells)) global_num_vertices = sum(unshared_vertices_dist) + MPI.sum( mpi_comm_world(), len(all_shared_global_indices)) mesh_editor.init_vertices(len(sub_vertices)) #mesh_editor.init_cells(len(sub_cells)) mesh_editor.init_cells_global(len(sub_cells), global_num_cells) global_index_start = sum( global_cell_distribution[:MPI.rank(mesh.mpi_comm())]) for index, cell in enumerate(sub_cells): if LooseVersion(dolfin_version()) >= LooseVersion("1.6.0"): mesh_editor.add_cell(index, *cell) else: mesh_editor.add_cell(int(index), global_index_start + index, np.array(cell, dtype=np.uintp)) for local_index, (global_index, coordinates) in sub_vertices.items(): #print coordinates mesh_editor.add_vertex_global(int(local_index), int(global_index), coordinates) mesh_editor.close() submesh.topology().init(0, len(sub_vertices), global_num_vertices) submesh.topology().init(mesh.ufl_cell().topological_dimension(), len(sub_cells), global_num_cells) # FIXME: Set up shared entities # What damage does this do? submesh.topology().shared_entities(0)[0] = [] # The code below sets up shared vertices, but lacks shared facets. # It is considered incomplete, and therefore commented out ''' #submesh.topology().shared_entities(0)[0] = [] from dolfin import compile_extension_module cpp_code = """ void set_shared_entities(Mesh& mesh, std::size_t idx, const Array<std::size_t>& other_processes) { std::set<unsigned int> set_other_processes; for (std::size_t i=0; i<other_processes.size(); i++) { set_other_processes.insert(other_processes[i]); //std::cout << idx << " --> " << other_processes[i] << std::endl; } //std::cout << idx << " --> " << set_other_processes[0] << std::endl; mesh.topology().shared_entities(0)[idx] = set_other_processes; } """ set_shared_entities = compile_extension_module(cpp_code).set_shared_entities base_se = mesh.topology().shared_entities(0) se = submesh.topology().shared_entities(0) for li in shared_local_indices: arr = np.array(base_se[li], dtype=np.uintp) sub_li = base_to_sub_local_indices[li] set_shared_entities(submesh, base_to_sub_local_indices[li], arr) ''' return submesh
def convert(ifilename, handler): """ Convert from Abaqus. The Abaqus format first defines a node block, then there should be a number of elements containing these nodes. """ # Dictionary of nodes (maps node id to coordinates) nodes = {} # Dictionary of elements (maps cell id to list of cell nodes) elems = {} # Lists of nodes for given name (key) node_sets = {} # Lists of cells for given name (key) cell_sets = {} # Lists of surfaces for given name (key) in the format: # {'SS1': [set(['SS1_S1', 'S1']), set(['SS1_S4', 'S4'])]}, # where SS1 is the name of the surface, SS1_S1 is the name of the # cell list whose first face is to be selected, ... surface_sets = {} # Open file Abaqus file csv_file = csv.reader(open(ifilename, 'rb'), delimiter=',', skipinitialspace=True) node_set_name = None generate = None # Set intial state state state = State.Init # Read data from input file for l in csv_file: # Sanity check if (len(l) == 0): print "Ooops, zero length." if l[0].startswith('**'): # Pass over comments continue elif l[0].startswith('*'): # Have a keyword state = State.Unknown if l[0].lower() == "*heading": state = State.ReadHeading elif l[0].lower() == "*part": part_name = _read_part_name(l) elif l[0].lower() == "*end part": state = State.Invalid elif l[0].lower() == "*node": node_set_name = _create_node_list_entry(node_sets, l) state = State.ReadNodes elif l[0].lower() == "*element": cell_type, cell_set_name = _read_element_keywords(cell_sets, l) state = State.ReadCells elif l[0].lower() == "*nset": node_set_name, generate = _read_nset_keywords(node_sets, l) state = State.ReadNodeSet elif l[0].lower() == "*elset": cell_set_name, generate = _read_elset_keywords(cell_sets, l) if generate: print "WARNING: generation of *elsets not tested." state = State.ReadCellSet elif l[0].lower() == "*surface": surface_set_name, generate = _read_surface_keywords( surface_sets, l) state = State.ReadSurfaceSet else: print "WARNING: unrecognised Abaqus input keyword:", l[0] state = State.Unknown else: if state == State.ReadHeading: model_name = _read_heading(l) elif state == State.ReadNodes: node_id = int(l[0]) - 1 coords = [float(c) for c in l[1:]] nodes[node_id] = coords if node_set_name is not None: node_sets[node_set_name].add(node_id) elif state == State.ReadCells: cell_id = int(l[0]) - 1 cell_connectivity = [int(v) - 1 for v in l[1:]] elems[cell_id] = cell_connectivity if cell_set_name is not None: cell_sets[cell_set_name].add(cell_id) elif state == State.ReadNodeSet: try: if generate: n0, n1, increment = l node_range = range( int(n0) - 1, int(n1) - 1, int(increment)) node_range.append(int(n1) - 1) node_sets[node_set_name].update(node_range) else: # Strip empty term at end of list, if present if l[-1] == '': l.pop(-1) node_range = [int(n) - 1 for n in l] node_sets[node_set_name].update(node_range) except: print "WARNING: Non-integer node sets not yet supported." elif state == State.ReadCellSet: try: if generate: n0, n1, increment = l cell_range = range( int(n0) - 1, int(n1) - 1, int(increment)) cell_range.append(int(n1) - 1) cell_sets[cell_set_name].update(cell_range) else: # Strip empty term at end of list, if present if l[-1] == '': l.pop(-1) cell_range = [int(n) - 1 for n in l] cell_sets[cell_set_name].update(cell_range) except: print "WARNING: Non-integer element sets not yet supported." elif state == State.ReadSurfaceSet: # Strip empty term at end of list, if present if l[-1] == '': l.pop(-1) surface_sets[surface_set_name].update([tuple(l)]) elif state == State.Invalid: # part raise StandardError("Inavlid Abaqus parser state..") # Close CSV object del csv_file # Write data to XML file # Note that vertices/cells must be consecutively numbered, which # isn't necessarily the case in Abaqus. Therefore we enumerate and # translate original IDs to sequence indexes if gaps are present. # FIXME handler.set_mesh_type("tetrahedron", 3) process_facets = len(surface_sets) > 0 if process_facets: try: from dolfin import MeshEditor, Mesh except ImportError: _error( "DOLFIN must be installed to handle Abaqus boundary regions") mesh = Mesh() mesh_editor = MeshEditor() mesh_editor.open(mesh, 3, 3) node_ids_order = {} # Check for gaps in vertex numbering node_ids = nodes.keys() if len(node_ids) > 0: vertex_gap = (min(node_ids) != 0 or max(node_ids) != len(node_ids) - 1) for x, y in enumerate(node_ids): node_ids_order[y] = x # Maps Abaqus IDs to Dolfin IDs else: vertex_gap = True # Check for gaps in cell numbering elemids = elems.keys() if len(elemids) > 0: cell_gap = (min(elemids) != 0 or max(elemids) != len(elemids) - 1) else: cell_gap = True # Write vertices to XML file handler.start_vertices(len(nodes)) if process_facets: mesh_editor.init_vertices_global(len(nodes), len(nodes)) if not vertex_gap: for v_id, v_coords in nodes.items(): handler.add_vertex(v_id, v_coords) if process_facets: mesh_editor.add_vertex(v_id, np.array(v_coords, dtype=np.float_)) else: for idx, (v_id, v_coords) in enumerate(nodes.items()): handler.add_vertex(idx, v_coords) if process_facets: mesh_editor.add_vertex(idx, np.array(v_coords, dtype=np.float_)) handler.end_vertices() # Write cells to XML file handler.start_cells(len(elems)) if process_facets: mesh_editor.init_cells_global(len(elems), len(elems)) if not vertex_gap and not cell_gap: for c_index, c_data in elems.items(): for v_id in c_data: if not (0 <= v_id < len(nodes)): handler.error( "Element %s references non-existent node %s" % (c_index, v_id)) handler.add_cell(c_index, c_data) if process_facets: c_data_tmp = np.array(c_data) c_data_tmp.sort() mesh_editor.add_cell(c_index, np.array(c_data_tmp, dtype=np.uintp)) elif not vertex_gap and cell_gap: for idx, (c_index, c_data) in enumerate(elems.items()): for v_id in c_data: if not (0 <= v_id < len(nodes)): handler.error( "Element %s references non-existent node %s" % (c_index, v_id)) handler.add_cell(idx, c_data) if process_facets: c_data_tmp = np.array(c_data) c_data_tmp.sort() mesh_editor.add_cell(idx, np.array(c_data_tmp, dtype=np.uintp)) else: for idx, (c_id, c_data) in enumerate(elems.items()): c_nodes = [] for v_id in c_data: try: c_nodes.append(node_ids_order[v_id]) except ValueError: handler.error( "Element %s references non-existent node %s" % (c_id, v_id)) handler.add_cell(idx, c_nodes) if process_facets: c_nodes.sort() mesh_editor.add_cell(idx, np.array(c_nodes, dtype=np.uintp)) handler.end_cells() # Write MeshValueCollections to XML file handler.start_domains() # Build a abaqus node ID -> dolfin cell ID map (which is not unique but that is irrelevant here) # and its local entity. if len(node_sets.items()) > 0: node_cell_map = {} for c_dolfin_index, (c_index, c_data) in enumerate(elems.items()): c_data_tmp = np.array(c_data) c_data_tmp.sort() for local_entity, n_index in enumerate(c_data_tmp): node_cell_map[n_index] = (c_dolfin_index, local_entity) # Write vertex/node sets dim = 0 for value, (name, node_set) in enumerate(node_sets.items()): handler.start_mesh_value_collection(name, dim, len(node_set), "uint") for node in node_set: try: cell, local_entity = node_cell_map[node] handler.add_entity_mesh_value_collection( dim, cell, value, local_entity=local_entity) except KeyError: print "Warning: Boundary references non-existent node %s" % node handler.end_mesh_value_collection() # Write cell/element sets dim = 3 for name, s in cell_sets.items(): handler.start_mesh_value_collection(name, dim, len(s), "uint") for cell in s: handler.add_entity_mesh_value_collection(dim, cell, 0) handler.end_mesh_value_collection() # Write surface sets if process_facets: dim = 2 nodes_facet_map = _nodes_facet_map(mesh) data = [int(0)] * mesh.num_facets() S1 = [0, 1, 2] S2 = [0, 3, 1] S3 = [1, 3, 2] S4 = [2, 3, 0] node_selector = { 'S1': S1, 'S2': S2, 'S3': S3, 'S4': S4, } for index, (name, s) in enumerate(surface_sets.items()): cell_face_list = [] for cell_set_name, face_index in s: cell_face_list += [(cell, face_index) for cell in cell_sets[cell_set_name]] for cell, face in cell_face_list: cell_nodes = elems[cell] # Extract the face nodes face_nodes = [cell_nodes[i] for i in node_selector[face]] dolfin_face_nodes = [node_ids_order[n] for n in face_nodes] dolfin_face_nodes.sort() # Convert the face_nodes to dolfin IDs face_id = nodes_facet_map[tuple(dolfin_face_nodes)] data[face_id] = index + 1 # Create and initialise the mesh function handler.start_meshfunction("facet_region", dim, mesh.num_facets()) for index, physical_region in enumerate(data): handler.add_entity_meshfunction(index, physical_region) handler.end_meshfunction() handler.end_domains()
solver.parameters["absolute_tolerance"] = 1E-8 solver.parameters["monitor_convergence"] = True info(solver.parameters, True) # set_log_level(PROGRESS) does not work in fenics 2018.1.0 solver.solve(A, phi.vector(), b) ele_pos_list = params.ele_coords vals = extract_pots(phi, ele_pos_list) # np.save(os.path.join('results', save_as), vals) return vals if __name__ == '__main__': print('Loading meshes') mesh = Mesh(os.path.join("mesh", "slice_saline_model.xml")) subdomains = MeshFunction( "size_t", mesh, os.path.join("mesh", "slice_saline_model_physical_region.xml")) boundaries = MeshFunction( "size_t", mesh, os.path.join("mesh", "slice_saline_model_facet_region.xml")) for dipole in params.dipole_list: print('Now computing FEM for dipole: ', dipole['name']) src_pos = dipole['src_pos'] snk_pos = dipole['snk_pos'] print('Done loading meshes') fem_20 = main_slice_fem(mesh, subdomains, boundaries, src_pos, snk_pos) print('Done 4Shell-FEM-20') f = open(os.path.join('Numerical_' + dipole['name'] + '.npz'), 'wb') np.savez(f, fem_20=fem_20)
def test_eim_approximation_04(expression_type, basis_generation): """ This test is an extension of test 03. The aim of this script is to test that integration of a subdomain is correctly handled by DEIM. * EIM: not applicable, as there is no difference with respect to test 03. * DEIM: the integral in form definitions is now restricted to a subdomain. """ class MockProblem(ParametrizedProblem): def __init__(self, V, **kwargs): ParametrizedProblem.__init__(self, "") self.V = V def name(self): return "MockProblem_04_" + expression_type + "_" + basis_generation class ParametrizedFunctionApproximation(EIMApproximation): def __init__(self, V, subdomains, expression_type, basis_generation): self.V = V # Parametrized function to be interpolated mock_problem = MockProblem(V) f = ParametrizedExpression( mock_problem, "exp( - 2*pow(x[0]-mu[0], 2) - 2*pow(x[1]-mu[1], 2) )", mu=(0., 0.), element=V.ufl_element()) # Subdomain measure dx = Measure("dx")(subdomain_data=subdomains)(1) # folder_prefix = os.path.join("test_eim_approximation_04_tempdir", expression_type, basis_generation) assert expression_type in ("Vector", "Matrix") if expression_type == "Vector": v = TestFunction(V) form = f * v * dx # Call Parent constructor EIMApproximation.__init__(self, mock_problem, ParametrizedTensorFactory(form), folder_prefix, basis_generation) elif expression_type == "Matrix": u = TrialFunction(V) v = TestFunction(V) form = f * u * v * dx # Call Parent constructor EIMApproximation.__init__(self, mock_problem, ParametrizedTensorFactory(form), folder_prefix, basis_generation) else: # impossible to arrive here anyway thanks to the assert raise AssertionError("Invalid expression_type") # 1. Create the mesh for this test mesh = Mesh("../../../tutorials/01_thermal_block/data/thermal_block.xml") subdomains = MeshFunction( "size_t", mesh, "../../../tutorials/01_thermal_block/data/thermal_block_physical_region.xml" ) # 2. Create Finite Element space (Lagrange P1) V = FunctionSpace(mesh, "Lagrange", 1) # 3. Allocate an object of the ParametrizedFunctionApproximation class parametrized_function_approximation = ParametrizedFunctionApproximation( V, subdomains, expression_type, basis_generation) mu_range = [(-1.0, 1.0), (-1.0, 1.0)] parametrized_function_approximation.set_mu_range(mu_range) # 4. Prepare reduction with EIM parametrized_function_reduction_method = EIMApproximationReductionMethod( parametrized_function_approximation) parametrized_function_reduction_method.set_Nmax(20) parametrized_function_reduction_method.set_tolerance(0.) # 5. Perform the offline phase parametrized_function_reduction_method.initialize_training_set( 100, sampling=EquispacedDistribution()) reduced_parametrized_function_approximation = parametrized_function_reduction_method.offline( ) # 6. Perform an online solve online_mu = (-1., -1.) reduced_parametrized_function_approximation.set_mu(online_mu) reduced_parametrized_function_approximation.solve() # 7. Perform an error analysis parametrized_function_reduction_method.initialize_testing_set(100) parametrized_function_reduction_method.error_analysis()
k = 1 # Magnitude solid body rotation . Uh = np.pi # Timestepping Tend = 2.0 dt = Constant(0.02) num_steps = np.rint(Tend / float(dt)) # Output directory store_step = 5 outdir = "./../../results/SlottedDisk_l2/" # Mesh mesh = Mesh("./../../meshes/circle_0.xml") mesh = refine(refine(refine(mesh))) outfile = XDMFFile(mesh.mpi_comm(), outdir + "psi_h.xdmf") # Particle output fname_list = [outdir + "xp.pickle", outdir + "rhop.pickle"] property_list = [0, 1] # Set slotted disk psi0_expr = SlottedDisk(radius=rdisk, center=[xc, yc], width=rwidth, depth=0.0, degree=3, lb=lb,
def _main(): args = _parse_cmd_arguments() content = np.load(args.infile) data = content.item()["data"] n = content.item()["n"] # # plot statistics # axes0 = problem.get_ellipse_axes(alpha0).T.flatten() # plt.plot(axes0, label='axes lengths before') # axes1 = problem.get_ellipse_axes(out.x).T.flatten() # plt.plot(axes1, label='axes lengths opt') # plt.legend() # plt.grid() # Plot unperturbed MacAdam # colorio.plot_luo_rigg( # ellipse_scaling=1, colorio.save_macadam("macadam-native.png", ellipse_scaling=10, plot_rgb_triangle=False, n=n) points, cells = meshzoo.triangle(corners=np.array([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]), n=n) # https://bitbucket.org/fenics-project/dolfin/issues/845/initialize-mesh-from-vertices editor = MeshEditor() mesh = Mesh() editor.open(mesh, "triangle", 2, 2) editor.init_vertices(points.shape[0]) editor.init_cells(cells.shape[0]) for k, point in enumerate(points): editor.add_vertex(k, point[:2]) for k, cell in enumerate(cells): editor.add_cell(k, cell) editor.close() V = FunctionSpace(mesh, "CG", 1) def get_u(alpha): n = V.dim() ax = alpha[:n] ay = alpha[n:] ux = Function(V) ux.vector().set_local(ax) ux.vector().apply("") uy = Function(V) uy.vector().set_local(ay) uy.vector().apply("") return ux, uy # Plot perturbed MacAdam def transform(XY, data=data): is_solo = len(XY.shape) == 1 if is_solo: XY = np.array([XY]).T # print(XY) ux, uy = get_u(data) out = np.array([[ux(x, y) for x, y in XY.T], [uy(x, y) for x, y in XY.T]]) if is_solo: out = out[..., 0] return out # colorio.plot_luo_rigg( # ellipse_scaling=1, plt.figure() colorio.plot_macadam( ellipse_scaling=10, # xy_to_2d=problem.pade2d.eval, xy_to_2d=transform, plot_rgb_triangle=False, mesh_resolution=n, ) # plt.xlim(-0.2, 0.9) # plt.ylim(+0.0, 0.7) plt.savefig(f"macadam-{n:03d}.png") return
def __init__(self): # https://fenicsproject.org/qa/12891/initialize-mesh-from-vertices-connectivities-at-once points, cells, _, cell_data, _ = meshes.ball_in_tube_cyl.generate() # 2018.1 # self.mesh = Mesh( # dolfin.mpi_comm_world(), dolfin.cpp.mesh.CellType.Type_triangle, # points[:, :2], cells['triangle'] # ) with TemporaryDirectory() as temp_dir: tmp_filename = os.path.join(temp_dir, "test.xml") meshio.write_points_cells( tmp_filename, points, cells, cell_data=cell_data, file_format="dolfin-xml", ) self.mesh = Mesh(tmp_filename) V0_element = FiniteElement("CG", self.mesh.ufl_cell(), 2) V1_element = FiniteElement("B", self.mesh.ufl_cell(), 3) self.W = FunctionSpace(self.mesh, V0_element * V1_element) self.P = FunctionSpace(self.mesh, "CG", 1) # Define mesh and boundaries. class LeftBoundary(SubDomain): # pylint: disable=no-self-use def inside(self, x, on_boundary): return on_boundary and x[0] < GMSH_EPS left_boundary = LeftBoundary() class RightBoundary(SubDomain): # pylint: disable=no-self-use def inside(self, x, on_boundary): return on_boundary and x[0] > 1.0 - GMSH_EPS right_boundary = RightBoundary() class LowerBoundary(SubDomain): # pylint: disable=no-self-use def inside(self, x, on_boundary): return on_boundary and x[1] < GMSH_EPS lower_boundary = LowerBoundary() # class UpperBoundary(SubDomain): # # pylint: disable=no-self-use # def inside(self, x, on_boundary): # return on_boundary and x[1] > 5.0-GMSH_EPS class CoilBoundary(SubDomain): # pylint: disable=no-self-use def inside(self, x, on_boundary): # One has to pay a little bit of attention when defining the # coil boundary; it's easy to miss the edges closest to x[0]=0. return (on_boundary and x[1] > 1.0 - GMSH_EPS and x[1] < 2.0 + GMSH_EPS and x[0] < 1.0 - GMSH_EPS) coil_boundary = CoilBoundary() self.u_bcs = [ DirichletBC(self.W, (0.0, 0.0), right_boundary), DirichletBC(self.W.sub(0), 0.0, left_boundary), DirichletBC(self.W, (0.0, 0.0), lower_boundary), DirichletBC(self.W, (0.0, 0.0), coil_boundary), ] self.p_bcs = [] # self.p_bcs = [DirichletBC(Q, 0.0, upper_boundary)] return
def fluent2xml(ifilename, ofilename): """Converting from ANSYS Fluent format (.msh) to FEniCS xml format The fluent mesh (the .msh file) is basically stored as a list of vertices, and then a list of faces for each zone of the mesh, the interior and the boundaries.""" # Use regular expressions to identify sections and tokens found in a fluent file re_dimline = re.compile(r"\(2\s(\d)\)") re_comment = re.compile(r"\(0\s.*") re_zone_init = re.compile(r"\(10\s\(0\s(\w+)\s(\w+)\s(\d+)\s(\d+)\)\)") re_zone = re.compile(r"\(10\s\((\w+)\s(\w+)\s(\w+)\s(\d+)\s(\d)\)(\(|)") re_face_init = re.compile(r"\(13(\s*)\(0\s+(\w+)\s+(\w+)\s+(0|0 0)\)\)") re_face = re.compile( r"\(13(\s*)\((\w+)\s+(\w+)\s+(\w+)\s+(\w+)\s+(\w+)\)(\s*)(\(|)") re_periodic = re.compile(r"\(18.*\((\w+)\s+(\w+)\s+(\w+)\s+(\w+)\).*\(") re_pfaces = re.compile(r"((^\s)|)(\w+)(\s*)(\w+)") re_cells_init = re.compile( r"\(12(\s*)\(0(\s+)(\w+)(\s+)(\w+)(\s+)(0|0 0)\)\)") re_cells = re.compile(r"\(12.*\((\w+)\s+(\w+)\s+(\w+)\s+(\d+)\s+(\d+)\)\)") re_cells2 = re.compile( r"\(12(\s*)\((\w+)\s+(\w+)\s+(\w+)\s+(\w+)\s+(\w+)\)(\s*)(\(|)") re_zones = re.compile( r"\((45|39)\s+\((\d+)\s+(\S+)\s+(\S+).*\)\((.*|[0-9]+[\.]*[0-9]*)\)\)") re_parthesis = re.compile(r"(^\s*\)(\s*)|^\s*\)\)(\s*)|^\s*\(\s*)") # Declare som maps that will be built when reading in the lists of vertices and faces: cell_map = {} # Maps cell id with vertices boundary_cells = { } # List of cells attached to a boundary facet. Key is zone id zones = {} # zone information (not really used yet) def read_periodic(ifile, periodic_dx): """Scan past periodic section. Periodicity is computed by FEniCS.""" while 1: line = ifile.readline() a = re.search(re_pfaces, line) if a: continue break def read_zone_vertices(dim, Nmin, Nmax, ifile, editor): """Scan ifile for vertices and add to mesh_editor.""" # First line could be either just "(" or a regular vertex. # Check for initial paranthesis. If paranthesis then read a new line, else reset pos = ifile.tell() line = ifile.readline() if not re.search(re_parthesis, line): ifile.seek(pos) # reset # read Nmax-Nmin vertices for i in range(Nmin, Nmax + 1): line = ifile.readline() vertex = [eval(x) for x in line.split()] if dim == 2: editor.add_vertex(i - Nmin, vertex[0], vertex[1]) else: editor.add_vertex(i - Nmin, vertex[0], vertex[1], vertex[2]) def read_faces(zone_id, Nmin, Nmax, bc_type, face, ifile): """Read all faces and create cell_map + boundary maps.""" pos = ifile.tell() # current position line = ifile.readline() if not re.search( re_parthesis, line ): # check for initial paranthesis. If paranthesis then read a new line, else reset ifile.seek(pos) # read Nmax-Nmin faces for i in range(Nmin, Nmax + 1): line = ifile.readline() ln = line.split() if face == 0: nd = int(ln[0], 16) # Number of vertices nds = [int(x, 16) for x in ln[1:(nd + 1)]] cells = [int(x, 16) for x in ln[(nd + 1):]] else: nd = face nds = [int(x, 16) for x in ln[:nd]] cells = [int(x, 16) for x in ln[nd:]] if min(cells) == 0: # A boundary zone if zone_id in boundary_cells: boundary_cells[zone_id][max(cells)] = array(nds) else: boundary_cells[zone_id] = {max(cells): array(nds)} for c in cells: if c > 0: if not c in cell_map: cell_map[c] = copy(nds) else: cell_map[c] = list(Set(cell_map[c] + nds)) def scan_fluent_mesh(ifile, mesh, editor): """Scan fluent mesh and generate maps.""" dim = 0 one = 0 while 1: line = ifile.readline() if len(line) == 0: print 'Finished reading file\n' break if dim == 0: # Dimension usually comes first a = re.search(re_dimline, line) if a: print 'Reading dimensions\n' dim = int(a.group(1)) editor.open(mesh, dim, dim) continue if one == 0: # The total number of vertices a = re.search(re_zone_init, line) if a: print 'Reading zone info\n' one, num_vertices, dummy1, dummy2 = int(a.group(1)), \ int(a.group(2), 16), int(a.group(3), 16), int(a.group(4)) editor.init_vertices(num_vertices) continue a = re.search(re_zone, line) # Vertices if a: zone_id, first_id, last_id = int(a.group(1), 16), \ int(a.group(2), 16), int(a.group(3), 16) print 'Reading ', last_id - first_id + 1, ' vertices in zone ', zone_id + 1, '\n' read_zone_vertices(dim, first_id, last_id, ifile, editor) continue a = re.search(re_zones, line) # Zone info if a: print 'Reading zone info ', line dummy, zone_id, zone_type, zone_name, radius = \ int(a.group(1)), int(a.group(2)), a.group(3), \ a.group(4), a.group(5) zones[zone_id] = [zone_type, zone_name, radius] continue a = re.search(re_cells_init, line) # Get total number of cells/elements if a: print 'Reading cell info ', line first_id, tot_num_cells = int(a.group(3), 16), int(a.group(5), 16) editor.init_cells(tot_num_cells) continue a = re.search(re_cells, line) # Get the cell info. if a: zone_id, first_id, last_id, bc_type, element_type = \ int(a.group(1)), int(a.group(2), 16), int(a.group(3), 16), \ int(a.group(4), 16), int(a.group(5), 16) print 'Found ', last_id - first_id + 1, ' cells in zone ', zone_id, '\n' if last_id == 0: raise TypeError("Zero elements!") continue a = re.search(re_cells2, line) # Get the cell info. if a: raise TypeError( "Wrong cell type. Can only handle one single cell type") a = re.search(re_face_init, line) if a: print 'Reading total number of faces\n', line continue a = re.search(re_face, line) if a: print 'Reading faces ', line zone_id, first_id, last_id, bc_type, face_type = \ int(a.group(2), 16), int(a.group(3), 16), int(a.group(4), 16), \ int(a.group(5), 16), int(a.group(6), 16) read_faces(zone_id, first_id, last_id, bc_type, face_type, ifile) continue a = re.search(re_periodic, line) if a: print 'Scanning past periodic connectivity\n', line read_periodic(ifile, periodic_dx) continue if any([re.search(st, line) for st in (re_parthesis, re_comment)]) or \ not line.strip(): continue # Should not make it here raise IOError('Something went wrong reading fluent mesh.') def write_fenics_file(ofile, mesh, editor): dim = mesh.geometry().dim() for i in range(1, len(cell_map) + 1): if dim == 2: editor.add_cell(i - 1, cell_map[i][0] - 1, cell_map[i][1] - 1, cell_map[i][2] - 1) else: editor.add_cell(i - 1, cell_map[i][0] - 1, cell_map[i][1] - 1, cell_map[i][2] - 1, cell_map[i][3] - 1) mesh.order() # Set MeshValueCollections from info in boundary_cell #mvc = mesh.domains().markers(dim-1) md = mesh.domains() for zone, cells in boundary_cells.iteritems(): for cell, nds in cells.iteritems(): dolfin_cell = Cell(mesh, cell - 1) vertices_of_cell = dolfin_cell.entities(0) vertices_of_face = nds - 1 for jj, ff in enumerate(facets(dolfin_cell)): facet_vertices = ff.entities(0) if all(map(lambda x: x in vertices_of_face, facet_vertices)): local_index = jj break #mvc.set_value(cell-1, local_index, zone) md.set_marker((ff.index(), zone), dim - 1) ofile << mesh from dolfin import plot plot(mesh, interactive=True) print 'Finished writing FEniCS mesh\n' ifile = open(ifilename, "r") ofile = File(ofilename) mesh = Mesh() editor = MeshEditor() scan_fluent_mesh(ifile, mesh, editor) write_fenics_file(ofile, mesh, editor) ifile.close()
def test(path, type='mf'): '''Evolve the tile in (n, n) pattern checking volume/surface properties''' comm = mpi_comm_world() h5 = HDF5File(comm, path, 'r') tile = Mesh() h5.read(tile, 'mesh', False) init_container = lambda type, dim: ( MeshFunction('size_t', tile, dim, 0) if type == 'mf' else MeshValueCollection('size_t', tile, dim)) for n in (2, 4): data = {} checks = {} for dim, name in zip((2, 3), ('surfaces', 'volumes')): # Get the collection collection = init_container(type, dim) h5.read(collection, name) if type == 'mvc': collection = as_meshf(collection) # Data to evolve tile.init(dim, 0) e2v = tile.topology()(dim, 0) # Only want to evolve tag 1 (interfaces) for the facets. data[(dim, 1)] = np.array( [e2v(e.index()) for e in SubsetIterator(collection, 1)], dtype='uintp') if dim == 2: check = lambda m, f: assemble( FacetArea(m) * ds(domain=m, subdomain_data=f, subdomain_id=1) + avg(FacetArea(m)) * dS(domain=m, subdomain_data=f, subdomain_id=1)) else: check = lambda m, f: assemble( CellVolume(m) * dx( domain=m, subdomain_data=f, subdomain_id=1)) checks[ dim] = lambda m, f, t=tile, c=collection, n=n, check=check: abs( check(m, f) - n**2 * check(t, c)) / (n**2 * check(t, c)) t = Timer('x') mesh, mesh_data = TileMesh(tile, (n, n), mesh_data=data) info('\tTiling took %g s. Ncells %d, nvertices %d, \n' % (t.stop(), mesh.num_vertices(), mesh.num_cells())) foos = mf_from_data(mesh, mesh_data) # Mesh Functions from_mf = np.array([checks[dim](mesh, foos[dim]) for dim in (2, 3)]) mvcs = mvc_from_data(mesh, mesh_data) foos = as_meshf(mvcs) # Mesh ValueCollections from_mvc = np.array([checks[dim](mesh, foos[dim]) for dim in (2, 3)]) assert np.linalg.norm(from_mf - from_mvc) < 1E-13 # I ignore shared facets so there is bound to be some error in facets # Volume should match well print from_mf
}, 'neumann': { 'values': [[0., -1e5]], 'regions': [2], 'types': ['cauchy'] } } } } # First solve the inverse elastostatics problem. problem = fm.SolidMechanicsProblem(config) solver = fm.SolidMechanicsSolver(problem, fname_disp="results/unloaded_config.pvd") solver.full_solve() # Move the mesh using dolfin's ALE functionality from dolfin import ALE, Mesh ALE.move(problem.mesh, problem.displacement) mesh_copy = Mesh(problem.mesh) # Only need to change relevant entries in config config['mesh']['mesh_file'] = mesh_copy config['formulation']['inverse'] = False # Solve a 'forward' problem. problem = fm.SolidMechanicsProblem(config) solver = fm.SolidMechanicsSolver(problem, fname_disp="results/loaded_config.pvd") solver.full_solve()
def create_mesh(self, parameters): from dolfin import Point, XDMFFile import hashlib d = { 'rad': parameters['geometry']['rad'], 'rad2': parameters['geometry']['rad2'], 'meshsize': parameters['geometry']['meshsize'] } fname = 'circle' meshfile = "meshes/%s-%s.xml" % (fname, self.signature) if os.path.isfile(meshfile): # already existing mesh print("Meshfile %s exists" % meshfile) else: # mesh_template = open('scripts/sandwich_pert.template.geo' ) print("Create meshfile, meshsize {}".format( parameters['geometry']['meshsize'])) nel = int(parameters['geometry']['rad'] / parameters['geometry']['meshsize']) # geom = mshr.Circle(Point(0., 0.), parameters['geometry']['rad']) # mesh = mshr.generate_mesh(geom, nel) mesh_template = open('scripts/coin.geo') src = Template(mesh_template.read()) geofile = src.substitute(d) if MPI.rank(MPI.comm_world) == 0: with open("scripts/coin-%s" % self.signature + ".geo", 'w') as f: f.write(geofile) # cmd = 'gmsh scripts/coin-{}.geo -2 -o meshes/coin-{}.msh'.format(self.signature, self.signature) # print(check_output([cmd], shell=True)) # run in shell mode in case you are not run in terminal # cmd = 'dolfin-convert -i gmsh meshes/coin-{}.msh meshes/coin-{}.xml'.format(self.signature, self.signature) # Popen([cmd], stdout=PIPE, shell=True).communicate() # mesh_xdmf = XDMFFile("meshes/%s-%s.xdmf"%(fname, self.signature)) # mesh_xdmf.write(mesh) form_compiler_parameters = { "representation": "uflacs", "quadrature_degree": 2, "optimize": True, "cpp_optimize": True, } # import pdb; pdb.set_trace() mesh = Mesh("meshes/coin.xml") self.domains = MeshFunction('size_t', mesh, 'meshes/coin_physical_region.xml') # dx = dx(subdomain_data=domains) # plt.figure() # plot(self.domains) # visuals.setspines0() # plt.savefig(os.path.join(self.outdir,'domains-{}.pdf' # .format(hashlib.md5(str(d).encode('utf-8')).hexdigest()))) self.ds = Measure("exterior_facet", domain=mesh) self.dS = Measure("interior_facet", domain=mesh) self.dx = Measure("dx", metadata=form_compiler_parameters, subdomain_data=self.domains) return mesh
__date__ = "2014-04-10" __copyright__ = "Copyright (C) 2014 " + __author__ __license__ = "GNU Lesser GPL version 3 or any later version" from dolfin import Mesh, AutoSubDomain, near import os if not os.path.isfile("mesh/cylinder.xml"): try: os.system("gmsh mesh/cylinder.geo -2 -o mesh/cylinder.msh") os.system("dolfin-convert mesh/cylinder.msh mesh/cylinder.xml") os.system("rm mesh/cylinder.msh") except RuntimeError: raise "Gmsh is required to run this demo" mesh = Mesh("mesh/cylinder.xml") H = 0.41 L = 2.2 D = 0.1 center = 0.2 cases = {1: {'Um': 0.3, 'Re': 20.0}, 2: {'Um': 1.5, 'Re': 100.0}} # Specify boundary conditions Inlet = AutoSubDomain(lambda x, on_bnd: on_bnd and x[0] < 1e-8) Wall = AutoSubDomain(lambda x, on_bnd: on_bnd and near(x[1] * (H - x[1]), 0)) Cyl = AutoSubDomain(lambda x, on_bnd: on_bnd and x[0] > 1e-6 and x[0] < 1 and x[1] < 3 * H / 4 and x[1] > H / 4) Outlet = AutoSubDomain(lambda x, on_bnd: on_bnd and x[0] > L - 1e-8)
# Protecting self assert not(set(('geo', '.geo')) & set(args.cleanup)) try: msh_file, h5_file = args.io[:2] except ValueError: msh_file = args.io[0] root, ext = os.path.splitext(msh_file) h5_file = '.'.join([root, 'h5']) assert convert(msh_file, h5_file, args.save_mvc) if args.save_pvd: h5 = HDF5File(mpi_comm_world(), h5_file, 'r') mesh = Mesh() h5.read(mesh, 'mesh', False) surfaces = MeshFunction('size_t', mesh, mesh.topology().dim()-1, 0) volumes = MeshFunction('size_t', mesh, mesh.topology().dim(), 0) if not args.save_mvc: h5.read(surfaces, 'surfaces') h5.read(volumes, 'volumes') # The data is mesh value collections else: from tiling_cpp import fill_mf_from_mvc surfaces_mvc = MeshValueCollection('size_t', mesh, mesh.topology().dim()-1) h5.read(surfaces_mvc, 'surfaces') fill_mf_from_mvc(surfaces_mvc, surfaces)
def mesh_AcuteSquare(n=0): mbasename = 'AcuteSquareMesh2' mesh = Mesh(mbasename + '_%d.xml' % n) return mesh
def get_mesh(geo_name, mesh_name = "mesh/mesh.xml"): from dolfin import Mesh return Mesh("/".join([DATADIR, geo_name, mesh_name]))
def gmsh2xml(ifilename, handler): """Convert between .gmsh v2.0 format (http://www.geuz.org/gmsh/) and .xml, parser implemented as a state machine: 0 = read 'MeshFormat' 1 = read mesh format data 2 = read 'EndMeshFormat' 3 = read 'Nodes' 4 = read number of vertices 5 = read vertices 6 = read 'EndNodes' 7 = read 'Elements' 8 = read number of cells 9 = read cells 10 = done Afterwards, extract physical region numbers if they are defined in the mesh file as a mesh function. """ print("Converting from Gmsh format (.msh, .gmsh) to DOLFIN XML format") # The dimension of the gmsh element types supported here as well as the dolfin cell types for each dimension gmsh_dim = {15: 0, 1: 1, 2: 2, 4: 3} cell_type_for_dim = {1: "interval", 2: "triangle", 3: "tetrahedron" } # the gmsh element types supported for conversion supported_gmsh_element_types = [1, 2, 4, 15] # Open files ifile = open(ifilename, "r") # Scan file for cell type cell_type = None highest_dim = 0 line = ifile.readline() while line: # Remove newline line = line.rstrip("\n\r") # Read dimension if line.find("$Elements") == 0: line = ifile.readline() num_elements = int(line) if num_elements == 0: _error("No elements found in gmsh file.") line = ifile.readline() # Now iterate through elements to find largest dimension. Gmsh # format might include elements of lower dimensions in the element list. # We also need to count number of elements of correct dimensions. # Also determine which vertices are not used. dim_count = {0: 0, 1: 0, 2: 0, 3: 0} vertices_used_for_dim = {0: [], 1: [], 2: [], 3: []} # Array used to store gmsh tags for 1D (type 1/line), 2D (type 2/triangular) elements and 3D (type 4/tet) elements tags_for_dim = {0: [], 1: [], 2: [], 3: []} while line.find("$EndElements") == -1: element = line.split() elem_type = int(element[1]) num_tags = int(element[2]) if elem_type in supported_gmsh_element_types: dim = gmsh_dim[elem_type] if highest_dim < dim: highest_dim = dim node_num_list = [int(node) for node in element[3 + num_tags:]] vertices_used_for_dim[dim].extend(node_num_list) if num_tags > 0: tags_for_dim[dim].append(tuple(int(tag) for tag in element[3:3+num_tags])) dim_count[dim] += 1 else: #TODO: output a warning here. "gmsh element type %d not supported" % elem_type pass line = ifile.readline() else: # Read next line line = ifile.readline() # Check that we got the cell type and set num_cells_counted if highest_dim == 0: _error("Unable to find cells of supported type.") num_cells_counted = dim_count[highest_dim] vertex_set = set(vertices_used_for_dim[highest_dim]) vertices_used_for_dim[highest_dim] = None vertex_dict = {} for n,v in enumerate(vertex_set): vertex_dict[v] = n # Step to beginning of file ifile.seek(0) # Set mesh type handler.set_mesh_type(cell_type_for_dim[highest_dim], highest_dim) # Initialise node list (gmsh does not export all vertexes in order) nodelist = {} # Current state state = 0 # Write data num_vertices_read = 0 num_cells_read = 0 # Only import the dolfin objects if facet markings exist process_facets = False if len(tags_for_dim[highest_dim-1]) > 0: # first construct the mesh try: from dolfin import MeshEditor, Mesh except ImportError: _error("DOLFIN must be installed to handle Gmsh boundary regions") mesh = Mesh() mesh_editor = MeshEditor () mesh_editor.open( mesh, highest_dim, highest_dim ) process_facets = True else: # TODO: Output a warning or an error here me = None while state != 10: # Read next line line = ifile.readline() if not line: break # Skip comments if line[0] == '#': continue # Remove newline line = line.rstrip("\n\r") if state == 0: if line == "$MeshFormat": state = 1 elif state == 1: (version, file_type, data_size) = line.split() state = 2 elif state == 2: if line == "$EndMeshFormat": state = 3 elif state == 3: if line == "$Nodes": state = 4 elif state == 4: num_vertices = len(vertex_dict) handler.start_vertices(num_vertices) if process_facets: mesh_editor.init_vertices_global(num_vertices, num_vertices) state = 5 elif state == 5: (node_no, x, y, z) = line.split() node_no = int(node_no) x,y,z = [float(xx) for xx in (x,y,z)] if node_no in vertex_dict: node_no = vertex_dict[node_no] else: continue nodelist[int(node_no)] = num_vertices_read handler.add_vertex(num_vertices_read, [x, y, z]) if process_facets: if highest_dim == 1: coords = numpy.array([x]) elif highest_dim == 2: coords = numpy.array([x, y]) elif highest_dim == 3: coords = numpy.array([x, y, z]) mesh_editor.add_vertex(num_vertices_read, coords) num_vertices_read +=1 if num_vertices == num_vertices_read: handler.end_vertices() state = 6 elif state == 6: if line == "$EndNodes": state = 7 elif state == 7: if line == "$Elements": state = 8 elif state == 8: handler.start_cells(num_cells_counted) if process_facets: mesh_editor.init_cells_global(num_cells_counted, num_cells_counted) state = 9 elif state == 9: element = line.split() elem_type = int(element[1]) num_tags = int(element[2]) if elem_type in supported_gmsh_element_types: dim = gmsh_dim[elem_type] else: dim = 0 if dim == highest_dim: node_num_list = [vertex_dict[int(node)] for node in element[3 + num_tags:]] for node in node_num_list: if not node in nodelist: _error("Vertex %d of %s %d not previously defined." % (node, cell_type_for_dim[dim], num_cells_read)) cell_nodes = [nodelist[n] for n in node_num_list] handler.add_cell(num_cells_read, cell_nodes) if process_facets: cell_nodes = numpy.array([nodelist[n] for n in node_num_list], dtype=numpy.uintp) mesh_editor.add_cell(num_cells_read, cell_nodes) num_cells_read +=1 if num_cells_counted == num_cells_read: handler.end_cells() if process_facets: mesh_editor.close() state = 10 elif state == 10: break # Write mesh function based on the Physical Regions defined by # gmsh, but only if they are not all zero. All zero physical # regions indicate that no physical regions were defined. if highest_dim not in [1,2,3]: _error("Gmsh tags not supported for dimension %i. Probably a bug" % dim) tags = tags_for_dim[highest_dim] physical_regions = tuple(tag[0] for tag in tags) if not all(tag == 0 for tag in physical_regions): handler.start_meshfunction("physical_region", dim, num_cells_counted) for i, physical_region in enumerate(physical_regions): handler.add_entity_meshfunction(i, physical_region) handler.end_meshfunction() # Now process the facet markers tags = tags_for_dim[highest_dim-1] if (len(tags) > 0) and (mesh is not None): physical_regions = tuple(tag[0] for tag in tags) if not all(tag == 0 for tag in physical_regions): mesh.init(highest_dim-1,0) # Get the facet-node connectivity information (reshape as a row of node indices per facet) if highest_dim==1: # for 1d meshes the mesh topology returns the vertex to vertex map, which isn't what we want # as facets are vertices facets_as_nodes = numpy.array([[i] for i in range(mesh.num_facets())]) else: facets_as_nodes = mesh.topology()(highest_dim-1,0)().reshape ( mesh.num_facets(), highest_dim ) # Build the reverse map nodes_as_facets = {} for facet in range(mesh.num_facets()): nodes_as_facets[tuple(facets_as_nodes[facet,:])] = facet data = [int(0*k) for k in range(mesh.num_facets()) ] for i, physical_region in enumerate(physical_regions): nodes = [n-1 for n in vertices_used_for_dim[highest_dim-1][highest_dim*i:(highest_dim*i+highest_dim)]] nodes.sort() if physical_region != 0: try: index = nodes_as_facets[tuple(nodes)] data[index] = physical_region except IndexError: raise Exception ( "The facet (%d) was not found to mark: %s" % (i, nodes) ) # Create and initialise the mesh function handler.start_meshfunction("facet_region", highest_dim-1, mesh.num_facets() ) for index, physical_region in enumerate ( data ): handler.add_entity_meshfunction(index, physical_region) handler.end_meshfunction() # Check that we got all data if state == 10: print("Conversion done") else: _error("Missing data, unable to convert \n\ Did you use version 2.0 of the gmsh file format?") # Close files ifile.close()
if __name__ == "__main__": xlim = 0.0, 3.0 ylim = 0.0, 0.0127 WAid = 12 INid = 13 BND_ids = WAid, INid meszf = 0.001 # mesh element size factor Domain, Facets = Generate_PBRpygmsh(xlim, ylim, BND_ids, meszf, folder='pygmeshio_test') mesh_D = Mesh() with XDMFFile(Domain) as infile: infile.read(mesh_D) mesh_F = Mesh() with XDMFFile(Facets) as infile: infile.read(mesh_F) print('num_cells :', mesh_D.num_cells()) print('num_vertices:', mesh_D.num_vertices()) print('cell_type :', mesh_D.ufl_cell()) #print('num_facets:', mesh_F.num_facets()) #print('num_edges:', mesh_F.num_edges())
def get_1d_matrices(mesh_, N, root=''): '''Given mesh construct 1d matrices for GEVP.''' if not isinstance(N, (int, float)): assert root return all([get_1d_matrices(mesh_, n, root) == 0 for n in N]) mesh_dir = '../plate-beam/py/fem_new/meshes' # Zig zag mesh if mesh_ == 'nonuniform': mesh = 'Pb_zig_zag_bif' mesh2d = '%s/%s_%d.xml.gz' % (mesh_dir, mesh, N) # mesh1d = '%s/%s_%d_facet_region.xml.gz' % (mesh_dir, mesh, N) mesh2d = Mesh(mesh2d) # Constructing facet function can be too expensive so here's and # alternative # mesh1d = get_marked_facets(mesh1d) # Structured meshes elif mesh_ == 'uniform': mesh = mesh_ N = int(N) mesh2d = UnitSquareMesh(N, N) # mesh1d = EdgeFunction('size_t', mesh2d, 0) # Beam at y = 0.5 # CompiledSubDomain('near(x[1], 0.5, 1E-10)').mark(mesh1d, 1) # Use the above here as well # from dolfin import SubsetIterator # mesh1d = [e.index() for e in SubsetIterator(mesh1d, 1)] mesh1d = '%s/%s_%d_edgelist' % (mesh_dir, mesh, N) mesh1d = map(int, np.loadtxt(mesh1d)) print FunctionSpace(mesh2d, 'CG', 1).dim() # Extract 1d import sys sys.setrecursionlimit(20000) mesh = interval_mesh_from_edge_f(mesh2d, mesh1d, 1)[0].pop() # Assemble V = FunctionSpace(mesh, 'CG', 1) u = TrialFunction(V) v = TestFunction(V) bc = DirichletBC(V, Constant(0), 'on_boundary') a = inner(grad(u), grad(v)) * dx m = inner(u, v) * dx L = inner(Constant(0), v) * dx A, _ = assemble_system(a, L, bc) M, _ = assemble_system(m, L, bc) A, M = A.array(), M.array() if root: dA = np.diagonal(A, 0) uA = np.r_[np.diagonal(A, 1), 0] A = np.c_[dA, uA] dM = np.diagonal(M, 0) uM = np.r_[np.diagonal(M, 1), 0] M = np.c_[dM, uM] header = 'main and upper diagonals of A, M' f = '_'.join([mesh_, str(N)]) import os f = os.path.join(root, f) np.savetxt(f, np.c_[A, M], header=header) return 0 else: return A, M
# ).vector().max()) # hmins.append(self.multimesh.part(i).hmin()) ALE.move(self.multimesh.part(i), s_move) # Compute L2 norm of movement self.move_norm = sqrt(sum(move_norm)) # self.move_max = max(move_max) # print(hmins, move_max) self.multimesh.build() for key in self.cover_points.keys(): self.multimesh.auto_cover(key, self.cover_points[key]) if __name__ == "__main__": meshes = [] for i in range(2): mesh_i = Mesh() with XDMFFile("meshes/multimesh_%d.xdmf" % i) as infile: infile.read(mesh_i) meshes.append(mesh_i) mfs = [] for i in range(2): mvc = MeshValueCollection("size_t", meshes[i], 1) with XDMFFile("meshes/mf_%d.xdmf" % i) as infile: infile.read(mvc, "name_to_read") mfs.append(cpp.mesh.MeshFunctionSizet(meshes[i], mvc)) cover = {0: Point(0.5, 0.5)} from create_meshes import (inflow, outflow, walls, inner_marker, outer_marker, L, H) bc_dict = { 0: {
def get_antarctica_coarse(): filename = inspect.getframeinfo(inspect.currentframe()).filename home = os.path.dirname(os.path.abspath(filename)) mesh = Mesh(home + '/antarctica/antarctica_50H_5l.xml') mesh.coordinates()[:, 2] /= 1000.0 return mesh
def test_convert_triangle( self): # Disabled because it fails, see FIXME below # test no. 1 from dolfin import Mesh, MPI fname = os.path.join(os.path.dirname(__file__), "data", "triangle") dfname = fname + ".xml" # Read triangle file and convert to a dolfin xml mesh file meshconvert.triangle2xml(fname, dfname) # Read in dolfin mesh and check number of cells and vertices mesh = Mesh(dfname) self.assertEqual(mesh.num_vertices(), 96) self.assertEqual(mesh.num_cells(), 159) # Clean up os.unlink(dfname) # test no. 2 from dolfin import MPI, Mesh, MeshFunction, \ edges, Edge, faces, Face, \ SubsetIterator, facets fname = os.path.join(os.path.dirname(__file__), "data", "test_Triangle_3") dfname = fname + ".xml" dfname0 = fname + ".attr0.xml" # Read triangle file and convert to a dolfin xml mesh file meshconvert.triangle2xml(fname, dfname) # Read in dolfin mesh and check number of cells and vertices mesh = Mesh(dfname) mesh.init() mfun = MeshFunction('double', mesh, dfname0) self.assertEqual(mesh.num_vertices(), 58) self.assertEqual(mesh.num_cells(), 58) # Create a size_t MeshFunction and assign the values based on the # converted Meshfunction cf = MeshFunction("size_t", mesh, mesh.topology().dim()) cf.array()[mfun.array() == 10.0] = 0 cf.array()[mfun.array() == -10.0] = 1 # Meassure total area of cells with 1 and 2 marker add = lambda x, y: x + y area0 = reduce(add, (Face(mesh, cell.index()).area() \ for cell in SubsetIterator(cf, 0)), 0.0) area1 = reduce(add, (Face(mesh, cell.index()).area() \ for cell in SubsetIterator(cf, 1)), 0.0) total_area = reduce(add, (face.area() for face in faces(mesh)), 0.0) # Check that all cells in the two domains are either above or below y=0 self.assertTrue( all(cell.midpoint().y() < 0 for cell in SubsetIterator(cf, 0))) self.assertTrue( all(cell.midpoint().y() > 0 for cell in SubsetIterator(cf, 1))) # Check that the areas add up self.assertAlmostEqual(area0 + area1, total_area) # Measure the edge length of the two edge domains #edge_markers = mesh.domains().facet_domains() edge_markers = mesh.domains().markers(mesh.topology().dim() - 1) self.assertTrue(edge_markers is not None) #length0 = reduce(add, (Edge(mesh, e.index()).length() \ # for e in SubsetIterator(edge_markers, 0)), 0.0) length0, length1 = 0.0, 0.0 for item in list(edge_markers.items()): if item[1] == 0: e = Edge(mesh, int(item[0])) length0 += Edge(mesh, int(item[0])).length() elif item[1] == 1: length1 += Edge(mesh, int(item[0])).length() # Total length of all edges and total length of boundary edges total_length = reduce(add, (e.length() for e in edges(mesh)), 0.0) boundary_length = reduce(add, (Edge(mesh, f.index()).length() \ for f in facets(mesh) if f.exterior()), 0.0) # Check that the edges add up self.assertAlmostEqual(length0 + length1, total_length) self.assertAlmostEqual(length1, boundary_length) # Clean up os.unlink(dfname) os.unlink(dfname0)
def get_greenland_detailed(): filename = inspect.getframeinfo(inspect.currentframe()).filename home = os.path.dirname(os.path.abspath(filename)) mesh = Mesh(home + '/greenland/greenland_detailed_mesh.xml') mesh.coordinates()[:, 2] /= 100000.0 return mesh
k = 1 # Magnitude solid body rotation . Uh = np.pi # Timestepping Tend = 2. dt = Constant(0.02) num_steps = np.rint(Tend / float(dt)) # Output directory store_step = 1 outdir = './../../results/SlottedDisk_Rotation_AddDelete/' # Mesh mesh = Mesh('./../../meshes/circle_0.xml') mesh = refine(mesh) mesh = refine(mesh) mesh = refine(mesh) outfile = XDMFFile(mesh.mpi_comm(), outdir + "psi_h.xdmf") # Set slotted disk psi0_expr = SlottedDisk(radius=rdisk, center=[xc, yc], width=rwidth, depth=0., degree=3, lb=lb, ub=ub)
def save_files_visualization(visualization_folder, dvp_, t, save_deg, mesh, **namespace): # Files for storing results if not "d_file" in namespace.keys(): d_file = XDMFFile( MPI.comm_world, str(visualization_folder.joinpath("displacement.xdmf"))) v_file = XDMFFile(MPI.comm_world, str(visualization_folder.joinpath("velocity.xdmf"))) p_file = XDMFFile(MPI.comm_world, str(visualization_folder.joinpath("pressure.xdmf"))) for tmp_t in [d_file, v_file, p_file]: tmp_t.parameters["flush_output"] = True tmp_t.parameters["rewrite_function_mesh"] = False if save_deg > 1: mesh_viz = Mesh(mesh) # copy the mesh for i in range(save_deg - 1): mesh_viz = refine(mesh_viz) # refine the mesh dve_viz = VectorElement('CG', mesh_viz.ufl_cell(), 1) pe_viz = FiniteElement('CG', mesh_viz.ufl_cell(), 1) FSdv_viz = FunctionSpace( mesh_viz, dve_viz) # Visualisation FunctionSpace for d and v FSp_viz = FunctionSpace( mesh_viz, pe_viz) # Visualisation FunctionSpace for p return_dict = dict(v_file=v_file, d_file=d_file, p_file=p_file, FSdv_viz=FSdv_viz, FSp_viz=FSp_viz) else: return_dict = dict(v_file=v_file, d_file=d_file, p_file=p_file) namespace.update(return_dict) else: return_dict = {} # Split function d = dvp_["n"].sub(0, deepcopy=True) v = dvp_["n"].sub(1, deepcopy=True) p = dvp_["n"].sub(2, deepcopy=True) if save_deg > 1: d = project(d, namespace["FSdv_viz"]) v = project(v, namespace["FSdv_viz"]) p = project(p, namespace["FSp_viz"]) # Name function d.rename("Displacement", "d") v.rename("Velocity", "v") p.rename("Pressure", "p") # Write results namespace["d_file"].write(d, t) namespace["v_file"].write(v, t) namespace["p_file"].write(p, t) return return_dict
def mesh_around_1d(mesh, size=1, scale=10, padding=0.05): ''' From a 1d in xd (X > 1) mesh (in XML format) produce a Xd mesh where the 1d structure is embedded. Mesh size close to strucure should be size(given as multiple of hmin(), elsewhere scale * size. Padding controls size of the bounding box. ''' dot = mesh.find('.') root, ext = mesh[:dot], mesh[dot:] assert ext == '.xml' or ext == '.xml.gz', ext mesh = Mesh(mesh) gdim = mesh.geometry().dim() assert gdim > 1 and mesh.topology().dim() == 1 x = mesh.coordinates() mesh.init(1, 0) # Compute fall back mesh size: assert size > 0 size = mesh.hmin() * size # Don't allow zero padding - collision of lines with bdry segfaults # too ofter so we prevent it assert padding > 0 # Finally scale better be positive assert scale > 0 point = (lambda xi: tuple(xi) + (0, ))\ if gdim == 2 else (lambda xi: tuple(xi)) geo = '.'.join([root, 'geo']) with open(geo, 'w') as outfile: # Setup outfile.write('SetFactory("OpenCASCADE");\n') outfile.write('size = %g;\n' % size) outfile.write('SIZE = %g;\n' % (size * scale)) # Points fmt = 'Point(%d) = {%.16f, %.16f, %.16f, size};\n' for i, xi in enumerate(x, 1): outfile.write(fmt % ((i, ) + point(xi))) # Lines fmt = 'Line(%d) = {%d, %d};\n' for i, cell in enumerate(cells(mesh), 1): outfile.write(fmt % ((i, ) + tuple(cell.entities(0) + 1))) # BBox xmin, xmax = x.min(0), x.max(0) padding = (xmax - xmin) * padding / 2. xmin -= padding xmax += padding dx = xmax - xmin if gdim == 2 or dx[-1] < 1E-14: # All points are on a plane rect = 'Rectangle(1) = {%g, %g, %g, %g, %g};\n' % ( xmin[0], xmin[1], 0 if gdim == 2 else xmin[2], dx[0], dx[1]) outfile.write(rect) bbox = 'Surface' else: box = 'Box(1) = {%g, %g, %g, %g, %g, %g};\n' % ( xmin[0], xmin[1], xmin[2], dx[0], dx[1], dx[2]) outfile.write(box) bbox = 'Volume' # Crack for line in xrange(1, mesh.num_cells() + 1): outfile.write('Line{%d} In %s{1};\n' % (line, bbox)) # Add Physical volume/surface outfile.write('Physical %s(1) = {1};\n' % bbox) # Add Physical surface/line lines = ', '.join( map(lambda v: '%d' % v, xrange(1, mesh.num_cells() + 1))) outfile.write('Physical Line(1) = {%s};\n' % lines) return geo, gdim