def __init__(self, solfiles, refine=0): def fname2idx(t): i = int(os.path.basename(t).split('.')[0].split('_')[-1]) return i solfiles = solfiles.set object.__init__(self) self.set = [] import mfem.ser as mfem for meshes, solf, in solfiles: idx = [fname2idx(x) for x in meshes] meshes = { i: mfem.Mesh(str(x), 1, refine) for i, x in zip(idx, meshes) } meshes = MeshDict(meshes) # to make dict weakref-able ### what is this refine = 0 !? for i in idx: meshes[i].ReorientTetMesh() meshes[i]._emesh_idx = i s = {} for key in six.iterkeys(solf): fr, fi = solf[key] i = fname2idx(fr) m = meshes[i] solr = (mfem.GridFunction(m, str(fr)) if fr is not None else None) soli = (mfem.GridFunction(m, str(fi)) if fi is not None else None) if solr is not None: solr._emesh_idx = i if soli is not None: soli._emesh_idx = i s[key] = (solr, soli) self.set.append((meshes, s))
def load_sol( solfiles, fesvar, refine=0, ): ''' read sol files in directory path. it reads only a file for the certain FES variable given by fesvar ''' from petram.sol.solsets import find_solfiles, MeshDict # solfiles = find_solfiles(path) def fname2idx(t): i = int(os.path.basename(t).split('.')[0].split('_')[-1]) return i solfiles = solfiles.set solset = [] for meshes, solf, in solfiles: s = {} for key in six.iterkeys(solf): name = key.split('_')[0] if name != fesvar: continue idx_to_read = int(key.split('_')[1]) break for meshes, solf, in solfiles: idx = [fname2idx(x) for x in meshes] meshes = { i: mfem.Mesh(str(x), 1, refine) for i, x in zip(idx, meshes) if i == idx_to_read } meshes = MeshDict(meshes) # to make dict weakref-able ### what is this refine = 0 !? for i in meshes.keys(): meshes[i].ReorientTetMesh() meshes[i]._emesh_idx = i s = {} for key in six.iterkeys(solf): name = key.split('_')[0] if name != fesvar: continue fr, fi = solf[key] i = fname2idx(fr) m = meshes[i] solr = (mfem.GridFunction(m, str(fr)) if fr is not None else None) soli = (mfem.GridFunction(m, str(fi)) if fi is not None else None) if solr is not None: solr._emesh_idx = i if soli is not None: soli._emesh_idx = i s[name] = (solr, soli) solset.append((meshes, s)) return solset
def run_test(): mesh = mfem.Mesh(10, 10, "TRIANGLE") fec = mfem.H1_FECollection(1, mesh.Dimension()) fespace = mfem.FiniteElementSpace(mesh, fec) gf = mfem.GridFunction(fespace) gf.Assign(1.0) odata = gf.GetDataArray().copy() visit_dc = mfem.VisItDataCollection("test_gf", mesh) visit_dc.RegisterField("gf", gf) visit_dc.Save() mesh2 = mfem.Mesh("test_gf_000000/mesh.000000") check_mesh(mesh, mesh2, ".mesh2 does not agree with original") gf2 = mfem.GridFunction(mesh2, "test_gf_000000/gf.000000") odata2 = gf2.GetDataArray().copy() check(odata, odata2, "odata2 file does not agree with original") visit_dc = mfem.VisItDataCollection("test_gf_gz", mesh) visit_dc.SetCompression(True) visit_dc.RegisterField("gf", gf) visit_dc.Save() with gzip.open("test_gf_gz_000000/mesh.000000", 'rt') as f: sio = io.StringIO(f.read()) mesh3 = mfem.Mesh(sio) check_mesh(mesh, mesh3, ".mesh3 does not agree with original") with gzip.open("test_gf_gz_000000/gf.000000", 'rt') as f: sio = io.StringIO(f.read()) # This is where the error is: gf3 = mfem.GridFunction(mesh3, sio) odata3 = gf3.GetDataArray() check(odata, odata3, "gf3 file does not agree with original") mesh4 = mfem.Mesh("test_gf_gz_000000/mesh.000000") check_mesh(mesh, mesh4, ".mesh4 does not agree with original") gf4 = mfem.GridFunction(mesh3, "test_gf_gz_000000/gf.000000") odata4 = gf4.GetDataArray() check(odata, odata4, "gf3 file does not agree with original") print("PASSED")
def write_ho_tet_mesh(filename, reader, ho_thre=1e-20): import mfem.ser as mfem @jit(numba.int64(numba.float64[:], numba.float64[:, :]), cache=False) def find_closest0(ptx, grids): x1 = ptx[0] y1 = ptx[1] z1 = ptx[2] for jj in range(10): d2 = ((x1 - grids[jj, 0])**2 + (y1 - grids[jj, 1])**2 + (z1 - grids[jj, 2])**2) if d2 < ho_thre: return jj assert(False) return -1 @jit(parallel=True, cache=False) def find_closest_tet_ptx(ptx, grids): idx = np.empty(10, dtype=numba.int64) for jj in prange(10): idx[jj] = find_closest0(ptx[jj], grids) return idx mesh = mfem.Mesh(filename) prepare_ho_node(mesh) n = mesh.GetNE() node_gf = mesh.GetNodes() nfes = node_gf.FESpace() nodes = node_gf.GetDataArray().copy() node_gf2 = mfem.GridFunction(mesh._linked_obj[0]) nodes2 = node_gf2.GetDataArray() grid_all = reader.dataset['GRIDS'] i_tetra = reader.dataset["ELEMS_HO"]["TETRA"] for i in range(n): # for i in [0]: vdofs = nfes.GetElementVDofs(i) ptx = nodes[vdofs].reshape(3, -1).transpose() grids = grid_all[i_tetra[i]] new_grids = linearized_grids(grids) idx = find_closest_tet_ptx(ptx, new_grids) tmp = grids[idx] data = np.hstack((tmp[:, 0], tmp[:, 1], tmp[:, 2])) nodes2[vdofs] = data if (i % 50000) == 0: print("processing elements "+str(i) + "/" + str(n)) node_gf.Assign(nodes2) filename2 = filename[:-5]+"_order2.mesh" mesh.Save(filename2)
def SetParameters(self, u): u_alpha_gf = mfem.GridFunction(self.fespace) u_alpha_gf.SetFromTrueDofs(u) for i in range(u_alpha_gf.Size()): u_alpha_gf[i] = self.kappa + self.alpha * u_alpha_gf[i] self.K = mfem.BilinearForm(self.fespace) u_coeff = mfem.GridFunctionCoefficient(u_alpha_gf) self.K.AddDomainIntegrator(mfem.DiffusionIntegrator(u_coeff)) self.K.Assemble() self.K.FormSystemMatrix(self.ess_tdof_list, self.Kmat) self.T = None
# 5. In this example, the Dirichlet boundary conditions are defined by # marking boundary attributes 1 and 2 in the marker Array 'dir_bdr'. # These b.c. are imposed weakly, by adding the appropriate boundary # integrators over the marked 'dir_bdr' to the bilinear and linear forms. # With this DG formulation, there are no essential boundary conditions. ess_tdof_list = intArray() dir_bdr = intArray(mesh.bdr_attributes.Max()) dir_bdr.Assign(0) dir_bdr[0] = 1 # boundary attribute 1 is Dirichlet dir_bdr[1] = 1 # boundary attribute 2 is Dirichlet # 6. Define the DG solution vector 'x' as a finite element grid function # corresponding to fespace. Initialize 'x' using the 'InitDisplacement' # function. x = mfem.GridFunction(fespace) init_x = InitDisplacement(dim) x.ProjectCoefficient(init_x) # 7. Set up the Lame constants for the two materials. They are defined as # piece-wise (with respect to the element attributes) constant # coefficients, i.e. type PWConstCoefficient. lamb = mfem.Vector(mesh.attributes.Max()) # lambda is not possible in python lamb.Assign(1.0) lamb[0] = 50. lambda_c = mfem.PWConstCoefficient(lamb) mu = mfem.Vector(mesh.attributes.Max()) mu.Assign(1.0); mu[0] = 50.0 mu_c = mfem.PWConstCoefficient(mu)
import mfem.ser as mfem import io mesh = mfem.Mesh(3) fec = mfem.H1_FECollection(1) fes = mfem.FiniteElementSpace(mesh, fec) x = mfem.GridFunction(fes) x.Assign(0.0) o = io.StringIO() l1 = mesh.WriteToStream(o) l2 = x.WriteToStream(o) v = mfem.Vector([1, 2, 3]) l3 = v.WriteToStream(o) print("result length: ", l1, " ", l2) print('result: ', o.getvalue())
# finite element fespace. b = mfem.LinearForm(fespace); f = f_exact() dd = mfem.VectorFEDomainLFIntegrator(f); b.AddDomainIntegrator(dd) b.Assemble(); # 7. Define the solution vector x as a finite element grid function # corresponding to fespace. Initialize x by projecting the exact # solution. Note that only values from the boundary edges will be used # when eliminating the non-homogeneous boundary condition to modify the # r.h.s. vector b. #from mfem.examples.ex3 import E_exact_cb x = mfem.GridFunction(fespace) E = E_exact() x.ProjectCoefficient(E); # 8. Set up the bilinear form corresponding to the EM diffusion operator # curl muinv curl + sigma I, by adding the curl-curl and the mass domain # integrators. muinv = mfem.ConstantCoefficient(1.0); sigma = mfem.ConstantCoefficient(1.0); a = mfem.BilinearForm(fespace); a.AddDomainIntegrator(mfem.CurlCurlIntegrator(muinv)); a.AddDomainIntegrator(mfem.VectorFEMassIntegrator(sigma)); # 9. Assemble the bilinear form and the corresponding linear system, # applying any necessary transformations such as: eliminating boundary
solver.SetPreconditioner(darcyPrec) solver.SetPrintLevel(1) x.Assign(0.0) solver.Mult(rhs, x) solve_time = clock() - stime if solver.GetConverged(): print("MINRES converged in " + str(solver.GetNumIterations()) + " iterations with a residual norm of " + str(solver.GetFinalNorm())) else: print("MINRES did not converge in " + str(solver.GetNumIterations()) + " iterations. Residual norm is " + str(solver.GetFinalNorm())) print("MINRES solver took " + str(solve_time) + "s.") u = mfem.GridFunction() p = mfem.GridFunction() u.MakeRef(R_space, x.GetBlock(0), 0) p.MakeRef(W_space, x.GetBlock(1), 0) order_quad = max(2, 2 * order + 1) irs = [mfem.IntRules.Get(i, order_quad) for i in range(mfem.Geometry.NumGeom)] norm_p = mfem.ComputeLpNorm(2, pcoeff, mesh, irs) norm_u = mfem.ComputeLpNorm(2, ucoeff, mesh, irs) err_u = u.ComputeL2Error(ucoeff, irs) err_p = p.ComputeL2Error(pcoeff, irs) print("|| u_h - u_ex || / || u_ex || = " + str(err_u / norm_u)) print("|| p_h - p_ex || / || p_ex || = " + str(err_p / norm_p))
def run(order=1, static_cond=False, meshfile=def_meshfile, visualization=False): mesh = mfem.Mesh(meshfile, 1, 1) dim = mesh.Dimension() # 3. Refine the mesh to increase the resolution. In this example we do # 'ref_levels' of uniform refinement. We choose 'ref_levels' to be the # largest number that gives a final mesh with no more than 50,000 # elements. ref_levels = int(np.floor( np.log(50000. / mesh.GetNE()) / np.log(2.) / dim)) for x in range(ref_levels): mesh.UniformRefinement() #5. Define a finite element space on the mesh. Here we use vector finite # elements, i.e. dim copies of a scalar finite element space. The vector # dimension is specified by the last argument of the FiniteElementSpace # constructor. For NURBS meshes, we use the (degree elevated) NURBS space # associated with the mesh nodes. if order > 0: fec = mfem.H1_FECollection(order, dim) elif mesh.GetNodes(): fec = mesh.GetNodes().OwnFEC() prinr("Using isoparametric FEs: " + str(fec.Name())) else: order = 1 fec = mfem.H1_FECollection(order, dim) fespace = mfem.FiniteElementSpace(mesh, fec) print('Number of finite element unknowns: ' + str(fespace.GetTrueVSize())) # 5. Determine the list of true (i.e. conforming) essential boundary dofs. # In this example, the boundary conditions are defined by marking all # the boundary attributes from the mesh as essential (Dirichlet) and # converting them to a list of true dofs. ess_tdof_list = mfem.intArray() if mesh.bdr_attributes.Size() > 0: ess_bdr = mfem.intArray([1] * mesh.bdr_attributes.Max()) ess_bdr = mfem.intArray(mesh.bdr_attributes.Max()) ess_bdr.Assign(1) fespace.GetEssentialTrueDofs(ess_bdr, ess_tdof_list) #6. Set up the linear form b(.) which corresponds to the right-hand side of # the FEM linear system, which in this case is (1,phi_i) where phi_i are # the basis functions in the finite element fespace. b = mfem.LinearForm(fespace) one = mfem.ConstantCoefficient(1.0) b.AddDomainIntegrator(mfem.DomainLFIntegrator(one)) b.Assemble() #7. Define the solution vector x as a finite element grid function # corresponding to fespace. Initialize x with initial guess of zero, # which satisfies the boundary conditions. x = mfem.GridFunction(fespace) x.Assign(0.0) #8. Set up the bilinear form a(.,.) on the finite element space # corresponding to the Laplacian operator -Delta, by adding the Diffusion # domain integrator. a = mfem.BilinearForm(fespace) a.AddDomainIntegrator(mfem.DiffusionIntegrator(one)) #9. Assemble the bilinear form and the corresponding linear system, # applying any necessary transformations such as: eliminating boundary # conditions, applying conforming constraints for non-conforming AMR, # static condensation, etc. if static_cond: a.EnableStaticCondensation() a.Assemble() A = mfem.OperatorPtr() B = mfem.Vector() X = mfem.Vector() a.FormLinearSystem(ess_tdof_list, x, b, A, X, B) print("Size of linear system: " + str(A.Height())) # 10. Solve AA = mfem.OperatorHandle2SparseMatrix(A) M = mfem.GSSmoother(AA) mfem.PCG(AA, M, B, X, 1, 200, 1e-12, 0.0) # 11. Recover the solution as a finite element grid function. a.RecoverFEMSolution(X, b, x) # 12. Save the refined mesh and the solution. This output can be viewed later # using GLVis: "glvis -m refined.mesh -g sol.gf". mesh.Print('refined.mesh', 8) x.Save('sol.gf', 8) #13. Send the solution by socket to a GLVis server. if (visualization): sol_sock = mfem.socketstream("localhost", 19916) sol_sock.precision(8) sol_sock.send_solution(mesh, x)
def ex19_main(args): ref_levels = args.refine order = args.order visualization = args.visualization mu = args.shear_modulus newton_rel_tol = args.relative_tolerance newton_abs_tol = args.absolute_tolerance newton_iter = args.newton_iterations parser.print_options(args) meshfile = expanduser(join(path, 'data', args.mesh)) mesh = mfem.Mesh(meshfile, 1, 1) dim = mesh.Dimension() for lev in range(ref_levels): mesh.UniformRefinement() # 4. Define the shear modulus for the incompressible Neo-Hookean material c_mu = mfem.ConstantCoefficient(mu) # 5. Define the finite element spaces for displacement and pressure # (Taylor-Hood elements). By default, the displacement (u/x) is a second # order vector field, while the pressure (p) is a linear scalar function. quad_coll = mfem.H1_FECollection(order, dim) lin_coll = mfem.H1_FECollection(order - 1, dim) R_space = mfem.FiniteElementSpace(mesh, quad_coll, dim, mfem.Ordering.byVDIM) W_space = mfem.FiniteElementSpace(mesh, lin_coll) spaces = [R_space, W_space] R_size = R_space.GetVSize() W_size = W_space.GetVSize() # 6. Define the Dirichlet conditions (set to boundary attribute 1 and 2) ess_bdr_u = mfem.intArray(R_space.GetMesh().bdr_attributes.Max()) ess_bdr_p = mfem.intArray(W_space.GetMesh().bdr_attributes.Max()) ess_bdr_u.Assign(0) ess_bdr_u[0] = 1 ess_bdr_u[1] = 1 ess_bdr_p.Assign(0) ess_bdr = [ess_bdr_u, ess_bdr_p] print("***********************************************************") print("dim(u) = " + str(R_size)) print("dim(p) = " + str(W_size)) print("dim(u+p) = " + str(R_size + W_size)) print("***********************************************************") block_offsets = intArray([0, R_size, W_size]) block_offsets.PartialSum() xp = mfem.BlockVector(block_offsets) # 9. Define grid functions for the current configuration, reference # configuration, final deformation, and pressure x_gf = mfem.GridFunction(R_space) x_ref = mfem.GridFunction(R_space) x_def = mfem.GridFunction(R_space) p_gf = mfem.GridFunction(W_space) x_gf.MakeRef(R_space, xp.GetBlock(0), 0) p_gf.MakeRef(W_space, xp.GetBlock(1), 0) deform = InitialDeformation(dim) refconfig = ReferenceConfiguration(dim) x_gf.ProjectCoefficient(deform) x_ref.ProjectCoefficient(refconfig) p_gf.Assign(0.0) # 10. Initialize the incompressible neo-Hookean operator oper = RubberOperator(spaces, ess_bdr, block_offsets, newton_rel_tol, newton_abs_tol, newton_iter, mu) # 11. Solve the Newton system oper.Solve(xp) # 12. Compute the final deformation mfem.subtract_vector(x_gf, x_ref, x_def) # 13. Visualize the results if requested if (visualization): vis_u = mfem.socketstream("localhost", 19916) visualize(vis_u, mesh, x_gf, x_def, "Deformation", True) vis_p = mfem.socketstream("localhost", 19916) visualize(vis_p, mesh, x_gf, p_gf, "Deformation", True) # 14. Save the displaced mesh, the final deformation, and the pressure nodes = x_gf owns_nodes = 0 nodes, owns_nodes = mesh.SwapNodes(nodes, owns_nodes) mesh.Print('deformed.mesh', 8) p_gf.Save('pressure.sol', 8) x_def.Save("deformation.sol", 8)
dfes = mfem.FiniteElementSpace(mesh, fec, dim, mfem.Ordering.byNODES) # Finite element space for all variables together (total thermodynamic state) vfes = mfem.FiniteElementSpace(mesh, fec, num_equation, mfem.Ordering.byNODES) assert fes.GetOrdering() == mfem.Ordering.byNODES, "Ordering must be byNODES" print("Number of unknowns: " + str(vfes.GetVSize())) # 6. Define the initial conditions, save the corresponding mesh and grid # functions to a file. This can be opened with GLVis with the -gc option. # The solution u has components {density, x-momentum, y-momentum, energy}. # These are stored contiguously in the BlockVector u_block. offsets = [k * vfes.GetNDofs() for k in range(num_equation + 1)] offsets = mfem.intArray(offsets) u_block = mfem.BlockVector(offsets) mom = mfem.GridFunction(dfes, u_block, offsets[1]) # # Define coefficient using VecotrPyCoefficient and PyCoefficient # A user needs to define EvalValue method # u0 = InitialCondition(num_equation) sol = mfem.GridFunction(vfes, u_block.GetData()) sol.ProjectCoefficient(u0) mesh.PrintToFile("vortex.mesh", 8) for k in range(num_equation): uk = mfem.GridFunction(fes, u_block.GetBlock(k).GetData()) sol_name = "vortex-" + str(k) + "-init.gf" uk.SaveToFile(sol_name, 8)
solver.SetPreconditioner(darcyPrec) solver.SetPrintLevel(1) x.Assign(0) solver.Mult(rhs, x) solve_time = time.clock() - stime if solver.GetConverged(): print("MINRES converged in " + str(solver.GetNumIterations()) + " iterations with a residual norm of " + str(solver.GetFinalNorm())) else: print("MINRES did not converge in " + str(solver.GetNumIterations()) + " iterations. Residual norm is " + str(solver.GetFinalNorm())) print("MINRES solver took " + str(solve_time) + "s.") u = mfem.GridFunction(); p = mfem.GridFunction() u.MakeRef(R_space, x.GetBlock(0), 0) p.MakeRef(W_space, x.GetBlock(1), 0) order_quad = max(2, 2*order+1); irs =[mfem.IntRules.Get(i, order_quad) for i in range(mfem.Geometry.NumGeom)] norm_p = mfem.ComputeLpNorm(2, pcoeff, mesh, irs) norm_u = mfem.ComputeLpNorm(2, ucoeff, mesh, irs) err_u = u.ComputeL2Error(ucoeff, irs) err_p = p.ComputeL2Error(pcoeff, irs) print("|| p_h - p_ex || / || p_ex || = " + str(err_p / norm_p)) print("|| u_h - u_ex || / || u_ex || = " + str(err_u / norm_u))
# 5. Define the vector finite element spaces representing the mesh # deformation x, the velocity v, and the initial configuration, x_ref. # Define also the elastic energy density, w, which is in a discontinuous # higher-order space. Since x and v are integrated in time as a system, # we group them together in block vector vx, with offsets given by the # fe_offset array. fec = mfem.H1_FECollection(order, dim) fespace = mfem.FiniteElementSpace(mesh, fec, dim) fe_size = fespace.GetVSize() print("Number of velocity/deformation unknowns: " + str(fe_size)) fe_offset = intArray([0, fe_size, 2 * fe_size]) vx = mfem.BlockVector(fe_offset) x = mfem.GridFunction() v = mfem.GridFunction() v.MakeRef(fespace, vx.GetBlock(0), 0) x.MakeRef(fespace, vx.GetBlock(1), 0) x_ref = mfem.GridFunction(fespace) mesh.GetNodes(x_ref) w_fec = mfem.L2_FECollection(order + 1, dim) w_fespace = mfem.FiniteElementSpace(mesh, w_fec) w = mfem.GridFunction(w_fespace) # 6. Set the initial conditions for v and x, and the boundary conditions on # a beam-like mesh (see description above). class InitialVelocity(mfem.VectorPyCoefficient):
Shatinv.iterative_mode = False P = mfem.BlockDiagonalPreconditioner(offsets) P.SetDiagonalBlock(0, S0inv) P.SetDiagonalBlock(1, Shatinv) # 10. Solve the normal equation system using the PCG iterative solver. # Check the weighted norm of residual for the DPG least square problem. # Wrap the primal variable in a GridFunction for visualization purposes. mfem.PCG(A, P, b, x, 1, 200, 1e-12, 0.0) LSres = mfem.Vector(s_test) B.Mult(x, LSres) LSres -= F res = sqrt(matSinv.InnerProduct(LSres, LSres)) print("|| B0*x0 + Bhat*xhat - F ||_{S^-1} = " + str(res)) x0 = mfem.GridFunction() x0.MakeRef(x0_space, x.GetBlock(x0_var), 0); # 11. Save the refined mesh and the solution. This output can be viewed # later using GLVis: "glvis -m refined.mesh -g sol.gf". mesh.Print('refined.mesh', 8) x0.Save('sol.gf', 8) if (visualization): sol_sock = mfem.socketstream("localhost", 19916) sol_sock.precision(8) sol_sock.send_solution(mesh, x0)
def RequestData(self, request, inInfo, outInfo): output = dsa.WrapDataObject(vtkUnstructuredGrid.GetData(outInfo)) import os import json import mfem.ser as mfem _, ext = os.path.splitext(self._filename) cwd = os.path.dirname(self._filename) if ext == ".mfem_root": with open(self._filename) as f: root = json.load(f) cycle = int(root['dsets']['main']['cycle']) mesh_filename = root['dsets']['main']['mesh']['path'] mesh_filename = format(mesh_filename % cycle) mesh_filename = os.path.join(cwd, mesh_filename) else: mesh_filename = self._filename mesh = mfem.Mesh(mesh_filename) dim = mesh.SpaceDimension() nelem = mesh.GetNE() # Points mesh_fes = mesh.GetNodalFESpace() nodes = mesh.GetNodes() if nodes is None: nnode = mesh.GetNV() points = np.array(mesh.GetVertexArray()) else: nnode = mesh.GetNodes().Size() // dim points = np.array(mesh.GetNodes().GetDataArray()) if mesh_fes.GetOrdering() == 0: points = points.reshape((dim, nnode)).T elif mesh_fes.GetOrdering() == 1: points = points.reshape((nnode, dim)) else: raise NotImplementedError if dim == 1: points = np.hstack([points, np.zeros((nnode, 2))]) elif dim == 2: points = np.hstack([points, np.zeros((nnode, 1))]) output.SetPoints(points) # Cells cell_attributes = np.empty((nelem), dtype=int) cell_types = np.empty((nelem), dtype=np.ubyte) cell_offsets = np.empty((nelem), dtype=int) cell_conn = [] offset = 0 if nodes is None: for i in range(nelem): v = mesh.GetElementVertices(i) geom = mesh.GetElementBaseGeometry(i) perm = VTKGeometry_VertexPermutation[geom] if perm: v = [v[i] for i in perm] cell_types[i] = VTKGeometry_Map[geom] cell_offsets[i] = offset offset += len(v) + 1 cell_conn.append(len(v)) cell_conn.extend(v) else: for i in range(nelem): v = mesh_fes.GetElementDofs(i) geom = mesh.GetElementBaseGeometry(i) order = mesh_fes.GetOrder(i) if order == 1: perm = VTKGeometry_VertexPermutation[geom] cell_types[i] = VTKGeometry_Map[geom] elif order == 2: perm = VTKGeometry_QuadraticVertexPermutation[geom] cell_types[i] = VTKGeometry_QuadraticMap[geom] else: # FIXME: this needs more work... # See CreateVTKMesh for reading VTK Lagrange elements and # invert that process to create VTK Lagrange elements. # https://github.com/mfem/mfem/blob/master/mesh/mesh_readers.cpp parray = mfem.intArray() mfem.CreateVTKElementConnectivity(parray, geom, order) perm = parray.ToList() cell_types[i] = VTKGeometry_HighOrderMap[geom] if perm: v = [v[i] for i in perm] cell_offsets[i] = offset offset += len(v) + 1 cell_conn.append(len(v)) cell_conn.extend(v) output.SetCells(cell_types, cell_offsets, cell_conn) # Attributes for i in range(nelem): cell_attributes[i] = mesh.GetAttribute(i) output.CellData.append(cell_attributes, "attribute") # Read fields if ext == ".mfem_root": fields = root['dsets']['main']['fields'] for name, prop in fields.items(): filename = prop['path'] filename = format(filename % cycle) filename = os.path.join(cwd, filename) gf = mfem.GridFunction(mesh, filename) gf_fes = gf.FESpace() gf_vdim = gf.VectorDim() gf_nnode = gf_fes.GetNDofs() // gf_vdim gf_nelem = gf_fes.GetNBE() data = np.array(gf.GetDataArray()) if prop['tags']['assoc'] == 'nodes': assert gf_nnode == nnode, "Mesh and grid function have different number of nodes" if gf_fes.GetOrdering() == 0: data = data.reshape((gf_vdim, gf_nnode)).T elif gf_fes.GetOrdering() == 1: data = data.reshape((gf_nnode, gf_vdim)) else: raise NotImplementedError output.PointData.append(data, name) elif prop['tags']['assoc'] == 'elements': assert gf_nelem == nelem, "Mesh and grid function have different number of elements" if gf_fes.GetOrdering() == 0: data = data.reshape((gf_vdim, gf_nelem)).T elif gf_fes.GetOrdering() == 1: data = data.reshape((gf_nelem, gf_vdim)) else: raise NotImplementedError output.CellData.append(data, name) else: raise NotImplementedError("assoc: '{}'".format( prop['tags']['assoc'])) return 1