def _applyToSolver(self, solver, matrix): if matrix.NumGlobalNonzeros() <= matrix.NumGlobalRows(): return self.Prec = ML.MultiLevelPreconditioner(matrix, False) self.Prec.SetParameterList({text_to_native_str("output"): 0, text_to_native_str("max levels") : 2, text_to_native_str("prec type") : text_to_native_str("MGV"), text_to_native_str("increasing or decreasing") : text_to_native_str("increasing"), text_to_native_str("aggregation: type") : text_to_native_str("METIS"), text_to_native_str("aggregation: local aggregates") : 1, text_to_native_str("aggregation: damping factor") : 4. / 3., text_to_native_str("eigen-analysis: type") : text_to_native_str("power-method"), text_to_native_str("eigen-analysis: iterations") : 20, text_to_native_str("smoother: sweeps") : 1, text_to_native_str("smoother: pre or post") : text_to_native_str("both"), text_to_native_str("smoother: type") : text_to_native_str("Aztec"), text_to_native_str("smoother: Aztec as solver") : False, text_to_native_str("coarse: type") : text_to_native_str("Amesos-KLU"), text_to_native_str("coarse: max size") : 128 }) self.Prec.ComputePreconditioner() solver.SetPrecOperator(self.Prec)
def _applyToSolver(self, solver, matrix): if matrix.NumGlobalNonzeros() <= matrix.NumGlobalRows(): return self.Prec = ML.MultiLevelPreconditioner(matrix, False) self.Prec.SetParameterList({ "output": 0, "max levels": 10, "prec type": "MGW", "increasing or decreasing": "increasing", "aggregation: type": "Uncoupled-MIS", "energy minimization: enable": True, "eigen-analysis: type": "power-method", "eigen-analysis: iterations": 20, "smoother: sweeps": 4, "smoother: damping factor": 0.67, "smoother: pre or post": 'post', "smoother: type": "symmetric Gauss-Seidel", "coarse: type": 'Amesos-KLU', "coarse: max size": 256 }) self.Prec.ComputePreconditioner() solver.SetPrecOperator(self.Prec)
def _applyToSolver(self, solver, matrix): if matrix.NumGlobalNonzeros() <= matrix.NumGlobalRows(): return self.Prec = ML.MultiLevelPreconditioner(matrix, False) self.Prec.SetParameterList({"output": 0, "max levels" : 3, "prec type" : "MGV", "increasing or decreasing" : "increasing", "aggregation: type" : "METIS", "aggregation: nodes per aggregate" : 512, "aggregation: next-level aggregates per process" : 128, "aggregation: damping factor" : 4. / 3., "eigen-analysis: type" : "power-method", "eigen-analysis: iterations" : 20, "smoother: sweeps" : 1, "smoother: pre or post" : 'both', "smoother: type" : "Aztec", "smoother: Aztec as solver" : False, "coarse: type" : 'Amesos-KLU', "coarse: max size" : 128 }) self.Prec.ComputePreconditioner() solver.SetPrecOperator(self.Prec)
def perform_ML(Label, Map, Matrix, LHS, RHS, ExactSolution, NullSpace, List): if MyPID == 0: print "<p><p><div class=\"outputBox\"><pre>"; print "<b><font color=midnightblue>Problem Label =", Label, "</font></b>"; print "<b><font color=midnightblue>Operation = multilevel preconditioner</b>"; print "Using", NumProcs, "processors." print "The AztecOO/ML output follows." print "</font>"; Time = Epetra.Time(Matrix.Comm()) # FIXME: ??? #if NumProcs > 1: #List['coarse: type'] = 'symmetric Gauss-Seidel'; Prec = ML.MultiLevelPreconditioner(Matrix, False); if NullSpace == "not-set": Prec.SetParameterList(List) else: Prec.SetParameterListAndNullSpace(List, NullSpace) Prec.ComputePreconditioner() PrecTime = Time.ElapsedTime() (ierr, iters, SolveTime, ConditionNumber) = iterative_solver(List, Matrix, LHS, RHS, Prec) del Prec; if MyPID == 0: add_result(List, Label + " ML", ierr, iters, PrecTime, SolveTime, ConditionNumber) print " <pre></div>";
def _applyToSolver(self, solver, matrix): if matrix.NumGlobalNonzeros() <= matrix.NumGlobalRows(): return self.Prec = ML.MultiLevelPreconditioner(matrix, False) self.Prec.SetParameterList({text_to_native_str("output"): 0, text_to_native_str("smoother: type") : text_to_native_str("Aztec"), text_to_native_str("smoother: Aztec as solver") : True}) self.Prec.ComputePreconditioner() solver.SetPrecOperator(self.Prec)
def trilinos_ml_prec(A_epetra): mlList = {"max levels": 10, "output": 0, "smoother: pre or post": "both", "smoother: type": "Aztec" } prec = ML.MultiLevelPreconditioner(A_epetra, mlList) return prec
def _applyToSolver(self, solver, matrix): if matrix.NumGlobalNonzeros() <= matrix.NumGlobalRows(): return self.Prec = ML.MultiLevelPreconditioner(matrix, False) self.Prec.SetParameterList({ "output": 0, "smoother: type": "symmetric Gauss-Seidel" }) self.Prec.ComputePreconditioner() solver.SetPrecOperator(self.Prec)
def _applyTrilinosSolver(self, A, LHS, RHS): Prec = ML.MultiLevelPreconditioner(A, False) Prec.SetParameterList(self.MLOptions) Prec.ComputePreconditioner() Prec.TestSmoothers() raw_input("Results of preconditioner tests shown above. Currently, the first tests in the 'Gauss-Seidel (sym)','Aztec preconditioner', and 'Aztec as solver' sections indicate the expected performance of the MultilevelSGSPreconditioner, MultilevelDDPreconditioner, and MultilevelSolverSmootherPreconditioner classes, respectively.\n\nPress enter to quit.") import sys sys.exit(0)
def _applyToSolver(self, solver, matrix): if matrix.NumGlobalNonzeros() <= matrix.NumGlobalRows(): return self.Prec = ML.MultiLevelPreconditioner(matrix, False) self.Prec.SetParameterList({ text_to_native_str("output"): 0, text_to_native_str("max levels"): 10, text_to_native_str("prec type"): text_to_native_str("MGV"), text_to_native_str("increasing or decreasing"): text_to_native_str("increasing"), text_to_native_str("aggregation: type"): text_to_native_str("Uncoupled-MIS"), text_to_native_str("aggregation: damping factor"): 4. / 3., ## "energy minimization: enable" : False, ## "smoother: type" : "Aztec", ## "smoother: type" : "symmetric Gauss-Seidel", ## "eigen-analysis: type" : "power-method", text_to_native_str("eigen-analysis: type"): text_to_native_str("cg"), text_to_native_str("eigen-analysis: iterations"): 10, text_to_native_str("smoother: sweeps"): 2, text_to_native_str("smoother: damping factor"): 1.0, text_to_native_str("smoother: pre or post"): text_to_native_str("both"), text_to_native_str("smoother: type"): text_to_native_str("symmetric Gauss-Seidel"), text_to_native_str("coarse: type"): text_to_native_str("Amesos-KLU"), text_to_native_str("coarse: max size"): 128 }) self.Prec.ComputePreconditioner() solver.SetPrecOperator(self.Prec)
A = as_backend_type(AA).mat() BB = assemble(b) LL = assemble(inner(grad(p), grad(q)) * dx) PP = assemble(pp) bcs.apply(PP) # bcs.apply(BB)make P = as_backend_type(PP).mat() B = as_backend_type(BB).mat() L = as_backend_type(LL).mat() b = as_backend_type(bb).vec() x = Epetra.Vector(0 * bb.array()) # exit # A = as_backend_type(AA).mat() print toc() ML_Hiptmair = ml.MultiLevelPreconditioner(P, B, L, MLList) ML_Hiptmair.ComputePreconditioner() # ML_Hiptmair.ComputePreconditioner() solver = AztecOO.AztecOO(A, x, b) solver.SetPrecOperator(ML_Hiptmair) solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_gmres) solver.SetAztecOption(AztecOO.AZ_output, 16) err = solver.Iterate(1550, 1e-5) # if (Solving == 'Direct'): # ksp = PETSc.KSP().create() # ksp.setOperators(A) # ksp.setFromOptions()
def runit(size, prec, diff): # builds the linear system matrix and sets up starting solution and # right-hand side Comm = Epetra.PyComm() print "SIZE = ", size print "PREC = ", prec print "DIFF = ", diff GaleriList = { "nx": size, "ny": size, "mx": 1, "my": 1, "conv": 1.0, "diff": diff } Map = Galeri.CreateMap("Cartesian2D", Comm, GaleriList) Matrix = Galeri.CreateCrsMatrix("BentPipe2D", Map, GaleriList) Util = Epetra.Util() Util.SetSeed(0) LHS = Epetra.Vector(Map) RHS = Epetra.Vector(Map) n = LHS.MyLength() for i in xrange(0, n): LHS[i] = sin(i * 3.1415 / n) * sin(i * 3.1415 / n) Matrix.Multiply(False, LHS, RHS) LHS.PutScalar(0.0) # sets up the parameters for ML using a python dictionary if prec == "SA": MLList = { "max levels": 10, "output": 10, "increasing or decreasing": "increasing", "aggregation: type": "Uncoupled-MIS", "smoother: type (level 0)": "symmetric Gauss-Seidel", "smoother: damping factor": 0.67, "smoother: sweeps": 1, "smoother: pre or post": "both", "PDE equations": 1, "aggregation: damping factor": 1.333, "eigen-analysis: type": "power-method" } elif prec == "NSA": MLList = { "max levels": 10, "output": 10, "increasing or decreasing": "increasing", "aggregation: type": "Uncoupled-MIS", "smoother: type (level 0)": "symmetric Gauss-Seidel", "smoother: damping factor": 0.67, "smoother: sweeps": 1, "smoother: pre or post": "both", "PDE equations": 1, "aggregation: damping factor": 0.0000, "eigen-analysis: type": "power-method" } elif prec == "NSR": MLList = { "max levels": 10, "output": 10, "increasing or decreasing": "increasing", "aggregation: type": "Uncoupled-MIS", "smoother: type (level 0)": "symmetric Gauss-Seidel", "smoother: damping factor": 0.67, "smoother: sweeps": 1, "smoother: pre or post": "both", "PDE equations": 1, "aggregation: use tentative restriction": True, "aggregation: damping factor": 1.0000, "eigen-analysis: type": "power-method" } elif prec == "EMIN": MLList = { "max levels": 10, "output": 10, "increasing or decreasing": "increasing", "aggregation: type": "Uncoupled-MIS", "smoother: type (level 0)": "symmetric Gauss-Seidel", "smoother: damping factor": 0.67, "smoother: sweeps": 1, "smoother: pre or post": "both", "PDE equations": 1, "energy minimization: enable": True, "energy minimization: type": 2 } # creates the preconditioner and computes it Prec = ML.MultiLevelPreconditioner(Matrix, False) Prec.SetParameterList(MLList) Prec.ComputePreconditioner() # sets up the solver, specifies Prec as preconditioner, and # solves using CG. Solver = AztecOO.AztecOO(Matrix, LHS, RHS) Solver.SetPrecOperator(Prec) Solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_gmres) Solver.SetAztecOption(AztecOO.AZ_kspace, 30) Solver.SetAztecOption(AztecOO.AZ_output, 32) Solver.Iterate(400, 1e-8) del Prec
"smoother: sweeps" : 1, "smoother: damping factor" : 1.0, "smoother: pre or post" : "both", "smoother: type" : "Hiptmair", "subsmoother: type" : "Chebyshev", "subsmoother: Chebyshev alpha" : 27.0, "subsmoother: node sweeps" : 4, "subsmoother: edge sweeps" : 4, "coarse: type" : "Amesos-KLU", "coarse: max size" : 128 } ML_Hiptmair = ml.MultiLevelPreconditioner(P11.down_cast().mat(),B.down_cast().mat(),P22.down_cast().mat(),MLList) # ML_Hiptmair = ml.MultiLevelPreconditioner(P11.down_cast().mat(),MLList) ML_Hiptmair.ComputePreconditioner() DoF =B1.array().size + B2.array().size PP = block_mat([[ConjGrad(P11,precond=bat.ML(P11),tolerance=1e-10,maxiter=50000,show=1),0],[0,ConjGrad(P22,precond=bat.ML(P22),tolerance=1e-10,maxiter=50000,show=1)]]) # PP = block_mat([[(P11),0],[0,MinRes(P22,precond=block.algebraic.trilinos.ML(P22),tolerance=1e-6,maxiter=50000,show=1)]]) print "DoF:",DoF # PP = block_mat([[(P11),0],[0,(P22)]]) # Max.minres(AA, bb,0*bb, PP, 1e-10,50000,1e-8) AAinv = MinRes(AA, precond = PP, tolerance=1e-8,maxiter=50000) uu, pp = AAinv * bb
Pname = "".join(["P", str(Nb[0] - 1)]) # SaveEpertaMatrix(A_epetra,Aname) # SaveEpertaMatrix(P_epetra,Pname) # b_epetra = NullSpace(bb,'vec') # x_epetra = NullSpace(x.vector(),'vec') print '\n\n\n DoF = ', Nb[0], '\n\n\n' DoF[xx - 1] = Nb[0] - 1 mlList = { "max levels": 200, "output": 10, "smoother: type": "symmetric Gauss-Seidel", "aggregation: type": "Uncoupled" } prec = ML.MultiLevelPreconditioner(P_epetra, False) prec.SetParameterList(mlList) prec.ComputePreconditioner() solver = AztecOO.AztecOO(A_epetra, x_epetra, b_epetra) solver.SetPrecOperator(prec) solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_gmres) solver.SetAztecOption(AztecOO.AZ_output, 100) err = solver.Iterate(1550, 1e-5) print 'done' # Ap = sp.save(A) # SaveEpertaMatrix(A,"A") # SaveEpertaMatrix(P.down_cast().mat(),"P")
"aggregation: type" : "Uncoupled", "smoother: type (level 0)" : "Aztec", "smoother: damping factor": 0.67, "smoother: sweeps": 1, "smoother: pre or post": "post", "smoother: type (level 1)" : "Aztec", "PDE equations": 5, "aggregation: use tentative restriction": False, "aggregation: damping factor": 0.000, "eigen-analysis: type": "power-method", "aggregation: block scaling": False, "energy minimization: enable": False, "energy minimization: type": 2 } # creates the preconditioner and computes it Prec = ML.MultiLevelPreconditioner(Matrix, False) Prec.SetParameterList(MLList) Prec.ComputePreconditioner() # sets up the solver, specifies Prec as preconditioner, and # solves using CG. Solver = AztecOO.AztecOO(Matrix, LHS, RHS) Solver.SetPrecOperator(Prec) Solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_gmres); Solver.SetAztecOption(AztecOO.AZ_kspace, 30); Solver.SetAztecOption(AztecOO.AZ_output, 1); Solver.Iterate(200, 1e-8) del Prec
"smoother: type (level 4)": "Hiptmair", "smoother: type (level 5)": "Hiptmair", "smoother: type (level 6)": "Hiptmair", "smoother: Hiptmair efficient symmetric": True, "subsmoother: type": "Chebyshev", "subsmoother: Chebyshev alpha": 27.0, "subsmoother: node sweeps": 4, "subsmoother: edge sweeps": 4, "coarse: type": "Amesos-KLU", "coarse: max size": 128, "coarse: pre or post": "post", "coarse: sweeps": 1 } comm = Epetra.PyComm() C = scipy_csr_matrix2CrsMatrix(System["C"].tocsr(), comm) CurlCurl = scipy_csr_matrix2CrsMatrix(System["CurlCurl"].tocsr(), comm) node = scipy_csr_matrix2CrsMatrix(System["node"].tocsr(), comm) ML_Hiptmair = ML.MultiLevelPreconditioner(CurlCurl, C, node, MLList) ML_Hiptmair.ComputePreconditioner() x = System["rhs"][0] b_epetra = TrilinosIO._numpyToTrilinosVector(x) x_epetra = TrilinosIO._numpyToTrilinosVector(System["rhs"] * 0) solver = AztecOO.AztecOO(CurlCurl, x_epetra, b_epetra) solver.SetPrecOperator(ML_Hiptmair) solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_cg) solver.SetAztecOption(AztecOO.AZ_output, 50) err = solver.Iterate(155000, 1e-10)
Acurl,b = assemble_system(a,L1,bc) Anode = assemble(l) scipy.io.savemat( "System.mat", {"CurlCurl":Acurl.sparray(),"node":Anode.sparray(),"C":C,"rhs":b.array()},oned_as='row') scipy.io.savemat( "node.mat", {"node":Anode.sparray()},oned_as='row') scipy.io.savemat( "rhs.mat", {"rhs":b.array()},oned_as='row') C = scipy_csr_matrix2CrsMatrix(C, comm) Acurl = scipy_csr_matrix2CrsMatrix(Acurl.sparray(), comm) Anode = scipy_csr_matrix2CrsMatrix(Anode.sparray(), comm) # Acurl = as_backend_type(Acurl).mat() # Anode = as_backend_type(Anode).mat() ML_Hiptmair = ML.MultiLevelPreconditioner(Acurl,C,Anode,MLList,True) ML_Hiptmair.ComputePreconditioner() x = Function(V) b_epetra = x_epetra = TrilinosIO._numpyToTrilinosVector(b.array()) x_epetra = TrilinosIO._numpyToTrilinosVector(x.vector().array()) tic() #u = M.SolveSystem(A,b,V,"cg","amg",1e-6,1e-6,1) print toc() import PyTrilinos.AztecOO as AztecOO solver = AztecOO.AztecOO(Acurl, x_epetra, b_epetra) solver.SetPrecOperator(ML_Hiptmair) solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_cg); solver.SetAztecOption(AztecOO.AZ_output, 50);
# "smoother: damping factor" : 1.0, # "smoother: pre or post" : "both", # "smoother: type" : "Hiptmair", # "subsmoother: type" : "Chebyshev", # "subsmoother: Chebyshev alpha" : 27.0, # "subsmoother: node sweeps" : 4, # "subsmoother: edge sweeps" : 4, # "PDE equations" : 1, # "coarse: type" : "Amesos-MUMPS", # "coarse: max size" : 25, # "print unused" : 0 # } MLList = Teuchos.ParameterList() ML.SetDefaults("maxwell", MLList) # MList.setParameters() MLList.set("default values", "maxwell") MLList.set("max levels", 10) MLList.set("prec type", "MGV") MLList.set("increasing or decreasing", "decreasing") MLList.set("aggregation: type", "Uncoupled-MIS") MLList.set("aggregation: damping factor", 4.0 / 3.0) # MLList.set("eigen-analysis: type", "cg") # MLList.set("eigen-analysis: iterations", 10) MLList.set("smoother: sweeps", 5) MLList.set("smoother: damping factor", 1.0) MLList.set("smoother: pre or post", "both") MLList.set("smoother: type", "Hiptmair") MLList.set("subsmoother: type", "Chebyshev")