**iterative_solver

Description

This keyword specifies the iterative solver used to solve the global interface problem involved in the FETI and AMPFETI domain decomposition methods.

Note

This command is only available within dd_feti and dd_mpfeti solvers contexts.

Syntax

The iterative solver command has the following syntax:

**iterative_solver type

where type may have different value depending on the type of domain decomposition solver used.

• FETI solver (whithin ***linear_solver dd_feti context)

  ddcg

  is a standard conjugate gradient (CG) algorithm;

  ddbicg

  is a standard bi-conjugate gradient (BiCG) algorithm (for non symmetric system);

  dd_ortho

  is a standard Orthomin algorithm (for non symmetric system);

• AMPFETI solver (whithin ***linear_solver dd_mpfeti context)

  ddcgb

  is a multi preconditioned conjugate gradient (MPCG) algorithm;

  ddcgb_adaptive_global

  is a MPCG algorithm where the selection of search direction involved in the multi preconditioning step is triggered by a global test, leading either to the use of all directions or to fall back to a classical CG at each iteration;

  ddcgb_adaptive_local

  is a MPCG algorithm where the selection of search direction involved in the multi preconditioning step is triggered by a local test at each iteration, leading to a finer selection;

  ddbicgb

  is a multi preconditioned bi-conjugate gradient algorithm (for non symmetric system);

  dd_orthob

  is a multi preconditioned Orthomin algorithm (for non symmetric system);

All subsequent commands are optional and default values are automatically set, which may be different depending on the solver used.

The following keywords are common to all iterative solvers.

[ *precision eps ] [ *max_iteration max_iter ] [ *min_iteration min_iter ] [ *standing_iteration standing_iter ] [ *convergence_type type ] [ *output_every_iter int ] [ *ortho_type type ] [ *ortho_number int ] [ *double_orthogonalization ]

*precision eps

where eps is a real value defining the relative precision required for convergence when solving the problem with the CG method. Default value is \(10^{-8}\).

*max_iteration max_iteration

is the maximum number of iterations allowed when solving the problem. Default value is 300.

*min_iteration min_iteration

where min_iteration is the minimum iterations when solving the problem. Default value is 0.

*standing_iteration

is an integer specifying the maximum number of iterations allowed without any significant decrease of the convergence ratio. Default value is 30 for ddcg or 5 for ddcgb and derived.

*convergence_type type

specifies which residual is monitored for the convergence. type can take these two values normal or precond. Let \({\bf r}_{i} = {\bf K} {\bf u}_{i} - {\bf F}\) be the residual at iteration \(i\) (notation are simplified). If type is set to normal, the convergence is reached when

\[\frac{\|{\bf r}_{i}\|_2}{\|{\bf r}_{0}\|_2} \leq \epsilon\]

For CG like solvers, it is sometimes more interesting to monitor convergence with the residual decrease in the norm defined by the preconditioner \(\hat{\bf S}\). It is possible since preconditioners available are symmetric positive definite (if the stiffness operator is SPD). Thus, if type is set to precond, the convergence is reached when

\[\frac{\|{\bf r}_{i}\|_{\hat{\bf S}}}{\|{\bf r}_{0}\|_{\hat{\bf S}}} = \frac{\sqrt{{\bf r}_i^T {\bf z}_i}} {\sqrt{{\bf r}_0^T {\bf z}_0}} \leq \epsilon \quad \text{where} \quad {\bf z}_{i} = \hat{\bf S} {\bf r}_{i} \quad \text{is the preconditioned residual}\]

Default value is normal.

*output_every_iter iter

where iter is the frequency of the iteration information output. Default value is 10.

*ortho_type type

specifies the kind of orthogonalisation used. type can take this two values gskss (i.e. Krylov subspace with Gram-Schmidt orthogonalization) and mgskss (i.e. Krylov subspace with modified Gram-Schmidt orthogonalization). The modified Gram-Schmidt orthogonalization is slightly more costly than the standard one. It is also more robust in terms of numerical round off. Default value is mgskss.

*ortho_number

is an integer specifying the maximum number of block of search directions retained. The classical CG short recurrence does not hold for multi preconditioned conjugate gradient. It is strongly advised to keep the default value -1 (i.e. all blocks of search directions are kept).

*double_orthogonalization

if set the orthogonalization process is made twice. It can be useful for ill conditioned problem. Disabled by default.

The following keywords are specific to multi preconditioned Krylov solvers ddcgb, ddcgb_adaptive_global, ddcgb_adaptive_local, ddbicgb and dd_orthob.

[ *collinearity_treatment type ] [ *pivoting_tolerance_type type ] [ *pivoting_tolerance eps ] [ *double_check_collinearity ] [ *double_check_collinearity_threshold eps ] [ *adaptivity_threshold tau ] [ *number_of_clusters nb_clusters ]

*collinearity_treatment

At each iteration, a multi preconditioned Krylov solver generates a group of search directions. These search directions may be collinear or (nearly) collinear. This collinearity has a direct impact on the rank of a dense matrix \(\Delta_i\) which has to be (pseudo)-inverted.

\[\Delta_i = {\bf W}_i^\top {\bf F} {\bf W}_i \quad \text{ where} \quad {\bf W}_i \ \text{are the search directions and } {\bf F} \ \text{is the FETI operator}\]

How we compute the pseudo-inverse is determined by the keyword collinearity_treatment. Some collinearity treatment are rank revealing, they can eliminate redundant search directions and recover a full rank family. It can take these 7 values defining how we deal with the \(\Delta_i\) matrices:

• inv computation of the inverse.

• cholesky Cholesky decomposition (fastest method but not ok for finite displacement)

• chol_rank_revealing rank revealing version of cholesky.

• crout Crout decomposition (fast method, slightly more robust, not ok for finite displacement)

• crout_rank_revealing rank revealing version of crout.

• lu LU decomposition (more robust and ok for finite displacement)

• lu_rank_revealing rank revealing version of lu.

*pivoting_tolerance_type type

it only matters if the collinearity_treatment chosen is rank revealing. type can take these two values absolute (i.e. search directions are dropped if the associated pivot or eigen value is below pivoting_tolerance) or relative (i.e. search directions are dropped if the associated pivot or eigen value is below pivoting_tolerance times the greatest pivot or eigen value). Default value is relative.

*pivoting_tolerance eps

specifies the threshold for rank revealing collinearity treatment. Default value is \(10^{-8}\).

*double_check_collinearity

enables a second collinearity check. For some ill conditioned problems and if pivoting_tolerance_type is set to relative it is possible that all pivots stay grouped during the decrease. Because of that, the collinearity treatment may be inefficient. This second check compress all search directions (i.e. AMPFETI acts as FETI) is the greatest pivots or eigen value is below double_check_collinearity_threshold. Disabled by default.

*double_check_collinearity_threshold

is the threshold associated with double_check_collinearity. Default value is \(10^{-9}\).

*adaptive_threshold tau

is the threshold used for the selection of search directions and thus is specific to adaptive solvers ddcgb_adaptive_global and ddcgb_adaptive_local. A high value of tau increases the number of selected search directions and adaptive solvers tend to behave like the ddcgb solver. With a low value, adaptive solvers act like classical ddcg solver. Default value is \(10^{-1}\).

*number_of_clusters nb_clusters

is an integer that drives the granularity of the multipreconditioning. The default value is -1 meaning automatic choice. With this choice, the number of clusters is equal to the number of sub-domains in the decomposition as long as where are below the value of Solver.Parallel.ClusterAutoLimit (default value 200).