Actual source code: cg.c

  1: /*
  2:     This file implements the conjugate gradient method in PETSc as part of
  3:     KSP. You can use this as a starting point for implementing your own
  4:     Krylov method that is not provided with PETSc.

  6:     The following basic routines are required for each Krylov method.
  7:         KSPCreate_XXX()          - Creates the Krylov context
  8:         KSPSetFromOptions_XXX()  - Sets runtime options
  9:         KSPSolve_XXX()           - Runs the Krylov method
 10:         KSPDestroy_XXX()         - Destroys the Krylov context, freeing all
 11:                                    memory it needed
 12:     Here the "_XXX" denotes a particular implementation, in this case
 13:     we use _CG (e.g. KSPCreate_CG, KSPDestroy_CG). These routines
 14:     are actually called via the common user interface routines
 15:     KSPSetType(), KSPSetFromOptions(), KSPSolve(), and KSPDestroy() so the
 16:     application code interface remains identical for all preconditioners.

 18:     Other basic routines for the KSP objects include
 19:         KSPSetUp_XXX()
 20:         KSPView_XXX()            - Prints details of solver being used.

 22:     Detailed Notes:
 23:     By default, this code implements the CG (Conjugate Gradient) method,
 24:     which is valid for real symmetric (and complex Hermitian) positive
 25:     definite matrices. Note that for the complex Hermitian case, the
 26:     VecDot() arguments within the code MUST remain in the order given
 27:     for correct computation of inner products.

 29:     Reference: Hestenes and Steifel, 1952.

 31:     By switching to the indefinite vector inner product, VecTDot(), the
 32:     same code is used for the complex symmetric case as well.  The user
 33:     must call KSPCGSetType(ksp,KSP_CG_SYMMETRIC) or use the option
 34:     -ksp_cg_type symmetric to invoke this variant for the complex case.
 35:     Note, however, that the complex symmetric code is NOT valid for
 36:     all such matrices ... and thus we don't recommend using this method.
 37: */
 38: /*
 39:     cgimpl.h defines the simple data structured used to store information
 40:     related to the type of matrix (e.g. complex symmetric) being solved and
 41:     data used during the optional Lanczos process used to compute eigenvalues
 42: */
 43: #include <../src/ksp/ksp/impls/cg/cgimpl.h>
 44: extern PetscErrorCode KSPComputeExtremeSingularValues_CG(KSP, PetscReal *, PetscReal *);
 45: extern PetscErrorCode KSPComputeEigenvalues_CG(KSP, PetscInt, PetscReal *, PetscReal *, PetscInt *);

 47: static PetscErrorCode KSPCGSetObjectiveTarget_CG(KSP ksp, PetscReal obj_min)
 48: {
 49:   KSP_CG *cg = (KSP_CG *)ksp->data;

 51:   PetscFunctionBegin;
 52:   cg->obj_min = obj_min;
 53:   PetscFunctionReturn(PETSC_SUCCESS);
 54: }

 56: static PetscErrorCode KSPCGSetRadius_CG(KSP ksp, PetscReal radius)
 57: {
 58:   KSP_CG *cg = (KSP_CG *)ksp->data;

 60:   PetscFunctionBegin;
 61:   cg->radius = radius;
 62:   PetscFunctionReturn(PETSC_SUCCESS);
 63: }

 65: static PetscErrorCode KSPCGGetObjFcn_CG(KSP ksp, PetscReal *obj)
 66: {
 67:   KSP_CG *cg = (KSP_CG *)ksp->data;

 69:   PetscFunctionBegin;
 70:   *obj = cg->obj;
 71:   PetscFunctionReturn(PETSC_SUCCESS);
 72: }

 74: /*
 75:      KSPSetUp_CG - Sets up the workspace needed by the CG method.

 77:       This is called once, usually automatically by KSPSolve() or KSPSetUp()
 78:      but can be called directly by KSPSetUp()
 79: */
 80: static PetscErrorCode KSPSetUp_CG(KSP ksp)
 81: {
 82:   KSP_CG  *cgP   = (KSP_CG *)ksp->data;
 83:   PetscInt maxit = ksp->max_it, nwork = 3;

 85:   PetscFunctionBegin;
 86:   /* get work vectors needed by CG */
 87:   if (cgP->singlereduction) nwork += 2;
 88:   PetscCall(KSPSetWorkVecs(ksp, nwork));

 90:   /*
 91:      If user requested computations of eigenvalues then allocate
 92:      work space needed
 93:   */
 94:   if (ksp->calc_sings) {
 95:     PetscCall(PetscFree4(cgP->e, cgP->d, cgP->ee, cgP->dd));
 96:     PetscCall(PetscMalloc4(maxit + 1, &cgP->e, maxit, &cgP->d, maxit, &cgP->ee, maxit, &cgP->dd));

 98:     ksp->ops->computeextremesingularvalues = KSPComputeExtremeSingularValues_CG;
 99:     ksp->ops->computeeigenvalues           = KSPComputeEigenvalues_CG;
100:   }
101:   PetscFunctionReturn(PETSC_SUCCESS);
102: }

104: /*
105:      A macro used in the following KSPSolve_CG and KSPSolve_CG_SingleReduction routines
106: */
107: #define VecXDot(x, y, a) (cg->type == KSP_CG_HERMITIAN ? VecDot(x, y, a) : VecTDot(x, y, a))

