def prepare_ho_node(mesh): import mfem.ser as mfem nfec = mfem.H1_FECollection(2, mesh.Dimension()) # mfem.BasisType.ClosedUniform) nfes = mfem.FiniteElementSpace(mesh, nfec, mesh.SpaceDimension(), mfem.Ordering.byVDIM) mesh.SetNodalFESpace(nfes) mesh._linked_obj = (nfes, nfec)
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")
sys.exit() # 3. Refine the mesh to increase the resolution. ref_levels = int(np.floor(np.log(5000./mesh.GetNE())/np.log(2.)/dim)) for x in range(ref_levels): mesh.UniformRefinement(); # Since NURBS meshes do not support DG integrators, we convert them to # regular polynomial mesh of the specified (solution) order. if (mesh.NURBSext): mesh.SetCurvature(order) # 4. Define a DG vector finite element space on the mesh. Here, we use # Gauss-Lobatto nodal basis because it gives rise to a sparser matrix # compared to the default Gauss-Legendre nodal basis. fec = mfem.DG_FECollection(order, dim, mfem.BasisType.GaussLobatto) fespace = mfem.FiniteElementSpace(mesh, fec, dim) print('Number of finite element unknowns: '+ str(fespace.GetVSize())) print('Assembling:') # 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
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())
order = 1 static_cond = False meshfile = expanduser(join(path, 'data', 'star.mesh')) mesh = mfem.Mesh(meshfile, 1, 1) dim = mesh.Dimension() ref_levels = int(np.floor(np.log(10000. / mesh.GetNE()) / np.log(2.) / dim)) for x in range(ref_levels): mesh.UniformRefinement() hdiv_coll = mfem.RT_FECollection(order, dim) l2_coll = mfem.L2_FECollection(order, dim) R_space = mfem.FiniteElementSpace(mesh, hdiv_coll) W_space = mfem.FiniteElementSpace(mesh, l2_coll) dimR = R_space.GetVSize() dimW = W_space.GetVSize() print("***********************************************************") print("dim(R) = " + str(dimR)) print("dim(W) = " + str(dimW)) print("dim(R+W) = " + str(dimR + dimW)) print("***********************************************************") block_offsets = intArray([0, dimR, dimW]) block_offsets.PartialSum() k = mfem.ConstantCoefficient(1.0)
temp = 1 + 2 * kappa * kappa F0 = temp * cos(kappa * x) * sin(kappa * y) F1 = temp * cos(kappa * y) * sin(kappa * x) if dim == 3: return (F0, F1, 0.0) else: return (F0, F1) ref_levels = int(np.floor(np.log(25000. / mesh.GetNE()) / np.log(2.) / dim)) for x in range(ref_levels): mesh.UniformRefinement() fec = mfem.RT_FECollection(order - 1, dim) fespace = mfem.FiniteElementSpace(mesh, fec) print("Number of finite element unknows : " + str(fespace.GetTrueVSize())) ess_tdof_list = intArray() if mesh.bdr_attributes.Size(): ess_bdr = intArray(mesh.bdr_attributes.Max()) if set_bc: ess_bdr.Assign(1) else: ess_bdr.Assign(0) fespace.GetEssentialTrueDofs(ess_bdr, ess_tdof_list) b = mfem.LinearForm(fespace) f = f_exact() dd = mfem.VectorFEDomainLFIntegrator(f) b.AddDomainIntegrator(dd) b.Assemble()
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)
dim = mesh.Dimension() sdim = mesh.SpaceDimension() # 3. Since a NURBS mesh can currently only be refined uniformly, we need to # convert it to a piecewise-polynomial curved mesh. First we refine the # NURBS mesh a bit more and then project the curvature to quadratic Nodes. if (mesh.NURBSext): for i in range(2): mesh.UniformRefinement() mesh.SetCurvature(2) # 4. Define a finite element space on the mesh. The polynomial order is # one (linear) by default, but this can be changed on the command line. fec = mfem.H1_FECollection(order, dim) fespace = mfem.FiniteElementSpace(mesh, fec) # 5. As in Example 1, we set up bilinear and linear forms corresponding to # the Laplace problem -\Delta u = 1. We don't assemble the discrete # problem yet, this will be done in the main loop. a = mfem.BilinearForm(fespace) b = mfem.LinearForm(fespace) one = mfem.ConstantCoefficient(1.0) zero = mfem.ConstantCoefficient(0.0) integ = mfem.DiffusionIntegrator(one) a.AddDomainIntegrator(integ) b.AddDomainIntegrator(mfem.DomainLFIntegrator(one)) # 6. The solution vector x and the associated finite element grid function
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)
else: print("Unknown ODE solver type: " + str(ode_solver_type)) exit # 4. Refine the mesh to increase the resolution. In this example we do # 'ref_levels' of uniform refinement, where 'ref_levels' is a # command-line parameter. for lev in range(ref_levels): mesh.UniformRefinement() # 5. Define the discontinuous DG finite element space of the given # polynomial order on the refined mesh. fec = mfem.DG_FECollection(order, dim) # Finite element space for a scalar (thermodynamic quantity) fes = mfem.FiniteElementSpace(mesh, fec) # Finite element space for a mesh-dim vector quantity (momentum) 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)
# 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(5000. / 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. fec = mfem.H1_FECollection(order, dim) fespace = mfem.FiniteElementSpace(mesh, fec, dim) print("Number of finite element unknowns: " + str(fespace.GetTrueVSize())) # 6. Determine the list of true (i.e. conforming) essential boundary dofs. # In this example, the boundary conditions are defined by marking only # boundary attribute 1 from the mesh as essential and converting it to a # list of true dofs. ess_tdof_list = intArray() ess_bdr = intArray([1] + [0] * (mesh.bdr_attributes.Max() - 1)) fespace.GetEssentialTrueDofs(ess_bdr, ess_tdof_list) # 7. Set up the linear form b(.) which corresponds to the right-hand side of # the FEM linear system. In this case, b_i equals the boundary integral # of f*phi_i where f represents a "pull down" force on the Neumann part # of the boundary and phi_i are the basis functions in the finite element # fespace. The force is defined by the VectorArrayCoefficient object f,
elif ode_solver_type == 14: ode_solver = mfem.RK4Solver() elif ode_solver_type == 22: ode_solver = mfem.ImplicitMidpointSolver() elif ode_solver_type == 23: ode_solver = mfem.SDIRK23Solver() elif ode_solver_type == 24: ode_solver = mfem.SDIRK34Solver() else: print("Unknown ODE solver type: " + str(ode_solver_type)) exit # 4. Refine the mesh to increase the resolution. In this example we do # 'ref_levels' of uniform refinement, where 'ref_levels' is a # command-line parameter. for lev in range(ref_levels): mesh.UniformRefinement() # 5. Define the vector finite element space representing the current and the # initial temperature, u_ref. fe_coll = mfem.H1_FECollection(order, dim) fespace = mfem.FiniteElementSpace(mesh, fe_coll) fe_size = fespace.GetTrueVSize() print("Number of temperature unknowns: " + str(fe_size)) u_gf = mfem.GridFunction(fespace) # 6. Set the initial conditions for u. All boundaries are considered # natural. u_0 = InitialTemperature() u_gf.ProjectCoefficient(u_0) u = mfem.Vector() u_gf.GetTrueDofs(u) # 7. Initialize the conduction operator and the visualization. oper = ConductionOperator(fespace, alpha, kappa, u) u_gf.SetFromTrueDofs(u)
# the mesh and the trial space order. trial_order = order trace_order = order - 1; test_order = order # reduced order, full order is (order + dim - 1) if (dim == 2 and (order%2 == 0 or (mesh.MeshGenerator() & 2 and order > 1))): test_order = test_order + 1 if (test_order < trial_order): print("Warning, test space not enriched enough to handle primal trial space") x0_fec = mfem.H1_FECollection(trial_order, dim) xhat_fec = mfem.RT_Trace_FECollection(trace_order, dim) test_fec = mfem.L2_FECollection(test_order, dim) x0_space = mfem.FiniteElementSpace(mesh, x0_fec) xhat_space = mfem.FiniteElementSpace(mesh, xhat_fec) test_space = mfem.FiniteElementSpace(mesh, test_fec) # 5. Define the block structure of the problem, by creating the offset # variables. Also allocate two BlockVector objects to store the solution # and rhs. x0_var = 0; xhat_var = 1; NVAR = 2 s0 = x0_space.GetVSize() s1 = xhat_space.GetVSize() s_test = test_space.GetVSize() offsets = mfem.intArray([0, s0, s0+s1]) offsets_test = mfem.intArray([0, s_test])
mesh.FinalizeTriMesh(1, 1, True) else: quad_v = [[-1, -1, -1], [+1, -1, -1], [+1, +1, -1], [-1, +1, -1], [-1, -1, +1], [+1, -1, +1], [+1, +1, +1], [-1, +1, +1]] quad_e = [[3, 2, 1, 0], [0, 1, 5, 4], [1, 2, 6, 5], [2, 3, 7, 6], [3, 0, 4, 7], [4, 5, 6, 7]] for j in range(Nvert): mesh.AddVertex(quad_v[j]) for j in range(Nelem): mesh.AddQuad(quad_e[j], j + 1) mesh.FinalizeQuadMesh(1, 1, True) # Set the space for the high-order mesh nodes. fec = mfem.H1_FECollection(order, mesh.Dimension()) nodal_fes = mfem.FiniteElementSpace(mesh, fec, mesh.SpaceDimension()) mesh.SetNodalFESpace(nodal_fes) def SnapNodes(mesh): nodes = mesh.GetNodes() node = mfem.Vector(mesh.SpaceDimension()) for i in np.arange(nodes.FESpace().GetNDofs()): for d in np.arange(mesh.SpaceDimension()): node[d] = nodes[nodes.FESpace().DofToVDof(i, d)] node /= node.Norml2() for d in range(mesh.SpaceDimension()): nodes[nodes.FESpace().DofToVDof(i, d)] = node[d]