def write_data(self, file_name): print file_name ### Create a 1d mesh editor = fc.MeshEditor() mesh = fc.Mesh() editor.open(mesh, 1, 1) editor.init_vertices(len(self.center_xs)) editor.init_cells(len(self.center_xs) - 1) # Add vertices i = 0 for d in self.distances: editor.add_vertex(i, d) i += 1 # Add cells for i in range(len(self.distances) - 1): editor.add_cell(i, np.array([i, i+1], dtype = np.uintp)) editor.close() ### Create output hdf5 file out_file = fc.HDF5File(mesh.mpi_comm(), file_name, "w") ### Create and set data functions V = fc.FunctionSpace(mesh, "CG", 1) smb = fc.Function(V) surface = fc.Function(V) bed = fc.Function(V) width = fc.Function(V) thickness = fc.Function(V) smb.vector().set_local(self.flowline_data['smb']) smb.vector().apply("insert") surface.vector().set_local(self.flowline_data['surface']) surface.vector().apply("insert") bed.vector().set_local(self.flowline_data['bed']) bed.vector().apply("insert") width.vector().set_local(self.flowline_data['width']) width.vector().apply("insert") thickness.vector().set_local(self.flowline_data['surface'] - self.flowline_data['bed']) thickness.vector().apply("insert") out_file.write(mesh, "/mesh") out_file.write(smb.vector(), "/smb") out_file.write(surface.vector(), "/surface") out_file.write(bed.vector(), "/bed") out_file.write(width.vector(), "/width") out_file.write(thickness.vector(), "/thickness") out_file.close()
def create_cocontinuous_mesh(self): if self.use_previously_stored_mesh: self.mesh = fe.Mesh(self.mesh_fname) print('Mesh has been loaded from file') return p = self.L * np.ones(3) geo = mesher.Box(fe.Point(0,0,0), fe.Point(p)) net = self.extrude_base_net() columns = self.create_cylindrical_columns() net += columns if self.keep_only_network: geo = net else: geo -= net print('Finished creating the geometry') self.mesh = mesher.generate_mesh(geo, self.mesh_density); print('Writing mesh to file') mesh_file = fe.File(self.mesh_fname) mesh_file << self.mesh print('Finished writing mesh to file')
def deepcopy(self): """ Return an entire deep copy of `self`. For example, this is useful for checkpointing small problems in memory, or for running a batch of simulations with parameter changes. """ sim = type(self)(time_order=self.time_order, integration_measure=self.integration_measure(), setup_solver=False) sim._mesh = fenics.Mesh(self.mesh) sim._function_space = fenics.FunctionSpace(sim.mesh, sim._element) for i in range(len(self._solutions)): sim._solutions[i] = fenics.Function(sim.function_space) sim._solutions[i].leaf_node().vector( )[:] = self._solutions[i].leaf_node().vector() sim._times[i] = 0. + self._times[i] for i in range(len(self._timestep_sizes)): sim._timestep_sizes[i] = self._timestep_sizes[i] sim.setup_solver() sim.solver.parameters = self.solver.parameters.copy() return sim
def read_checkpoint(self, filepath): """Read solutions and times from a checkpoint file.""" self._mesh = fenics.Mesh() print("Reading checkpoint from " + filepath) with fenics.HDF5File(self.mesh.mpi_comm(), filepath, "r") as h5: h5.read(self._mesh, "mesh", True) self._function_space = fenics.FunctionSpace( self.mesh, self._element) for i in range(self.time_order + 1): self._solutions[i] = fenics.Function(self.function_space) h5.read(self._solutions[i], "solution" + str(i)) """ fenics.HDF5File doesn't implement read methods for every write method. Our only option here seems to be to use a fenics.Vector to store values, because a reader is implemented for GenericVector, which Vector inherits from. Furthermore, for the correct read method to be called, we must pass a boolean as a third argument related to distributed memory. """ time = fenics.Vector(fenics.mpi_comm_world(), 1) h5.read(time, "time" + str(i), False) self._times[i] = time.get_local()[0] self.newton_solution = fenics.Function(self.function_space) self.setup_solver()
def load_mesh(self): """ Method to load the mesh file given the mesh folder path. Returns: """ return fn.Mesh(self.mesh_folder_path)
def _build_mesh(self): args = self.args # mesh = fa.Mesh(args.root_path + '/' + args.solutions_path + '/saved_mesh/mesh_square.xml') mesh = fa.Mesh(args.root_path + '/' + args.solutions_path + '/saved_mesh/mesh_disk.xml') # mesh = fa.RectangleMesh(fa.Point(0, 0), fa.Point(1, 1), 3, 3) self.mesh = mesh
def build_mesh(self): self.length = 1. self.height = 1. self.mesh = fe.Mesh() editor = fe.MeshEditor() editor.open(self.mesh, 'triangle', 2, 2) editor.init_vertices(10) editor.init_cells(8) editor.add_vertex(0, fe.Point(0.5, 0.5)) editor.add_vertex(1, fe.Point(1., 0.5)) editor.add_vertex(2, fe.Point(1., 1.)) editor.add_vertex(3, fe.Point(0.5, 1.)) editor.add_vertex(4, fe.Point(0., 1.)) editor.add_vertex(5, fe.Point(0., 0.5)) editor.add_vertex(6, fe.Point(0., 0.)) editor.add_vertex(7, fe.Point(0.5, 0.)) editor.add_vertex(8, fe.Point(1., 0.)) editor.add_vertex(9, fe.Point(0., 0.5)) editor.add_cell(0, [0, 1, 3]) editor.add_cell(1, [1, 2, 3]) editor.add_cell(2, [0, 3, 4]) editor.add_cell(3, [0, 4, 5]) editor.add_cell(4, [0, 9, 7]) editor.add_cell(5, [6, 7, 9]) editor.add_cell(6, [0, 7, 8]) editor.add_cell(7, [0, 8, 1]) editor.close() base_refinement = 4 self.total_refinement = base_refinement + self.local_refinement_iteration for i in range(self.total_refinement): self.mesh = fe.refine(self.mesh)
def load(self): # Convert mesh from MSH to Dolfin-XML shutil.copyfile("input/%s.msh" % input_mesh, "%s.msh" % input_mesh) destination_xml = "%s.xml" % input_mesh subprocess.call( ["dolfin-convert", "%s.msh" % input_mesh, destination_xml]) # Load mesh and boundaries mesh = d.Mesh(destination_xml) self.patches = d.MeshFunction("size_t", mesh, "%s_facet_region.xml" % input_mesh) self.subdomains = d.MeshFunction("size_t", mesh, "%s_physical_region.xml" % input_mesh) # Define differential over subdomains self.dxs = d.dx[self.subdomains] # Turn subdomains into a Numpy array self.subdomains_array = N.asarray(self.subdomains.array(), dtype=N.int32) # Create a map from subdomain indices to tissues self.tissues_by_subdomain = {} for i, t in v.tissues.items(): print(i, t) for j in t["indices"]: self.tissues_by_subdomain[j] = t self.mesh = mesh self.setup_fe() self.prepare_increase_conductivity()
def adapt_coarse_solution_to_fine_solution(scalar, coarse_solution, fine_solution, element, absolute_tolerance=1.e-2, maximum_refinement_cycles=6, circumradius_threshold=0.01): """ Refine the mesh of the coarse solution until the interpolation error tolerance is met. """ adapted_coarse_mesh = fenics.Mesh(coarse_solution.function_space().mesh()) adapted_coarse_function_space = fenics.FunctionSpace( adapted_coarse_mesh, element) adapted_coarse_solution = fenics.Function(adapted_coarse_function_space) adapted_coarse_solution.leaf_node().vector( )[:] = coarse_solution.leaf_node().vector() for refinement_cycle in range(maximum_refinement_cycles): cell_markers = fenics.MeshFunction( "bool", adapted_coarse_mesh.leaf_node(), adapted_coarse_mesh.topology().dim(), False) for coarse_cell in fenics.cells(adapted_coarse_mesh.leaf_node()): coarse_value = scalar(adapted_coarse_solution.leaf_node(), coarse_cell.midpoint()) fine_value = scalar(fine_solution.leaf_node(), coarse_cell.midpoint()) if (abs(coarse_value - fine_value) > absolute_tolerance): cell_markers[coarse_cell] = True cell_markers = unmark_cells_below_circumradius( adapted_coarse_mesh.leaf_node(), cell_markers, circumradius_threshold) if any(cell_markers): adapted_coarse_mesh = fenics.refine(adapted_coarse_mesh, cell_markers) adapted_coarse_function_space = fenics.FunctionSpace( adapted_coarse_mesh, element) adapted_coarse_solution = fenics.project( fine_solution.leaf_node(), adapted_coarse_function_space.leaf_node()) else: break return adapted_coarse_solution, adapted_coarse_function_space, adapted_coarse_mesh
def distribute_mesh(mesh): """Distribute a local copy of a mesh Required argument: mesh: a sequential copy of the mesh to be distributed. Only the copy on the rank 0 process is used. This mesh will be distribuetd among all processes connected to MPI.COMM_WORLD so that it can be used for FEniCS computations. Return value: the distributed mesh """ scomm = MPI.COMM_SELF wcomm = MPI.COMM_WORLD gmesh = gather_mesh(mesh) if wcomm.rank == 0: assert (gmesh.mpi_comm().size == 1) # check it's sequential with tempfile.TemporaryDirectory() as td: meshfile = os.path.join(td, 'mesh.xml') logGATHER('writing ' + meshfile) File(MPI.COMM_SELF, meshfile) << gmesh logGATHER('broadcasting meshfile') meshfile = wcomm.bcast(meshfile, root=0) try: with open(meshfile, 'r') as mf: # rank 0 dmesh = fe.Mesh(wcomm, meshfile) logGATHER('dmesh', dmesh) except FileNotFoundError: logGATHER('meshfile', meshfile, 'not found') wcomm.Barrier() # wait for everyone to read it logGATHER('destroying temp directory') # context manager destroyed, temp dir gets deleted else: meshfile = None logGATHER('receiving broadcast meshfile') meshfile = wcomm.bcast(meshfile, root=0) logGATHER('meshfile', meshfile) try: with open(meshfile, 'r') as mf: # rank != 0 dmesh = fe.Mesh(wcomm, meshfile) logGATHER('dmesh', dmesh) except FileNotFoundError: logGATHER('meshfile', meshfile, 'not found') wcomm.Barrier() return (dmesh)
def meshReader(dictMesh): ''' converts json mesh to fenics mesh and apply the boundary conditions. dict:: dictMesh, the mesh from database in the form of a python dictionary output: dolfin.ccp.mesh:: feMesh, mesh defined in fenics object ''' # conver dict to object mesh = namedtuple("mesh", dictMesh.keys())(*dictMesh.values()) nodes = np.array(mesh.nodes) cells = np.array(mesh.connectivity, dtype=np.uintp) feMesh = fn.Mesh() editor = fn.MeshEditor() # cell type, topological, and geometrical dimensions. i.e. 2, 3 for 3d surface mesh editor.open(feMesh, "triangle", 2, 3) # cell types available: point, interval, triangle, quadrilateral, tetrahedron, hexahedron editor.init_vertices(len(mesh.nodes)) editor.init_cells(len(mesh.connectivity)) [editor.add_vertex(i, n) for i, n in enumerate(nodes)] [editor.add_cell(i, n - 1) for i, n in enumerate(cells)] editor.close() # construct faces faceSets = fn.MeshFunction('size_t', feMesh, 2) for face, faceCells in mesh.faces.items(): for index in faceCells: faceSets.set_value(index, int(face), feMesh) # construct edges edgeSets = fn.MeshFunction('size_t', feMesh, 1) meshEdges = {} for edge in fn.edges(feMesh): meshEdges[edge.index()] = [] for vert in fn.vertices(edge): meshEdges[edge.index()].append(vert.index()) for edge, nodes in meshEdges.items(): for edgeName, edgeList in mesh.edges.items(): if nodes in edgeList: edgeSets.set_value(edge, int(edgeName), feMesh) # construct points pointSets = fn.MeshFunction('size_t', feMesh, 0) for pointName, point in mesh.points.items(): pointSets.set_value(point, int(pointName), feMesh) return dict(feMesh=feMesh, faceSets=faceSets, edgeSets=edgeSets, pointSets=pointSets)
def readMesh(self): """ If mesh instance is None, read mesh instance from file denoted by filename property. """ # TODO: implement mesh read in for open file if self.mesh is None: xdmffile = fenics.XDMFFile(self.xdmffilename) self.mesh = fenics.Mesh() xdmffile.read(self.mesh) xdmffile.close()
def build_mesh(self): path_to_msh = 'data/gmsh/{}/{}/mesh'.format(self.case_name, self.mesh_refinement_level) save_with_meshio(path_to_msh, 2) path_to_xdmf = 'data/gmsh/{}/{}/mesh.xdmf'.format( self.case_name, self.mesh_refinement_level) xdmf_mesh = fe.XDMFFile(path_to_xdmf) self.mesh = fe.Mesh() xdmf_mesh.read(self.mesh) self.length = 500 self.height = 500 self.segment = 30 # domain = mshr.Polygon([fe.Point(0., 0.), # fe.Point(0., self.height)]) # resolution = 100 if self.local_refinement_iteration == 0 else 200 # self.mesh = mshr.generate_mesh(domain, resolution) # Reference # https://scicomp.stackexchange.com/questions/32647/how-to-use-meshfunction-in-fenics-dolfin # https://fenicsproject.org/qa/596/setting-condition-for-mesh-refinement/ # for i in range(self.local_refinement_iteration): # cell_markers = fe.MeshFunction('bool', self.mesh, self.mesh.topology().dim()) # cell_markers.set_all(False) # for cell in fe.cells(self.mesh): # p = cell.midpoint() # if p[0] > 1./20.*self.length and p[0] < 10.5/20.*self.length and p[1] > 9.5/20.*self.height and p[1] < 13/20*self.height: # # if np.sqrt((p[0] - self.length/2.)**2 + (p[1] - self.height/2.)**2) < self.length/5.: # cell_markers[cell] = True # self.mesh = fe.refine(self.mesh, cell_markers) length = self.length height = self.height segment = self.segment class Lower(fe.SubDomain): def inside(self, x, on_boundary): return on_boundary and fe.near(x[1], 0) class Upper(fe.SubDomain): def inside(self, x, on_boundary): return on_boundary and fe.near(x[1], height) class Segment(fe.SubDomain): def inside(self, x, on_boundary): return fe.near(x[1], height / 2.) and fe.near( x[0], length - segment) # return fe.near(x[1], height/2.) and x[0] >= length - segment self.lower = Lower() self.upper = Upper() self.segment = Segment()
def wrapper2D(par, meshName, N_PN, boundaryFilePrefix, solutionFolder): #-------- load mesh -------- mesh = fe.Mesh(meshName + '.xml') boundaryMarkers = fe.MeshFunction('size_t', mesh, meshName + '_facet_region.xml') ds = fe.Measure('ds', domain=mesh, subdomain_data=boundaryMarkers) u = solvePN2nd(par, N_PN, mesh, boundaryFilePrefix, ds) #fe.plot(u[0]) # first moment: u0 = int_{4pi} I * b0 dOmega, b0 = sqrt(1 / 4 / pi) # radiative energy: phi = int_{4pi} I dOmega radiativeEnergy = np.sqrt(4 * np.pi) * u[0].compute_vertex_values() createFolder(solutionFolder) sio.savemat('%sradiativeEnergy_P%d2nd_%s.mat'%(solutionFolder, N_PN, meshName.split('/')[-1]), {'radiativeEnergy': radiativeEnergy, 'points': mesh.coordinates(), 'connectivityList': mesh.cells()}) return u
def readXDMFFile(self, xdmffilename, group_value_dict): xdmffile = fenics.XDMFFile(xdmffilename) self.group_value_dict = group_value_dict self.mesh = fenics.Mesh() xdmffile.read(self.mesh) self.markers = {} self.marked = {} self.ds = {} self.bcs = {} for (key, value) in self.group_value_dict.iteritems(): # Fenics interface here: create facet function of type size_t (positive int) for every group # TODO: examine whether size_t is appropriate or this class could be generalized self.markers[key] = fenics.FacetFunction("size_t", self.mesh) xdmffile.read(self.markers[key], key) self.marked[key] = value.get("marked", 1) self.ds[key] = fenics.Measure("ds", domain=self.mesh, subdomain_data=self.markers[key]) self.bcs[key] = value xdmffile.close()
def preprocess(fname): """Loads mesh, defines system of equations and prepares system matrix.""" mesh = fe.Mesh(fname + ".xml") if INPUTS['saving']['mesh']: fe.File(fname + "_mesh.pvd") << mesh boundaries = fe.MeshFunction('size_t', mesh, fname + '_facet_region.xml') if INPUTS['saving']['boundaries']: fe.File(fname + "_subdomains.pvd") << boundaries subdomains = fe.MeshFunction('size_t', mesh, fname + '_physical_region.xml') if INPUTS['saving']['subdomains']: fe.File(fname + "_subdomains.pvd") << subdomains if INPUTS['plotting']['mesh']: fe.plot(mesh, title='Mesh') if INPUTS['plotting']['boundaries']: fe.plot(boundaries, title='Boundaries') if INPUTS['plotting']['subdomains']: fe.plot(subdomains, title='Subdomains') fun_space = fe.FunctionSpace(mesh, INPUTS['element_type'], INPUTS['element_degree'], constrained_domain=PeriodicDomain()) if ARGS['--verbose']: dofmap = fun_space.dofmap() print('Number of DOFs:', len(dofmap.dofs())) field = fe.TrialFunction(fun_space) test_func = fe.TestFunction(fun_space) cond = Conductivity(subdomains, fe.Constant(INPUTS['conductivity']['gas']), fe.Constant(INPUTS['conductivity']['solid']), degree=0) system_matrix = -cond * fe.inner(fe.grad(field), fe.grad(test_func)) * fe.dx bctop = fe.Constant(INPUTS['boundary_conditions']['top']) bcbot = fe.Constant(INPUTS['boundary_conditions']['bottom']) bcs = [ fe.DirichletBC(fun_space, bctop, boundaries, 1), fe.DirichletBC(fun_space, bcbot, boundaries, 2) ] field = fe.Function(fun_space) return system_matrix, field, bcs, cond
def read_checkpoint(self, checkpoint_filepath): """Read the checkpoint solution and time, perhaps to restart.""" phaseflow.helpers.print_once("Reading checkpoint file from " + checkpoint_filepath) self.mesh = fenics.Mesh() with fenics.HDF5File(self.mesh.mpi_comm(), checkpoint_filepath, "r") as h5: h5.read(self.mesh, "mesh", True) self.setup_element() self.setup_function_space() self.setup_states() with fenics.HDF5File(self.mesh.mpi_comm(), checkpoint_filepath, "r") as h5: h5.read(self.old_state.solution, "solution") if self.second_order_time_discretization: h5.read(self.old_old_state.solution, "old_solution") with h5py.File(checkpoint_filepath, "r") as h5: self.old_state.time = h5["time"].value self.set_timestep_size(h5["timestep_size"].value) if self.second_order_time_discretization: self.old_old_state.time = h5["old_time"].value self.restarted = True self.output_dir += "restarted_t" + str(self.old_state.time) + "/"
def build_mesh(self): # Read mesh from matlab file .mat and convert it to FEniCS mesh mesh_matlab = loadmat('data/mat/mesh/PF-1.mat') points = mesh_matlab['p'] cells = mesh_matlab['t'] points = points.T cells = [("triangle", (cells[:-1, :] - 1).T)] meshio.write_points_cells( 'data/xdmf/{}/mesh.xdmf'.format(self.case_name), points, cells) xdmf_mesh = fe.XDMFFile('data/xdmf/{}/mesh.xdmf'.format( self.case_name)) self.mesh = fe.Mesh() xdmf_mesh.read(self.mesh) self.length = 1 self.height = 1 length = self.length height = self.height class Lower(fe.SubDomain): def inside(self, x, on_boundary): return on_boundary and fe.near(x[1], 0) class Upper(fe.SubDomain): def inside(self, x, on_boundary): return on_boundary and fe.near(x[1], height) class Corner(fe.SubDomain): def inside(self, x, on_boundary): return fe.near(x[0], 0) and fe.near(x[1], 0) class Middle(fe.SubDomain): def inside(self, x, on_boundary): return np.absolute( x[1] - 0.5) < 1e-2 and (x[0] - 0.3) * (x[0] - 0.7) < 1e-7 self.lower = Lower() self.upper = Upper() self.corner = Corner() self.middle = Middle()
def readXDMFfile(self, xdmffilename, group_value_dict): """ Initialization of CellExpressionXDMF by reading an XDMF file. @param: xdmffilename: path to xdmf file @param: group_value_dict: {"groupname":function(x)} function(x) is a function which is evaluated at the marked positions of the cells """ xdmffile = fenics.XDMFFile(xdmffilename) self.group_value_dict = group_value_dict self.mesh = fenics.Mesh() xdmffile.read(self.mesh) self.markers = {} self.dx = {} for (key, value) in self.group_value_dict.iteritems(): # Fenics interface here: create cell function of type int for every group # TODO: examine whether int is appropriate or this class could be generalized self.markers[key] = fenics.CellFunction("size_t", self.mesh) xdmffile.read(self.markers[key], key) self.dx[key] = fenics.Measure("dx", domain=self.mesh, subdomain_data=self.markers[key]) xdmffile.close()
def _inp_to_XML(args): input_name = args['names'][0] output_name = args['names'][1] if not input_name: return 'no input name' if not output_name: return 'no output name' try: file = open(input_name, 'r') csv_file = csv.reader(file, delimiter=',', skipinitialspace=True) except FileNotFoundError: return FileNotFoundError exists = os.path.isfile(output_name) if exists: return 'Not removing an existed file:' + output_name else: ofile = open(output_name, "w+") try: nodes, elems, node_sets, cell_sets = _read_input(csv_file, ofile) # Close CSV object file.close() del csv_file except: raise result = _write_XMP(ofile, nodes, elems, node_sets, cell_sets) ofile.close() if result: try: mesh = fe.Mesh(output_name) result = 'The XML file is created and tested.' except: raise return result
def load_2d_muscle_geo(filename='../geo/muscle_2d.xml', L0=1e-2): mesh = fe.Mesh(filename) coords = mesh.coordinates() coords *= L0 mesh.bounding_box_tree().build(mesh) # Define Boundaries bottom = fe.CompiledSubDomain("near(x[1], side, 0.01) && on_boundary", side=-20.0 * L0) top = fe.CompiledSubDomain("near(x[1], side, 0.01) && on_boundary", side=20.0 * L0) # Initialize mesh function for boundary domains boundaries = fe.MeshFunction('size_t', mesh, 2) boundaries.set_all(0) bottom.mark(boundaries, 1) top.mark(boundaries, 2) # Define new measures associated with the interior domains and # exterior boundaries dx = fe.Measure('dx', domain=mesh) ds = fe.Measure('ds', domain=mesh, subdomain_data=boundaries) return mesh, dx, ds, {"top": top, "bottom": bottom}
# Get the libraries import fenics as fn import numpy as np import sympy as sym import scipy as sc from scipy import constants import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D from matplotlib import cm #Colormap import meshio as mio #import mshr as msr # %% # %% mesh = fn.Mesh() with fn.XDMFFile("meshing/Dmesh.xdmf") as infile: infile.read(mesh) mvc = fn.MeshValueCollection("size_t", mesh, 2) with fn.XDMFFile("meshing/Dmf.xdmf") as infile: infile.read(mvc, "name_to_read") mf = fn.cpp.mesh.MeshFunctionSizet(mesh, mvc) # %% M = 2 #species Poly = fn.FiniteElement('Lagrange', mesh.ufl_cell(), 2) Multi = fn.FiniteElement('Real', mesh.ufl_cell(), 0) ElemP = [Poly] * (M + 1) ElemR = [Multi] * (M) Elem = [ElemP + ElemR][0]
def _load_fct(path): return fn.Mesh(path)
import fenics as fe import dolfin import numpy as np from dolfin.fem.norms import errornorm from dolfin.common.plotting import plot import matplotlib.pyplot as plt import sys EPSILON = 1.0e-14 DEG = 2 mesh = fe.Mesh('step.xml') # Control pannel MODEL = False # flag to use SA model b = fe.Expression(('0', '0'), degree=DEG) # forcing nu = fe.Constant(2e-6) rho = fe.Constant(1) RE = 0.01 lmx = 1 # mixing length dt = 0.1 # Re = 10 / 1e-4 = 1e5 V = fe.VectorElement("Lagrange", mesh.ufl_cell(), 2) P = fe.FiniteElement("Lagrange", mesh.ufl_cell(), 1) NU = fe.FiniteElement("Lagrange", mesh.ufl_cell(), 1) if MODEL: M = fe.MixedElement([V, P, NU]) else: M = fe.MixedElement([V, P]) W = fe.FunctionSpace(mesh, M) W0 = fe.Function(W)
def load_mesh(self, fn: str = None): if fn is not None: self.mesh = fe.Mesh(fn) else: self.mesh = fe.UnitCubeMesh(10, 12, 14)
_Faces[key] = grp break for key in _Faces.keys(): del _groups[key] for key, value in _Faces.items(): _Faces[key] = list(map(int, value)) for key, value in _groups.items(): _groups[key] = list(map(int, value)) return _groups, _Faces ImportedMesh = MeshImport("./UserFiles/myMesh.unv") ImportedMesh.UNVtoXMLConverter() Edges, Faces = ImportedMesh.MeshGroups() mesh = fn.Mesh("./UserFiles/mesh.xml") V = fn.FunctionSpace(mesh, 'CG', 1) # Create subdomains BoundaryEdges = fn.BoundaryMesh(mesh, 'exterior').entity_map(1).array() BoundaryNodes = fn.BoundaryMesh(mesh, 'exterior').entity_map(0).array() boundaries = fn.MeshFunction('size_t', mesh, dim=1) boundaries.set_all(0) interior = {} idx = 1 for key, nodes in Edges.items(): if all(item in BoundaryNodes for item in nodes): for node in nodes: ver = fn.Vertex(mesh, node) for edge in fn.edges(ver): if edge.index() in BoundaryEdges:
########################### COMPILER OPTIONS ################################# fe.parameters.linear_algebra_backend = 'PETSc' fe.parameters.form_compiler.cpp_optimize_flags = '-O3' fe.parameters.form_compiler.quadrature_degree = 3 ############################### IMPORT MESH ################################## #cprint("\nMESH PRE-PROCESSING", 'blue', attrs=['bold']) # Import mesh and groups #cprint("Creating gmsh mesh...", 'green') subprocess.check_output("gmsh ./gmsh/beam.geo -3", shell=True) #cprint("Converting mesh to DOLFIN format...", 'green') subprocess.check_output('dolfin-convert ./gmsh/beam.msh mesh/beam.xml', shell=True) #cprint("Importing mesh in FEniCS...", 'green') mesh = fe.Mesh('mesh/beam.xml') #cprint("Generating boundaries and subdomains...", 'green') subdomains = fe.MeshFunction("size_t", mesh, "mesh/beam_physical_region.xml") boundaries = fe.MeshFunction("size_t", mesh, "mesh/beam_facet_region.xml") # Redefine the integration measures dxp = fe.Measure('dx', domain=mesh, subdomain_data=subdomains) dsp = fe.Measure('ds', domain=mesh, subdomain_data=boundaries) ##################### FINITE ELEMENT SPACES ################################## # Finite element spaces W = fe.FunctionSpace(mesh, 'P', 1) V = fe.VectorFunctionSpace(mesh, 'P', 1) Z = fe.TensorFunctionSpace(mesh, 'P', 1) # Finite element functions
def expand_mesh(mesh, transform=None): """expand_mesh -- expand a corner submesh to a full mesh. Required parameter: mesh -- the corner submesh to be expanded Optional parameter: transform -- the transform to integerfiy the vertex coordinates of the submesh. Returns: A list of four values: emsh, maps, cellmaps, and vertexmaps. emesh is the desired expanded mesh. maps is a list of 2**dim functions. Each, applied to a pair of coordinates in the submesh, maps them to a corresponding point in the appropriate sector of the expanded mesh. cellmaps is a 2**dim x nc integer ndarray (where nc is the number of cells in mesh). Each rowlists the cells in one of the 2**dim sectors of emesh to which cells in the original submesh correspond. These lists are all disjoint. vertexmaps is a 2**dim x nv integer ndarray (where nv is the number of vertexes in mesh. Each row lists the vertexes of emesh to which vertexes of the original submesh map. These are not disjoint -- they overlap on the border of the submesh. """ nvs = mesh.num_vertices() ncs = mesh.num_cells() cells = mesh.cells() dim = mesh.geometry().dim() cols = np.arange(dim) icols = ['i' + str(i) for i in range(dim)] if transform is None: mtrans = integerify_transform(mesh.coordinates()) else: mtrans = transform imax = 2 * mtrans[-1] mtrans = list(mtrans[:-1]) + [imax] meshstats = mesh_stats(mesh) width = meshstats['xmax'] symmetries = evenodd_symmetries(dim) maps = [ lambda x, eo=eo, width=width: 2 * width * eo + (1 - 2 * eo) * x for eo in symmetries ] vertexes = vertex_list(mesh) vertexes['mesh'] = np.arange(nvs) ecoords = np.concatenate([map(mesh.coordinates()) for map in maps]) evertexes = vertex_list(ecoords, transform=mtrans) evertexes.reset_index(inplace=True) evertexes = evertexes.drop_duplicates(subset=icols) evertexes.set_index(icols, inplace=True) evertexes.sort_index(inplace=True) envs = len(evertexes) encs = len(maps) * ncs emesh = fe.Mesh(MPI.COMM_SELF) editor = fe.MeshEditor() editor.open(emesh, str(cellShapes[dim - 1]), dim, dim) editor.init_vertices_global(envs, envs) editor.init_cells_global(encs, encs) for v in range(envs): coords = evertexes.iloc[v, cols].values editor.add_vertex_global(v, v, coords) emesh.order() evertexes = vertex_list(emesh) evertexes['global'] = np.arange(envs) base = 0 cellmaps = [] vertexmaps = [] for map in maps: scoords = map(mesh.coordinates()) svertexes = vertex_list(scoords) svertexes = svertexes.merge(evertexes, how='inner') vertexmap = svertexes['global'].values vertexmaps.append(vertexmap) for c, cell in enumerate(cells): editor.add_cell(base + c, vertexmap[cell]) cellmap = base + np.arange(ncs) cellmaps.append(cellmap) base += ncs editor.close() cellmaps = np.array(cellmaps) vertexmaps = np.array(vertexmaps) return emesh, maps, cellmaps, vertexmaps
def import_mesh(arg): """Imports a mesh file for use with CASHOCS / FEniCS. This function imports a mesh file that was generated by GMSH and converted to .xdmf with the command line function :ref:`cashocs-convert <cashocs_convert>`. If there are Physical quantities specified in the GMSH file, these are imported to the subdomains and boundaries output of this function and can also be directly accessed via the measures, e.g., with ``dx(1)``, ``ds(1)``, etc. Parameters ---------- arg : str or configparser.ConfigParser This is either a string, in which case it corresponds to the location of the mesh file in .xdmf file format, or a config file that has this path stored in its settings, under the section Mesh, as parameter ``mesh_file``. Returns ------- mesh : dolfin.cpp.mesh.Mesh The imported (computational) mesh. subdomains : dolfin.cpp.mesh.MeshFunctionSizet A :py:class:`fenics.MeshFunction` object containing the subdomains, i.e., the Physical regions marked in the GMSH file. boundaries : dolfin.cpp.mesh.MeshFunctionSizet A MeshFunction object containing the boundaries, i.e., the Physical regions marked in the GMSH file. Can, e.g., be used to set up boundary conditions. dx : ufl.measure.Measure The volume measure of the mesh corresponding to the subdomains (i.e. GMSH Physical region indices). ds : ufl.measure.Measure The surface measure of the mesh corresponding to the boundaries (i.e. GMSH Physical region indices). dS : ufl.measure.Measure The interior facet measure of the mesh corresponding to boundaries (i.e. GMSH Physical region indices). """ start_time = time.time() print('Importing mesh to FEniCS') # Check for the file format if type(arg) == str: mesh_file = arg mesh_attribute = 'str' elif type(arg) == configparser.ConfigParser: mesh_attribute = 'config' ### overloading for remeshing if not arg.getboolean('Mesh', 'remesh', fallback=False): mesh_file = arg.get('Mesh', 'mesh_file') else: if not ('_cashocs_remesh_flag' in sys.argv): mesh_file = arg.get('Mesh', 'mesh_file') else: temp_dir = sys.argv[-1] with open(temp_dir + '/temp_dict.json', 'r') as file: temp_dict = json.load(file) mesh_file = temp_dict['mesh_file'] else: raise InputError( 'cashocs.geometry.import_mesh', 'arg', 'Not a valid argument for import_mesh. Has to be either a path to a mesh file (str) or a config.' ) if mesh_file[-5:] == '.xdmf': file_string = mesh_file[:-5] else: raise InputError( 'cashocs.geometry.import_mesh', 'arg', 'Not a suitable mesh file format. Has to end in .xdmf.') mesh = fenics.Mesh() xdmf_file = fenics.XDMFFile(mesh.mpi_comm(), mesh_file) xdmf_file.read(mesh) xdmf_file.close() subdomains_mvc = fenics.MeshValueCollection('size_t', mesh, mesh.geometric_dimension()) boundaries_mvc = fenics.MeshValueCollection('size_t', mesh, mesh.geometric_dimension() - 1) if os.path.isfile(file_string + '_subdomains.xdmf'): xdmf_subdomains = fenics.XDMFFile(mesh.mpi_comm(), file_string + '_subdomains.xdmf') xdmf_subdomains.read(subdomains_mvc, 'subdomains') xdmf_subdomains.close() if os.path.isfile(file_string + '_boundaries.xdmf'): xdmf_boundaries = fenics.XDMFFile(mesh.mpi_comm(), file_string + '_boundaries.xdmf') xdmf_boundaries.read(boundaries_mvc, 'boundaries') xdmf_boundaries.close() subdomains = fenics.MeshFunction('size_t', mesh, subdomains_mvc) boundaries = fenics.MeshFunction('size_t', mesh, boundaries_mvc) dx = fenics.Measure('dx', domain=mesh, subdomain_data=subdomains) ds = fenics.Measure('ds', domain=mesh, subdomain_data=boundaries) dS = fenics.Measure('dS', domain=mesh, subdomain_data=boundaries) end_time = time.time() print('Done Importing Mesh. Elapsed Time: ' + format(end_time - start_time, '.3e') + ' s') print('') # Add an attribute to the mesh to show with what procedure it was generated mesh._cashocs_generator = mesh_attribute return mesh, subdomains, boundaries, dx, ds, dS
import matplotlib.pyplot as plt config.update("jax_enable_x64", True) fn.set_log_level(fn.LogLevel.ERROR) # Create mesh, refined in the center n = 64 mesh = fn.UnitSquareMesh(n, n) cf = fn.MeshFunction("bool", mesh, mesh.geometry().dim()) subdomain = fn.CompiledSubDomain( "std::abs(x[0]-0.5) < 0.25 && std::abs(x[1]-0.5) < 0.25" ) subdomain.mark(cf, True) mesh = fn.Mesh(fn.refine(mesh, cf)) # Define discrete function spaces and functions V = fn.FunctionSpace(mesh, "CG", 1) W = fn.FunctionSpace(mesh, "DG", 0) solve_templates = (fn.Function(W),) assemble_templates = (fn.Function(V), fn.Function(W)) # Define and solve the Poisson equation @build_jax_solve_eval(solve_templates) def fenics_solve(f): u = fn.Function(V, name="State") v = fn.TestFunction(V) F = (ufl.inner(ufl.grad(u), ufl.grad(v)) - f * v) * ufl.dx bcs = [fn.DirichletBC(V, 0.0, "on_boundary")]