109: /*
110:      KSPSolve_CG - This routine actually applies the conjugate gradient method

112:      Note : this routine can be replaced with another one (see below) which implements
113:             another variant of CG.

115:    Input Parameter:
116: .     ksp - the Krylov space object that was set to use conjugate gradient, by, for
117:             example, KSPCreate(MPI_Comm,KSP *ksp); KSPSetType(ksp,KSPCG);
118: */
119: static PetscErrorCode KSPSolve_CG(KSP ksp)
120: {
121:   PetscInt    i, stored_max_it, eigs;
122:   PetscScalar dpi = 0.0, a = 1.0, beta, betaold = 1.0, b = 0, *e = NULL, *d = NULL, dpiold;
123:   PetscReal   dp = 0.0;
124:   PetscReal   r2, norm_p, norm_d, dMp;
125:   Vec         X, B, Z, R, P, W;
126:   KSP_CG     *cg;
127:   Mat         Amat, Pmat;
128:   PetscBool   diagonalscale, testobj;

130:   PetscFunctionBegin;
131:   PetscCall(PCGetDiagonalScale(ksp->pc, &diagonalscale));
132:   PetscCheck(!diagonalscale, PetscObjectComm((PetscObject)ksp), PETSC_ERR_SUP, "Krylov method %s does not support diagonal scaling", ((PetscObject)ksp)->type_name);

134:   cg            = (KSP_CG *)ksp->data;
135:   eigs          = ksp->calc_sings;
136:   stored_max_it = ksp->max_it;
137:   X             = ksp->vec_sol;
138:   B             = ksp->vec_rhs;
139:   R             = ksp->work[0];
140:   Z             = ksp->work[1];
141:   P             = ksp->work[2];
142:   W             = Z;
143:   r2            = PetscSqr(cg->radius);

145:   if (eigs) {
146:     e    = cg->e;
147:     d    = cg->d;
148:     e[0] = 0.0;
149:   }
150:   PetscCall(PCGetOperators(ksp->pc, &Amat, &Pmat));

152:   ksp->its = 0;
153:   if (!ksp->guess_zero) {
154:     PetscCall(KSP_MatMult(ksp, Amat, X, R)); /*    r <- b - Ax                       */

156:     PetscCall(VecAYPX(R, -1.0, B));
157:     if (cg->radius) { /* XXX direction? */
158:       PetscCall(VecNorm(X, NORM_2, &norm_d));
159:       norm_d *= norm_d;
160:     }
161:   } else {
162:     PetscCall(VecCopy(B, R)); /*    r <- b (x is 0)                   */
163:     norm_d = 0.0;
164:   }
165:   /* This may be true only on a subset of MPI ranks; setting it here so it will be detected by the first norm computation below */
166:   PetscCall(VecFlag(R, ksp->reason == KSP_DIVERGED_PC_FAILED));

168:   switch (ksp->normtype) {
169:   case KSP_NORM_PRECONDITIONED:
170:     PetscCall(KSP_PCApply(ksp, R, Z));  /*    z <- Br                           */
171:     PetscCall(VecNorm(Z, NORM_2, &dp)); /*    dp <- z'*z = e'*A'*B'*B*A*e       */
172:     KSPCheckNorm(ksp, dp);
173:     break;
174:   case KSP_NORM_UNPRECONDITIONED:
175:     PetscCall(VecNorm(R, NORM_2, &dp)); /*    dp <- r'*r = e'*A'*A*e            */
176:     KSPCheckNorm(ksp, dp);
177:     break;
178:   case KSP_NORM_NATURAL:
179:     PetscCall(KSP_PCApply(ksp, R, Z)); /*    z <- Br                           */
180:     PetscCall(VecXDot(Z, R, &beta));   /*    beta <- z'*r                      */
181:     KSPCheckDot(ksp, beta);
182:     dp = PetscSqrtReal(PetscAbsScalar(beta)); /*    dp <- r'*z = r'*B*r = e'*A'*B*A*e */
183:     break;
184:   case KSP_NORM_NONE:
185:     dp = 0.0;
186:     break;
187:   default:
188:     SETERRQ(PetscObjectComm((PetscObject)ksp), PETSC_ERR_SUP, "%s", KSPNormTypes[ksp->normtype]);
189:   }

191:   /* Initialize objective function
192:      obj = 1/2 x^T A x - x^T b */
193:   testobj = (PetscBool)(cg->obj_min < 0.0);
194:   PetscCall(VecXDot(R, X, &a));
195:   cg->obj = 0.5 * PetscRealPart(a);
196:   PetscCall(VecXDot(B, X, &a));
197:   cg->obj -= 0.5 * PetscRealPart(a);

199:   if (testobj) PetscCall(PetscInfo(ksp, "it %" PetscInt_FMT " obj %g\n", ksp->its, (double)cg->obj));
200:   PetscCall(KSPLogResidualHistory(ksp, dp));
201:   PetscCall(KSPMonitor(ksp, ksp->its, dp));
202:   ksp->rnorm = dp;

204:   PetscCall((*ksp->converged)(ksp, ksp->its, dp, &ksp->reason, ksp->cnvP)); /* test for convergence */

206:   if (!ksp->reason && testobj && cg->obj <= cg->obj_min) {
207:     PetscCall(PetscInfo(ksp, "converged to objective target minimum\n"));
208:     ksp->reason = KSP_CONVERGED_ATOL;
209:   }

211:   if (ksp->reason) PetscFunctionReturn(PETSC_SUCCESS);

213:   if (ksp->normtype != KSP_NORM_PRECONDITIONED && (ksp->normtype != KSP_NORM_NATURAL)) { PetscCall(KSP_PCApply(ksp, R, Z)); /*     z <- Br                           */ }
214:   if (ksp->normtype != KSP_NORM_NATURAL) {
215:     PetscCall(VecXDot(Z, R, &beta)); /*     beta <- z'*r                      */
216:     KSPCheckDot(ksp, beta);
217:   }

219:   i = 0;
220:   do {
221:     ksp->its = i + 1;
222:     if (beta == 0.0) {
223:       ksp->reason = KSP_CONVERGED_ATOL;
224:       PetscCall(PetscInfo(ksp, "converged due to beta = 0\n"));
225:       break;
226: #if !defined(PETSC_USE_COMPLEX)
227:     } else if ((i > 0) && (beta * betaold < 0.0)) {
228:       PetscCheck(!ksp->errorifnotconverged, PetscObjectComm((PetscObject)ksp), PETSC_ERR_NOT_CONVERGED, "Diverged due to indefinite preconditioner, beta %g, betaold %g", (double)PetscRealPart(beta), (double)PetscRealPart(betaold));
229:       ksp->reason = KSP_DIVERGED_INDEFINITE_PC;
230:       PetscCall(PetscInfo(ksp, "diverging due to indefinite preconditioner\n"));
231:       break;
232: #endif
233:     }
234:     if (!i) {
235:       PetscCall(VecCopy(Z, P)); /*     p <- z                           */
236:       if (cg->radius) {
237:         PetscCall(VecNorm(P, NORM_2, &norm_p));
238:         norm_p *= norm_p;
239:         dMp = 0.0;
240:         if (!ksp->guess_zero) { PetscCall(VecDotRealPart(X, P, &dMp)); }
241:       }
242:       b = 0.0;
243:     } else {
244:       b = beta / betaold;
245:       if (eigs) {
246:         PetscCheck(ksp->max_it == stored_max_it, PetscObjectComm((PetscObject)ksp), PETSC_ERR_SUP, "Can not change maxit AND calculate eigenvalues");
247:         e[i] = PetscSqrtReal(PetscAbsScalar(b)) / a;
248:       }
249:       PetscCall(VecAYPX(P, b, Z)); /*     p <- z + b* p                    */
250:       if (cg->radius) {
251:         PetscCall(VecDotRealPart(X, P, &dMp));
252:         PetscCall(VecNorm(P, NORM_2, &norm_p));
253:         norm_p *= norm_p;
254:       }
255:     }
256:     dpiold = dpi;
257:     PetscCall(KSP_MatMult(ksp, Amat, P, W)); /*     w <- Ap                          */
258:     PetscCall(VecXDot(P, W, &dpi));          /*     dpi <- p'w                       */
259:     KSPCheckDot(ksp, dpi);
260:     betaold = beta;

262:     if ((dpi == 0.0) || ((i > 0) && ((PetscSign(PetscRealPart(dpi)) * PetscSign(PetscRealPart(dpiold))) < 0.0))) {
263:       if (cg->radius) {
264:         a = 0.0;
265:         if (i == 0) {
266:           if (norm_p > 0.0) {
267:             a = PetscSqrtReal(r2 / norm_p);
268:           } else {
269:             PetscCall(VecNorm(R, NORM_2, &dp));
270:             a = cg->radius > dp ? 1.0 : cg->radius / dp;
271:           }
272:         } else if (norm_p > 0.0) {
273:           a = (PetscSqrtReal(dMp * dMp + norm_p * (r2 - norm_d)) - dMp) / norm_p;
274:         }
275:         PetscCall(VecAXPY(X, a, P)); /*     x <- x + ap                      */
276:         cg->obj += PetscRealPart(a * (0.5 * a * dpi - betaold));
277:       }
278:       if (testobj) PetscCall(PetscInfo(ksp, "it %" PetscInt_FMT " N obj %g\n", i + 1, (double)cg->obj));
279:       if (ksp->converged_neg_curve) {
280:         PetscCall(PetscInfo(ksp, "converged due to negative curvature: %g\n", (double)(PetscRealPart(dpi))));
281:         ksp->reason = KSP_CONVERGED_NEG_CURVE;
282:       } else {
283:         PetscCheck(!ksp->errorifnotconverged, PetscObjectComm((PetscObject)ksp), PETSC_ERR_NOT_CONVERGED, "Diverged due to indefinite matrix, dpi %g, dpiold %g", (double)PetscRealPart(dpi), (double)PetscRealPart(dpiold));
284:         ksp->reason = KSP_DIVERGED_INDEFINITE_MAT;
285:         PetscCall(PetscInfo(ksp, "diverging due to indefinite matrix\n"));
286:       }
287:       break;
288:     }
289:     a = beta / dpi; /*     a = beta/p'w                     */
290:     if (eigs) d[i] = PetscSqrtReal(PetscAbsScalar(b)) * e[i] + 1.0 / a;
291:     if (cg->radius) { /* Steihaugh-Toint */
292:       PetscReal norm_dp1 = norm_d + PetscRealPart(a) * (2.0 * dMp + PetscRealPart(a) * norm_p);
293:       if (norm_dp1 > r2) {
294:         ksp->reason = KSP_CONVERGED_STEP_LENGTH;
295:         PetscCall(PetscInfo(ksp, "converged to the trust region radius %g\n", (double)cg->radius));
296:         if (norm_p > 0.0) {
297:           dp = (PetscSqrtReal(dMp * dMp + norm_p * (r2 - norm_d)) - dMp) / norm_p;
298:           PetscCall(VecAXPY(X, dp, P)); /*     x <- x + ap                      */
299:           cg->obj += PetscRealPart(dp * (0.5 * dp * dpi - beta));
300:         }
301:         if (testobj) PetscCall(PetscInfo(ksp, "it %" PetscInt_FMT " R obj %g\n", i + 1, (double)cg->obj));
302:         break;
303:       }
304:     }
305:     PetscCall(VecAXPY(X, a, P));  /*     x <- x + ap                      */
306:     PetscCall(VecAXPY(R, -a, W)); /*     r <- r - aw                      */
307:     if (ksp->normtype == KSP_NORM_PRECONDITIONED && ksp->chknorm < i + 2) {
308:       PetscCall(KSP_PCApply(ksp, R, Z));  /*     z <- Br                          */
309:       PetscCall(VecNorm(Z, NORM_2, &dp)); /*     dp <- z'*z                       */
310:       KSPCheckNorm(ksp, dp);
311:     } else if (ksp->normtype == KSP_NORM_UNPRECONDITIONED && ksp->chknorm < i + 2) {
312:       PetscCall(VecNorm(R, NORM_2, &dp)); /*     dp <- r'*r                       */
313:       KSPCheckNorm(ksp, dp);
314:     } else if (ksp->normtype == KSP_NORM_NATURAL) {
315:       PetscCall(KSP_PCApply(ksp, R, Z)); /*     z <- Br                          */
316:       PetscCall(VecXDot(Z, R, &beta));   /*     beta <- r'*z                     */
317:       KSPCheckDot(ksp, beta);
318:       dp = PetscSqrtReal(PetscAbsScalar(beta));
319:     } else {
320:       dp = 0.0;
321:     }
322:     cg->obj -= PetscRealPart(0.5 * a * betaold);
323:     if (testobj) PetscCall(PetscInfo(ksp, "it %" PetscInt_FMT " obj %g\n", i + 1, (double)cg->obj));

325:     ksp->rnorm = dp;
326:     PetscCall(KSPLogResidualHistory(ksp, dp));
327:     PetscCall(KSPMonitor(ksp, i + 1, dp));
328:     PetscCall((*ksp->converged)(ksp, i + 1, dp, &ksp->reason, ksp->cnvP));

330:     if (!ksp->reason && testobj && cg->obj <= cg->obj_min) {
331:       PetscCall(PetscInfo(ksp, "converged to objective target minimum\n"));
332:       ksp->reason = KSP_CONVERGED_ATOL;
333:     }

335:     if (ksp->reason) break;

337:     if (cg->radius) {
338:       PetscCall(VecNorm(X, NORM_2, &norm_d));
339:       norm_d *= norm_d;
340:     }

342:     if ((ksp->normtype != KSP_NORM_PRECONDITIONED && (ksp->normtype != KSP_NORM_NATURAL)) || (ksp->chknorm >= i + 2)) { PetscCall(KSP_PCApply(ksp, R, Z)); /*     z <- Br                          */ }
343:     if ((ksp->normtype != KSP_NORM_NATURAL) || (ksp->chknorm >= i + 2)) {
344:       PetscCall(VecXDot(Z, R, &beta)); /*     beta <- z'*r                     */
345:       KSPCheckDot(ksp, beta);
346:     }

348:     i++;
349:   } while (i < ksp->max_it);
350:   if (i >= ksp->max_it) ksp->reason = KSP_DIVERGED_ITS;
351:   PetscFunctionReturn(PETSC_SUCCESS);
352: }

