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
