def main(): mesh = df.Mesh() h5f = df.HDF5File(mesh.mpi_comm(), "simple_duct.h5", "r") h5f.read(mesh, "mesh", False) V = df.VectorFunctionSpace(mesh, "CG", 1) P = df.FunctionSpace(mesh, "CG", 1) u_expr = df.Expression(("0.", "0.", expr_str(100)), degree=1) u = ft.interpolate_nonmatching_mesh(u_expr, V) u_avg = df.assemble(u.sub(2) * df.dx) / 40. u.vector()[:] /= u_avg xdmff = df.XDMFFile(mesh.mpi_comm(), "simple_duct_u0.xdmf") xdmff.parameters["rewrite_function_mesh"] = False xdmff.parameters["flush_output"] = True xdmff.write(u, float(0.)) p_expr = df.Expression("0.", degree=1) p = ft.interpolate_nonmatching_mesh(p_expr, P) xdmfp = df.XDMFFile(mesh.mpi_comm(), "simple_duct_p0.xdmf") xdmfp.parameters["rewrite_function_mesh"] = False xdmfp.parameters["flush_output"] = True xdmfp.write(p, float(0.)) df.plot(u.sub(2), interactive=True)
def import_mesh(self, filename=None): r"""Load mesh from generated xdmf files.""" name = MESH if filename is None: directory = APP_DIR else: # check if path exist if not os.path.exists(filename): raise ValueError(error(E_PATH, filename)) directory, name = os.path.split(filename) name = name.split(".")[0] # remove extension if exists try: mesh = self with dolfin.XDMFFile(directory.child(name + XDMF)) as infile: infile.read(mesh) mvc_bnd = dolfin.MeshValueCollection("size_t", self, 1) with dolfin.XDMFFile(directory.child(name + BND_XDMF)) as infile: infile.read(mvc_bnd, "bnd") mvc_dom = dolfin.MeshValueCollection("size_t", self, 2) with dolfin.XDMFFile(directory.child(name + DOM_XDMF)) as infile: infile.read(mvc_dom, "dom") self._mvc_bnd = mvc_bnd self._mvc_dom = mvc_dom except RuntimeError as e: logging.error("RunTimeError\n{}\n\n".format(e))
def store_mesh(self, mesh: dolfin.Mesh, cell_domains: dolfin.MeshFunction = None, facet_domains: dolfin.MeshFunction = None) -> None: """Save the mesh, and cellfunction and facet function if provided.""" with dolfin.XDMFFile(mesh.mpi_comm(), str(self._casedir / "mesh.xdmf")) as meshfile: meshfile.write(mesh) # if cell_domains is not None: # meshfile.write(cell_domains, "cell_domains") # if facet_domains is not None: # meshfile.write(facet_domains, "facet_domains") if cell_domains is not None: with df.XDMFFile(mesh.mpi_comm(), str(self._casedir / "cell_function.xdmf")) as cf_file: cf_file.write(mesh) cf_file.write(cell_domains) if facet_domains is not None: with df.XDMFFile(mesh.mpi_comm(), str(self._casedir / "facet_function.xdmf")) as ff_file: ff_file.write(mesh) ff_file.write(facet_domains)
def main(): args = get_settings() interp = itp.Interpolation(args.mesh_file_in, args.u_file_in, p_filename_in=args.p_file_in) interp.update(args.step) u_1 = interp.u p_1 = interp.p mesh_2 = import_mesh(args.other_mesh_in) S_2 = df.FunctionSpace(mesh_2, "CG", 1) u_ = dict() for key, val in u_1.iteritems(): u_[key] = ft.interpolate_nonmatching_mesh(val, S_2) u__ = df.as_vector([u_[key] for key in u_.keys()]) u = AssignedVectorFunction(u__) u() p = ft.interpolate_nonmatching_mesh(p_1, S_2) xdmff_u = df.XDMFFile(mesh_2.mpi_comm(), args.initfile_out + "_u.xdmf") xdmff_u.parameters["rewrite_function_mesh"] = False xdmff_u.parameters["flush_output"] = True xdmff_u.write(u, 0.) xdmff_p = df.XDMFFile(mesh_2.mpi_comm(), args.initfile_out + "_p.xdmf") xdmff_p.parameters["rewrite_function_mesh"] = False xdmff_p.parameters["flush_output"] = True xdmff_p.write(p, 0.)
def __init__(self, parameters, mesh_name, facet_name, bc_dict={ "obstacle": 2, "channel_walls": 1, "inlet": 3, "outlet": 4 }): """ Create the required function spaces, functions and boundary conditions for a channel flow problem """ self.bc_dict = bc_dict self.mesh = df.Mesh() with df.XDMFFile(mesh_name) as infile: infile.read(self.mesh) mvc = df.MeshValueCollection("size_t", self.mesh, self.mesh.topology().dim() - 1) with df.XDMFFile(facet_name) as infile: infile.read(mvc, "name_to_read") self.mf = mf = df.cpp.mesh.MeshFunctionSizet(self.mesh, mvc) self.V = V = df.VectorFunctionSpace(self.mesh, 'P', parameters["degree velocity"]) self.Q = Q = df.FunctionSpace(self.mesh, 'P', parameters["degree pressure"]) self.rho = df.Constant(parameters["density [kg/m3]"]) self.mu = df.Constant(parameters["viscosity [Pa*s]"]) self.dt = df.Constant(parameters["dt [s]"]) self.g = df.Constant((0, 0)) self.vu, self.vp = df.TestFunction(V), df.TestFunction(Q) self.u_, self.p_ = df.Function(V), df.Function(Q) self.u_1, self.p_1 = df.Function(V), df.Function(Q) self.u_k, self.p_k = df.Function(V), df.Function(Q) self.u, self.p = df.TrialFunction(V), df.TrialFunction(Q) # unknown! self.U_m = U_m = parameters["velocity [m/s]"] x = [0, .41 / 2] # center of the channel Ucenter = 4. * U_m * x[1] * (.41 - x[1]) / (.41 * .41) U0_str = "4.*U_m*x[1]*(.41-x[1])/(.41*.41)" self.U_mean = np.mean(2 / 3 * Ucenter) U0 = df.Expression((U0_str, "0"), U_m=U_m, degree=2) bc0 = df.DirichletBC(V, df.Constant((0, 0)), mf, bc_dict["obstacle"]) bc1 = df.DirichletBC(V, df.Constant((0, 0)), mf, bc_dict["channel_walls"]) bc2 = df.DirichletBC(V, U0, mf, bc_dict["inlet"]) bc3 = df.DirichletBC(Q, df.Constant(0), mf, bc_dict["outlet"]) self.bcu = [bc0, bc1, bc2] self.bcp = [bc3] self.ds_ = df.Measure("ds", domain=self.mesh, subdomain_data=mf) return
def save(self, save_number=1, it=0): # save samples for visualization if save_number > self.number_particles_all: save_number = self.number_particles_all if self.rank == 0: mean = self.model.generate_vector(PARAMETER) for p in range(self.nproc): for m in range(self.number_particles_all): mean.axpy(1.0/(self.nproc*self.number_particles_all), self.particles_gather[p][m]) particle_fun = dl.Function(self.model.problem.Vh[PARAMETER], name='particle') particle_fun.vector().axpy(1.0, mean) filename = 'data/mean' + '_iteration_' + str(it) + '_isProjection_' + str(self.options["is_projection"]) + '_' + str(self.options["low_rank_Hessian"]) + '.xdmf' if dlversion() <= (1, 6, 0): dl.File(self.model.prior.R.mpi_comm(), filename) << particle_fun else: xf = dl.XDMFFile(self.model.prior.R.mpi_comm(), filename) xf.write(particle_fun) variance = self.model.generate_vector(PARAMETER) if self.nproc*self.number_particles_all > 1: for p in range(self.nproc): for m in range(self.number_particles_all): vhelp = self.model.generate_vector(PARAMETER) vhelp.axpy(1.0, self.particles_gather[p][m]) vhelp.axpy(-1.0, mean) vsqured = vhelp.get_local()**2 vhelp.set_local(vsqured) variance.axpy(1.0 / (self.nproc*self.number_particles_all-1), vhelp) particle_fun = dl.Function(self.model.problem.Vh[PARAMETER], name='particle') particle_fun.vector().axpy(1.0, variance) filename = 'data/variance' + '_iteration_' + str(it) + '_isProjection_' + str(self.options["is_projection"]) + '_' + str(self.options["low_rank_Hessian"]) + '.xdmf' if dlversion() <= (1, 6, 0): dl.File(self.model.prior.R.mpi_comm(), filename) << particle_fun else: xf = dl.XDMFFile(self.model.prior.R.mpi_comm(), filename) xf.write(particle_fun) for n in range(save_number): if self.type_parameter is 'field': particle_fun = dl.Function(self.model.problem.Vh[PARAMETER], name='particle') particle_fun.vector().axpy(1.0, self.particles[n]) filename = 'data/rank_' + str(self.rank) + '_particle_' + str(n) + '_iteration_' + str(it) + str(self.options["is_projection"]) + '_' + str(self.options["low_rank_Hessian"]) + '.xdmf' if dlversion() <= (1, 6, 0): dl.File(self.model.prior.R.mpi_comm(), filename) << particle_fun else: xf = dl.XDMFFile(self.model.prior.R.mpi_comm(), filename) xf.write(particle_fun) elif self.type_parameter is 'vector': filename = 'data/rank_' + str(self.rank) + '_particle_' + str(n) + '_iteration_' + str(it) np.savez(filename, particle=self.particles[n].get_local())
def XDMFFile(arg1, arg2=None): if arg2 is None: assert isinstance(arg1, str) filename = arg1 if filename.endswith(".rtc.xdmf"): return MeshRestrictionXDMFFile(filename) else: return dolfin.XDMFFile(filename) else: assert isinstance(arg2, str) mpi_comm = arg1 filename = arg2 assert not filename.endswith(".rtc.xdmf") return dolfin.XDMFFile(mpi_comm, filename)
def _open_xdmf_output_solution(self, add=''): if self.array_tag is False: filestring = self.result_dir + "solution_real" + self.study + add + ".xdmf" else: filestring = self.result_dir + "solution_real" + self.study + "_" + str(self.array_iter) + add + ".xdmf" self.logger.debug('opening xdmffile ' + filestring) self.datafileXDMFreal = d.XDMFFile(self.mesh.mesh.mpi_comm(), filestring) if self.array_tag is False: filestring = self.result_dir + "solution_imag" + self.study + add + ".xdmf" else: filestring = self.result_dir + "solution_imag" + self.study + "_" + str(self.array_iter) + add + ".xdmf" self.logger.debug('opening xdmffile ' + filestring) self.datafileXDMFimag = d.XDMFFile(self.mesh.mesh.mpi_comm(), filestring)
def test_bndModel(): Lx, Ly, Nx, Ny, NxyMicro = 2.0, 0.5, 12, 4, 50 singleScaleFile = resultFolder + "bar_single_scale.xdmf" multiScaleFile = resultFolder + "bar_multiscale_standalone_%s.xdmf" start = timer() print("simulating single scale") os.system("python bar_single_scale.py %d %d" % (Nx, Ny)) end = timer() print('finished in ', end - start) for bndModel in ['per', 'lin', 'MR', 'lag']: suffix = "{0} {1} {2} {3} > log_{3}.txt".format( Nx, Ny, NxyMicro, bndModel) start = timer() print("simulating using " + bndModel) os.system("python bar_multiscale_standalone.py " + suffix) end = timer() print('finished in ', end - start) mesh = df.RectangleMesh(df.Point(0.0, 0.0), df.Point(Lx, Ly), Nx, Ny, "right/left") Uh = df.VectorFunctionSpace(mesh, "Lagrange", 1) uh0 = df.Function(Uh) with df.XDMFFile(resultFolder + "bar_single_scale.xdmf") as f: f.read_checkpoint(uh0, 'u') error = {} ehtemp = df.Function(Uh) for bndModel in ['per', 'lin', 'MR', 'lag']: with df.XDMFFile(multiScaleFile % bndModel) as f: f.read_checkpoint(ehtemp, 'u') ehtemp.vector().set_local(ehtemp.vector().get_local()[:] - uh0.vector().get_local()[:]) error[bndModel] = df.norm(ehtemp) print(error[bndModel]) assert np.abs(error['lin'] - error['lag']) < 1e-12 assert np.abs(error['per'] - 0.006319071443377064) < 1e-12 assert np.abs(error['lin'] - 0.007901978018038507) < 1e-12 assert np.abs(error['MR'] - 0.0011744201374588351) < 1e-12
def function_from_xdmf(function_space, function_name="", xdmf_path=""): """Read a finite element function from a xdmf file with checkpoint format. Multiple functions can also be read at once. Parameters ---------- function_space : dolfin.FunctionSpace Function space appropriate for the previously saved function. The mesh must be identical to the one used for the saved function. function_name : str or list of str The name(s) of the saved function. xdmf_path : pathlib.Path or str Path of the xdmf file. It can be a Path object or a string. Extension must be '.xmdf' If multiple functions are requested: #TODO : test the first argument must be a list of tuples (FunctionSpace, function name) the second argument must be empty. Returns ------- dolfin.Function, list of dolfin.Function New function(s) that is(are) identical to the previously saved function(s). Example -------- >>> import dolfin as fe >>> mesh = xdmf_mesh("mesh.xdmf") >>> V = fe.VectorFunctionSpace(mesh, "CG", 2) >>> W = fe.VectorFunctionSpace(mesh, "DG", 1) >>> function_from_xdmf([(V,"u"),(W,"eps")], xdmf_path="checkpoint.xdmf") """ if isinstance(function_space, list): all_f = list() with fe.XDMFFile(str(xdmf_path)) as f_in: for fspace, fname in function_space: f = fe.Function(fspace) f_in.read_checkpoint(f, fname) f.rename(fname, "") all_f.append(f) return all_f else: f = fe.Function(function_space) f_in = fe.XDMFFile(str(xdmf_path)) f_in.read_checkpoint(f, function_name) f_in.close() f.rename(function_name, "") return f
def mesh3d(width, depth, height, nx, ny, nz): mesh = dolfin.BoxMesh(Point(0., 0., 0.), Point(width, depth, height), nx, ny, nz) boundary = (dolfin.MeshFunction("size_t", mesh, mesh.topology().dim() - 1, 0), {}) for f in dolfin.facets(mesh): if dolfin.near(f.midpoint()[2], 0.): boundary[0][f] = 1 # bottom boundary[1]['bottom'] = 1 elif dolfin.near(f.midpoint()[2], height): boundary[0][f] = 2 # top boundary[1]['top'] = 2 elif dolfin.near(f.midpoint()[0], 0.): boundary[0][f] = 3 # left boundary[1]['left'] = 3 elif dolfin.near(f.midpoint()[0], width): boundary[0][f] = 4 # right boundary[1]['right'] = 4 elif dolfin.near(f.midpoint()[1], 0): boundary[0][f] = 5 # front boundary[1]['front'] = 5 elif dolfin.near(f.midpoint()[1], depth): boundary[0][f] = 6 # back boundary[1]['back'] = 6 # Definition of measures and normal vector: n = dolfin.FacetNormal(mesh) dx = dolfin.Measure("dx", mesh) ds = dolfin.Measure("ds", subdomain_data=boundary[0]) mesh_xdmf = dolfin.XDMFFile(mpi_comm_world(), "data/mesh_3D.xdmf") mesh_xdmf.write(boundaries[0]) return (mesh, boundary, n, dx, ds)
def load_mesh_function(self, name: str, directory: Path = None) -> dolfin.MeshFunction: """Lead and return a mesh function. There are two options, 'cell_function' or 'facet_function'. Arguments: name: Either 'cell_function' or 'facet_function'. """ # TODO: I could use Enum rather than hard-coding names msg = "Meshfunctions are stored as 'cell_function' or 'facet_function'." # if not name in ("cell_function", "facet_function"): # raise ValueError(msg) self.load_mesh() # Method tests if mesh is already loaded dimension = self.mesh.geometry().dim() # if cell function if name == "facet_function" or name[-3:] == "_ff": dimension -= 1 # dimension is one less # mvc = df.MeshValueCollection("size_t", self.mesh, dimension) cell_function = df.MeshFunction("size_t", self.mesh, dimension) _directory = self._casedir if directory is not None: _directory = Path(directory) infile_name = _directory / f"{name}.xdmf" if not infile_name.exists(): raise RuntimeError(f"Mesh function {infile_name} does not exist") with df.XDMFFile(str(infile_name)) as infile: infile.read(cell_function) # infile.read(mvc) # cell_function = df.MeshFunction("size_t", self.mesh, mvc) return cell_function
def loadDolfin(filename, exterior=False): """Reads a `Fenics/Dolfin` file format (.xml or .xdmf). Return an ``Actor(vtkActor)`` object.""" import sys if sys.version_info[0] < 3: return _loadDolfin_old(filename) import dolfin if filename.lower().endswith('.xdmf'): f = dolfin.XDMFFile(filename) m = dolfin.Mesh() f.read(m) else: m = dolfin.Mesh(filename) bm = dolfin.BoundaryMesh(m, "exterior") if exterior: poly = utils.buildPolyData(bm.coordinates(), bm.cells(), fast=True) else: polyb = utils.buildPolyData(bm.coordinates(), bm.cells(), fast=True) polym = utils.buildPolyData(m.coordinates(), m.cells(), fast=True) app = vtk.vtkAppendPolyData() app.AddInputData(polym) app.AddInputData(polyb) app.Update() poly = app.GetOutput() return Actor(poly).lw(0.1)
def gmsh2dolfin(msh_file, unlink: bool = True): name = Path(msh_file).stem triangle_mesh_name = Path(f"triangle_mesh_{name}.xdmf") tetra_mesh_name = Path(f"mesh_{name}.xdmf") markers = {} if not (triangle_mesh_name.is_file() and tetra_mesh_name.is_file()): markers = convert_msh_to_xdmf(msh_file, triangle_mesh_name, tetra_mesh_name) mesh = df.Mesh() with df.XDMFFile(tetra_mesh_name.as_posix()) as infile: infile.read(mesh) cfun = df.MeshFunction("size_t", mesh, 3) read_meshfunction(tetra_mesh_name, cfun) ffun_val = df.MeshValueCollection("size_t", mesh, 2) read_meshfunction(triangle_mesh_name, ffun_val) ffun = df.MeshFunction("size_t", mesh, ffun_val) if unlink: triangle_mesh_name.unlink() triangle_mesh_name.with_suffix(".h5").unlink() tetra_mesh_name.unlink() tetra_mesh_name.with_suffix(".h5").unlink() return mesh, ffun, markers
def __init__(self, data, logger): # use __init__ from Fenics class super().__init__(data, logger) self.logger.info("Starting Heat simulation.") ### # FEM part ### self._set_function_space() self._prepare_boundaries() self.logger.debug("Set DirichletBC") self.boundaries.set_DirichletBC(self.V, self.logger) self.datafileXDMFT = d.XDMFFile(self.mesh.mesh.mpi_comm(), self.result_dir + "Tsolution" + self. study + '.xdmf') ### # Physics part ### stationary = 'timesteps' not in self.data if stationary: self._set_material_constants(stat=True) self._set_stationary_problem() self.logger.debug("Stationary problem set.") self.N = 1 self.t = 0 else: self._set_timestepping() self._set_material_constants() self._set_problem() self.logger.debug("Time-dependent problem set.") self._setup_solver() self._solve_problem() self.datafileXDMFT.close()
def _open_output_efield(self, add=''): """ for the output we can add information, e.g. about the respective subdomain """ if self.array_tag is False: filestring = self.result_dir + "efield_real" + self.study + add + ".xdmf" else: filestring = self.result_dir + "efield_real" + self.study + "_" + str(self.array_iter) + add + ".xdmf" self.logger.debug('opening xdmffile ' + filestring) self.dataXDMFEreal = d.XDMFFile(self.mesh.mesh.mpi_comm(), filestring) if self.array_tag is False: filestring = self.result_dir + "efield_imag" + self.study + add + ".xdmf" else: filestring = self.result_dir + "efield_imag" + self.study + "_" + str(self.array_iter) + add + ".xdmf" self.logger.debug('opening xdmffile ' + filestring) self.dataXDMFEimag = d.XDMFFile(self.mesh.mesh.mpi_comm(), filestring)
def __init__(self, model, filename="out.xdmf"): self.model = model self.plot = df.XDMFFile(filename) self.plot.parameters["functions_share_mesh"] = True self.model.d.rename("u", "u") self.model.k.rename("kappa", "kappa")
def read_mesh(self, numElementsFilm, reGen=True): if reGen: self.gen_mesh(numElementsFilm=2.0) fileName = "mesh/geometry_quad.xdmf" self.mesh = dl.Mesh() f = dl.XDMFFile(dl.mpi_comm_world(), fileName) f.read(self.mesh) f.close()
def test_parallel(): Lx, Ly, Ny, Nx, NxyMicro = 0.5, 2.0, 12, 5, 50 bndModel = 'per' suffix = "%d %d %d %s > log_%s.txt" % (Nx, Ny, NxyMicro, bndModel, bndModel) start = timer() print("simulating single core") os.system("python bar_multiscale_standalone.py " + suffix) end = timer() print('finished in ', end - start) for nProc in [1, 2, 3, 4]: start = timer() print("simulating using nProc", nProc) os.system("mpirun -n %d python bar_multiscale_parallel.py " % nProc + suffix) end = timer() print('finished in ', end - start) mesh = df.RectangleMesh(df.Point(0.0, 0.0), df.Point(Lx, Ly), Nx, Ny, "right/left") Uh = df.VectorFunctionSpace(mesh, "Lagrange", 1) uh0 = df.Function(Uh) with df.XDMFFile("bar_multiscale_standalone_%s.xdmf" % bndModel) as f: f.read_checkpoint(uh0, 'u') error = {} ehtemp = df.Function(Uh) for nProc in [1, 2, 3, 4]: with df.XDMFFile("bar_multiscale_parallel_%s_np%d.xdmf" % (bndModel, nProc)) as f: f.read_checkpoint(ehtemp, 'u') ehtemp.vector().set_local(ehtemp.vector().get_local()[:] - uh0.vector().get_local()[:]) error[nProc] = df.norm(ehtemp) assert np.max(np.array(list(error.values()))) < 1e-13
def get_mesh( directory: Path, name: str, facet_function_name: str = None, cell_function_name: str = None ) -> tp.Tuple[df.Mesh, df.MeshFunction, df.MeshFunction]: mesh = df.Mesh() mesh_name = str(directory / f"{name}.xdmf") with df.XDMFFile(mesh_name) as infile: infile.read(mesh) if cell_function_name is None: cell_function_name = f"{name}_cf.xdmf" _cell_function_name = directory / cell_function_name if not _cell_function_name.suffix == ".xdmf": _cell_function_name = Path(f"{_cell_function_name}.xdmf") if not _cell_function_name.exists(): cell_function = None logging.info( f"Could not read cell function, file '{_cell_function_name} does not exist" ) else: mvc = df.MeshValueCollection("size_t", mesh, mesh.geometry().dim()) with df.XDMFFile(str(_cell_function_name)) as infile: infile.read(mvc) # infile.read(mvc, "tetra") cell_function = df.MeshFunction("size_t", mesh, mvc) if facet_function_name is None: facet_function_name = f"{name}_ff.xdmf" _facet_function_name = directory / facet_function_name if not _facet_function_name.suffix == ".xdmf": _facet_function_name = Path(f"{_facet_function_name}.xdmf") if not _facet_function_name.exists(): facet_function = None logging.info( f"Could not read facet function, file '{_facet_function_name} does not exist" ) else: mvc = df.MeshValueCollection("size_t", mesh, mesh.geometry().dim() - 1) with df.XDMFFile(str(_facet_function_name)) as infile: infile.read(mvc) facet_function = df.MeshFunction("size_t", mesh, mvc) return mesh, cell_function, facet_function
def load_checkpoint( self, name: str, timestep_iterable: Iterable[int] = None, ) -> Iterator[Tuple[int, float, dolfin.Function]]: """yield tuple(float, function).""" metadata = self.load_metadata(name) _timestep_iterable = timestep_iterable timestep_iterable, time_iterable = self.load_time() # from IPython import embed; embed() # assert False if _timestep_iterable is None: _timestep_iterable = timestep_iterable if self.mesh is None: self.mesh = self.load_mesh() element_tuple = ( dolfin.interval, dolfin.triangle, dolfin.tetrahedron ) element = dolfin.FiniteElement( metadata["element_family"], element_tuple[self.mesh.geometry().dim() - 1], # zero indexed metadata["element_degree"] ) V_space = dolfin.FunctionSpace(self.mesh, element) v_func = dolfin.Function(V_space) _filename = self.casedir / Path("{name}/{name}_chk.xdmf".format(name=name)) if _filename.exists(): filename_list = [_filename] else: assert False, f"Could not open {_filename}" previous_timestep = -100 for filename in filename_list: with dolfin.XDMFFile(dolfin.MPI.comm_world, str(filename)) as fieldfile: for savad_timestep_index, timestep in enumerate(_timestep_iterable): if timestep == previous_timestep: continue previous_timestep = timestep if timestep < int(metadata["start_timestep"]): continue if timestep % int(metadata["stride_timestep"]) != 0: continue try: fieldfile.read_checkpoint(v_func, name, counter=timestep) except RuntimeError as e: LOGGER.info(f"Could not read timestep: {e}") yield time_iterable[savad_timestep_index], v_func
def get_mesh(directory: str, name: str) -> Tuple[df.Mesh, df.MeshFunction, df.MeshFunction]: mesh = df.Mesh() with df.XDMFFile(f"{directory}/{name}.xdmf") as infile: infile.read(mesh) mvc = df.MeshValueCollection("size_t", mesh, 2) with df.XDMFFile(f"{directory}/{name}_cf.xdmf") as infile: infile.read(mvc, "cell_data") cell_function = df.MeshFunction("size_t", mesh, mvc) try: mvc = df.MeshValueCollection("size_t", mesh, 1) with df.XDMFFile(f"{directory}/{name}_ff.xdmf") as infile: infile.read(mvc, "facet_data") interface_function = df.MeshFunction("size_t", mesh, mvc) except: interface_function = df.MeshFunction("size_t", mesh, mesh.geometric_dimension() - 1) interface_function.set_all(0) return mesh, cell_function, interface_function
def exportState(self, x, filename, varname): out_file = dl.XDMFFile(self.Vh[STATE].mesh().mpi_comm(), filename) out_file.parameters["functions_share_mesh"] = True out_file.parameters["rewrite_function_mesh"] = False ufunc = dl.Function(self.Vh[STATE], name=varname) t = self.simulation_times[0] out_file.write(vector2Function(x[PARAMETER], self.Vh[STATE], name=varname),t) for t in self.simulation_times[1:]: x[STATE].retrieve(ufunc.vector(), t) out_file.write(ufunc, t)
def get_indicator_function(function_path: Path, mesh: df.Mesh, name: str = "indicator") -> df.Function: # Has to be the same as in the bidomain solver function_space = df.FunctionSpace(mesh, "CG", 1) function = df.Function(function_space) with df.XDMFFile(str(function_path)) as infile: infile.read_checkpoint(function, name, 0) return function
def load_mesh(self, name: str = None) -> dolfin.mesh: """Load and return the mesh stored as xdmf.""" if self.mesh is None: self.mesh = df.Mesh() if name is None: mesh_name = self._casedir / Path("mesh.xdmf") else: mesh_name = self._casedir / Path(f"{name}.xdmf") with df.XDMFFile(str(mesh_name)) as infile: infile.read(self.mesh) return self.mesh
def _save_all_localization_fields(xdmf_path: Path, localization_dicts: list): """Sauvegarde de tous les champs de localisation dans un .xdmf localization_dicts : list de dictionnaires.""" with fe.XDMFFile(str(xdmf_path)) as fo: fo.parameters["functions_share_mesh"] = True for d in localization_dicts: for k, fields in d.items(): for f in fields: logger.debug(f"Saving field {f.name()}") fo.write(f, 0.0) return None
def _plot_mesh(self): if self.mesh.dimension < 3: self.logger.info("Plotting mesh") d.plot(self.mesh.mesh, title='mesh') plt.show() p = d.plot(self.mesh.cells, title="subdomains ") loc = plticker.MultipleLocator(base=1.0) # some hacks from the internet plt.colorbar(p, format='%d', ticks=loc, fraction=0.03, pad=0.04) plt.show() self.logger.debug( "Mesh was plotted, subdomains and facets also match the mesh") else: self.logger.info( "Plotting mesh does not make sense in 3D. Output is written to paraview readable files." ) self.mesh_dir = "mesh/" if not os.path.exists(self.mesh_dir): try: os.makedirs(self.mesh_dir) except OSError as exc: # Guard against race condition if exc.errno != errno.EEXIST: raise tmp = d.XDMFFile( self.mesh.mesh.mpi_comm(), self.mesh_dir + self.mesh.meshname + str('_plot.xdmf')) tmp.write(self.mesh.mesh) tmp.close() tmp = d.XDMFFile( self.mesh.mesh.mpi_comm(), self.mesh_dir + self.mesh.meshname + str('_subdomains') + str('.xdmf')) tmp.write(self.mesh.cells) tmp.close() tmp = d.XDMFFile( self.mesh.mesh.mpi_comm(), self.mesh_dir + self.mesh.meshname + str('_facets') + str('.xdmf')) tmp.write(self.mesh.facets) tmp.close() self.logger.debug("Mesh was written out.")
def _plot_submesh(self, subdomain): try: if 'mesh' in self.plot: if self.plot['mesh'] is True: tmp = d.XDMFFile( self.mesh.mesh.mpi_comm(), self.mesh_dir + self.mesh.meshname + '_plot_' + str(subdomain) + '.xdmf') tmp.write(self.sub_mesh) tmp.close() except TypeError: pass
def save_mesh(directory: Path, name: str, *, mesh: tp.Optional[df.Mesh] = None, cell_function: tp.Optional[df.MeshFunction] = None, facet_function: tp.Optional[df.MeshFunction] = None) -> None: if mesh is not None: mesh_path = directory / f"{name}.xdmf" logger.info(f"Saving mesh as {mesh_path}") with df.XDMFFile(str(mesh_path)) as mesh_file: mesh_file.write(mesh) if cell_function is not None: cell_path = directory / f"{name}_cf.xdmf" logger.info(f"Saving cell_function as {cell_path}") with df.XDMFFile(str(cell_path)) as cell_file: cell_file.write(cell_function) if facet_function is not None: facet_path = directory / f"{name}_ff.xdmf" logger.info(f"Saving facet_function as {facet_path}") with df.XDMFFile(str(facet_path)) as facet_file: facet_file.write(facet_function)
def define_spatially_varying_penalty(simulation, P, k_min, k_max, boost_factor=3, exponent=1): """ Define the penalty parameter used in the Poisson equations Spatially varying version, returns a DGT0 function Arguments: mesh: the mesh used in the simulation P: the polynomial degree of the unknown k_min: the minimum diffusion coefficient k_max: the maximum diffusion coefficient boost_factor: the penalty is multiplied by this factor exponent: set this to greater than 1 for superpenalisation """ assert k_max >= k_min mesh = simulation.data['mesh'] ndim = mesh.geometry().dim() # Compute the constant part of the penalty pconst = boost_factor * k_max**2 / k_min * (P + 1) * (P + ndim) / ndim # Compute the spatially varying penalty V = dolfin.FunctionSpace(mesh, 'DG', 0) dm = V.dofmap() penalty_func = dolfin.Function(V) arr = penalty_func.vector().get_local() for cell in dolfin.cells(mesh): vol = cell.volume() area = sum(cell.facet_area(i) for i in range(ndim + 1)) geom_fac = area / vol dof, = dm.cell_dofs(cell.index()) arr[dof] = pconst * geom_fac**exponent penalty_func.vector().set_local(arr) penalty_func.vector().apply('insert') # Optionally plot the penalty function to file if simulation.input.get_value('output/plot_elliptic_penalty', False, 'bool'): prefix = simulation.input.get_value('output/prefix', '', 'string') pfile = prefix + '_elliptic_dg_penalty.xdmf' simulation.log.info( ' Plotting elliptic DG penalty to XDMF file %r' % pfile) penalty_func.rename('penalty', 'penalty') with dolfin.XDMFFile(mesh.mpi_comm(), pfile) as xdmf: xdmf.write(penalty_func) return penalty_func