354: /*
355:        KSPSolve_CG_SingleReduction

357:        This variant of CG is identical in exact arithmetic to the standard algorithm,
358:        but is rearranged to use only a single reduction stage per iteration, using additional
359:        intermediate vectors.

361:        See KSPCGUseSingleReduction_CG()

363: */
364: static PetscErrorCode KSPSolve_CG_SingleReduction(KSP ksp)
365: {
366:   PetscInt    i, stored_max_it, eigs;
367:   PetscScalar dpi = 0.0, a = 1.0, beta, betaold = 1.0, b = 0, *e = NULL, *d = NULL, delta, dpiold, tmp[2];
368:   PetscReal   dp = 0.0;
369:   Vec         X, B, Z, R, P, S, W, tmpvecs[2];
370:   KSP_CG     *cg;
371:   Mat         Amat, Pmat;
372:   PetscBool   diagonalscale;

374:   PetscFunctionBegin;
375:   PetscCall(PCGetDiagonalScale(ksp->pc, &diagonalscale));
376:   PetscCheck(!diagonalscale, PetscObjectComm((PetscObject)ksp), PETSC_ERR_SUP, "Krylov method %s does not support diagonal scaling", ((PetscObject)ksp)->type_name);

378:   cg            = (KSP_CG *)ksp->data;
379:   eigs          = ksp->calc_sings;
380:   stored_max_it = ksp->max_it;
381:   X             = ksp->vec_sol;
382:   B             = ksp->vec_rhs;
383:   R             = ksp->work[0];
384:   Z             = ksp->work[1];
385:   P             = ksp->work[2];
386:   S             = ksp->work[3];
387:   W             = ksp->work[4];

389:   if (eigs) {
390:     e    = cg->e;
391:     d    = cg->d;
392:     e[0] = 0.0;
393:   }
394:   PetscCall(PCGetOperators(ksp->pc, &Amat, &Pmat));

396:   ksp->its = 0;
397:   if (!ksp->guess_zero) {
398:     PetscCall(KSP_MatMult(ksp, Amat, X, R)); /*    r <- b - Ax                       */
399:     PetscCall(VecAYPX(R, -1.0, B));
400:   } else {
401:     PetscCall(VecCopy(B, R)); /*    r <- b (x is 0)                   */
402:   }

404:   switch (ksp->normtype) {
405:   case KSP_NORM_PRECONDITIONED:
406:     PetscCall(KSP_PCApply(ksp, R, Z));  /*    z <- Br                           */
407:     PetscCall(VecNorm(Z, NORM_2, &dp)); /*    dp <- z'*z = e'*A'*B'*B*A'*e'     */
408:     KSPCheckNorm(ksp, dp);
409:     break;
410:   case KSP_NORM_UNPRECONDITIONED:
411:     PetscCall(VecNorm(R, NORM_2, &dp)); /*    dp <- r'*r = e'*A'*A*e            */
412:     KSPCheckNorm(ksp, dp);
413:     break;
414:   case KSP_NORM_NATURAL:
415:     PetscCall(KSP_PCApply(ksp, R, Z)); /*    z <- Br                           */
416:     PetscCall(KSP_MatMult(ksp, Amat, Z, S));
417:     PetscCall(VecXDot(Z, S, &delta)); /*    delta <- z'*A*z = r'*B*A*B*r      */
418:     PetscCall(VecXDot(Z, R, &beta));  /*    beta <- z'*r                      */
419:     KSPCheckDot(ksp, beta);
420:     dp = PetscSqrtReal(PetscAbsScalar(beta)); /*    dp <- r'*z = r'*B*r = e'*A'*B*A*e */
421:     break;
422:   case KSP_NORM_NONE:
423:     dp = 0.0;
424:     break;
425:   default:
426:     SETERRQ(PetscObjectComm((PetscObject)ksp), PETSC_ERR_SUP, "%s", KSPNormTypes[ksp->normtype]);
427:   }
428:   PetscCall(KSPLogResidualHistory(ksp, dp));
429:   PetscCall(KSPMonitor(ksp, 0, dp));
430:   ksp->rnorm = dp;

432:   PetscCall((*ksp->converged)(ksp, 0, dp, &ksp->reason, ksp->cnvP)); /* test for convergence */
433:   if (ksp->reason) PetscFunctionReturn(PETSC_SUCCESS);

435:   if (ksp->normtype != KSP_NORM_PRECONDITIONED && (ksp->normtype != KSP_NORM_NATURAL)) { PetscCall(KSP_PCApply(ksp, R, Z)); /*    z <- Br                           */ }
436:   if (ksp->normtype != KSP_NORM_NATURAL) {
437:     PetscCall(KSP_MatMult(ksp, Amat, Z, S));
438:     PetscCall(VecXDot(Z, S, &delta)); /*    delta <- z'*A*z = r'*B*A*B*r      */
439:     PetscCall(VecXDot(Z, R, &beta));  /*    beta <- z'*r                      */
440:     KSPCheckDot(ksp, beta);
441:   }

443:   i = 0;
444:   do {
445:     ksp->its = i + 1;
446:     if (beta == 0.0) {
447:       ksp->reason = KSP_CONVERGED_ATOL;
448:       PetscCall(PetscInfo(ksp, "converged due to beta = 0\n"));
449:       break;
450: #if !defined(PETSC_USE_COMPLEX)
451:     } else if ((i > 0) && (beta * betaold < 0.0)) {
452:       PetscCheck(!ksp->errorifnotconverged, PetscObjectComm((PetscObject)ksp), PETSC_ERR_NOT_CONVERGED, "Diverged due to indefinite preconditioner");
453:       ksp->reason = KSP_DIVERGED_INDEFINITE_PC;
454:       PetscCall(PetscInfo(ksp, "diverging due to indefinite preconditioner\n"));
455:       break;
456: #endif
457:     }
458:     if (!i) {
459:       PetscCall(VecCopy(Z, P)); /*    p <- z                           */
460:       b = 0.0;
461:     } else {
462:       b = beta / betaold;
463:       if (eigs) {
464:         PetscCheck(ksp->max_it == stored_max_it, PetscObjectComm((PetscObject)ksp), PETSC_ERR_SUP, "Can not change maxit AND calculate eigenvalues");
465:         e[i] = PetscSqrtReal(PetscAbsScalar(b)) / a;
466:       }
467:       PetscCall(VecAYPX(P, b, Z)); /*    p <- z + b* p                     */
468:     }
469:     dpiold = dpi;
470:     if (!i) {
471:       PetscCall(KSP_MatMult(ksp, Amat, P, W)); /*    w <- Ap                           */
472:       PetscCall(VecXDot(P, W, &dpi));          /*    dpi <- p'w                        */
473:     } else {
474:       PetscCall(VecAYPX(W, beta / betaold, S));                 /*    w <- Ap                           */
475:       dpi = delta - beta * beta * dpiold / (betaold * betaold); /*    dpi <- p'w                        */
476:     }
477:     betaold = beta;
478:     KSPCheckDot(ksp, beta);

480:     if ((dpi == 0.0) || ((i > 0) && (PetscRealPart(dpi * dpiold) <= 0.0))) {
481:       PetscCheck(!ksp->errorifnotconverged, PetscObjectComm((PetscObject)ksp), PETSC_ERR_NOT_CONVERGED, "Diverged due to indefinite matrix");
482:       ksp->reason = KSP_DIVERGED_INDEFINITE_MAT;
483:       PetscCall(PetscInfo(ksp, "diverging due to indefinite or negative definite matrix\n"));
484:       break;
485:     }
486:     a = beta / dpi; /*    a = beta/p'w                      */
487:     if (eigs) d[i] = PetscSqrtReal(PetscAbsScalar(b)) * e[i] + 1.0 / a;
488:     PetscCall(VecAXPY(X, a, P));  /*    x <- x + ap                       */
489:     PetscCall(VecAXPY(R, -a, W)); /*    r <- r - aw                       */
490:     if (ksp->normtype == KSP_NORM_PRECONDITIONED && ksp->chknorm < i + 2) {
491:       PetscCall(KSP_PCApply(ksp, R, Z)); /*    z <- Br                           */
492:       PetscCall(KSP_MatMult(ksp, Amat, Z, S));
493:       PetscCall(VecNorm(Z, NORM_2, &dp)); /*    dp <- z'*z                        */
494:       KSPCheckNorm(ksp, dp);
495:     } else if (ksp->normtype == KSP_NORM_UNPRECONDITIONED && ksp->chknorm < i + 2) {
496:       PetscCall(VecNorm(R, NORM_2, &dp)); /*    dp <- r'*r                        */
497:       KSPCheckNorm(ksp, dp);
498:     } else if (ksp->normtype == KSP_NORM_NATURAL) {
499:       PetscCall(KSP_PCApply(ksp, R, Z)); /*    z <- Br                           */
500:       tmpvecs[0] = S;
501:       tmpvecs[1] = R;
502:       PetscCall(KSP_MatMult(ksp, Amat, Z, S));
503:       PetscCall(VecMDot(Z, 2, tmpvecs, tmp)); /*    delta <- z'*A*z = r'*B*A*B*r      */
504:       delta = tmp[0];
505:       beta  = tmp[1]; /*    beta <- z'*r                      */
506:       KSPCheckDot(ksp, beta);
507:       dp = PetscSqrtReal(PetscAbsScalar(beta)); /*    dp <- r'*z = r'*B*r = e'*A'*B*A*e */
508:     } else {
509:       dp = 0.0;
510:     }
511:     ksp->rnorm = dp;
512:     PetscCall(KSPLogResidualHistory(ksp, dp));
513:     PetscCall(KSPMonitor(ksp, i + 1, dp));
514:     PetscCall((*ksp->converged)(ksp, i + 1, dp, &ksp->reason, ksp->cnvP));
515:     if (ksp->reason) break;

517:     if ((ksp->normtype != KSP_NORM_PRECONDITIONED && (ksp->normtype != KSP_NORM_NATURAL)) || (ksp->chknorm >= i + 2)) {
518:       PetscCall(KSP_PCApply(ksp, R, Z)); /*    z <- Br                           */
519:       PetscCall(KSP_MatMult(ksp, Amat, Z, S));
520:     }
521:     if ((ksp->normtype != KSP_NORM_NATURAL) || (ksp->chknorm >= i + 2)) {
522:       tmpvecs[0] = S;
523:       tmpvecs[1] = R;
524:       PetscCall(VecMDot(Z, 2, tmpvecs, tmp));
525:       delta = tmp[0];
526:       beta  = tmp[1];         /*    delta <- z'*A*z = r'*B'*A*B*r     */
527:       KSPCheckDot(ksp, beta); /*    beta <- z'*r                      */
528:     }

530:     i++;
531:   } while (i < ksp->max_it);
532:   if (i >= ksp->max_it) ksp->reason = KSP_DIVERGED_ITS;
533:   PetscFunctionReturn(PETSC_SUCCESS);
534: }

