DOUG: Robust Coarse Spaces

Implementation is based on the work by Ivan Graham, Robert Scheichl and Jan Van lent, "Robust Coarse Spaces for Overlapping Schwarz Methods".

Input

- injection matrices mapping from the vectors taking values at all points of the fine mesh to vectors taking values at the points in the interior of the support of basis function i. This also identifies aggregates with the overlap included (although no aggregate neighbour information is directly available).
A - system matrix
<unavailable, ie may leave out for the first implementation> - neighbour information, i.e. which aggregates overlap.

Note:: At the moment projection matrices are only available without overlap (i.e. simple aggregates). The extended aggregates are extracted from the restriction matrix of the smoothing method.

Output

$\hat{R}$ - restriction matrix from fine space to coarse space

Algorithm

Note:: No parallel implementation is yet available

Definitions

n - number of fine-level subdomains
- number of coarse nodes (number of coarse node supports), also number of fine aggregates

General description

To get restriction matrix we need to solve the problem (g - vector of Lagrange multipliers in the energy minimization problem)

$B g = 1 \mbox{ where } B = \sum\limits_i^{n_c} R_i^T A_i^{-1} R_i \mbox{ and } A_i = R_i A R_i^T$

The CG solver (see preconditioner below) can be found in pcg_forRCS(). Because matrix B is not sparse special datatype RobustCoarseMtx_mod::SumOfInversedSubMtx has been introduced. Matrix-vector multiplication for this type of matrix is implemented in the subroutine SOISMtx_pmvm().

Then we get $ r_i $ - rows of the $\hat{R}$ with

$r_i = R^T_i q_i \mbox{ where } A_i q_i = g_i \mbox{ and } g_i = R_i g$

The implementation of this last step can be found in RobustRestrictMtxBuild().

Construction of preconditioner

CG is slow, so preconditioner must be introduced for $ B g = 1 $ .

Preconditioner C for the B is

$C = \sum\limits_{j=1}^{n_c} R_j^T B_j^{-1} R_j$

Multiplying a vector by the matrix C can be implemented efficiently using the following formulas which involve only sparse matrices

$B_j^{-1} = A_j - A_j \left[ \begin{array}{ccc} I_{jk} & \cdots & I_{jl} \end{array} \right] H_{kl}^{-1} \left[ \begin{array}{c} I_{kj} \\ \vdots \\ I_{lj} \end{array} \right] \mbox{ where }$

$H_{kl} = \left[ \begin{array}{ccc} A_k & \\ & \ddots \\ & & A_l \end{array} \right] + \left[ \begin{array}{c} I_{kj} \\ \vdots \\ I_{lj} \end{array} \right] A_j \left[ \begin{array}{ccc} I_{jk} & \cdots & I_{jl} \end{array} \right] \mbox{ and }$

$I_{jk} = R_j R_k^T \mbox{ for overlapping R's (coarse supports) } j \neq k$

Note:: currently I's for all combinations of R's are calculated, non-overlaping are simply zero

The data of C preconditioner is stored in pcgRobust_mod::RobustPreconditionMtx datatype. The implementation of preconditioner is in 2 subroutines

precondition_forRCS::initialize() - initializes datatype: creates I and H matrices
pcgRobust_mod::precondition_forRCS() applies C