_-PhodZddlmZddlZddlmZddlmcm Z ddlm Z ddl Z ddlmZddlmZdd lmZdd lmZdd lmZGd d ZdZGddeZdS)zGeneric AMG solver.)warnNpinv)LinearOperator)krylov)to_type)set_tol) smoothing)upcastceZdZdZGddZGddeZddZdZdd Zd Z d Z d Z dZ ddZ ddZddZdS)MultilevelSolveraStores multigrid hierarchy and implements the multigrid cycle. The class constructs the cycling process and points to the methods for coarse grid solves. A MultilevelSolver object is typically returned from a particular AMG method (see ruge_stuben_solver or smoothed_aggregation_solver for example). A call to MultilevelSolver.solve() is a typical access point. The class also defines methods for constructing operator, cycle, and grid complexities. Attributes ---------- levels : level array Array of level objects that contain A, R, and P. coarse_solver : string String passed to coarse_grid_solver indicating the solve type Methods ------- aspreconditioner() Create a preconditioner using this multigrid cycle cycle_complexity() A measure of the cost of a single multigrid cycle. grid_complexity() A measure of the rate of coarsening. operator_complexity() A measure of the size of the multigrid hierarchy. solve() Iteratively solves a linear system for the right hand side. change_solve_matrix(A) Change matrix solve/preconditioning matrix. This also changes the corresponding relaxation routines on the fine grid. This can be used, for example, to precondition a quadratic finite element discretization with AMG built from a linear discretization on quadratic quadrature points. ceZdZdZdZdS)MultilevelSolver.LevelaStores one level of the multigrid hierarchy. All level objects will have an 'A' attribute referencing the matrix of that level. All levels, except for the coarsest level, will also have 'P' and 'R' attributes referencing the prolongation and restriction operators that act between each level and the next coarser level. Attributes ---------- A : csr_matrix Problem matrix for Ax=b R : csr_matrix Restriction matrix between levels (often R = P.T) P : csr_matrix Prolongation or Interpolation matrix. Notes ----- The functionality of this class is a struct cd|_dS)zLevel construct (empty).N)Aselfs P/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/pyamg/multilevel.py__init__zMultilevelSolver.Level.__init__Ns DFFFN)__name__ __module__ __qualname____doc__rrrLevelr6s-  .     rrc"eZdZdZfdZxZS)MultilevelSolver.levelzDeprecated level class.cvttdtddS)-Raise deprecation warning on use, not import.z#level() is deprecated. use Level()category stacklevelNsuperrrDeprecationWarning)r __class__s rrzMultilevelSolver.level.__init__UsB GG      6, < < < < < %% < < < < < < < < >> # manual construction of a two-level AMG hierarchy >>> from pyamg.gallery import poisson >>> from pyamg.multilevel import MultilevelSolver >>> from pyamg.strength import classical_strength_of_connection >>> from pyamg.classical.interpolate import direct_interpolation >>> from pyamg.classical.split import RS >>> # compute necessary operators >>> A = poisson((100, 100), format='csr') >>> C = classical_strength_of_connection(A) >>> splitting = RS(A) >>> P = direct_interpolation(A, C, splitting) >>> R = P.T >>> # store first level data >>> levels = [] >>> levels.append(MultilevelSolver.Level()) >>> levels.append(MultilevelSolver.Level()) >>> levels[0].A = A >>> levels[0].C = C >>> levels[0].splitting = splitting >>> levels[0].P = P >>> levels[0].R = R >>> # store second level data >>> levels[1].A = R @ A @ P # coarse-level matrix >>> # create MultilevelSolver >>> ml = MultilevelSolver(levels, coarse_solver='splu') >>> print(ml) MultilevelSolver Number of Levels: 2 Operator Complexity: 1.891 Grid Complexity: 1.500 Coarse Solver: 'splu' level unknowns nonzeros 0 10000 49600 [52.88%] 1 5000 44202 [47.12%] FNR) symmetric_smoothinglevelscoarse_grid_solver coarse_solverhasattrPT conjugater0)rr2r4r-s rrzMultilevelSolver.__init__[soZ$)  / >>CRC[ 0 0E5#&& 0')--// 0 0rc d}|dt|jdz }|d|ddz }|d|ddz }|d|jdz }t d|jD}|d z }t|jD]>\}}|j}d |j z|z }||d d |j d dd |j dd|ddz }?|S)z5Print basic statistics about the multigrid hierarchy.zMultilevelSolver zNumber of Levels:  zOperator Complexity: z6.3fzGrid Complexity: zCoarse Solver: c3.K|]}|jjVdSNrnnz.0r-s r z,MultilevelSolver.__repr__..s&== ======rz level unknowns nonzeros dz>6 rz>11z>12z [z2.2fz%] ) lenr2operator_complexitygrid_complexityr4namesum enumeraterr>shape)routput total_nnznr-rratios r__repr__zMultilevelSolver.__repr__s=%?3t{+;+;????N4+C+C+E+ENNNNNJ4+?+?+A+AJJJJJH4+=+B+B+D+DHHHH=======  55!$+.. O OHAuA!%K)+E NNN NNNNNNeNNNN NFF rVctt|}djDfdfdfd|dkr d}n5|dvr d}n%|dkr d}ntd |d t |t dz S) aCycle complexity of V, W, AMLI, and F(1,1) cycle with simple relaxation. Cycle complexity is an approximate measure of the number of floating point operations (FLOPs) required to perform a single multigrid cycle relative to the cost a single smoothing operation. Parameters ---------- cycle : {'V','W','F','AMLI'} Type of multigrid cycle to perform in each iteration. Returns ------- cc : float Defined as F_sum / F_0, where F_sum is the total number of nonzeros in the matrix on all levels encountered during a cycle and F_0 is the number of nonzeros in the matrix on the finest level. Notes ----- This is only a rough estimate of the true cycle complexity. The estimate assumes that the cost of pre and post-smoothing are (each) equal to the number of nonzeros in the matrix on that level. This assumption holds for smoothers like Jacobi and Gauss-Seidel. However, the true cycle complexity of cycle using more expensive methods, like block Gauss-Seidel will be underestimated. Additionally, if the cycle used in practice isn't a (1,1)-cycle, then this cost estimate will be off. c&g|]}|jjSrr=r?s r z5MultilevelSolver.cycle_complexity..s444uuw{444rctjdkrdS|tjdz krd|z|dzzSd|z|dzzSNrrr"rDr2)r-rPr>rs rrPz,MultilevelSolver.cycle_complexity..Vsu4;1$$1v DK((1,,,3u:~EAI66s5z>AAeaiLL0 0rctjdkrdS|tjdz krd|z|dzzSd|zd|dzzzSrUrV)r-Wr>rs rrXz,MultilevelSolver.cycle_complexity..Wsz4;1$$1v DK((1,,,3u:~EAI66s5z>A%!) $44 4rctjdkrdS|tjdz krd|z|dzzSd|z|dzz|dzzSrUrV)r-FrPr>rs rrZz,MultilevelSolver.cycle_complexity..Fs4;1$$1v DK((1,,,3u:~EAI66s5z>AAeaiLL011UQY<<? ?rrPr)rXAMLIrZUnrecognized cycle type ())strupperr2 TypeErrorfloat)rcycleflopsrZrPrXr>s` @@@@rcycle_complexityz!MultilevelSolver.cycle_complexitys-BE   ""44 444 1 1 1 1 1 1 1 5 5 5 5 5 5 5 @ @ @ @ @ @ @ @ C<<AaDDEE m # #AaDDEE c\\AaDDEE@@@@AA AU||eCFmm++rctd|jDt|jdjjz S)zOperator complexity of this multigrid hierarchy. Defined as: Number of nonzeros in the matrix on all levels / Number of nonzeros in the matrix on the finest level c3.K|]}|jjVdSr<r=r?s rrAz7MultilevelSolver.operator_complexity..s&88557;888888rr)rHr2rarr>rs rrEz$MultilevelSolver.operator_complexitysA88DK88888 $+a."& ' '( (rctd|jDt|jdjjdz S)zGrid complexity of this multigrid hierarchy. Defined as: Number of unknowns on all levels / Number of unknowns on the finest level c3:K|]}|jjdVdS)rN)rrJr?s rrAz3MultilevelSolver.grid_complexity.."s+==57=#======rr)rHr2rarrJrs rrFz MultilevelSolver.grid_complexitysF======= $+a."(+ , ,- -rch||jd_tj|jddS)a|Change matrix solve/preconditioning matrix. Parameters ---------- A : csr_matrix Target solution matrix Notes ----- This also changes the corresponding relaxation routines on the fine grid. This can be used, for example, to precondition a quadratic finite element discretization with linears. rN)r2rr rebuild_smoother)rrs rchange_solve_matrixz$MultilevelSolver.change_solve_matrix%s/ A"4;q>22222rc0||dS)zLegacy solve interface.r)maxitersolve)rbs rpsolvezMultilevelSolver.psolve7szz!Qz'''rcjdjj}jdjj}fd}t |||S)aCreate a preconditioner using this multigrid cycle. Parameters ---------- cycle : {'V','W','F','AMLI'} Type of multigrid cycle to perform in each iteration. Returns ------- precond : LinearOperator Preconditioner suitable for the iterative solvers in defined in the scipy.sparse.linalg module (e.g. cg, gmres) and any other solver that uses the LinearOperator interface. Refer to the LinearOperator documentation in scipy.sparse.linalg See Also -------- MultilevelSolver.solve, scipy.sparse.linalg.LinearOperator Examples -------- >>> from pyamg.aggregation import smoothed_aggregation_solver >>> from pyamg.gallery import poisson >>> from scipy.sparse.linalg import cg >>> import scipy as sp >>> A = poisson((100, 100), format='csr') # matrix >>> b = np.random.rand(A.shape[0]) # random RHS >>> ml = smoothed_aggregation_solver(A) # AMG solver >>> M = ml.aspreconditioner(cycle='V') # preconditioner >>> x, info = cg(A, b, tol=1e-8, maxiter=30, M=M) # solve with CG rc6|ddS)Nrg-q=)rmrbtolrn)rprbrs rmatvecz1MultilevelSolver.aspreconditioner..matvec_s::a%U:CC Crdtype)r2rrJrwr)rrbrJrwrus`` raspreconditionerz!MultilevelSolver.aspreconditioner;sdB A & A & D D D D D DeV59999rNh㈵>rBrFc f|tj} ntj|} |jdjt |}|dkr*tdrjdkrtd|1|dkr|j std|d kr|dkrtd i} t|t rBi} tt|rtt|}ntt|}|| } |f|||| d | \} }| r| |fS| S#t"$ra4tj| zz gdd<fd }n}|| d<d| d<|f||| |d| \} }| r| |fcYS| cYSwxYwtj}|dkrd}tj| zz }|gdd<t)j| jj}t-|| g\} tjtj| } d} t1|jdkr|} n|d| || |dz }tj| zz }| | |||zkr| r| dfS| S||kr| r| |fS| S)a Execute multigrid cycling. Parameters ---------- b : array Right hand side. x0 : array Initial guess. tol : float Stopping criteria: relative residual r[k]/||b|| tolerance. If `accel` is used, the stopping criteria is set by the Krylov method. maxiter : int Stopping criteria: maximum number of allowable iterations. cycle : {'V','W','F','AMLI'} Type of multigrid cycle to perform in each iteration. accel : string, function Defines acceleration method. Can be a string such as 'cg' or 'gmres' which is the name of an iterative solver in pyamg.krylov (preferred) or scipy.sparse.linalg. If accel is not a string, it will be treated like a function with the same interface provided by the iterative solvers in SciPy. callback : function User-defined function called after each iteration. It is called as callback(xk) where xk is the k-th iterate vector. residuals : list List to contain residual norms at each iteration. The residuals will be the residuals from the Krylov iteration -- see the `accel` method to see verify whether this ||r|| or ||Mr|| (as in the case of GMRES). cycles_per_level: int, default 1 Number of V-cycles on each level of an F-cycle return_info : bool If true, will return (x, info) If false, will return x (default) Returns ------- x : array Approximate solution to Ax=b after k iterations info : string Halting status == ======================================= 0 successful exit >0 convergence to tolerance not achieved, return iteration count instead. == ======================================= See Also -------- aspreconditioner Examples -------- >>> from numpy import ones >>> from pyamg import ruge_stuben_solver >>> from pyamg.gallery import poisson >>> A = poisson((100, 100), format='csr') >>> b = A * ones(A.shape[0]) >>> ml = ruge_stuben_solver(A, max_coarse=10) >>> residuals = [] >>> x = ml.solve(b, tol=1e-12, residuals=residuals) # standalone solver Nrr[symmetry hermitianz@AMLI cycles require symmetry to be hermitiancgzIncompatible non-symmetric multigrid preconditioner detected, due to presmoother/postsmoother combination. CG requires SPD preconditioner, not just SPD matrix.fgmreszIAMLI cycles require acceleration (accel) to be fgmres, or no acceleration)rb)x0rtrmMcallback residualsctj|r|n8tj|zz  |dSdSr<)npisscalarappendlinalgnorm)xrrprrs rcallback_wrapperz0MultilevelSolver.solve..callback_wrapperst;q>>H%,,Q////%,,RY^^AAI-F-FGGG#/$HQKKKKK0/rrtolatol)rrmrrgg?Tr)r zeros_likearrayr2rr^r_r5r{ ValueErrorr1r isinstancergetattrslarxr`rrr rwr ravelrDr4_MultilevelSolver__solver)rrprrtrmrbaccelrrcycles_per_level return_inforkwargsrinfornormbnormrtpitrs ` `` @rrozMultilevelSolver.solveds$F : a  AA A KN E   "" VOOJ!7!7Oz[(( ".///   (@ LMMM !! "DEEEF%%% 065))0#FE22EE#C//E%%E%22A %1Rg)1YRRJPRR4#d7N    ($&INN1q1u9$=$=#>IaaaL((((((((((0$"%v!"v%1EW)9EE=CEE4#d7NNN5 >INN1%%E|| q1q5y))  !7IaaaLAGQWag . .aV$$A HQKK HQKK  4;1$$&&q!,, Q1e-=>>> !GBINN1q1u9--E$  '''# sU{"" a4KW}}!b5L1 s=EEA$G?GGc |j|j}|j|||||||zz }|j|j|z}t j|} |t |jdz kr-||jdj|| dd<n|dkr||dz| |dn|dkr8||dz| ||||dz| ||n|dkrM||dz| |||td|D]} ||dz| |ddn\|d krBd} |j|dzj} t j | |j df|j } t j | | f|j }t| D]}d| |ddf<||dz| |ddf |j ||t|D]}t j| |ddf| | |ddfzt j| |ddf| | |ddfzz |||f<| |ddfxx|||f| |ddfzzcc<| | |ddfz}t j| |ddft j|t j| |ddf|z }| || |ddf | j zz } ||| |j zz}nt#d |d ||j|j| zz }|j||||dS) aMultigrid cycling. Parameters ---------- lvl : int Solve problem on level `lvl` x : numpy array Initial guess `x` and return correction b : numpy array Right-hand side for Ax=b cycle : {'V','W','F','AMLI'} Recursively called cycling function. The Defines the cycling used: cycle = 'V', V-cycle cycle = 'W', W-cycle cycle = 'F', F-cycle cycle = 'AMLI', AMLI-cycle cycles_per_level : int, default 1 Number of V-cycles on each level of an F-cycle r"r/NrPrrXrZrr[rvr\r])r2r presmootherr0rrrDr4rrangezerosrJrwreshapeinnerconjrr`r6 postsmoother)rlvlrrprbrrresidualcoarse_bcoarse_x_nAMLIAcpbetakjApalphas r__solvezMultilevelSolver.__solves* K   C$$Q1---q1u9;s#%0=** #dk""Q& & &,,T[_->IIHQQQKK|| S1Wh#>>>># S1Wh%@@@ S1Wh%@@@@# S1Wh%AQRRRq"233FFALLq(Hc1EEEEF&[q)+HeX^A%67x~NNNxhnEEEuCCAAadGLLq!AqqqD'//(.*I*I!)5222#1XX88%'Xa111gllnnb1QT7l%K%KHQq!!!tW\\^^R!AqqqD'\BB&CQT !QQQ$41:!QQQ$#77a111gBHQq!!!tW\\^^RXh5G5GHH1aaa4445E!QQQ$(G(G GGH 8>(B(B BBHH+C. DE D D DEEE T[  ( ** C%%aA.....rr)rP) NryrBrPNNNrF)r)rrrrrr-rrOrdrErFrkrqrxrorrrrrrs@""H8<<<<<<<<S0S0S0S0j(I,I,I,I,V ( ( ( - - -333$(((':':':':RIMMRyyyyvL/L/L/L/L/L/rrcd}|\dvrfdndkrfdndkrfdndkrfd nd vrGttrttnttfd nBd vrd vrdd <fdn.dn(t rfdnt dGfdd}|S)aReturn a coarse grid solver suitable for MultilevelSolver. Parameters ---------- solver : string, callable, tuple The solver method is either (1) a string such as 'splu' or 'pinv' of a callable object which receives only parameters (A, b) and returns an (approximate or exact) solution to the linear system Ax = b, or (2) a callable object that takes parameters (A,b) and returns an (approximate or exact) solution to Ax = b, or (3) a tuple of the form (string|callable, args), where args is a dictionary of arguments to be passed to the function denoted by string or callable. The set of valid string arguments is: - Sparse direct methods: + splu : sparse LU solver - Sparse iterative methods: + the name of any method in scipy.sparse.linalg or pyamg.krylov (e.g. 'cg'). Methods in pyamg.krylov take precedence. + relaxation method, such as 'gauss_seidel' or 'jacobi', present in pyamg.relaxation - Dense methods: + pinv : pseudoinverse (SVD) + lu : LU factorization + cholesky : Cholesky factorization Returns ------- ptr : GenericSolver A class for use as a standalone or coarse grids solver Examples -------- >>> import numpy as np >>> from scipy.sparse import spdiags >>> from pyamg.gallery import poisson >>> from pyamg import coarse_grid_solver >>> A = poisson((10, 10), format='csr') >>> b = A * np.ones(A.shape[0]) >>> cgs = coarse_grid_solver('lu') >>> x = cgs(A, b) cTt|tr|d|dfS|ifS)Nrr)rtuple)vs r unpack_argz&coarse_grid_solver..unpack_args/ a   Q41: "u r)rpinv2ct|ds$t|fi|_t j|j|S)Nr6)r5rtoarrayr6rdotrrrprs rroz!coarse_grid_solver..solvesH4%% 5aiikk44V446$&!$$ $rluct|ds.tjj|fi|_tj|j|S)NLU)r5spr lu_factorrrlu_solvers rroz!coarse_grid_solver..solvesT4&& E)-aiikkDDVDD9%%dgq11 1rcholeskyct|ds.tjj|fi|_tj|j|S)NL)r5rr cho_factorrr cho_solvers rroz!coarse_grid_solver..solvesT4%% E-aiikkDDVDD9&&tvq11 1rspluct|ds|}||jdd|jddz }|dkd}t j|jd|jdd}|dd|f}|j |z|z}t jj j |fi|_ ||_ |j |j tj|j j |zzS)Nrr/rrcsc)format)r5tocsceliminate_zerosindptrnonzerorsparseeyerJr7rrrLU_Maprorr)rrrpAcscdiffptr nonzero_colsMaprs rroz!coarse_grid_solver..solves4&& "wwyy$$&&&+crc*T[_< '1 5577: immDJqM4:a=mOO!!!\/*u{{}}t+c1)*/????! ;rx 8I/J/J!K!KK Kr)bicgbicgstabr}cgsgmresqmrminrescZdvrt|jd<||fidS)Nrtr)r rw)rrrpfnrs rroz!coarse_grid_solver..solves@F"" ' 0 0u 2a%%f%%a( (r) gauss_seideljacobiblock_gauss_seidelschwarz block_jacobi richardsonsor chebyshev jacobi_negauss_seidel_negauss_seidel_nr iterations ct}||_ttdt z}||fi}t j|}|||||S)Nsetup_)rrrrr r^rr) rrrprrrelaxrrsolvers rroz!coarse_grid_solver..solvesq"((**CCEHs6{{$:;;BBs%%f%%E a  A E!QNNNHrNc d|zS)Nrr)r__rps rroz!coarse_grid_solver..solves q5Lrc||fiSr<r)rrrprrs rroz!coarse_grid_solver..solves6!Q))&)) )rzunknown solver: cBeZdZdZfdZfdZefdZdS))coarse_grid_solver..GenericSolverzGeneric solver class.ctj|}|jdkrtj|j}n |||}t |tjrtj|}nRt |tjr)tj|}tj|}ntd| |jS)Nrzunrecognized type) r asanyarrayr>rrJrndarrayasarraymatrixrr)rrrprros r__call__z2coarse_grid_solver..GenericSolver.__call__s a  AuzzHQW%%E$1%%!RZ(( 6JqMMAry)) 6JqMMJqMM !455599QW%% %rc.dtzdzS)Nzcoarse_grid_solver(r]repr)rrs rrOz2coarse_grid_solver..GenericSolver.__repr__s(4<<7#= =rc"tS)zReturn the coarse solver name.r)clsrs rrGz.coarse_grid_solver..GenericSolver.name s<< rN)rrrrrrO classmethodrG)rorsr GenericSolverrsr## & & & & &* > > > > >         rr)r5rrrcallabler)rrrrrros` @@@rr3r3ns=\  Z''NFF """ % % % % % % 4 2 2 2 2 2 2 :   2 2 2 2 2 2 6   L L L L L L N N N 66 " " &((BBf%%B ) ) ) ) ) ) ) G G G v % %#%F<              &  6 * * * * * * *4F44555           @ =??rc"eZdZdZfdZxZS)multilevel_solverzlDeprecated level class. .. deprecated:: 4.2.3 Use :class:`MultilevelSolver` instead. chtj|i|tdtddS)r!z8multilevel_solver is deprecated. use MultilevelSolver()r"r#Nr&)rargsrr)s rrzmultilevel_solver.__init__sH$)&))) G(Q 8 8 8 8 8 8rr*r,s@rrrsB 888888888rr)rwarningsrscipyr scipy.linalgrscipy.sparse.linalgrrrrnumpyrr util.utilsr util.paramsr relaxationr utilr rr3rrrrrsG!!!!!!!!!...... !!!!!!Z /Z /Z /Z /Z /Z /Z /Z /zbbbJ 8 8 8 8 8( 8 8 8 8 8r