536: /*
537:      KSPDestroy_CG - Frees resources allocated in KSPSetup_CG and clears function
538:                      compositions from KSPCreate_CG. If adding your own KSP implementation,
539:                      you must be sure to free all allocated resources here to prevent
540:                      leaks.
541: */
542: PetscErrorCode KSPDestroy_CG(KSP ksp)
543: {
544:   KSP_CG *cg = (KSP_CG *)ksp->data;

546:   PetscFunctionBegin;
547:   PetscCall(PetscFree4(cg->e, cg->d, cg->ee, cg->dd));
548:   PetscCall(KSPDestroyDefault(ksp));
549:   PetscCall(PetscObjectComposeFunction((PetscObject)ksp, "KSPCGSetObjectiveTarget_C", NULL));
550:   PetscCall(PetscObjectComposeFunction((PetscObject)ksp, "KSPCGSetRadius_C", NULL));
551:   PetscCall(PetscObjectComposeFunction((PetscObject)ksp, "KSPCGSetType_C", NULL));
552:   PetscCall(PetscObjectComposeFunction((PetscObject)ksp, "KSPCGUseSingleReduction_C", NULL));
553:   PetscCall(PetscObjectComposeFunction((PetscObject)ksp, "KSPCGGetObjFcn_C", NULL));
554:   PetscFunctionReturn(PETSC_SUCCESS);
555: }

