Actual source code: deflation.c
1: #include <../src/ksp/pc/impls/deflation/deflation.h>
3: const char *const PCDeflationSpaceTypes[] = {"haar", "db2", "db4", "db8", "db16", "biorth22", "meyer", "aggregation", "user", "PCDeflationSpaceType", "PC_DEFLATION_SPACE_", NULL};
5: static PetscErrorCode PCDeflationSetInitOnly_Deflation(PC pc, PetscBool flg)
6: {
7: PC_Deflation *def = (PC_Deflation *)pc->data;
9: PetscFunctionBegin;
10: def->init = flg;
11: PetscFunctionReturn(PETSC_SUCCESS);
12: }
14: /*@
15: PCDeflationSetInitOnly - Do only initialization step.
16: Sets initial guess to the solution on the deflation space but does not apply
17: the deflation preconditioner. The additional preconditioner is still applied.
19: Logically Collective
21: Input Parameters:
22: + pc - the preconditioner context
23: - flg - default `PETSC_FALSE`
25: Options Database Key:
26: . -pc_deflation_init_only <false> - if true computes only the special guess
28: Level: intermediate
30: .seealso: [](ch_ksp), `PCDEFLATION`
31: @*/
32: PetscErrorCode PCDeflationSetInitOnly(PC pc, PetscBool flg)
33: {
34: PetscFunctionBegin;
37: PetscTryMethod(pc, "PCDeflationSetInitOnly_C", (PC, PetscBool), (pc, flg));
38: PetscFunctionReturn(PETSC_SUCCESS);
39: }
41: static PetscErrorCode PCDeflationSetLevels_Deflation(PC pc, PetscInt current, PetscInt max)
42: {
43: PC_Deflation *def = (PC_Deflation *)pc->data;
45: PetscFunctionBegin;
46: if (current) def->lvl = current;
47: def->maxlvl = max;
48: PetscFunctionReturn(PETSC_SUCCESS);
49: }
51: /*@
52: PCDeflationSetLevels - Set the maximum level of deflation nesting.
54: Logically Collective
56: Input Parameters:
57: + pc - the preconditioner context
58: - max - maximum deflation level
60: Options Database Key:
61: . -pc_deflation_max_lvl <0> - maximum number of levels for multilevel deflation
63: Level: intermediate
65: .seealso: [](ch_ksp), `PCDeflationSetSpaceToCompute()`, `PCDeflationSetSpace()`, `PCDEFLATION`
66: @*/
67: PetscErrorCode PCDeflationSetLevels(PC pc, PetscInt max)
68: {
69: PetscFunctionBegin;
72: PetscTryMethod(pc, "PCDeflationSetLevels_C", (PC, PetscInt, PetscInt), (pc, 0, max));
73: PetscFunctionReturn(PETSC_SUCCESS);
74: }
76: static PetscErrorCode PCDeflationSetReductionFactor_Deflation(PC pc, PetscInt red)
77: {
78: PC_Deflation *def = (PC_Deflation *)pc->data;
80: PetscFunctionBegin;
81: def->reductionfact = red;
82: PetscFunctionReturn(PETSC_SUCCESS);
83: }
85: /*@
86: PCDeflationSetReductionFactor - Set reduction factor for the `PCDEFLATION`
88: Logically Collective
90: Input Parameters:
91: + pc - the preconditioner context
92: - red - reduction factor (or `PETSC_DETERMINE`)
94: Options Database Key:
95: . -pc_deflation_reduction_factor <\-1> - reduction factor on bottom level coarse problem for `PCDEFLATION`
97: Note:
98: Default is computed based on the size of the coarse problem.
100: Level: intermediate
102: .seealso: [](ch_ksp), `PCTELESCOPE`, `PCDEFLATION`, `PCDeflationSetLevels()`
103: @*/
104: PetscErrorCode PCDeflationSetReductionFactor(PC pc, PetscInt red)
105: {
106: PetscFunctionBegin;
109: PetscTryMethod(pc, "PCDeflationSetReductionFactor_C", (PC, PetscInt), (pc, red));
110: PetscFunctionReturn(PETSC_SUCCESS);
111: }
113: static PetscErrorCode PCDeflationSetCorrectionFactor_Deflation(PC pc, PetscScalar fact)
114: {
115: PC_Deflation *def = (PC_Deflation *)pc->data;
117: PetscFunctionBegin;
118: /* TODO PETSC_DETERMINE -> compute max eigenvalue with power method */
119: def->correct = PETSC_TRUE;
120: def->correctfact = fact;
121: if (def->correctfact == 0.0) def->correct = PETSC_FALSE;
122: PetscFunctionReturn(PETSC_SUCCESS);
123: }
125: /*@
126: PCDeflationSetCorrectionFactor - Set coarse problem correction factor.
127: The preconditioner becomes P*M^{-1} + fact*Q.
129: Logically Collective
131: Input Parameters:
132: + pc - the preconditioner context
133: - fact - correction factor
135: Options Database Keys:
136: + -pc_deflation_correction <false> - if true apply coarse problem correction
137: - -pc_deflation_correction_factor <1.0> - sets coarse problem correction factor
139: Note:
140: Any non-zero fact enables the coarse problem correction.
142: Level: intermediate
144: .seealso: [](ch_ksp), `PCDEFLATION`, `PCDeflationSetLevels()`, `PCDeflationSetReductionFactor()`
145: @*/
146: PetscErrorCode PCDeflationSetCorrectionFactor(PC pc, PetscScalar fact)
147: {
148: PetscFunctionBegin;
151: PetscTryMethod(pc, "PCDeflationSetCorrectionFactor_C", (PC, PetscScalar), (pc, fact));
152: PetscFunctionReturn(PETSC_SUCCESS);
153: }
155: static PetscErrorCode PCDeflationSetSpaceToCompute_Deflation(PC pc, PCDeflationSpaceType type, PetscInt size)
156: {
157: PC_Deflation *def = (PC_Deflation *)pc->data;
159: PetscFunctionBegin;
160: if (type) def->spacetype = type;
161: if (size > 0) def->spacesize = size;
162: PetscFunctionReturn(PETSC_SUCCESS);
163: }
165: /*@
166: PCDeflationSetSpaceToCompute - Set deflation space type and size to compute.
168: Logically Collective
170: Input Parameters:
171: + pc - the preconditioner context
172: . type - deflation space type to compute (or `PETSC_IGNORE`)
173: - size - size of the space to compute (or `PETSC_DEFAULT`)
175: Options Database Keys:
176: + -pc_deflation_compute_space <haar> - compute `PCDeflationSpaceType` deflation space
177: - -pc_deflation_compute_space_size <1> - size of the deflation space
179: Notes:
180: For wavelet-based deflation, size represents number of levels.
182: The deflation space is computed in `PCSetUp()`.
184: Level: intermediate
186: .seealso: [](ch_ksp), `PCDeflationSetLevels()`, `PCDEFLATION`
187: @*/
188: PetscErrorCode PCDeflationSetSpaceToCompute(PC pc, PCDeflationSpaceType type, PetscInt size)
189: {
190: PetscFunctionBegin;
194: PetscTryMethod(pc, "PCDeflationSetSpaceToCompute_C", (PC, PCDeflationSpaceType, PetscInt), (pc, type, size));
195: PetscFunctionReturn(PETSC_SUCCESS);
196: }
198: static PetscErrorCode PCDeflationSetSpace_Deflation(PC pc, Mat W, PetscBool transpose)
199: {
200: PC_Deflation *def = (PC_Deflation *)pc->data;
202: PetscFunctionBegin;
203: /* possibly allows W' = Wt (which is valid but not tested) */
204: PetscCall(PetscObjectReference((PetscObject)W));
205: if (transpose) {
206: PetscCall(MatDestroy(&def->Wt));
207: def->Wt = W;
208: } else {
209: PetscCall(MatDestroy(&def->W));
210: def->W = W;
211: }
212: PetscFunctionReturn(PETSC_SUCCESS);
213: }
215: /*@
216: PCDeflationSetSpace - Set the deflation space matrix (or its (Hermitian) transpose).
218: Logically Collective
220: Input Parameters:
221: + pc - the preconditioner context
222: . W - deflation matrix
223: - transpose - indicates that W is an explicit transpose of the deflation matrix
225: Level: intermediate
227: Notes:
228: Setting W as a multipliplicative `MATCOMPOSITE` enables use of the multilevel
229: deflation. If W = W0*W1*W2*...*Wn, W0 is taken as the first deflation space and
230: the coarse problem (W0'*A*W0)^{-1} is again preconditioned by deflation with
231: W1 as the deflation matrix. This repeats until the maximum level set by
232: PCDeflationSetLevels() is reached or there are no more matrices available.
233: If there are matrices left after reaching the maximum level,
234: they are merged into a deflation matrix ...*W{n-1}*Wn.
236: .seealso: [](ch_ksp), `PCDeflationSetLevels()`, `PCDEFLATION`, `PCDeflationSetProjectionNullSpaceMat()`
237: @*/
238: PetscErrorCode PCDeflationSetSpace(PC pc, Mat W, PetscBool transpose)
239: {
240: PetscFunctionBegin;
244: PetscTryMethod(pc, "PCDeflationSetSpace_C", (PC, Mat, PetscBool), (pc, W, transpose));
245: PetscFunctionReturn(PETSC_SUCCESS);
246: }
248: static PetscErrorCode PCDeflationSetProjectionNullSpaceMat_Deflation(PC pc, Mat mat)
249: {
250: PC_Deflation *def = (PC_Deflation *)pc->data;
252: PetscFunctionBegin;
253: PetscCall(PetscObjectReference((PetscObject)mat));
254: PetscCall(MatDestroy(&def->WtA));
255: def->WtA = mat;
256: PetscFunctionReturn(PETSC_SUCCESS);
257: }
259: /*@
260: PCDeflationSetProjectionNullSpaceMat - Set the projection null space matrix (W'*A).
262: Collective
264: Input Parameters:
265: + pc - preconditioner context
266: - mat - projection null space matrix
268: Level: developer
270: .seealso: [](ch_ksp), `PCDEFLATION`, `PCDeflationSetSpace()`
271: @*/
272: PetscErrorCode PCDeflationSetProjectionNullSpaceMat(PC pc, Mat mat)
273: {
274: PetscFunctionBegin;
277: PetscTryMethod(pc, "PCDeflationSetProjectionNullSpaceMat_C", (PC, Mat), (pc, mat));
278: PetscFunctionReturn(PETSC_SUCCESS);
279: }
281: static PetscErrorCode PCDeflationSetCoarseMat_Deflation(PC pc, Mat mat)
282: {
283: PC_Deflation *def = (PC_Deflation *)pc->data;
285: PetscFunctionBegin;
286: PetscCall(PetscObjectReference((PetscObject)mat));
287: PetscCall(MatDestroy(&def->WtAW));
288: def->WtAW = mat;
289: PetscFunctionReturn(PETSC_SUCCESS);
290: }
292: /*@
293: PCDeflationSetCoarseMat - Set the coarse problem `Mat`.
295: Collective
297: Input Parameters:
298: + pc - preconditioner context
299: - mat - coarse problem mat
301: Level: developer
303: .seealso: [](ch_ksp), `PCDEFLATION`, `PCDeflationGetCoarseKSP()`
304: @*/
305: PetscErrorCode PCDeflationSetCoarseMat(PC pc, Mat mat)
306: {
307: PetscFunctionBegin;
310: PetscTryMethod(pc, "PCDeflationSetCoarseMat_C", (PC, Mat), (pc, mat));
311: PetscFunctionReturn(PETSC_SUCCESS);
312: }
314: static PetscErrorCode PCDeflationGetCoarseKSP_Deflation(PC pc, KSP *ksp)
315: {
316: PC_Deflation *def = (PC_Deflation *)pc->data;
318: PetscFunctionBegin;
319: *ksp = def->WtAWinv;
320: PetscFunctionReturn(PETSC_SUCCESS);
321: }
323: /*@
324: PCDeflationGetCoarseKSP - Returns the coarse problem `KSP`.
326: Not Collective
328: Input Parameter:
329: . pc - preconditioner context
331: Output Parameter:
332: . ksp - coarse problem `KSP` context
334: Level: advanced
336: .seealso: [](ch_ksp), `PCDEFLATION`, `PCDeflationSetCoarseMat()`
337: @*/
338: PetscErrorCode PCDeflationGetCoarseKSP(PC pc, KSP *ksp)
339: {
340: PetscFunctionBegin;
342: PetscAssertPointer(ksp, 2);
343: PetscTryMethod(pc, "PCDeflationGetCoarseKSP_C", (PC, KSP *), (pc, ksp));
344: PetscFunctionReturn(PETSC_SUCCESS);
345: }
347: static PetscErrorCode PCDeflationGetPC_Deflation(PC pc, PC *apc)
348: {
349: PC_Deflation *def = (PC_Deflation *)pc->data;
351: PetscFunctionBegin;
352: *apc = def->pc;
353: PetscFunctionReturn(PETSC_SUCCESS);
354: }
356: /*@
357: PCDeflationGetPC - Returns the additional preconditioner M^{-1}.
359: Not Collective
361: Input Parameter:
362: . pc - the preconditioner context
364: Output Parameter:
365: . apc - additional preconditioner
367: Level: advanced
369: .seealso: [](ch_ksp), `PCDEFLATION`, `PCDeflationGetCoarseKSP()`
370: @*/
371: PetscErrorCode PCDeflationGetPC(PC pc, PC *apc)
372: {
373: PetscFunctionBegin;
375: PetscAssertPointer(pc, 1);
376: PetscTryMethod(pc, "PCDeflationGetPC_C", (PC, PC *), (pc, apc));
377: PetscFunctionReturn(PETSC_SUCCESS);
378: }
380: /*
381: x <- x + W*(W'*A*W)^{-1}*W'*r = x + Q*r
382: */
383: static PetscErrorCode PCPreSolve_Deflation(PC pc, KSP ksp, Vec b, Vec x)
384: {
385: PC_Deflation *def = (PC_Deflation *)pc->data;
386: Mat A;
387: Vec r, w1, w2;
388: PetscBool nonzero;
390: PetscFunctionBegin;
391: w1 = def->workcoarse[0];
392: w2 = def->workcoarse[1];
393: r = def->work;
394: PetscCall(PCGetOperators(pc, NULL, &A));
396: PetscCall(KSPGetInitialGuessNonzero(ksp, &nonzero));
397: PetscCall(KSPSetInitialGuessNonzero(ksp, PETSC_TRUE));
398: if (nonzero) {
399: PetscCall(MatMult(A, x, r)); /* r <- b - Ax */
400: PetscCall(VecAYPX(r, -1.0, b));
401: } else {
402: PetscCall(VecCopy(b, r)); /* r <- b (x is 0) */
403: }
405: if (def->Wt) {
406: PetscCall(MatMult(def->Wt, r, w1)); /* w1 <- W'*r */
407: } else {
408: PetscCall(MatMultHermitianTranspose(def->W, r, w1)); /* w1 <- W'*r */
409: }
410: PetscCall(KSPSolve(def->WtAWinv, w1, w2)); /* w2 <- (W'*A*W)^{-1}*w1 */
411: PetscCall(MatMult(def->W, w2, r)); /* r <- W*w2 */
412: PetscCall(VecAYPX(x, 1.0, r));
413: PetscFunctionReturn(PETSC_SUCCESS);
414: }
416: /*
417: if (def->correct) {
418: z <- M^{-1}r - W*(W'*A*W)^{-1}*(W'*A*M^{-1}r - l*W'*r) = (P*M^{-1} + l*Q)*r
419: } else {
420: z <- M^{-1}*r - W*(W'*A*W)^{-1}*W'*A*M{-1}*r = P*M^{-1}*r
421: }
422: */
423: static PetscErrorCode PCApply_Deflation(PC pc, Vec r, Vec z)
424: {
425: PC_Deflation *def = (PC_Deflation *)pc->data;
426: Mat A;
427: Vec u, w1, w2;
429: PetscFunctionBegin;
430: w1 = def->workcoarse[0];
431: w2 = def->workcoarse[1];
432: u = def->work;
433: PetscCall(PCGetOperators(pc, NULL, &A));
435: PetscCall(PCApply(def->pc, r, z)); /* z <- M^{-1}*r */
436: if (!def->init) {
437: PetscCall(MatMult(def->WtA, z, w1)); /* w1 <- W'*A*z */
438: if (def->correct) {
439: if (def->Wt) {
440: PetscCall(MatMult(def->Wt, r, w2)); /* w2 <- W'*r */
441: } else {
442: PetscCall(MatMultHermitianTranspose(def->W, r, w2)); /* w2 <- W'*r */
443: }
444: PetscCall(VecAXPY(w1, -1.0 * def->correctfact, w2)); /* w1 <- w1 - l*w2 */
445: }
446: PetscCall(KSPSolve(def->WtAWinv, w1, w2)); /* w2 <- (W'*A*W)^{-1}*w1 */
447: PetscCall(MatMult(def->W, w2, u)); /* u <- W*w2 */
448: PetscCall(VecAXPY(z, -1.0, u)); /* z <- z - u */
449: }
450: PetscFunctionReturn(PETSC_SUCCESS);
451: }
453: static PetscErrorCode PCSetUp_Deflation(PC pc)
454: {
455: PC_Deflation *def = (PC_Deflation *)pc->data;
456: DM dm;
457: KSP innerksp;
458: PC pcinner;
459: Mat Amat, nextDef = NULL, *mats;
460: PetscInt i, m, red, size;
461: PetscMPIInt commsize;
462: PetscBool match, flgspd, isset, transp = PETSC_FALSE;
463: MatCompositeType ctype;
464: MPI_Comm comm;
465: char prefix[128] = "";
467: PetscFunctionBegin;
468: if (pc->setupcalled) PetscFunctionReturn(PETSC_SUCCESS);
469: PetscCall(PetscObjectGetComm((PetscObject)pc, &comm));
470: PetscCall(PCGetOperators(pc, NULL, &Amat));
471: if (!def->lvl && !def->prefix) PetscCall(PCGetOptionsPrefix(pc, &def->prefix));
472: if (def->lvl) PetscCall(PetscSNPrintf(prefix, sizeof(prefix), "%" PetscInt_FMT "_", def->lvl));
474: /* compute a deflation space */
475: if (def->W || def->Wt) {
476: def->spacetype = PC_DEFLATION_SPACE_USER;
477: } else {
478: PetscCall(PCDeflationComputeSpace(pc));
479: }
481: /* nested deflation */
482: if (def->W) {
483: PetscCall(PetscObjectTypeCompare((PetscObject)def->W, MATCOMPOSITE, &match));
484: if (match) {
485: PetscCall(MatCompositeGetType(def->W, &ctype));
486: PetscCall(MatCompositeGetNumberMat(def->W, &size));
487: }
488: } else {
489: PetscCall(MatCreateHermitianTranspose(def->Wt, &def->W));
490: PetscCall(PetscObjectTypeCompare((PetscObject)def->Wt, MATCOMPOSITE, &match));
491: if (match) {
492: PetscCall(MatCompositeGetType(def->Wt, &ctype));
493: PetscCall(MatCompositeGetNumberMat(def->Wt, &size));
494: }
495: transp = PETSC_TRUE;
496: }
497: if (match && ctype == MAT_COMPOSITE_MULTIPLICATIVE) {
498: if (!transp) {
499: if (def->lvl < def->maxlvl) {
500: PetscCall(PetscMalloc1(size, &mats));
501: for (i = 0; i < size; i++) PetscCall(MatCompositeGetMat(def->W, i, &mats[i]));
502: size -= 1;
503: PetscCall(MatDestroy(&def->W));
504: def->W = mats[size];
505: PetscCall(PetscObjectReference((PetscObject)mats[size]));
506: if (size > 1) {
507: PetscCall(MatCreateComposite(comm, size, mats, &nextDef));
508: PetscCall(MatCompositeSetType(nextDef, MAT_COMPOSITE_MULTIPLICATIVE));
509: } else {
510: nextDef = mats[0];
511: PetscCall(PetscObjectReference((PetscObject)mats[0]));
512: }
513: PetscCall(PetscFree(mats));
514: } else {
515: /* TODO test merge side performance */
516: /* PetscCall(MatCompositeSetMergeType(def->W,MAT_COMPOSITE_MERGE_LEFT)); */
517: PetscCall(MatCompositeMerge(def->W));
518: }
519: } else {
520: if (def->lvl < def->maxlvl) {
521: PetscCall(PetscMalloc1(size, &mats));
522: for (i = 0; i < size; i++) PetscCall(MatCompositeGetMat(def->Wt, i, &mats[i]));
523: size -= 1;
524: PetscCall(MatDestroy(&def->Wt));
525: def->Wt = mats[0];
526: PetscCall(PetscObjectReference((PetscObject)mats[0]));
527: if (size > 1) {
528: PetscCall(MatCreateComposite(comm, size, &mats[1], &nextDef));
529: PetscCall(MatCompositeSetType(nextDef, MAT_COMPOSITE_MULTIPLICATIVE));
530: } else {
531: nextDef = mats[1];
532: PetscCall(PetscObjectReference((PetscObject)mats[1]));
533: }
534: PetscCall(PetscFree(mats));
535: } else {
536: /* PetscCall(MatCompositeSetMergeType(def->W,MAT_COMPOSITE_MERGE_LEFT)); */
537: PetscCall(MatCompositeMerge(def->Wt));
538: }
539: }
540: }
542: if (transp) {
543: PetscCall(MatDestroy(&def->W));
544: PetscCall(MatHermitianTranspose(def->Wt, MAT_INITIAL_MATRIX, &def->W));
545: }
547: /* assemble WtA */
548: if (!def->WtA) {
549: if (def->Wt) {
550: PetscCall(MatMatMult(def->Wt, Amat, MAT_INITIAL_MATRIX, PETSC_CURRENT, &def->WtA));
551: } else {
552: #if defined(PETSC_USE_COMPLEX)
553: PetscCall(MatHermitianTranspose(def->W, MAT_INITIAL_MATRIX, &def->Wt));
554: PetscCall(MatMatMult(def->Wt, Amat, MAT_INITIAL_MATRIX, PETSC_CURRENT, &def->WtA));
555: #else
556: PetscCall(MatTransposeMatMult(def->W, Amat, MAT_INITIAL_MATRIX, PETSC_CURRENT, &def->WtA));
557: #endif
558: }
559: }
560: /* setup coarse problem */
561: if (!def->WtAWinv) {
562: PetscCall(MatGetSize(def->W, NULL, &m));
563: if (!def->WtAW) {
564: PetscCall(MatMatMult(def->WtA, def->W, MAT_INITIAL_MATRIX, PETSC_CURRENT, &def->WtAW));
565: /* TODO create MatInheritOption(Mat,MatOption) */
566: PetscCall(MatIsSPDKnown(Amat, &isset, &flgspd));
567: if (isset) PetscCall(MatSetOption(def->WtAW, MAT_SPD, flgspd));
568: if (PetscDefined(USE_DEBUG)) {
569: /* Check columns of W are not in kernel of A */
570: PetscReal *norms;
572: PetscCall(PetscMalloc1(m, &norms));
573: PetscCall(MatGetColumnNorms(def->WtAW, NORM_INFINITY, norms));
574: for (i = 0; i < m; i++) PetscCheck(norms[i] > 100 * PETSC_MACHINE_EPSILON, PetscObjectComm((PetscObject)def->WtAW), PETSC_ERR_SUP, "Column %" PetscInt_FMT " of W is in kernel of A.", i);
575: PetscCall(PetscFree(norms));
576: }
577: } else PetscCall(MatIsSPDKnown(def->WtAW, &isset, &flgspd));
579: /* TODO use MATINV ? */
580: PetscCall(KSPCreate(comm, &def->WtAWinv));
581: PetscCall(KSPSetNestLevel(def->WtAWinv, pc->kspnestlevel));
582: PetscCall(KSPSetOperators(def->WtAWinv, def->WtAW, def->WtAW));
583: PetscCall(KSPGetPC(def->WtAWinv, &pcinner));
584: /* Setup KSP and PC */
585: if (nextDef) { /* next level for multilevel deflation */
586: innerksp = def->WtAWinv;
587: /* set default KSPtype */
588: if (!def->ksptype) {
589: def->ksptype = KSPFGMRES;
590: if (isset && flgspd) { /* SPD system */
591: def->ksptype = KSPFCG;
592: }
593: }
594: PetscCall(KSPSetType(innerksp, def->ksptype)); /* TODO iherit from KSP + tolerances */
595: PetscCall(PCSetType(pcinner, PCDEFLATION)); /* TODO create coarse preconditinoner M_c = WtMW ? */
596: PetscCall(PCDeflationSetSpace(pcinner, nextDef, transp));
597: PetscCall(PCDeflationSetLevels_Deflation(pcinner, def->lvl + 1, def->maxlvl));
598: /* inherit options */
599: if (def->prefix) ((PC_Deflation *)pcinner->data)->prefix = def->prefix;
600: ((PC_Deflation *)pcinner->data)->init = def->init;
601: ((PC_Deflation *)pcinner->data)->ksptype = def->ksptype;
602: ((PC_Deflation *)pcinner->data)->correct = def->correct;
603: ((PC_Deflation *)pcinner->data)->correctfact = def->correctfact;
604: ((PC_Deflation *)pcinner->data)->reductionfact = def->reductionfact;
605: PetscCall(MatDestroy(&nextDef));
606: } else { /* the last level */
607: PetscCall(KSPSetType(def->WtAWinv, KSPPREONLY));
608: PetscCall(PCSetType(pcinner, PCTELESCOPE));
609: /* do not overwrite PCTELESCOPE */
610: if (def->prefix) PetscCall(KSPSetOptionsPrefix(def->WtAWinv, def->prefix));
611: PetscCall(KSPAppendOptionsPrefix(def->WtAWinv, "deflation_tel_"));
612: PetscCall(PCSetFromOptions(pcinner));
613: PetscCall(PetscObjectTypeCompare((PetscObject)pcinner, PCTELESCOPE, &match));
614: PetscCheck(match, comm, PETSC_ERR_SUP, "User can not overwrite PCTELESCOPE on bottom level, use reduction factor = 1 instead.");
615: /* Reduction factor choice */
616: red = def->reductionfact;
617: if (red < 0) {
618: PetscCallMPI(MPI_Comm_size(comm, &commsize));
619: red = PetscCeilInt(commsize, PetscCeilInt(m, commsize));
620: PetscCall(PetscObjectTypeCompareAny((PetscObject)def->WtAW, &match, MATSEQDENSE, MATMPIDENSE, MATDENSE, ""));
621: if (match) red = commsize;
622: PetscCall(PetscInfo(pc, "Auto choosing reduction factor %" PetscInt_FMT "\n", red));
623: }
624: PetscCall(PCTelescopeSetReductionFactor(pcinner, red));
625: PetscCall(PCSetUp(pcinner));
626: PetscCall(PCTelescopeGetKSP(pcinner, &innerksp));
627: if (innerksp) {
628: PetscCall(KSPGetPC(innerksp, &pcinner));
629: PetscCall(PCSetType(pcinner, PCLU));
630: #if defined(PETSC_HAVE_SUPERLU)
631: PetscCall(MatGetFactorAvailable(def->WtAW, MATSOLVERSUPERLU, MAT_FACTOR_LU, &match));
632: if (match) PetscCall(PCFactorSetMatSolverType(pcinner, MATSOLVERSUPERLU));
633: #endif
634: #if defined(PETSC_HAVE_SUPERLU_DIST)
635: PetscCall(MatGetFactorAvailable(def->WtAW, MATSOLVERSUPERLU_DIST, MAT_FACTOR_LU, &match));
636: if (match) PetscCall(PCFactorSetMatSolverType(pcinner, MATSOLVERSUPERLU_DIST));
637: #endif
638: }
639: }
641: if (innerksp) {
642: if (def->prefix) {
643: PetscCall(KSPSetOptionsPrefix(innerksp, def->prefix));
644: PetscCall(KSPAppendOptionsPrefix(innerksp, "deflation_"));
645: } else {
646: PetscCall(KSPSetOptionsPrefix(innerksp, "deflation_"));
647: }
648: PetscCall(KSPAppendOptionsPrefix(innerksp, prefix));
649: PetscCall(KSPSetFromOptions(innerksp));
650: PetscCall(KSPSetUp(innerksp));
651: }
652: }
653: PetscCall(KSPSetFromOptions(def->WtAWinv));
654: PetscCall(KSPSetUp(def->WtAWinv));
656: /* create preconditioner */
657: if (!def->pc) {
658: PetscCall(PCCreate(comm, &def->pc));
659: PetscCall(PCSetOperators(def->pc, Amat, Amat));
660: PetscCall(PCSetType(def->pc, PCNONE));
661: if (def->prefix) PetscCall(PCSetOptionsPrefix(def->pc, def->prefix));
662: PetscCall(PCAppendOptionsPrefix(def->pc, "deflation_"));
663: PetscCall(PCAppendOptionsPrefix(def->pc, prefix));
664: PetscCall(PCAppendOptionsPrefix(def->pc, "pc_"));
665: PetscCall(PCGetDM(pc, &dm));
666: PetscCall(PCSetDM(def->pc, dm));
667: PetscCall(PCSetFromOptions(def->pc));
668: PetscCall(PCSetUp(def->pc));
669: }
671: /* create work vecs */
672: PetscCall(MatCreateVecs(Amat, NULL, &def->work));
673: PetscCall(KSPCreateVecs(def->WtAWinv, 2, &def->workcoarse, 0, NULL));
674: PetscFunctionReturn(PETSC_SUCCESS);
675: }
677: static PetscErrorCode PCReset_Deflation(PC pc)
678: {
679: PC_Deflation *def = (PC_Deflation *)pc->data;
681: PetscFunctionBegin;
682: PetscCall(VecDestroy(&def->work));
683: PetscCall(VecDestroyVecs(2, &def->workcoarse));
684: PetscCall(MatDestroy(&def->W));
685: PetscCall(MatDestroy(&def->Wt));
686: PetscCall(MatDestroy(&def->WtA));
687: PetscCall(MatDestroy(&def->WtAW));
688: PetscCall(KSPDestroy(&def->WtAWinv));
689: PetscCall(PCDestroy(&def->pc));
690: PetscFunctionReturn(PETSC_SUCCESS);
691: }
693: static PetscErrorCode PCDestroy_Deflation(PC pc)
694: {
695: PetscFunctionBegin;
696: PetscCall(PCReset_Deflation(pc));
697: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetInitOnly_C", NULL));
698: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetLevels_C", NULL));
699: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetReductionFactor_C", NULL));
700: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetCorrectionFactor_C", NULL));
701: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetSpaceToCompute_C", NULL));
702: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetSpace_C", NULL));
703: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetProjectionNullSpaceMat_C", NULL));
704: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetCoarseMat_C", NULL));
705: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationGetCoarseKSP_C", NULL));
706: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationGetPC_C", NULL));
707: PetscCall(PetscFree(pc->data));
708: PetscFunctionReturn(PETSC_SUCCESS);
709: }
711: static PetscErrorCode PCView_Deflation(PC pc, PetscViewer viewer)
712: {
713: PC_Deflation *def = (PC_Deflation *)pc->data;
714: PetscInt its;
715: PetscBool iascii;
717: PetscFunctionBegin;
718: PetscCall(PetscObjectTypeCompare((PetscObject)viewer, PETSCVIEWERASCII, &iascii));
719: if (iascii) {
720: if (def->correct) PetscCall(PetscViewerASCIIPrintf(viewer, "using CP correction, factor = %g+%gi\n", (double)PetscRealPart(def->correctfact), (double)PetscImaginaryPart(def->correctfact)));
721: if (!def->lvl) PetscCall(PetscViewerASCIIPrintf(viewer, "deflation space type: %s\n", PCDeflationSpaceTypes[def->spacetype]));
723: PetscCall(PetscViewerASCIIPrintf(viewer, "--- Additional PC:\n"));
724: PetscCall(PetscViewerASCIIPushTab(viewer));
725: PetscCall(PCView(def->pc, viewer));
726: PetscCall(PetscViewerASCIIPopTab(viewer));
728: PetscCall(PetscViewerASCIIPrintf(viewer, "--- Coarse problem solver:\n"));
729: PetscCall(PetscViewerASCIIPushTab(viewer));
730: PetscCall(KSPGetTotalIterations(def->WtAWinv, &its));
731: PetscCall(PetscViewerASCIIPrintf(viewer, "total number of iterations: %" PetscInt_FMT "\n", its));
732: PetscCall(KSPView(def->WtAWinv, viewer));
733: PetscCall(PetscViewerASCIIPopTab(viewer));
734: }
735: PetscFunctionReturn(PETSC_SUCCESS);
736: }
738: static PetscErrorCode PCSetFromOptions_Deflation(PC pc, PetscOptionItems *PetscOptionsObject)
739: {
740: PC_Deflation *def = (PC_Deflation *)pc->data;
742: PetscFunctionBegin;
743: PetscOptionsHeadBegin(PetscOptionsObject, "Deflation options");
744: PetscCall(PetscOptionsBool("-pc_deflation_init_only", "Use only initialization step - Initdef", "PCDeflationSetInitOnly", def->init, &def->init, NULL));
745: PetscCall(PetscOptionsInt("-pc_deflation_levels", "Maximum of deflation levels", "PCDeflationSetLevels", def->maxlvl, &def->maxlvl, NULL));
746: PetscCall(PetscOptionsInt("-pc_deflation_reduction_factor", "Reduction factor for coarse problem solution using PCTELESCOPE", "PCDeflationSetReductionFactor", def->reductionfact, &def->reductionfact, NULL));
747: PetscCall(PetscOptionsBool("-pc_deflation_correction", "Add coarse problem correction Q to P", "PCDeflationSetCorrectionFactor", def->correct, &def->correct, NULL));
748: PetscCall(PetscOptionsScalar("-pc_deflation_correction_factor", "Set multiple of Q to use as coarse problem correction", "PCDeflationSetCorrectionFactor", def->correctfact, &def->correctfact, NULL));
749: PetscCall(PetscOptionsEnum("-pc_deflation_compute_space", "Compute deflation space", "PCDeflationSetSpace", PCDeflationSpaceTypes, (PetscEnum)def->spacetype, (PetscEnum *)&def->spacetype, NULL));
750: PetscCall(PetscOptionsInt("-pc_deflation_compute_space_size", "Set size of the deflation space to compute", "PCDeflationSetSpace", def->spacesize, &def->spacesize, NULL));
751: PetscCall(PetscOptionsBool("-pc_deflation_space_extend", "Extend deflation space instead of truncating (wavelets)", "PCDeflation", def->extendsp, &def->extendsp, NULL));
752: PetscOptionsHeadEnd();
753: PetscFunctionReturn(PETSC_SUCCESS);
754: }
756: /*MC
757: PCDEFLATION - Deflation preconditioner shifts (deflates) part of the spectrum to zero or to a predefined value.
759: Options Database Keys:
760: + -pc_deflation_init_only <false> - if true computes only the special guess
761: . -pc_deflation_max_lvl <0> - maximum number of levels for multilevel deflation
762: . -pc_deflation_reduction_factor <\-1> - reduction factor on bottom level coarse problem for PCTELESCOPE (default based on the size of the coarse problem)
763: . -pc_deflation_correction <false> - if true apply coarse problem correction
764: . -pc_deflation_correction_factor <1.0> - sets coarse problem correction factor
765: . -pc_deflation_compute_space <haar> - compute PCDeflationSpaceType deflation space
766: - -pc_deflation_compute_space_size <1> - size of the deflation space (corresponds to number of levels for wavelet-based deflation)
768: Notes:
769: Given a (complex - transpose is always Hermitian) full rank deflation matrix W, the deflation (introduced in [1,2])
770: preconditioner uses projections Q = W*(W'*A*W)^{-1}*W' and P = I - Q*A, where A is pmat.
772: The deflation computes initial guess x0 = x_{-1} - Q*r_{-1}, which is the solution on the deflation space.
773: If `PCDeflationSetInitOnly()` or -pc_deflation_init_only is set to `PETSC_TRUE` (InitDef scheme), the application of the
774: preconditioner consists only of application of the additional preconditioner M^{-1}. Otherwise, the preconditioner
775: application consists of P*M^{-1} + factor*Q. The first part of the preconditioner (PM^{-1}) shifts some eigenvalues
776: to zero while the addition of the coarse problem correction (factor*Q) makes the preconditioner to shift some
777: eigenvalues to the given factor. The InitDef scheme is recommended for deflation using high accuracy estimates
778: of eigenvectors of A when it exhibits similar convergence to the full deflation but is cheaper.
780: The deflation matrix is by default automatically computed. The type of deflation matrix and its size to compute can
781: be controlled by `PCDeflationSetSpaceToCompute()` or -pc_deflation_compute_space and -pc_deflation_compute_space_size.
782: User can set an arbitrary deflation space matrix with `PCDeflationSetSpace()`. If the deflation matrix
783: is a multiplicative `MATCOMPOSITE`, a multilevel deflation [3] is used. The first matrix in the composite is used as the
784: deflation matrix, and the coarse problem (W'*A*W)^{-1} is solved by `KSPFCG` (if A is `MAT_SPD`) or `KSPFGMRES` preconditioned
785: by deflation with deflation matrix being the next matrix in the `MATCOMPOSITE`. This scheme repeats until the maximum
786: level is reached or there are no more matrices. If the maximum level is reached, the remaining matrices are merged
787: (multiplied) to create the last deflation matrix. The maximum level defaults to 0 and can be set by
788: `PCDeflationSetLevels()` or by -pc_deflation_levels.
790: The coarse problem `KSP` can be controlled from the command line with prefix -deflation_ for the first level and -deflation_[lvl-1]
791: from the second level onward. You can also use
792: `PCDeflationGetCoarseKSP()` to control it from code. The bottom level KSP defaults to
793: `KSPPREONLY` with `PCLU` direct solver (`MATSOLVERSUPERLU`/`MATSOLVERSUPERLU_DIST` if available) wrapped into `PCTELESCOPE`.
794: For convenience, the reduction factor can be set by `PCDeflationSetReductionFactor()`
795: or -pc_deflation_recduction_factor. The default is chosen heuristically based on the coarse problem size.
797: The additional preconditioner can be controlled from command line with prefix -deflation_[lvl]_pc (same rules used for
798: coarse problem `KSP` apply for [lvl]_ part of prefix), e.g., -deflation_1_pc_pc_type bjacobi. You can also use
799: `PCDeflationGetPC()` to control the additional preconditioner from code. It defaults to `PCNONE`.
801: The coarse problem correction term (factor*Q) can be turned on by -pc_deflation_correction and the factor value can
802: be set by pc_deflation_correction_factor or by `PCDeflationSetCorrectionFactor()`. The coarse problem can
803: significantly improve convergence when the deflation coarse problem is not solved with high enough accuracy. We
804: recommend setting factor to some eigenvalue, e.g., the largest eigenvalue so that the preconditioner does not create
805: an isolated eigenvalue.
807: The options are automatically inherited from the previous deflation level.
809: The preconditioner supports `KSPMonitorDynamicTolerance()`. This is useful for the multilevel scheme for which we also
810: recommend limiting the number of iterations for the coarse problems.
812: See section 3 of [4] for additional references and description of the algorithm when used for conjugate gradients.
813: Section 4 describes some possible choices for the deflation space.
815: Contributed by Jakub Kruzik (PERMON), Institute of Geonics of the Czech
816: Academy of Sciences and VSB - TU Ostrava.
818: Developed from PERMON code used in [4] while on a research stay with
819: Prof. Reinhard Nabben at the Institute of Mathematics, TU Berlin.
821: References:
822: + * - A. Nicolaides. "Deflation of conjugate gradients with applications to boundary value problems", SIAM J. Numer. Anal. 24.2, 1987.
823: . * - Z. Dostal. "Conjugate gradient method with preconditioning by projector", Int J. Comput. Math. 23.3-4, 1988.
824: . * - Y. A. Erlangga and R. Nabben. "Multilevel Projection-Based Nested Krylov Iteration for Boundary Value Problems", SIAM J. Sci. Comput. 30.3, 2008.
825: - * - J. Kruzik "Implementation of the Deflated Variants of the Conjugate Gradient Method", Master's thesis, VSB-TUO, 2018 - http://dspace5.vsb.cz/bitstream/handle/10084/130303/KRU0097_USP_N2658_2612T078_2018.pdf
827: Level: intermediate
829: .seealso: [](ch_ksp), `PCCreate()`, `PCSetType()`, `PCType`, `PC`,
830: `PCDeflationSetInitOnly()`, `PCDeflationSetLevels()`, `PCDeflationSetReductionFactor()`,
831: `PCDeflationSetCorrectionFactor()`, `PCDeflationSetSpaceToCompute()`,
832: `PCDeflationSetSpace()`, `PCDeflationSpaceType`, `PCDeflationSetProjectionNullSpaceMat()`,
833: `PCDeflationSetCoarseMat()`, `PCDeflationGetCoarseKSP()`, `PCDeflationGetPC()`
834: M*/
836: PETSC_EXTERN PetscErrorCode PCCreate_Deflation(PC pc)
837: {
838: PC_Deflation *def;
840: PetscFunctionBegin;
841: PetscCall(PetscNew(&def));
842: pc->data = (void *)def;
844: def->init = PETSC_FALSE;
845: def->correct = PETSC_FALSE;
846: def->correctfact = 1.0;
847: def->reductionfact = -1;
848: def->spacetype = PC_DEFLATION_SPACE_HAAR;
849: def->spacesize = 1;
850: def->extendsp = PETSC_FALSE;
851: def->lvl = 0;
852: def->maxlvl = 0;
853: def->W = NULL;
854: def->Wt = NULL;
856: pc->ops->apply = PCApply_Deflation;
857: pc->ops->presolve = PCPreSolve_Deflation;
858: pc->ops->setup = PCSetUp_Deflation;
859: pc->ops->reset = PCReset_Deflation;
860: pc->ops->destroy = PCDestroy_Deflation;
861: pc->ops->setfromoptions = PCSetFromOptions_Deflation;
862: pc->ops->view = PCView_Deflation;
864: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetInitOnly_C", PCDeflationSetInitOnly_Deflation));
865: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetLevels_C", PCDeflationSetLevels_Deflation));
866: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetReductionFactor_C", PCDeflationSetReductionFactor_Deflation));
867: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetCorrectionFactor_C", PCDeflationSetCorrectionFactor_Deflation));
868: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetSpaceToCompute_C", PCDeflationSetSpaceToCompute_Deflation));
869: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetSpace_C", PCDeflationSetSpace_Deflation));
870: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetProjectionNullSpaceMat_C", PCDeflationSetProjectionNullSpaceMat_Deflation));
871: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationSetCoarseMat_C", PCDeflationSetCoarseMat_Deflation));
872: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationGetCoarseKSP_C", PCDeflationGetCoarseKSP_Deflation));
873: PetscCall(PetscObjectComposeFunction((PetscObject)pc, "PCDeflationGetPC_C", PCDeflationGetPC_Deflation));
874: PetscFunctionReturn(PETSC_SUCCESS);
875: }