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)