557: /*
558:      KSPView_CG - Prints information about the current Krylov method being used.
559:                   If your Krylov method has special options or flags that information
560:                   should be printed here.
561: */
562: PetscErrorCode KSPView_CG(KSP ksp, PetscViewer viewer)
563: {
564:   KSP_CG   *cg = (KSP_CG *)ksp->data;
565:   PetscBool iascii;

567:   PetscFunctionBegin;
568:   PetscCall(PetscObjectTypeCompare((PetscObject)viewer, PETSCVIEWERASCII, &iascii));
569:   if (iascii) {
570: #if defined(PETSC_USE_COMPLEX)
571:     PetscCall(PetscViewerASCIIPrintf(viewer, "  variant %s\n", KSPCGTypes[cg->type]));
572: #endif
573:     if (cg->singlereduction) PetscCall(PetscViewerASCIIPrintf(viewer, "  using single-reduction variant\n"));
574:   }
575:   PetscFunctionReturn(PETSC_SUCCESS);
576: }

578: /*
579:     KSPSetFromOptions_CG - Checks the options database for options related to the
580:                            conjugate gradient method.
581: */
582: PetscErrorCode KSPSetFromOptions_CG(KSP ksp, PetscOptionItems *PetscOptionsObject)
583: {
584:   KSP_CG   *cg = (KSP_CG *)ksp->data;
585:   PetscBool flg;

587:   PetscFunctionBegin;
588:   PetscOptionsHeadBegin(PetscOptionsObject, "KSP CG and CGNE options");
589: #if defined(PETSC_USE_COMPLEX)
590:   PetscCall(PetscOptionsEnum("-ksp_cg_type", "Matrix is Hermitian or complex symmetric", "KSPCGSetType", KSPCGTypes, (PetscEnum)cg->type, (PetscEnum *)&cg->type, NULL));
591: #endif
592:   PetscCall(PetscOptionsBool("-ksp_cg_single_reduction", "Merge inner products into single MPI_Allreduce()", "KSPCGUseSingleReduction", cg->singlereduction, &cg->singlereduction, &flg));
593:   if (flg) PetscCall(KSPCGUseSingleReduction(ksp, cg->singlereduction));
594:   PetscOptionsHeadEnd();
595:   PetscFunctionReturn(PETSC_SUCCESS);
596: }

