def pcg(atol=0.0,
rtol=0.0,
max_num_iter=5,
print_level=-1,
preconditioner=None,
**kwargs):
prc = kwargs.pop('prc')
blockname = kwargs.pop('blockname')
if use_parallel:
pcg = mfem.CGSolver(MPI.COMM_WORLD)
else:
pgc = mfem.CGSolver()
pcg.iterative_mode = False
pcg.SetRelTol(rtol)
pcg.SetAbsTol(atol)
pcg.SetMaxIter(max_num_iter)
pcg.SetPrintLevel(print_level)
r0 = prc.get_row_by_name(blockname)
c0 = prc.get_col_by_name(blockname)
A0 = prc.get_operator_block(r0, c0)
pcg.SetOperator(A0)
if preconditioner is not None:
pcg.SetPreconditioner(preconditioner)
# keep this object from being freed...
pcg._prc = preconditioner
return pcg
def __init__(self, spaces, mass, offsets):
self.pressure_mass = mass
self.block_offsets = offsets
self.spaces = spaces
super(JacobianPreconditioner, self).__init__(offsets[2])
self.gamma = 0.00001
# The mass matrix and preconditioner do not change every Newton cycle, so we
# only need to define them once
self.mass_prec = mfem.HypreBoomerAMG()
self.mass_prec.SetPrintLevel(0)
mass_pcg = mfem.CGSolver(MPI.COMM_WORLD)
mass_pcg.SetRelTol(1e-12)
mass_pcg.SetAbsTol(1e-12)
mass_pcg.SetMaxIter(200)
mass_pcg.SetPrintLevel(0)
mass_pcg.SetPreconditioner(self.mass_prec)
mass_pcg.SetOperator(self.pressure_mass)
mass_pcg.iterative_mode = False
self.mass_pcg = mass_pcg
# The stiffness matrix does change every Newton cycle, so we will define it
# during SetOperator
self.stiff_pcg = None
self.stiff_prec = None
def __init__(self, fespace, alpha, kappa, u):
mfem.PyTimeDependentOperator.__init__(self, fespace.GetTrueVSize(),
0.0)
rel_tol = 1e-8
self.alpha = alpha
self.kappa = kappa
self.T = None
self.K = None
self.M = None
self.fespace = fespace
self.ess_tdof_list = intArray()
self.Mmat = mfem.HypreParMatrix()
self.Kmat = mfem.HypreParMatrix()
self.M_solver = mfem.CGSolver(fespace.GetComm())
self.M_prec = mfem.HypreSmoother()
self.T_solver = mfem.CGSolver(fespace.GetComm())
self.T_prec = mfem.HypreSmoother()
self.z = mfem.Vector(self.Height())
self.M = mfem.ParBilinearForm(fespace)
self.M.AddDomainIntegrator(mfem.MassIntegrator())
self.M.Assemble()
self.M.FormSystemMatrix(self.ess_tdof_list, self.Mmat)
self.M_solver.iterative_mode = False
self.M_solver.SetRelTol(rel_tol)
self.M_solver.SetAbsTol(0.0)
self.M_solver.SetMaxIter(100)
self.M_solver.SetPrintLevel(0)
self.M_prec.SetType(mfem.HypreSmoother.Jacobi)
self.M_solver.SetPreconditioner(self.M_prec)
self.M_solver.SetOperator(self.Mmat)
self.T_solver.iterative_mode = False
self.T_solver.SetRelTol(rel_tol)
self.T_solver.SetAbsTol(0.0)
self.T_solver.SetMaxIter(100)
self.T_solver.SetPrintLevel(0)
self.T_solver.SetPreconditioner(self.T_prec)
self.SetParameters(u)
def __init__(self, M, K, b):
mfem.PyTimeDependentOperator.__init__(self, M.Height())
self.M_prec = mfem.HypreSmoother()
self.M_solver = mfem.CGSolver(M.GetComm())
self.z = mfem.Vector(M.Height())
self.K = K
self.M = M
self.b = b
self.M_prec.SetType(mfem.HypreSmoother.Jacobi)
self.M_solver.SetPreconditioner(self.M_prec)
self.M_solver.SetOperator(M)
self.M_solver.iterative_mode = False
self.M_solver.SetRelTol(1e-9)
self.M_solver.SetAbsTol(0.0)
self.M_solver.SetMaxIter(100)
self.M_solver.SetPrintLevel(0)
# the rotated H(curl) problem). S0inv = mfem.HypreBoomerAMG(matS0) S0inv.SetPrintLevel(0) Shat = mfem.RAP(matSinv, matBhat) if (dim == 2): Shatinv = mfem.HypreAMS(Shat, xhat_space) else: Shatinv = mfem.HypreADS(Shat, xhat_space) P = mfem.BlockDiagonalPreconditioner(true_offsets) P.SetDiagonalBlock(0, S0inv) P.SetDiagonalBlock(1, Shatinv) # 12. 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. pcg = mfem.CGSolver(MPI.COMM_WORLD) pcg.SetOperator(A) pcg.SetPreconditioner(P) pcg.SetRelTol(1e-6) pcg.SetMaxIter(200) pcg.SetPrintLevel(1) pcg.Mult(b, x) LSres = mfem.HypreParVector(test_space) tmp = mfem.HypreParVector(test_space) B.Mult(x, LSres) LSres -= trueF matSinv.Mult(LSres, tmp) res = sqrt(mfem.InnerProduct(LSres, tmp))
# 14. Create the linear system: eliminate boundary conditions, constrain
# hanging nodes and possibly apply other transformations. The system
# will be solved for true (unconstrained) DOFs only.
A = mfem.HypreParMatrix()
B = mfem.Vector()
X = mfem.Vector()
copy_interior = 1
a.FormLinearSystem(ess_tdof_list, x, b, A, X, B, copy_interior)
# 15. Define and apply a parallel PCG solver for AX=B with the BoomerAMG
# preconditioner from hypre.
amg = mfem.HypreBoomerAMG()
amg.SetPrintLevel(0)
pcg = mfem.CGSolver(A.GetComm())
pcg.SetPreconditioner(amg)
pcg.SetOperator(A)
pcg.SetRelTol(1e-6)
pcg.SetMaxIter(200)
pcg.SetPrintLevel(3)
pcg.Mult(B, X)
# 16. Extract the parallel grid function corresponding to the finite element
# approximation X. This is the local solution on each processor.
a.RecoverFEMSolution(X, b, x)
if (global_dofs > max_dofs):
if (myid == 0): print("Reached the maximum number of dofs. Stop.")
break
refiner.Apply(pmesh)
def __init__(self, fespace, ess_bdr, visc, mu, K):
mfem.PyTimeDependentOperator.__init__(self, 2 * fespace.TrueVSize(),
0.0)
rel_tol = 1e-8
skip_zero_entries = 0
ref_density = 1.0
self.ess_tdof_list = intArray()
self.z = mfem.Vector(self.Height() // 2)
self.fespace = fespace
self.viscosity = visc
self.newton_solver = mfem.NewtonSolver(fespace.GetComm())
M = mfem.ParBilinearForm(fespace)
S = mfem.ParBilinearForm(fespace)
H = mfem.ParNonlinearForm(fespace)
self.M = M
self.H = H
self.S = S
rho = mfem.ConstantCoefficient(ref_density)
M.AddDomainIntegrator(mfem.VectorMassIntegrator(rho))
M.Assemble(skip_zero_entries)
M.EliminateEssentialBC(ess_bdr)
M.Finalize(skip_zero_entries)
self.Mmat = M.ParallelAssemble()
fespace.GetEssentialTrueDofs(ess_bdr, self.ess_tdof_list)
self.Mmat.EliminateRowsCols(self.ess_tdof_list)
M_solver = mfem.CGSolver(fespace.GetComm())
M_prec = mfem.HypreSmoother()
M_solver.iterative_mode = False
M_solver.SetRelTol(rel_tol)
M_solver.SetAbsTol(0.0)
M_solver.SetMaxIter(30)
M_solver.SetPrintLevel(0)
M_prec.SetType(mfem.HypreSmoother.Jacobi)
M_solver.SetPreconditioner(M_prec)
M_solver.SetOperator(self.Mmat)
self.M_solver = M_solver
self.M_prec = M_prec
model = mfem.NeoHookeanModel(mu, K)
H.AddDomainIntegrator(mfem.HyperelasticNLFIntegrator(model))
H.SetEssentialTrueDofs(self.ess_tdof_list)
self.model = model
visc_coeff = mfem.ConstantCoefficient(visc)
S.AddDomainIntegrator(mfem.VectorDiffusionIntegrator(visc_coeff))
S.Assemble(skip_zero_entries)
S.EliminateEssentialBC(ess_bdr)
S.Finalize(skip_zero_entries)
self.reduced_oper = ReducedSystemOperator(M, S, H, self.ess_tdof_list)
J_hypreSmoother = mfem.HypreSmoother()
J_hypreSmoother.SetType(mfem.HypreSmoother.l1Jacobi)
J_hypreSmoother.SetPositiveDiagonal(True)
J_prec = J_hypreSmoother
J_minres = mfem.MINRESSolver(fespace.GetComm())
J_minres.SetRelTol(rel_tol)
J_minres.SetAbsTol(0.0)
J_minres.SetMaxIter(300)
J_minres.SetPrintLevel(-1)
J_minres.SetPreconditioner(J_prec)
self.J_solver = J_minres
self.J_prec = J_prec
newton_solver = mfem.NewtonSolver(fespace.GetComm())
newton_solver.iterative_mode = False
newton_solver.SetSolver(self.J_solver)
newton_solver.SetOperator(self.reduced_oper)
newton_solver.SetPrintLevel(1)
#print Newton iterations
newton_solver.SetRelTol(rel_tol)
newton_solver.SetAbsTol(0.0)
newton_solver.SetMaxIter(10)
self.newton_solver = newton_solver
def run(order = 1, static_cond = False,
meshfile = def_meshfile, visualization = False,
use_strumpack = False):
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();
mesh.ReorientTetMesh();
pmesh = mfem.ParMesh(MPI.COMM_WORLD, mesh)
del mesh
par_ref_levels = 2
for l in range(par_ref_levels):
pmesh.UniformRefinement();
if order > 0:
fec = mfem.H1_FECollection(order, dim)
elif mesh.GetNodes():
fec = mesh.GetNodes().OwnFEC()
print( "Using isoparametric FEs: " + str(fec.Name()));
else:
order = 1
fec = mfem.H1_FECollection(order, dim)
fespace =mfem.ParFiniteElementSpace(pmesh, fec)
fe_size = fespace.GlobalTrueVSize()
if (myid == 0):
print('Number of finite element unknowns: '+ str(fe_size))
ess_tdof_list = mfem.intArray()
if pmesh.bdr_attributes.Size()>0:
ess_bdr = mfem.intArray(pmesh.bdr_attributes.Max())
ess_bdr.Assign(1)
fespace.GetEssentialTrueDofs(ess_bdr, ess_tdof_list)
# the basis functions in the finite element fespace.
b = mfem.ParLinearForm(fespace)
one = mfem.ConstantCoefficient(1.0)
b.AddDomainIntegrator(mfem.DomainLFIntegrator(one))
b.Assemble();
x = mfem.ParGridFunction(fespace);
x.Assign(0.0)
a = mfem.ParBilinearForm(fespace);
a.AddDomainIntegrator(mfem.DiffusionIntegrator(one))
if static_cond: a.EnableStaticCondensation()
a.Assemble();
A = mfem.HypreParMatrix()
B = mfem.Vector()
X = mfem.Vector()
a.FormLinearSystem(ess_tdof_list, x, b, A, X, B)
if (myid == 0):
print("Size of linear system: " + str(x.Size()))
print("Size of linear system: " + str(A.GetGlobalNumRows()))
if use_strumpack:
import mfem.par.strumpack as strmpk
Arow = strmpk.STRUMPACKRowLocMatrix(A)
args = ["--sp_hss_min_sep_size", "128", "--sp_enable_hss"]
strumpack = strmpk.STRUMPACKSolver(args, MPI.COMM_WORLD)
strumpack.SetPrintFactorStatistics(True)
strumpack.SetPrintSolveStatistics(False)
strumpack.SetKrylovSolver(strmpk.KrylovSolver_DIRECT);
strumpack.SetReorderingStrategy(strmpk.ReorderingStrategy_METIS)
strumpack.SetMC64Job(strmpk.MC64Job_NONE)
# strumpack.SetSymmetricPattern(True)
strumpack.SetOperator(Arow)
strumpack.SetFromCommandLine()
strumpack.Mult(B, X);
else:
amg = mfem.HypreBoomerAMG(A)
cg = mfem.CGSolver(MPI.COMM_WORLD)
cg.SetRelTol(1e-12)
cg.SetMaxIter(200)
cg.SetPrintLevel(1)
cg.SetPreconditioner(amg)
cg.SetOperator(A)
cg.Mult(B, X);
a.RecoverFEMSolution(X, b, x)
smyid = '{:0>6d}'.format(myid)
mesh_name = "mesh."+smyid
sol_name = "sol."+smyid
pmesh.Print(mesh_name, 8)
x.Save(sol_name, 8)
def __init__(self,
fespace,
lmbda=1.,
mu=1.,
rho=1.,
visc=0.0,
vess_tdof_list=None,
vess_bdr=None,
xess_tdof_list=None,
xess_bdr=None,
v_gfBdr=None,
x_gfBdr=None,
deform=None,
velo=None,
vx=None):
mfem.PyTimeDependentOperator.__init__(self, 2 * fespace.GetTrueVSize(),
0.0)
self.lmbda = lmbda
self.mu = mu
self.viscosity = visc
self.deform = deform
self.velo = velo
self.x_gfBdr = x_gfBdr
self.v_gfBdr = v_gfBdr
self.vx = vx
self.z = mfem.Vector(self.Height() / 2)
self.z.Assign(0.0)
self.w = mfem.Vector(self.Height() / 2)
self.w.Assign(0.0)
self.tmpVec = mfem.Vector(self.Height() / 2)
self.tmpVec.Assign(0.0)
self.fespace = fespace
self.xess_bdr = xess_bdr
self.vess_bdr = vess_bdr
self.xess_tdof_list = xess_tdof_list
self.vess_tdof_list = vess_tdof_list
# setting up linear form
cv = mfem.Vector(3)
cv.Assign(0.0)
#self.zero_coef = mfem.ConstantCoefficient(0.0)
self.zero_coef = mfem.VectorConstantCoefficient(cv)
self.bx = mfem.LinearForm(self.fespace)
self.bx.AddDomainIntegrator(
mfem.VectorBoundaryLFIntegrator(self.zero_coef))
self.bx.Assemble()
self.bv = mfem.LinearForm(self.fespace)
self.bv.AddDomainIntegrator(
mfem.VectorBoundaryLFIntegrator(self.zero_coef))
self.bv.Assemble()
self.Bx = mfem.Vector()
self.Bv = mfem.Vector()
# setting up bilinear forms
self.M = mfem.ParBilinearForm(self.fespace)
self.K = mfem.ParBilinearForm(self.fespace)
self.S = mfem.ParBilinearForm(self.fespace)
self.ro = mfem.ConstantCoefficient(rho)
self.M.AddDomainIntegrator(mfem.VectorMassIntegrator(self.ro))
self.M.Assemble(0)
self.M.EliminateEssentialBC(self.vess_bdr)
self.M.Finalize(0)
self.Mmat = self.M.ParallelAssemble()
self.M_solver = mfem.CGSolver(self.fespace.GetComm())
self.M_solver.iterative_mode = False
self.M_solver.SetRelTol(1e-8)
self.M_solver.SetAbsTol(0.0)
self.M_solver.SetMaxIter(30)
self.M_solver.SetPrintLevel(0)
self.M_prec = mfem.HypreSmoother()
self.M_prec.SetType(mfem.HypreSmoother.Jacobi)
self.M_solver.SetPreconditioner(self.M_prec)
self.M_solver.SetOperator(self.Mmat)
lambVec = mfem.Vector(self.fespace.GetMesh().attributes.Max())
print('Number of volume attributes : ' +
str(self.fespace.GetMesh().attributes.Max()))
lambVec.Assign(lmbda)
lambVec[0] = lambVec[1] * 1.0
lambda_func = mfem.PWConstCoefficient(lambVec)
muVec = mfem.Vector(self.fespace.GetMesh().attributes.Max())
muVec.Assign(mu)
muVec[0] = muVec[1] * 1.0
mu_func = mfem.PWConstCoefficient(muVec)
self.K.AddDomainIntegrator(
mfem.ElasticityIntegrator(lambda_func, mu_func))
self.K.Assemble(0)
# to set essential BC to zero value uncomment
#self.K.EliminateEssentialBC(self.xess_bdr)
#self.K.Finalize(0)
#self.Kmat = self.K.ParallelAssemble()
# to set essential BC to non-zero uncomment
self.Kmat = mfem.HypreParMatrix()
visc_coeff = mfem.ConstantCoefficient(visc)
self.S.AddDomainIntegrator(mfem.VectorDiffusionIntegrator(visc_coeff))
self.S.Assemble(0)
#self.S.EliminateEssentialBC(self.vess_bdr)
#self.S.Finalize(0)
#self.Smat = self.S.ParallelAssemble()
self.Smat = mfem.HypreParMatrix()
# VX solver for implicit time-stepping
self.VX_solver = mfem.CGSolver(self.fespace.GetComm())
self.VX_solver.iterative_mode = False
self.VX_solver.SetRelTol(1e-8)
self.VX_solver.SetAbsTol(0.0)
self.VX_solver.SetMaxIter(30)
self.VX_solver.SetPrintLevel(0)
self.VX_prec = mfem.HypreSmoother()
self.VX_prec.SetType(mfem.HypreSmoother.Jacobi)
self.VX_solver.SetPreconditioner(self.VX_prec)
# setting up operators
empty_tdof_list = intArray()
self.S.FormLinearSystem(empty_tdof_list, self.v_gfBdr, self.bv,
self.Smat, self.vx.GetBlock(0), self.Bv, 1)
self.K.FormLinearSystem(empty_tdof_list, self.x_gfBdr, self.bx,
self.Kmat, self.vx.GetBlock(1), self.Bx, 1)
