_-Phӂ$dZddlmZmZddlZddlmZddlm Z ddl m Z m Z m Z ddlmZdd lmZmZmZmZd d lmZd d lmZd Zd ZgdZgdZdZdZdZdZ dZ!d5dZ"eefdZ#eddfdZ$eddddefdZ%eefdZ&eddddfdZ'eeddfdZ(edfdZ)deefd Z*d!d"d#efd$Z+eddfd%Z,eedfd&Z-eedfd'Z.eeedd(fd)Z/eeedd(fd*Z0eeedddd(fd+Z1eeedddd(fd,Z2d-eddddfd.Z3d-edddfd/Z4d-edddfd0Z5d-edddfd1Z6d2Z7d3Z8d4Z9dS)6aMethod to create pre and post-smoothers on the levels of a MultilevelSolver. The setup_smoother_name functions are helper functions for parsing user input and assigning each level the appropriate smoother for the functions in 'change_smoothers'. The standard interface is Parameters ---------- lvl : multilevel level the level in the hierarchy for which to assign a smoother iterations : int how many smoother iterations optional_params : dict optional params specific for each method such as omega or sweep Returns ------- Function pointer for the appropriate relaxation method for level=lvl Examples -------- See change_smoothers above )partialupdate_wrapperN)sparse)LinearOperator) scale_rowsget_block_diag get_diagonal)approximate_spectral_radius)gmrescgnecgnrcg) relaxation)!chebyshev_polynomial_coefficientsforward)jacobi richardson block_jacobi jacobi_ne chebyshevN)rr rr cTt|tr|d|dfS|ifS)Nrr) isinstancetuple)vs Z/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/pyamg/relaxation/smoothing.py _unpack_argr3s/!UtQqTz b5Lc |j}n"#t$r}td|d}~wwxYw|jtkrt dt jt j|dt}t j|dt}||fS)zCheck and extract splitting.z&CF splitting is required in hierarchy.Nz'CF splitting is required to be boolean.rdtype) splittingAttributeErrorr"bool ValueErrornpwhere logical_notastypeint)lvlr#excFptsCptss r_extract_splittingr09sPM PPPEFFCOP$BCCC 8BN9-- . .q 1 8 8s 8 C CD 8I  q ! ( (s ( 3 3D :s )$)c fd|_t|ttfs||g}n$t|tst dt|ttfs||g}n$t|tst dd}d}i}i}t t|t|t|jdd}td|D]}t||\}}t|} | |j|fi||j|_ t||\}}t|} | |j|fi||j|_ d|vr |d} nt} d|vr |d} nt} | | krd|_||fd vr|d t} |d t}|d t}|d t}| |kr||ksd|_V||kr d|_e|t vs |t vr d|_|t"vra|d r d|_|d t&}|d t&}||fdvrd|_t|t|krt t|t|jdd}t||D]}| |j|fi||j|_ t||\}}t|} | |j|fi||j|_ d|vr |d} nt} d|vr |d} nt} | | krd|_||fd vr|d t} |d t}|d t}|d t}| |kr||ksd|_/||kr d|_>|t vs |t vr d|_Y|t"vra|d r d|_|d t&}|d t&}||fdvrd|_Őn0t|t|kr t t|t|jdd}t||D]}t||\}}t|} | |j|fi||j|_ | |j|fi||j|_ d|vr |d} nt} d|vr |d} nt} | | krd|_||fd vr|d t} |d t}|d t}|d t}| |kr||ksd|_/||kr d|_>|t vs |t vr d|_Y|t"vra|d r d|_|d t&}|d t&}||fdvrd|_n|}t|t|jddD]J}| |j|fi||j|_ | |j|fi||j|_ KdS)aInitialize pre and post smoothers. Initialize pre- and post- smoothers throughout a MultilevelSolver, with the option of having different smoothers at different levels For each level of the MultilevelSolver 'ml' (except the coarsest level), initialize the .presmoother() and .postsmoother() methods used in the multigrid cycle. Parameters ---------- ml : pyamg multilevel hierarchy Data structure that stores the multigrid hierarchy. presmoother : None, string, tuple, list presmoother can be (1) the name of a supported smoother, e.g. "gauss_seidel", (2) a tuple of the form ('method','opts') where 'method' is the name of a supported smoother and 'opts' a dict of keyword arguments to the smoother, or (3) a list of instances of options 1 or 2. See the Examples section for illustrations of the format. If presmoother is a list, presmoother[i] determines the smoothing strategy for level i. Else, presmoother defines the same strategy for all levels. If len(presmoother) < len(ml.levels), then presmoother[-1] is used for all remaining levels If len(presmoother) > len(ml.levels), then the remaining smoothing strategies are ignored postsmoother : string, tuple, list Defines postsmoother in identical fashion to presmoother Returns ------- ml changed in place ml.levels[i].presmoother <=== presmoother[i] ml.levels[i].postsmoother <=== postsmoother[i] ml.symmetric_smoothing is marked True/False depending on whether the smoothing scheme is symmetric. Notes ----- - Parameter 'omega' of the Jacobi, Richardson, and jacobi_ne methods is scaled by the spectral radius of the matrix on each level. Therefore 'omega' should be in the interval (0,2). - Parameter 'withrho' (default: True) controls whether the omega is rescaled by the spectral radius in jacobi, block_jacobi, and jacobi_ne - By initializing the smoothers after the hierarchy has been setup, allows for "algebraically" directed relaxation, such as strength_based_schwarz, which uses only the strong connections of a degree-of-freedom to define overlapping regions - Available smoother methods:: gauss_seidel block_gauss_seidel jacobi block_jacobi cf_jacobi fc_jacobi cf_block_jacobi fc_block_jacobi richardson sor chebyshev gauss_seidel_nr gauss_seidel_ne jacobi_ne cg gmres cgne cgnr schwarz strength_based_schwarz None Examples -------- >>> from pyamg.gallery import poisson >>> from pyamg.aggregation import smoothed_aggregation_solver >>> from pyamg.relaxation.smoothing import change_smoothers >>> from pyamg.util.linalg import norm >>> import numpy as np >>> A = poisson((10,10), format='csr') >>> b = np.random.rand(A.shape[0],) >>> ml = smoothed_aggregation_solver(A, max_coarse=10) >>> # Set all levels to use gauss_seidel's defaults >>> smoothers = 'gauss_seidel' >>> change_smoothers(ml, presmoother=smoothers, postsmoother=smoothers) >>> residuals=[] >>> x = ml.solve(b, tol=1e-8, residuals=residuals) >>> # Set all levels to use three iterations of gauss_seidel's defaults >>> smoothers = ('gauss_seidel', {'iterations' : 3}) >>> change_smoothers(ml, presmoother=smoothers, postsmoother=None) >>> residuals=[] >>> x = ml.solve(b, tol=1e-8, residuals=residuals) >>> # Set level 0 to use gauss_seidel's defaults, and all >>> # subsequent levels to use 5 iterations of cgnr >>> smoothers = ['gauss_seidel', ('cgnr', {'maxiter' : 5})] >>> change_smoothers(ml, presmoother=smoothers, postsmoother=smoothers) >>> residuals=[] >>> x = ml.solve(b, tol=1e-8, residuals=residuals) TNzXUnrecognized presmoother -- use a string: "method" or ("method", opts) or list thereof.zYUnrecognized postsmoother -- use a string: "method" or ("method", opts) or list thereof.r iterationsF)) cf_jacobi fc_jacobi)r5r4)cf_block_jacobifc_block_jacobi)r7r6 f_iterations c_iterations)cf_fc_sweep))rbackward)r=r) symmetricr>)symmetric_smoothingrstrrlistr&minlenlevelsranger _setup_call presmoother postsmoother DEFAULT_NITERgetKRYLOV_RELAXATIONSYMMETRIC_RELAXATION startswith DEFAULT_SWEEP)mlrGrHfn1fn2kwargs1kwargs2min_lenisetup_presmoothersetup_postsmootherit1it2fit1fit2cit1cit2sweep1sweep2mid_lens rchange_smoothersraJseT"B+U|,,J1D"m  T * *JIJJ J,e --J,2F$~  d + +JIJJ J C CGG#k""C $5$5s29SbS>7J7JKKG 1g  5353";q>22 W',,#4#4RYq\#M#MW#M#M !  #<?33 W(--$6$6ry|$O$Ow$O$O ! ! 7 " ",'CCC 7 " ",'CCC #::%*B " "3ZDDD ;;~}==D;;~}==D;;~}==D;;~}==DDLLTT\\).& CZZ%*B " " % % %0A)A)A%*B " " , , ,~~n-- 3).&& Wm<< Wm<<F#,HHH.3B* ;#l++++c,''RYss^)<)<==w((0 70 7A'8'81'Q'Q'Q'QBIaL $'|A77LC!,S!1!1 (:(:29Q<(S(S7(S(SBIaL %w&&l+#w&&l+$czz).&&s HHH{{>=AA{{>=AA{{>=AA{{>=AA -2B*).&&)))S4E-E-E).&&000>>.117-2B**$[[-@@F$[[-@@F'0LLL27.a0 7d [  C -- - -c+&&BIcrcN(;(;<<w((1 71 7A&{1~66LC +C 0 0 '8'81'Q'Q'Q'QBIaL $);(:29Q<(S(S7(S(SBIaL %w&&l+#w&&l+#czz).&&s HHH {{>=AA{{>=AA{{>=AA{{>=AA -2B*).&&)))S4E-E-E).&&000>>.117-2B**$[[-@@F$[[-@@F'0LLL27.c1 7f7C #2#// 0 0PP#4#4RYq\#M#MW#M#M !  $6$6ry|$O$Ow$O$O ! !!PPrct|ds7t|d}t||d}t||_|jS)aReturn the (approx.) spectral radius of D^-1 * A. Parameters ---------- A : sparse-matrix Returns ------- approximate spectral radius of diag(A)^{-1} A Examples -------- >>> from pyamg.gallery import poisson >>> from pyamg.relaxation.smoothing import rho_D_inv_A >>> from scipy.sparse import csr_matrix >>> import numpy as np >>> A = csr_matrix(np.array([[1.0,0,0],[0,2.0,0],[0,0,3.0]])) >>> print(f'{rho_D_inv_A(A):2.2}') 1.0 rho_D_invT)inv)copy)hasattrr rr rc)AD_invD_inv_As r rho_D_inv_ArjssS, 1k " ";QD)))QD1111':: ;rc>tdsjd}jdjdkrtdjdtjd|z krtdt jt jjdt jjddzfjfd}tj|j }t|_ j S) aTReturn the (approx.) spectral radius of block D^-1 * A. Parameters ---------- A : sparse-matrix size NxN Dinv : array Inverse of diagonal blocks of A size (N/blocksize, blocksize, blocksize) Returns ------- approximate spectral radius of (Dinv A) Examples -------- >>> from pyamg.gallery import poisson >>> from pyamg.relaxation.smoothing import rho_block_D_inv_A >>> from pyamg.util.utils import get_block_diag >>> A = poisson((10,10), format='csr') >>> Dinv = get_block_diag(A, blocksize=4, inv_flag=True) rho_block_D_invrrzDinv has incorrect dimensionsrz'Dinv and A have incompatible dimensions)shapec|zzSN)xrgDinvs rmatvecz!rho_block_D_inv_A..matvecs1: rr!) rfrmr&r+r bsr_matrixr'arangerr"r rl)rgrr blocksizersris`` rrho_block_D_inv_Arws0 1' ( (AJqM :a=DJqM ) )<== = :a=C 9 455 5 5FGG G $"$)DJqM":":"$)DJqM!O"<"<">()w000        &@@@7@@ rc||z}t||}|dkr.|t|dt|dzz }t||rn|j|kr|dkrt |||nc|j|kr,|dkr&t ||||n,t|d|z}t |||t||S)aSet a matrix to a specific format. This routine looks for the matrix "name" in the specified format as a member of the level instance, lvl. For example, if name='A', format='bsr' and blocksize=(4,4), and if lvl.Absr44 exists with the correct blocksize, then lvl.Absr is returned. If the matrix doesn't already exist, lvl.name is converted to the desired format, and made a member of lvl. Only create such persistent copies of a matrix for routines such as presmoothing and postsmoothing, where the matrix conversion is done every cycle. Calling this function can _dramatically_ increase your memory costs. Be careful with it's usage. bsrrr)rvto)getattrr@rfformatsetattrtobsr)r,namer|rvdesired_matrixMnewMs rmatrix_asformatrs"F]NTA #il++C ! ,=,===sN## + V  %^Q'''' V  % ^QWWyW%A%ABBBB)wq$-((**^T*** 3 ' ''rcrttj||}t|tj|S)zSet up Gauss-Seidel.r3r<)rr gauss_seidelr)r,r3r<smoothers rsetup_gauss_seidelrs1z.:USSSH8Z4555 Org?Tc|r|t|jz }ttj||}t |tj|S)zSet up weighted-Jacobi.r3omega)rjrgrrrrr,r3rwithrhors r setup_jacobirsM)k#%(((z(ZuMMMH8Z./// Orctddjtjj\fd}t |tj|S)zSet up Schwarz.rgcsrc Ltjj||  dS)N)r3 subdomain subdomain_ptr inv_subblockinv_subblock_ptrr<)rschwarzAcsr) rgrqbrrr3r,rrr<s rrzsetup_schwarz..smoothersE38Qj%.)6(4,.strength_based_schwarzs? y/??? |cey4HHHz4 IUDDDH8Z:;;; OrcDt|jz fd}|S)zSet up Richardson.c<tj|||gdSN) coefficientsr3r polynomial)rgrqrr3rs rrz$setup_richardson..richardsones'aAUG SSSSSSr)r rg)r,r3rrs `` rsetup_richardsonrasC -ce44 4ETTTTTT rg?ctttj|||}t|tj|S)z Set up SOR.)r3rr<)rrsorr)r,rr3r<rs r setup_sorrjs2z~*EQVWWWH8Z^,,, Org?g?c t|j}||z}||z}t|||dd fd}|S)zSet up Chebyshev.Nr2c:tj|||dSrr)rgrqrrr3s rrz"setup_chebyshev..chebyshevzs%aALZXXXXXXr)r rgr) r, lower_bound upper_bounddegreer3rhoarrrs ` @rsetup_chebyshevrqsp &ce , ,C kA kA5aFCCCRCHHLYYYYYY rctdd|rtjdzz fd}t|tj|S)zSet up Jacobi NE.rgrrcDtjj||dS)Nr)rrr)rgrqrr3r,rs rrz!setup_jacobi_ne..smoothers4SXq! #( * * * * * *r)rrjrrrrrs``` rsetup_jacobi_nersuCe$$$/k#(++Q..*******8Z1222 Orcttddfd}t|tj|S)zSet up Gauss-Seidel NE.rgrcFtjj||dSN)r3r<r)rgauss_seidel_nerrgrqrr3r,rr<s rrz'setup_gauss_seidel_ne..smoother6"38Qj).e = = = = = =r)rrrrr,r3r<rrs```` rsetup_gauss_seidel_ner\Ce$$$========8Z7888 Orcttddfd}t|tj|S)zSet up Gauss-Seidel NR.rgcsccFtjj||dSr)rgauss_seidel_nrAcscrs rrz'setup_gauss_seidel_nr..smootherrr)rrrrrs```` rsetup_gauss_seidel_nrrrrFc |r|t|jz }t|\}}ttj||||||}t |tj|S)zSet up coarse-fine Jacobi.r/r.r8r9r3r)rjrgr0rrr4r r,r8r9r3rrr.r/rs rsetup_cf_jacobirr)k#%(((#C((JD$z+$T$0|",E;;;H8Z1222 Orc |r|t|jz }t|\}}ttj||||||}t |tj|S)zSet up fine-coarse Jacobi.r)rjrgr0rrr5rrs rsetup_fc_jacobirrrc |J|Htj|jrd}nRtj|jr|jjd}n&|$tj|r|jd}nd}|jjd|zdkrt dt|j|z|jjdkrt d|dkr/t||||}t|tj |St|\} } |t|j|d}|r|t|j|z }t!tj | | |||||| }t|tj |S z Set up coarse-fine block Jacobi.Nrrz)Blocksize does not divide size of matrix.z;Blocksize not compatible with CF-splitting and matrix size.rTr)r/r.r8r9r3rrrrv)rrrgrrvrmr&rCr#rrrr6r0r rwr r,r8r9r3rrrrvrrr.r/s rsetup_cf_block_jacobir T\   ' ' +II  "35 ) ) +*I     & & q)III  A"q((DEEE 3=)#su{1~55VWWWA~~"3:UT[\\\x!;<<<#C((JD$ |cey4HHH5't444z14$0 ",EPY[[[H8Z7888 Orc |J|Htj|jrd}nRtj|jr|jjd}n&|$tj|r|jd}nd}|jjd|zdkrt dt|j|z|jjdkrt d|dkr/t||||}t|tj |St|\} } |t|j|d}|r|t|j|z }t!tj | | |||||| }t|tj |Sr)rrrgrrvrmr&rCr#rrrr7r0r rwrrs rsetup_fc_block_jacobirrrg-q=cPfd}t|t|S)zSet up GMRES smoothing.c ~t||| d|j|dd<dS)N)x0tolmaxiterrestartrcallback residualsr)r reshaperm) rgrqrrrrrrrs rrzsetup_gmres..smoothersQQaS'7a&)====>@@G@P@P !!!r)rr )r,rrrrrrrs `````` r setup_gmresrs[QQQQQQQQQQ8U### OrcLfd}t|t|S)zSet up CG smoothing.c |t|||d|j|dd<dSN)rrrrrrr)rrrmrgrqrrrrrrs rrzsetup_cg..smoother$sN!Q1#w!#y::::;==DWQW=M=M !!!r)rrr,rrrrrrs ````` rsetup_cgr"sTNNNNNNNNN8R   OrcLfd}t|t|S)zSet up CGNE smoothing.c |t|||d|j|dd<dSr)r rrmrs rrzsetup_cgne..smoother.NAqQCA%<<<<=??Fwqw?O?O !!!r)rr rs ````` r setup_cgner+TPPPPPPPPP8T""" OrcLfd}t|t|S)zSet up CGNR smoothing.c |t|||d|j|dd<dSr)rrrmrs rrzsetup_cgnr..smoother8rr)rrrs ````` r setup_cgnrr5rrc d}|S)zSet up default, empty smoother.cdSrorp)rgrqrs rnonezsetup_none..noneAs rrp)r,rs r setup_noner?s   Krcidtdtdtdtdtdt dt dtd td td td td tdtdtdtdt t"t$t&t(d}|d}t+|t,st/d|||vrt/d|d||S)zqRegister setup functions. This is a helper function to call the setup methods and avoids use of eval(). rrrrrrrrrrrrr4r5r6r7r )rr rrNrz,Input function must be a string or None: fn=z Function z does not have a setup)rrrrrrrrrrrrrrrrrrrrrrr@r&)fnsetup_registers rrFrFFs] "4, - !">  "4  ":  "2 ) / / "7 "7 / / "7 "7!" +#$#+",",",+N0 z  b#  NLLLMMM ?R???@@@ " rc |jj}|jj}n"#t$r}td|d}~wwxYwt |}|||_t |}|||_dS)aRebuild the pre/post smoother on a level. Parameters ---------- lvl : Level object Notes ----- This rebuilds a smoother on level lvl using the existing pre and post smoothers. If different methods are needed, see `change_smoothers`. z,The pre/post smoothers need to be functions.N)rG__name__rHr$rF)r,rPrQr-rVrWs rrebuild_smootherrosVo&' VVVKLLRUUV$C(('',,CO%S))))#..Cs :5:ro):__doc__ functoolsrrnumpyr'scipyrscipy.sparse.linalgr util.utilsrr r util.linalgr krylovr r rrrrrrNrIrLrKrr0rarjrwrrrrrrrrrrrrrrrrrrrrrrrFrrprrr s+4.-------......AAAAAAAAAA555555************888888  888433 "fPfPfPR <---b&(&(&(&(T(5M"/c4#04 $4$%(2?'4""""*(5Cd!%t<.;#0"&$:&3#m&.3q,    %2d    +8} #    +8} #    '4-,C    '4-,C    -: %2#DTX"'((((V-: %2#DTX"'((((V ttVZ]dTUY}t}t&&&R/////r