598: /*
599:     KSPCGSetType_CG - This is an option that is SPECIFIC to this particular Krylov method.
600:                       This routine is registered below in KSPCreate_CG() and called from the
601:                       routine KSPCGSetType() (see the file cgtype.c).
602: */
603: PetscErrorCode KSPCGSetType_CG(KSP ksp, KSPCGType type)
604: {
605:   KSP_CG *cg = (KSP_CG *)ksp->data;

607:   PetscFunctionBegin;
608:   cg->type = type;
609:   PetscFunctionReturn(PETSC_SUCCESS);
610: }

612: /*
613:     KSPCGUseSingleReduction_CG

615:     This routine sets a flag to use a variant of CG. Note that (in somewhat
616:     atypical fashion) it also swaps out the routine called when KSPSolve()
617:     is invoked.
618: */
619: static PetscErrorCode KSPCGUseSingleReduction_CG(KSP ksp, PetscBool flg)
620: {
621:   KSP_CG *cg = (KSP_CG *)ksp->data;

623:   PetscFunctionBegin;
624:   cg->singlereduction = flg;
625:   if (cg->singlereduction) {
626:     ksp->ops->solve = KSPSolve_CG_SingleReduction;
627:     PetscCall(PetscObjectComposeFunction((PetscObject)ksp, "KSPCGGetObjFcn_C", NULL));
628:   } else {
629:     ksp->ops->solve = KSPSolve_CG;
630:     PetscCall(PetscObjectComposeFunction((PetscObject)ksp, "KSPCGGetObjFcn_C", KSPCGGetObjFcn_CG));
631:   }
632:   PetscFunctionReturn(PETSC_SUCCESS);
633: }

635: PETSC_INTERN PetscErrorCode KSPBuildResidual_CG(KSP ksp, Vec t, Vec v, Vec *V)
636: {
637:   PetscFunctionBegin;
638:   PetscCall(VecCopy(ksp->work[0], v));
639:   *V = v;
640:   PetscFunctionReturn(PETSC_SUCCESS);
641: }

643: /*MC
644:    KSPCG - The Preconditioned Conjugate Gradient (PCG) iterative method {cite}`hs:52` and {cite}`malek2014preconditioning`

646:    Options Database Keys:
647: +   -ksp_cg_type Hermitian - (for complex matrices only) indicates the matrix is Hermitian, see `KSPCGSetType()`
648: .   -ksp_cg_type symmetric - (for complex matrices only) indicates the matrix is symmetric
649: -   -ksp_cg_single_reduction - performs both inner products needed in the algorithm with a single `MPI_Allreduce()` call, see `KSPCGUseSingleReduction()`

651:    Level: beginner

653:    Notes:
654:    The PCG method requires both the matrix and preconditioner to be symmetric positive (or negative) (semi) definite.

656:    Only left preconditioning is supported; there are several ways to motivate preconditioned CG, but they all produce the same algorithm.
657:    One can interpret preconditioning A with B to mean any of the following\:
658: .vb
659:    (1) Solve a left-preconditioned system BAx = Bb, using inv(B) to define an inner product in the algorithm.
660:    (2) Solve a right-preconditioned system ABy = b, x = By, using B to define an inner product in the algorithm.
661:    (3) Solve a symmetrically-preconditioned system, E^TAEy = E^Tb, x = Ey, where B = EE^T.
662:    (4) Solve Ax=b with CG, but use the inner product defined by B to define the method [2].
663:    In all cases, the resulting algorithm only requires application of B to vectors.
664: .ve

666:    For complex numbers there are two different CG methods, one for Hermitian symmetric matrices and one for non-Hermitian symmetric matrices. Use
667:    `KSPCGSetType()` to indicate which type you are using.

669:    One can use `KSPSetComputeEigenvalues()` and `KSPComputeEigenvalues()` to compute the eigenvalues of the (preconditioned) operator

671:    Developer Note:
672:     KSPSolve_CG() should actually query the matrix to determine if it is Hermitian symmetric or not and NOT require the user to
673:    indicate it to the `KSP` object.

675: .seealso: [](ch_ksp), `KSPCreate()`, `KSPSetType()`, `KSPType`, `KSP`, `KSPSetComputeEigenvalues()`, `KSPComputeEigenvalues()`
676:           `KSPCGSetType()`, `KSPCGUseSingleReduction()`, `KSPPIPECG`, `KSPGROPPCG`
677: M*/

679: /*
680:     KSPCreate_CG - Creates the data structure for the Krylov method CG and sets the
681:        function pointers for all the routines it needs to call (KSPSolve_CG() etc)

683:     It must be labeled as PETSC_EXTERN to be dynamically linkable in C++
684: */
685: PETSC_EXTERN PetscErrorCode KSPCreate_CG(KSP ksp)
686: {
687:   KSP_CG *cg;

689:   PetscFunctionBegin;
690:   PetscCall(PetscNew(&cg));
691: #if !defined(PETSC_USE_COMPLEX)
692:   cg->type = KSP_CG_SYMMETRIC;
693: #else
694:   cg->type = KSP_CG_HERMITIAN;
695: #endif
696:   cg->obj_min = 0.0;
697:   ksp->data   = (void *)cg;

699:   PetscCall(KSPSetSupportedNorm(ksp, KSP_NORM_PRECONDITIONED, PC_LEFT, 3));
700:   PetscCall(KSPSetSupportedNorm(ksp, KSP_NORM_UNPRECONDITIONED, PC_LEFT, 2));
701:   PetscCall(KSPSetSupportedNorm(ksp, KSP_NORM_NATURAL, PC_LEFT, 2));
702:   PetscCall(KSPSetSupportedNorm(ksp, KSP_NORM_NONE, PC_LEFT, 1));

704:   /*
705:        Sets the functions that are associated with this data structure
706:        (in C++ this is the same as defining virtual functions)
707:   */
708:   ksp->ops->setup          = KSPSetUp_CG;
709:   ksp->ops->solve          = KSPSolve_CG;
710:   ksp->ops->destroy        = KSPDestroy_CG;
711:   ksp->ops->view           = KSPView_CG;
712:   ksp->ops->setfromoptions = KSPSetFromOptions_CG;
713:   ksp->ops->buildsolution  = KSPBuildSolutionDefault;
714:   ksp->ops->buildresidual  = KSPBuildResidual_CG;

716:   /*
717:       Attach the function KSPCGSetType_CG() to this object. The routine
718:       KSPCGSetType() checks for this attached function and calls it if it finds
719:       it. (Sort of like a dynamic member function that can be added at run time
720:   */
721:   PetscCall(PetscObjectComposeFunction((PetscObject)ksp, "KSPCGSetType_C", KSPCGSetType_CG));
722:   PetscCall(PetscObjectComposeFunction((PetscObject)ksp, "KSPCGUseSingleReduction_C", KSPCGUseSingleReduction_CG));
723:   PetscCall(PetscObjectComposeFunction((PetscObject)ksp, "KSPCGSetRadius_C", KSPCGSetRadius_CG));
724:   PetscCall(PetscObjectComposeFunction((PetscObject)ksp, "KSPCGSetObjectiveTarget_C", KSPCGSetObjectiveTarget_CG));
725:   PetscCall(PetscObjectComposeFunction((PetscObject)ksp, "KSPCGGetObjFcn_C", KSPCGGetObjFcn_CG));
726:   PetscFunctionReturn(PETSC_SUCCESS);
727: }