/*
KSPBuildResidualDefault - Default code to compute the residual.
Input Parameters:
. ksp - iterative context
. t - pointer to temporary vector
. v - pointer to user vector
Output Parameter:
. V - pointer to a vector containing the residual
Level: advanced
Developers Note: This is PETSC_EXTERN because it may be used by user written plugin KSP implementations
.keywords: KSP, build, residual, default
.seealso: KSPBuildSolutionDefault()
*/
PetscErrorCode KSPBuildResidualDefault(KSP ksp,Vec t,Vec v,Vec *V)
{
PetscErrorCode ierr;
Mat Amat,Pmat;
PetscFunctionBegin;
if (!ksp->pc) {ierr = KSPGetPC(ksp,&ksp->pc);CHKERRQ(ierr);}
ierr = PCGetOperators(ksp->pc,&Amat,&Pmat);CHKERRQ(ierr);
ierr = KSPBuildSolution(ksp,t,NULL);CHKERRQ(ierr);
ierr = KSP_MatMult(ksp,Amat,t,v);CHKERRQ(ierr);
ierr = VecAYPX(v,-1.0,ksp->vec_rhs);CHKERRQ(ierr);
*V = v;
PetscFunctionReturn(0);
}
PetscErrorCode IFunction_Hull1972A1(TS ts, PetscReal t, Vec Y, Vec Ydot, Vec F, void *s)
{
PetscErrorCode ierr;
PetscScalar *y,*f;
PetscFunctionBegin;
ierr = VecGetArray(Y,&y);CHKERRQ(ierr);
ierr = VecGetArray(F,&f);CHKERRQ(ierr);
f[0] = -y[0];
ierr = VecRestoreArray(Y,&y);CHKERRQ(ierr);
ierr = VecRestoreArray(F,&f);CHKERRQ(ierr);
/* Left hand side = ydot - f(y) */
ierr = VecAYPX(F,-1.0,Ydot);
PetscFunctionReturn(0);
}
static PetscErrorCode MonitorError(TS ts,PetscInt step,PetscReal t,Vec x,void *ctx)
{
PetscErrorCode ierr;
MonitorCtx *mon = (MonitorCtx*)ctx;
PetscReal h,nrm_x,nrm_exact,nrm_diff;
PetscFunctionBeginUser;
if (!mon->problem->solution) PetscFunctionReturn(0);
ierr = (*mon->problem->solution)(t,mon->x,mon->problem->data);CHKERRQ(ierr);
ierr = VecNorm(x,NORM_2,&nrm_x);CHKERRQ(ierr);
ierr = VecNorm(mon->x,NORM_2,&nrm_exact);CHKERRQ(ierr);
ierr = VecAYPX(mon->x,-1,x);CHKERRQ(ierr);
ierr = VecNorm(mon->x,NORM_2,&nrm_diff);CHKERRQ(ierr);
ierr = TSGetTimeStep(ts,&h);CHKERRQ(ierr);
ierr = PetscPrintf(mon->comm,"step %4D t=%12.8e h=% 8.2e |x|=%9.2e |x_e|=%9.2e |x-x_e|=%9.2e\n",step,t,h,nrm_x,nrm_exact,nrm_diff);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
// assemble the right-hand side of the system for the Lagrangian forces
PetscErrorCode RigidKinematicsSolver::assembleRHSForces()
{
PetscErrorCode ierr;
PetscFunctionBeginUser;
ierr = PetscLogStagePush(stageRHSForces); CHKERRQ(ierr);
// rhsf = UB - E u^{**}
ierr = MatMult(E, solution->UGlobal, rhsf); CHKERRQ(ierr);
ierr = VecScale(rhsf, -1.0); CHKERRQ(ierr);
ierr = VecAYPX(rhsf, 1.0, UB); CHKERRQ(ierr);
ierr = PetscLogStagePop(); CHKERRQ(ierr);
PetscFunctionReturn(0);
} // assembleRHSForces
/* these functions were associated with the PETScMatrixSolver class, before it was
* depreciated */
Vec _GetResidual( MGSolver_PETScData* mgData ) {
if( mgData->expiredResidual ) {
VecDuplicate( mgData->curSolution, &mgData->residual );
VecSetFromOptions( mgData->residual );
#if( PETSC_VERSION_MAJOR <= 2 && PETSC_VERSION_MINOR >= 3 && PETSC_VERSION_SUBMINOR >= 3 )
VecSetOption( mgData->residual, VEC_IGNORE_NEGATIVE_INDICES );
#elif( PETSC_VERSION_MAJOR >= 3 )
VecSetOption( mgData->residual, VEC_IGNORE_NEGATIVE_INDICES, PETSC_TRUE );
#endif
MatMult( mgData->matrix, mgData->curSolution, mgData->residual );
VecAYPX( mgData->residual, -1.0, mgData->curRHS );
mgData->expiredResidual = False;
}
return mgData->residual;
}
PetscErrorCode IFunction_Hull1972C34(TS ts, PetscReal t, Vec Y, Vec Ydot, Vec F, void *s)
{
PetscErrorCode ierr;
PetscScalar *y,*f;
PetscInt N,i;
PetscFunctionBegin;
ierr = VecGetSize (Y,&N);CHKERRQ(ierr);
ierr = VecGetArray(Y,&y);CHKERRQ(ierr);
ierr = VecGetArray(F,&f);CHKERRQ(ierr);
f[0] = -2.0*y[0] + y[1];
for (i = 1; i < N-1; i++) {
f[i] = y[i-1] - 2.0*y[i] + y[i+1];
}
f[N-1] = y[N-2] - 2.0*y[N-1];
ierr = VecRestoreArray(Y,&y);CHKERRQ(ierr);
ierr = VecRestoreArray(F,&f);CHKERRQ(ierr);
/* Left hand side = ydot - f(y) */
ierr = VecAYPX(F,-1.0,Ydot);
PetscFunctionReturn(0);
}
PetscErrorCode MatMultAdd_SchurComplement(Mat N,Vec x,Vec y,Vec z)
{
Mat_SchurComplement *Na = (Mat_SchurComplement*)N->data;
PetscErrorCode ierr;
PetscFunctionBegin;
if (!Na->work1) {ierr = MatGetVecs(Na->A,&Na->work1,PETSC_NULL);CHKERRQ(ierr);}
if (!Na->work2) {ierr = MatGetVecs(Na->A,&Na->work2,PETSC_NULL);CHKERRQ(ierr);}
ierr = MatMult(Na->B,x,Na->work1);CHKERRQ(ierr);
ierr = KSPSolve(Na->ksp,Na->work1,Na->work2);CHKERRQ(ierr);
if (y == z) {
ierr = VecScale(Na->work2,-1.0);CHKERRQ(ierr);
ierr = MatMultAdd(Na->C,Na->work2,z,z);CHKERRQ(ierr);
} else {
ierr = MatMult(Na->C,Na->work2,z);CHKERRQ(ierr);
ierr = VecAYPX(z,-1.0,y);CHKERRQ(ierr);
}
if (Na->D) {
ierr = MatMultAdd(Na->D,x,z,z);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
PetscErrorCode
Metos3DTimeStepFunction(SNES snes, Vec ynBD, Vec fnBD, void *ctx)
{
Metos3D *metos3d = (Metos3D*)ctx;
// geometry
PetscInt nvec = metos3d->vectorLength;
// bgc
PetscInt ntracer = metos3d->tracerCount;
// load
PetscInt nvecloc = metos3d->vectorLengthLocal;
// parameter
PetscInt nparam = metos3d->parameterCount;
PetscReal *u0 = metos3d->u0;
// work vars
PetscInt itracer;
Vec *yin, *yinold, *yout;
PetscFunctionBegin;
// create work vectors
Metos3DUtilVecCreateAndSetValue(metos3d, ntracer, nvec, nvecloc, &yin, 0.0);
Metos3DUtilVecCreateAndSetValue(metos3d, ntracer, nvec, nvecloc, &yinold, 0.0);
Metos3DUtilVecCreateAndSetValue(metos3d, ntracer, nvec, nvecloc, &yout, 0.0);
// yin = ynBD
// yinold = ynBD
// yout = Phi(yin)
// yout = - yout + yinold;
// fnBD = yout
Metos3DUtilVecCopyDiagonalToSeparate(metos3d, ntracer, nvecloc, &ynBD, yin);
Metos3DUtilVecCopyDiagonalToSeparate(metos3d, ntracer, nvecloc, &ynBD, yinold);
Metos3DTimeStepPhi(metos3d, yin, yout, nparam, u0);
for (itracer = 0; itracer < ntracer; itracer++) VecAYPX(yout[itracer], -1.0, yinold[itracer]);
Metos3DUtilVecCopySeparateToDiagonal(metos3d, ntracer, nvecloc, yout, &fnBD);
// free work vectors
VecDestroyVecs(ntracer, &yin);
VecDestroyVecs(ntracer, &yinold);
VecDestroyVecs(ntracer, &yout);
// debug
Metos3DDebug(metos3d, kDebugLevel, "Metos3DTimeStepFunction\n");
PetscFunctionReturn(0);
}
PetscErrorCode VecAYPX_MultiVec(Vec y, const PetscScalar alpha, Vec x)
{
#if !defined(NDEBUG)
TBOX_ASSERT(y);
TBOX_ASSERT(x);
#endif
Vec_MultiVec* my = static_cast<Vec_MultiVec*>(y->data);
Vec_MultiVec* mx = static_cast<Vec_MultiVec*>(x->data);
#if !defined(NDEBUG)
TBOX_ASSERT(my);
TBOX_ASSERT(mx);
TBOX_ASSERT(my->n == mx->n);
#endif
PetscErrorCode ierr;
for (PetscInt k = 0; k < my->n; ++k)
{
ierr = VecAYPX(my->array[k], alpha, mx->array[k]);
CHKERRQ(ierr);
}
ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(y));
CHKERRQ(ierr);
PetscFunctionReturn(0);
} // VecAYPX_MultiVec
/*@
SNESApplyNPC - Calls SNESSolve() on preconditioner for the SNES
Collective on SNES
Input Parameters:
+ snes - the SNES context
. x - input vector
- f - optional; the function evaluation on x
Output Parameter:
. y - function vector, as set by SNESSetFunction()
Notes:
SNESComputeFunction() should be called on x before SNESApplyNPC() is called, as it is
with SNESComuteJacobian().
Level: developer
.keywords: SNES, nonlinear, compute, function
.seealso: SNESGetNPC(),SNESSetNPC(),SNESComputeFunction()
@*/
PetscErrorCode SNESApplyNPC(SNES snes,Vec x,Vec f,Vec y)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(snes,SNES_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,2);
PetscValidHeaderSpecific(y,VEC_CLASSID,3);
PetscCheckSameComm(snes,1,x,2);
PetscCheckSameComm(snes,1,y,3);
ierr = VecValidValues(x,2,PETSC_TRUE);CHKERRQ(ierr);
if (snes->pc) {
if (f) {
ierr = SNESSetInitialFunction(snes->pc,f);CHKERRQ(ierr);
}
ierr = VecCopy(x,y);CHKERRQ(ierr);
ierr = PetscLogEventBegin(SNES_NPCSolve,snes->pc,x,y,0);CHKERRQ(ierr);
ierr = SNESSolve(snes->pc,snes->vec_rhs,y);CHKERRQ(ierr);
ierr = PetscLogEventEnd(SNES_NPCSolve,snes->pc,x,y,0);CHKERRQ(ierr);
ierr = VecAYPX(y,-1.0,x);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscFunctionReturn(0);
}
PetscErrorCode KSPSolve_GCR( KSP ksp )
{
KSP_GCR *ctx = (KSP_GCR*)ksp->data;
PetscErrorCode ierr;
Mat A, B;
Vec r,b,x;
PetscReal norm_r;
PetscFunctionBegin;
ierr = KSPGetOperators( ksp, &A, &B, PETSC_NULL );CHKERRQ(ierr);
x = ksp->vec_sol;
b = ksp->vec_rhs;
r = ctx->R;
/* compute initial residual */
ierr = MatMult( A, x, r );CHKERRQ(ierr);
ierr = VecAYPX( r, -1.0, b );CHKERRQ(ierr); /* r = b - A x */
ierr = VecNorm( r, NORM_2, &norm_r );CHKERRQ(ierr);
ksp->its = 0;
ksp->rnorm0 = norm_r;
KSPLogResidualHistory(ksp,ksp->rnorm0);
ierr = KSPMonitor(ksp,ksp->its,ksp->rnorm0);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,ksp->its,ksp->rnorm0,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) PetscFunctionReturn(0);
do {
ierr = KSPSolve_GCR_cycle( ksp );CHKERRQ(ierr);
if (ksp->reason) break; /* catch case when convergence occurs inside the cycle */
} while( ksp->its < ksp->max_it );CHKERRQ(ierr);
if ( ksp->its >= ksp->max_it) {
ksp->reason = KSP_DIVERGED_ITS;
}
PetscFunctionReturn(0);
}
PetscErrorCode KSPSolve_CG(KSP ksp)
{
PetscErrorCode ierr;
PetscInt i,stored_max_it,eigs;
PetscScalar dpi = 0.0,a = 1.0,beta,betaold = 1.0,b = 0,*e = 0,*d = 0,delta,dpiold;
PetscReal dp = 0.0;
Vec X,B,Z,R,P,S,W;
KSP_CG *cg;
Mat Amat,Pmat;
PetscBool diagonalscale;
PetscFunctionBegin;
ierr = PCGetDiagonalScale(ksp->pc,&diagonalscale);CHKERRQ(ierr);
if (diagonalscale) SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"Krylov method %s does not support diagonal scaling",((PetscObject)ksp)->type_name);
cg = (KSP_CG*)ksp->data;
eigs = ksp->calc_sings;
stored_max_it = ksp->max_it;
X = ksp->vec_sol;
B = ksp->vec_rhs;
R = ksp->work[0];
Z = ksp->work[1];
P = ksp->work[2];
if (cg->singlereduction) {
S = ksp->work[3];
W = ksp->work[4];
} else {
S = 0; /* unused */
W = Z;
}
#define VecXDot(x,y,a) (((cg->type) == (KSP_CG_HERMITIAN)) ? VecDot(x,y,a) : VecTDot(x,y,a))
if (eigs) {e = cg->e; d = cg->d; e[0] = 0.0; }
ierr = PCGetOperators(ksp->pc,&Amat,&Pmat);CHKERRQ(ierr);
ksp->its = 0;
if (!ksp->guess_zero) {
ierr = KSP_MatMult(ksp,Amat,X,R);CHKERRQ(ierr); /* r <- b - Ax */
ierr = VecAYPX(R,-1.0,B);CHKERRQ(ierr);
} else {
ierr = VecCopy(B,R);CHKERRQ(ierr); /* r <- b (x is 0) */
}
switch (ksp->normtype) {
case KSP_NORM_PRECONDITIONED:
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
ierr = VecNorm(Z,NORM_2,&dp);CHKERRQ(ierr); /* dp <- z'*z = e'*A'*B'*B*A'*e' */
break;
case KSP_NORM_UNPRECONDITIONED:
ierr = VecNorm(R,NORM_2,&dp);CHKERRQ(ierr); /* dp <- r'*r = e'*A'*A*e */
break;
case KSP_NORM_NATURAL:
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
if (cg->singlereduction) {
ierr = KSP_MatMult(ksp,Amat,Z,S);CHKERRQ(ierr);
ierr = VecXDot(Z,S,&delta);CHKERRQ(ierr);
}
ierr = VecXDot(Z,R,&beta);CHKERRQ(ierr); /* beta <- z'*r */
if (PetscIsInfOrNanScalar(beta)) {
if (ksp->errorifnotconverged) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_NOT_CONVERGED,"KSPSolve has not converged due to Nan or Inf inner product");
else {
ksp->reason = KSP_DIVERGED_NANORINF;
PetscFunctionReturn(0);
}
}
dp = PetscSqrtReal(PetscAbsScalar(beta)); /* dp <- r'*z = r'*B*r = e'*A'*B*A*e */
break;
case KSP_NORM_NONE:
dp = 0.0;
break;
default: SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"%s",KSPNormTypes[ksp->normtype]);
}
ierr = KSPLogResidualHistory(ksp,dp);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,0,dp);CHKERRQ(ierr);
ksp->rnorm = dp;
ierr = (*ksp->converged)(ksp,0,dp,&ksp->reason,ksp->cnvP);CHKERRQ(ierr); /* test for convergence */
if (ksp->reason) PetscFunctionReturn(0);
if (ksp->normtype != KSP_NORM_PRECONDITIONED && (ksp->normtype != KSP_NORM_NATURAL)) {
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
}
if (ksp->normtype != KSP_NORM_NATURAL) {
if (cg->singlereduction) {
ierr = KSP_MatMult(ksp,Amat,Z,S);CHKERRQ(ierr);
ierr = VecXDot(Z,S,&delta);CHKERRQ(ierr);
}
ierr = VecXDot(Z,R,&beta);CHKERRQ(ierr); /* beta <- z'*r */
if (PetscIsInfOrNanScalar(beta)) {
if (ksp->errorifnotconverged) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_NOT_CONVERGED,"KSPSolve has not converged due to Nan or Inf inner product");
else {
ksp->reason = KSP_DIVERGED_NANORINF;
PetscFunctionReturn(0);
}
}
}
i = 0;
do {
ksp->its = i+1;
if (beta == 0.0) {
ksp->reason = KSP_CONVERGED_ATOL;
ierr = PetscInfo(ksp,"converged due to beta = 0\n");CHKERRQ(ierr);
break;
#if !defined(PETSC_USE_COMPLEX)
} else if ((i > 0) && (beta*betaold < 0.0)) {
ksp->reason = KSP_DIVERGED_INDEFINITE_PC;
ierr = PetscInfo(ksp,"diverging due to indefinite preconditioner\n");CHKERRQ(ierr);
break;
#endif
}
if (!i) {
ierr = VecCopy(Z,P);CHKERRQ(ierr); /* p <- z */
b = 0.0;
} else {
b = beta/betaold;
if (eigs) {
if (ksp->max_it != stored_max_it) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"Can not change maxit AND calculate eigenvalues");
e[i] = PetscSqrtReal(PetscAbsScalar(b))/a;
}
ierr = VecAYPX(P,b,Z);CHKERRQ(ierr); /* p <- z + b* p */
}
dpiold = dpi;
if (!cg->singlereduction || !i) {
ierr = KSP_MatMult(ksp,Amat,P,W);CHKERRQ(ierr); /* w <- Ap */
ierr = VecXDot(P,W,&dpi);CHKERRQ(ierr); /* dpi <- p'w */
} else {
ierr = VecAYPX(W,beta/betaold,S);CHKERRQ(ierr); /* w <- Ap */
dpi = delta - beta*beta*dpiold/(betaold*betaold); /* dpi <- p'w */
}
betaold = beta;
if (PetscIsInfOrNanScalar(dpi)) {
if (ksp->errorifnotconverged) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_NOT_CONVERGED,"KSPSolve has not converged due to Nan or Inf inner product");
else {
ksp->reason = KSP_DIVERGED_NANORINF;
PetscFunctionReturn(0);
}
}
if ((dpi == 0.0) || ((i > 0) && (PetscRealPart(dpi*dpiold) <= 0.0))) {
ksp->reason = KSP_DIVERGED_INDEFINITE_MAT;
ierr = PetscInfo(ksp,"diverging due to indefinite or negative definite matrix\n");CHKERRQ(ierr);
break;
}
a = beta/dpi; /* a = beta/p'w */
if (eigs) d[i] = PetscSqrtReal(PetscAbsScalar(b))*e[i] + 1.0/a;
ierr = VecAXPY(X,a,P);CHKERRQ(ierr); /* x <- x + ap */
ierr = VecAXPY(R,-a,W);CHKERRQ(ierr); /* r <- r - aw */
if (ksp->normtype == KSP_NORM_PRECONDITIONED && ksp->chknorm < i+2) {
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
if (cg->singlereduction) {
ierr = KSP_MatMult(ksp,Amat,Z,S);CHKERRQ(ierr);
}
ierr = VecNorm(Z,NORM_2,&dp);CHKERRQ(ierr); /* dp <- z'*z */
} else if (ksp->normtype == KSP_NORM_UNPRECONDITIONED && ksp->chknorm < i+2) {
ierr = VecNorm(R,NORM_2,&dp);CHKERRQ(ierr); /* dp <- r'*r */
} else if (ksp->normtype == KSP_NORM_NATURAL) {
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
if (cg->singlereduction) {
PetscScalar tmp[2];
Vec vecs[2];
vecs[0] = S; vecs[1] = R;
ierr = KSP_MatMult(ksp,Amat,Z,S);CHKERRQ(ierr);
ierr = VecMDot(Z,2,vecs,tmp);CHKERRQ(ierr);
delta = tmp[0]; beta = tmp[1];
} else {
ierr = VecXDot(Z,R,&beta);CHKERRQ(ierr); /* beta <- r'*z */
}
if (PetscIsInfOrNanScalar(beta)) {
if (ksp->errorifnotconverged) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_NOT_CONVERGED,"KSPSolve has not converged due to Nan or Inf inner product");
else {
ksp->reason = KSP_DIVERGED_NANORINF;
PetscFunctionReturn(0);
}
}
dp = PetscSqrtReal(PetscAbsScalar(beta));
} else {
dp = 0.0;
}
ksp->rnorm = dp;
CHKERRQ(ierr);KSPLogResidualHistory(ksp,dp);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,i+1,dp);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,i+1,dp,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) break;
if ((ksp->normtype != KSP_NORM_PRECONDITIONED && (ksp->normtype != KSP_NORM_NATURAL)) || (ksp->chknorm >= i+2)) {
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
if (cg->singlereduction) {
ierr = KSP_MatMult(ksp,Amat,Z,S);CHKERRQ(ierr);
}
}
if ((ksp->normtype != KSP_NORM_NATURAL) || (ksp->chknorm >= i+2)) {
if (cg->singlereduction) {
PetscScalar tmp[2];
Vec vecs[2];
vecs[0] = S; vecs[1] = R;
ierr = VecMDot(Z,2,vecs,tmp);CHKERRQ(ierr);
delta = tmp[0]; beta = tmp[1];
} else {
ierr = VecXDot(Z,R,&beta);CHKERRQ(ierr); /* beta <- z'*r */
}
if (PetscIsInfOrNanScalar(beta)) {
if (ksp->errorifnotconverged) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_NOT_CONVERGED,"KSPSolve has not converged due to Nan or Inf inner product");
else {
ksp->reason = KSP_DIVERGED_NANORINF;
PetscFunctionReturn(0);
}
}
}
i++;
} while (i<ksp->max_it);
if (i >= ksp->max_it) ksp->reason = KSP_DIVERGED_ITS;
PetscFunctionReturn(0);
}
PetscErrorCode KSPSolve_PIPECG(KSP ksp)
{
PetscErrorCode ierr;
PetscInt i;
PetscScalar alpha = 0.0,beta = 0.0,gamma = 0.0,gammaold = 0.0,delta = 0.0;
PetscReal dp = 0.0;
Vec X,B,Z,P,W,Q,U,M,N,R,S;
Mat Amat,Pmat;
PetscBool diagonalscale;
PetscFunctionBegin;
ierr = PCGetDiagonalScale(ksp->pc,&diagonalscale);CHKERRQ(ierr);
if (diagonalscale) SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"Krylov method %s does not support diagonal scaling",((PetscObject)ksp)->type_name);
X = ksp->vec_sol;
B = ksp->vec_rhs;
M = ksp->work[0];
Z = ksp->work[1];
P = ksp->work[2];
N = ksp->work[3];
W = ksp->work[4];
Q = ksp->work[5];
U = ksp->work[6];
R = ksp->work[7];
S = ksp->work[8];
ierr = PCGetOperators(ksp->pc,&Amat,&Pmat);CHKERRQ(ierr);
ksp->its = 0;
if (!ksp->guess_zero) {
ierr = KSP_MatMult(ksp,Amat,X,R);CHKERRQ(ierr); /* r <- b - Ax */
ierr = VecAYPX(R,-1.0,B);CHKERRQ(ierr);
} else {
ierr = VecCopy(B,R);CHKERRQ(ierr); /* r <- b (x is 0) */
}
ierr = KSP_PCApply(ksp,R,U);CHKERRQ(ierr); /* u <- Br */
switch (ksp->normtype) {
case KSP_NORM_PRECONDITIONED:
ierr = VecNormBegin(U,NORM_2,&dp);CHKERRQ(ierr); /* dp <- u'*u = e'*A'*B'*B*A'*e' */
ierr = PetscCommSplitReductionBegin(PetscObjectComm((PetscObject)U));CHKERRQ(ierr);
ierr = KSP_MatMult(ksp,Amat,U,W);CHKERRQ(ierr); /* w <- Au */
ierr = VecNormEnd(U,NORM_2,&dp);CHKERRQ(ierr);
break;
case KSP_NORM_UNPRECONDITIONED:
ierr = VecNormBegin(R,NORM_2,&dp);CHKERRQ(ierr); /* dp <- r'*r = e'*A'*A*e */
ierr = PetscCommSplitReductionBegin(PetscObjectComm((PetscObject)R));CHKERRQ(ierr);
ierr = KSP_MatMult(ksp,Amat,U,W);CHKERRQ(ierr); /* w <- Au */
ierr = VecNormEnd(R,NORM_2,&dp);CHKERRQ(ierr);
break;
case KSP_NORM_NATURAL:
ierr = VecDotBegin(R,U,&gamma);CHKERRQ(ierr); /* gamma <- u'*r */
ierr = PetscCommSplitReductionBegin(PetscObjectComm((PetscObject)R));CHKERRQ(ierr);
ierr = KSP_MatMult(ksp,Amat,U,W);CHKERRQ(ierr); /* w <- Au */
ierr = VecDotEnd(R,U,&gamma);CHKERRQ(ierr);
KSPCheckDot(ksp,gamma);
dp = PetscSqrtReal(PetscAbsScalar(gamma)); /* dp <- r'*u = r'*B*r = e'*A'*B*A*e */
break;
case KSP_NORM_NONE:
ierr = KSP_MatMult(ksp,Amat,U,W);CHKERRQ(ierr);
dp = 0.0;
break;
default: SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"%s",KSPNormTypes[ksp->normtype]);
}
ierr = KSPLogResidualHistory(ksp,dp);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,0,dp);CHKERRQ(ierr);
ksp->rnorm = dp;
ierr = (*ksp->converged)(ksp,0,dp,&ksp->reason,ksp->cnvP);CHKERRQ(ierr); /* test for convergence */
if (ksp->reason) PetscFunctionReturn(0);
i = 0;
do {
if (i > 0 && ksp->normtype == KSP_NORM_UNPRECONDITIONED) {
ierr = VecNormBegin(R,NORM_2,&dp);CHKERRQ(ierr);
} else if (i > 0 && ksp->normtype == KSP_NORM_PRECONDITIONED) {
ierr = VecNormBegin(U,NORM_2,&dp);CHKERRQ(ierr);
}
if (!(i == 0 && ksp->normtype == KSP_NORM_NATURAL)) {
ierr = VecDotBegin(R,U,&gamma);CHKERRQ(ierr);
}
ierr = VecDotBegin(W,U,&delta);CHKERRQ(ierr);
ierr = PetscCommSplitReductionBegin(PetscObjectComm((PetscObject)R));CHKERRQ(ierr);
ierr = KSP_PCApply(ksp,W,M);CHKERRQ(ierr); /* m <- Bw */
ierr = KSP_MatMult(ksp,Amat,M,N);CHKERRQ(ierr); /* n <- Am */
if (i > 0 && ksp->normtype == KSP_NORM_UNPRECONDITIONED) {
ierr = VecNormEnd(R,NORM_2,&dp);CHKERRQ(ierr);
} else if (i > 0 && ksp->normtype == KSP_NORM_PRECONDITIONED) {
ierr = VecNormEnd(U,NORM_2,&dp);CHKERRQ(ierr);
}
if (!(i == 0 && ksp->normtype == KSP_NORM_NATURAL)) {
ierr = VecDotEnd(R,U,&gamma);CHKERRQ(ierr);
}
ierr = VecDotEnd(W,U,&delta);CHKERRQ(ierr);
if (i > 0) {
if (ksp->normtype == KSP_NORM_NATURAL) dp = PetscSqrtReal(PetscAbsScalar(gamma));
else if (ksp->normtype == KSP_NORM_NONE) dp = 0.0;
ksp->rnorm = dp;
ierr = KSPLogResidualHistory(ksp,dp);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,i,dp);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,i,dp,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) break;
}
if (i == 0) {
alpha = gamma / delta;
ierr = VecCopy(N,Z);CHKERRQ(ierr); /* z <- n */
ierr = VecCopy(M,Q);CHKERRQ(ierr); /* q <- m */
ierr = VecCopy(U,P);CHKERRQ(ierr); /* p <- u */
ierr = VecCopy(W,S);CHKERRQ(ierr); /* s <- w */
} else {
beta = gamma / gammaold;
alpha = gamma / (delta - beta / alpha * gamma);
ierr = VecAYPX(Z,beta,N);CHKERRQ(ierr); /* z <- n + beta * z */
ierr = VecAYPX(Q,beta,M);CHKERRQ(ierr); /* q <- m + beta * q */
ierr = VecAYPX(P,beta,U);CHKERRQ(ierr); /* p <- u + beta * p */
ierr = VecAYPX(S,beta,W);CHKERRQ(ierr); /* s <- w + beta * s */
}
ierr = VecAXPY(X, alpha,P);CHKERRQ(ierr); /* x <- x + alpha * p */
ierr = VecAXPY(U,-alpha,Q);CHKERRQ(ierr); /* u <- u - alpha * q */
ierr = VecAXPY(W,-alpha,Z);CHKERRQ(ierr); /* w <- w - alpha * z */
ierr = VecAXPY(R,-alpha,S);CHKERRQ(ierr); /* r <- r - alpha * s */
gammaold = gamma;
i++;
ksp->its = i;
/* if (i%50 == 0) { */
/* ierr = KSP_MatMult(ksp,Amat,X,R);CHKERRQ(ierr); /\* w <- b - Ax *\/ */
/* ierr = VecAYPX(R,-1.0,B);CHKERRQ(ierr); */
/* ierr = KSP_PCApply(ksp,R,U);CHKERRQ(ierr); */
/* ierr = KSP_MatMult(ksp,Amat,U,W);CHKERRQ(ierr); */
/* } */
} while (i<ksp->max_it);
if (i >= ksp->max_it) ksp->reason = KSP_DIVERGED_ITS;
PetscFunctionReturn(0);
}
PetscErrorCode SNESSolve_NCG(SNES snes)
{
SNES_NCG *ncg = (SNES_NCG*)snes->data;
Vec X,dX,lX,F,dXold;
PetscReal fnorm, ynorm, xnorm, beta = 0.0;
PetscScalar dXdotdX, dXolddotdXold, dXdotdXold, lXdotdX, lXdotdXold;
PetscInt maxits, i;
PetscErrorCode ierr;
PetscBool lsSuccess = PETSC_TRUE;
SNESLineSearch linesearch;
SNESConvergedReason reason;
PetscFunctionBegin;
ierr = PetscCitationsRegister(SNESCitation,&SNEScite);CHKERRQ(ierr);
snes->reason = SNES_CONVERGED_ITERATING;
maxits = snes->max_its; /* maximum number of iterations */
X = snes->vec_sol; /* X^n */
dXold = snes->work[0]; /* The previous iterate of X */
dX = snes->work[1]; /* the preconditioned direction */
lX = snes->vec_sol_update; /* the conjugate direction */
F = snes->vec_func; /* residual vector */
ierr = SNESGetLineSearch(snes, &linesearch);CHKERRQ(ierr);
ierr = PetscObjectSAWsTakeAccess((PetscObject)snes);CHKERRQ(ierr);
snes->iter = 0;
snes->norm = 0.;
ierr = PetscObjectSAWsGrantAccess((PetscObject)snes);CHKERRQ(ierr);
/* compute the initial function and preconditioned update dX */
if (snes->pc && snes->functype == SNES_FUNCTION_PRECONDITIONED) {
ierr = SNESApplyNPC(snes,X,NULL,dX);CHKERRQ(ierr);
ierr = SNESGetConvergedReason(snes->pc,&reason);CHKERRQ(ierr);
if (reason < 0 && reason != SNES_DIVERGED_MAX_IT) {
snes->reason = SNES_DIVERGED_INNER;
PetscFunctionReturn(0);
}
ierr = VecCopy(dX,F);CHKERRQ(ierr);
ierr = VecNorm(F,NORM_2,&fnorm);CHKERRQ(ierr);
} else {
if (!snes->vec_func_init_set) {
ierr = SNESComputeFunction(snes,X,F);CHKERRQ(ierr);
if (snes->domainerror) {
snes->reason = SNES_DIVERGED_FUNCTION_DOMAIN;
PetscFunctionReturn(0);
}
} else snes->vec_func_init_set = PETSC_FALSE;
/* convergence test */
ierr = VecNorm(F,NORM_2,&fnorm);CHKERRQ(ierr);
if (PetscIsInfOrNanReal(fnorm)) {
snes->reason = SNES_DIVERGED_FNORM_NAN;
PetscFunctionReturn(0);
}
ierr = VecCopy(F,dX);CHKERRQ(ierr);
}
if (snes->pc) {
if (snes->functype == SNES_FUNCTION_UNPRECONDITIONED) {
ierr = SNESApplyNPC(snes,X,F,dX);CHKERRQ(ierr);
ierr = SNESGetConvergedReason(snes->pc,&reason);CHKERRQ(ierr);
if (reason < 0 && reason != SNES_DIVERGED_MAX_IT) {
snes->reason = SNES_DIVERGED_INNER;
PetscFunctionReturn(0);
}
}
}
ierr = VecCopy(dX,lX);CHKERRQ(ierr);
ierr = VecDot(dX, dX, &dXdotdX);CHKERRQ(ierr);
ierr = PetscObjectSAWsTakeAccess((PetscObject)snes);CHKERRQ(ierr);
snes->norm = fnorm;
ierr = PetscObjectSAWsGrantAccess((PetscObject)snes);CHKERRQ(ierr);
ierr = SNESLogConvergenceHistory(snes,fnorm,0);CHKERRQ(ierr);
ierr = SNESMonitor(snes,0,fnorm);CHKERRQ(ierr);
/* test convergence */
ierr = (*snes->ops->converged)(snes,0,0.0,0.0,fnorm,&snes->reason,snes->cnvP);CHKERRQ(ierr);
if (snes->reason) PetscFunctionReturn(0);
/* Call general purpose update function */
if (snes->ops->update) {
ierr = (*snes->ops->update)(snes, snes->iter);CHKERRQ(ierr);
}
/* first update -- just use the (preconditioned) residual direction for the initial conjugate direction */
for (i = 1; i < maxits + 1; i++) {
lsSuccess = PETSC_TRUE;
/* some update types require the old update direction or conjugate direction */
if (ncg->type != SNES_NCG_FR) {
ierr = VecCopy(dX, dXold);CHKERRQ(ierr);
}
ierr = SNESLineSearchApply(linesearch,X,F,&fnorm,lX);CHKERRQ(ierr);
ierr = SNESLineSearchGetSuccess(linesearch, &lsSuccess);CHKERRQ(ierr);
if (!lsSuccess) {
if (++snes->numFailures >= snes->maxFailures) {
snes->reason = SNES_DIVERGED_LINE_SEARCH;
PetscFunctionReturn(0);
}
}
if (snes->nfuncs >= snes->max_funcs) {
snes->reason = SNES_DIVERGED_FUNCTION_COUNT;
PetscFunctionReturn(0);
}
if (snes->domainerror) {
snes->reason = SNES_DIVERGED_FUNCTION_DOMAIN;
PetscFunctionReturn(0);
}
ierr = SNESLineSearchGetNorms(linesearch, &xnorm, &fnorm, &ynorm);CHKERRQ(ierr);
/* Monitor convergence */
ierr = PetscObjectSAWsTakeAccess((PetscObject)snes);CHKERRQ(ierr);
snes->iter = i;
snes->norm = fnorm;
ierr = PetscObjectSAWsGrantAccess((PetscObject)snes);CHKERRQ(ierr);
ierr = SNESLogConvergenceHistory(snes,snes->norm,0);CHKERRQ(ierr);
ierr = SNESMonitor(snes,snes->iter,snes->norm);CHKERRQ(ierr);
/* Test for convergence */
ierr = (*snes->ops->converged)(snes,snes->iter,xnorm,ynorm,fnorm,&snes->reason,snes->cnvP);CHKERRQ(ierr);
if (snes->reason) PetscFunctionReturn(0);
/* Call general purpose update function */
if (snes->ops->update) {
ierr = (*snes->ops->update)(snes, snes->iter);CHKERRQ(ierr);
}
if (snes->pc) {
if (snes->functype == SNES_FUNCTION_PRECONDITIONED) {
ierr = SNESApplyNPC(snes,X,NULL,dX);CHKERRQ(ierr);
ierr = SNESGetConvergedReason(snes->pc,&reason);CHKERRQ(ierr);
if (reason < 0 && reason != SNES_DIVERGED_MAX_IT) {
snes->reason = SNES_DIVERGED_INNER;
PetscFunctionReturn(0);
}
ierr = VecCopy(dX,F);CHKERRQ(ierr);
} else {
ierr = SNESApplyNPC(snes,X,F,dX);CHKERRQ(ierr);
ierr = SNESGetConvergedReason(snes->pc,&reason);CHKERRQ(ierr);
if (reason < 0 && reason != SNES_DIVERGED_MAX_IT) {
snes->reason = SNES_DIVERGED_INNER;
PetscFunctionReturn(0);
}
}
} else {
ierr = VecCopy(F,dX);CHKERRQ(ierr);
}
/* compute the conjugate direction lX = dX + beta*lX with beta = ((dX, dX) / (dX_old, dX_old) (Fletcher-Reeves update)*/
switch (ncg->type) {
case SNES_NCG_FR: /* Fletcher-Reeves */
dXolddotdXold= dXdotdX;
ierr = VecDot(dX, dX, &dXdotdX);CHKERRQ(ierr);
beta = PetscRealPart(dXdotdX / dXolddotdXold);
break;
case SNES_NCG_PRP: /* Polak-Ribiere-Poylak */
dXolddotdXold= dXdotdX;
ierr = VecDotBegin(dX, dX, &dXdotdXold);CHKERRQ(ierr);
ierr = VecDotBegin(dXold, dX, &dXdotdXold);CHKERRQ(ierr);
ierr = VecDotEnd(dX, dX, &dXdotdX);CHKERRQ(ierr);
ierr = VecDotEnd(dXold, dX, &dXdotdXold);CHKERRQ(ierr);
beta = PetscRealPart(((dXdotdX - dXdotdXold) / dXolddotdXold));
if (beta < 0.0) beta = 0.0; /* restart */
break;
case SNES_NCG_HS: /* Hestenes-Stiefel */
ierr = VecDotBegin(dX, dX, &dXdotdX);CHKERRQ(ierr);
ierr = VecDotBegin(dX, dXold, &dXdotdXold);CHKERRQ(ierr);
ierr = VecDotBegin(lX, dX, &lXdotdX);CHKERRQ(ierr);
ierr = VecDotBegin(lX, dXold, &lXdotdXold);CHKERRQ(ierr);
ierr = VecDotEnd(dX, dX, &dXdotdX);CHKERRQ(ierr);
ierr = VecDotEnd(dX, dXold, &dXdotdXold);CHKERRQ(ierr);
ierr = VecDotEnd(lX, dX, &lXdotdX);CHKERRQ(ierr);
ierr = VecDotEnd(lX, dXold, &lXdotdXold);CHKERRQ(ierr);
beta = PetscRealPart((dXdotdX - dXdotdXold) / (lXdotdX - lXdotdXold));
break;
case SNES_NCG_DY: /* Dai-Yuan */
ierr = VecDotBegin(dX, dX, &dXdotdX);CHKERRQ(ierr);
ierr = VecDotBegin(lX, dX, &lXdotdX);CHKERRQ(ierr);
ierr = VecDotBegin(lX, dXold, &lXdotdXold);CHKERRQ(ierr);
ierr = VecDotEnd(dX, dX, &dXdotdX);CHKERRQ(ierr);
ierr = VecDotEnd(lX, dX, &lXdotdX);CHKERRQ(ierr);
ierr = VecDotEnd(lX, dXold, &lXdotdXold);CHKERRQ(ierr);
beta = PetscRealPart(dXdotdX / (lXdotdXold - lXdotdX));CHKERRQ(ierr);
break;
case SNES_NCG_CD: /* Conjugate Descent */
ierr = VecDotBegin(dX, dX, &dXdotdX);CHKERRQ(ierr);
ierr = VecDotBegin(lX, dXold, &lXdotdXold);CHKERRQ(ierr);
ierr = VecDotEnd(dX, dX, &dXdotdX);CHKERRQ(ierr);
ierr = VecDotEnd(lX, dXold, &lXdotdXold);CHKERRQ(ierr);
beta = PetscRealPart(dXdotdX / lXdotdXold);CHKERRQ(ierr);
break;
}
if (ncg->monitor) {
ierr = PetscViewerASCIIPrintf(ncg->monitor, "beta = %e\n", (double)beta);CHKERRQ(ierr);
}
ierr = VecAYPX(lX, beta, dX);CHKERRQ(ierr);
}
ierr = PetscInfo1(snes, "Maximum number of iterations has been reached: %D\n", maxits);CHKERRQ(ierr);
if (!snes->reason) snes->reason = SNES_DIVERGED_MAX_IT;
PetscFunctionReturn(0);
}
PetscErrorCode KSPSolve_QCG(KSP ksp)
{
/*
Correpondence with documentation above:
B = g = gradient,
X = s = step
Note: This is not coded correctly for complex arithmetic!
*/
KSP_QCG *pcgP = (KSP_QCG*)ksp->data;
Mat Amat,Pmat;
Vec W,WA,WA2,R,P,ASP,BS,X,B;
PetscScalar scal,beta,rntrn,step;
PetscReal q1,q2,xnorm,step1,step2,rnrm,btx,xtax;
PetscReal ptasp,rtr,wtasp,bstp;
PetscReal dzero = 0.0,bsnrm;
PetscErrorCode ierr;
PetscInt i,maxit;
PC pc = ksp->pc;
PCSide side;
PetscBool diagonalscale;
PetscFunctionBegin;
ierr = PCGetDiagonalScale(ksp->pc,&diagonalscale);CHKERRQ(ierr);
if (diagonalscale) SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"Krylov method %s does not support diagonal scaling",((PetscObject)ksp)->type_name);
if (ksp->transpose_solve) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"Currently does not support transpose solve");
ksp->its = 0;
maxit = ksp->max_it;
WA = ksp->work[0];
R = ksp->work[1];
P = ksp->work[2];
ASP = ksp->work[3];
BS = ksp->work[4];
W = ksp->work[5];
WA2 = ksp->work[6];
X = ksp->vec_sol;
B = ksp->vec_rhs;
if (pcgP->delta <= dzero) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_ARG_OUTOFRANGE,"Input error: delta <= 0");
ierr = KSPGetPCSide(ksp,&side);CHKERRQ(ierr);
if (side != PC_SYMMETRIC) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_ARG_OUTOFRANGE,"Requires symmetric preconditioner!");
/* Initialize variables */
ierr = VecSet(W,0.0);CHKERRQ(ierr); /* W = 0 */
ierr = VecSet(X,0.0);CHKERRQ(ierr); /* X = 0 */
ierr = PCGetOperators(pc,&Amat,&Pmat);CHKERRQ(ierr);
/* Compute: BS = D^{-1} B */
ierr = PCApplySymmetricLeft(pc,B,BS);CHKERRQ(ierr);
ierr = VecNorm(BS,NORM_2,&bsnrm);CHKERRQ(ierr);
ierr = PetscObjectSAWsTakeAccess((PetscObject)ksp);CHKERRQ(ierr);
ksp->its = 0;
ksp->rnorm = bsnrm;
ierr = PetscObjectSAWsGrantAccess((PetscObject)ksp);CHKERRQ(ierr);
ierr = KSPLogResidualHistory(ksp,bsnrm);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,0,bsnrm);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,0,bsnrm,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) PetscFunctionReturn(0);
/* Compute the initial scaled direction and scaled residual */
ierr = VecCopy(BS,R);CHKERRQ(ierr);
ierr = VecScale(R,-1.0);CHKERRQ(ierr);
ierr = VecCopy(R,P);CHKERRQ(ierr);
ierr = VecDotRealPart(R,R,&rtr);CHKERRQ(ierr);
for (i=0; i<=maxit; i++) {
ierr = PetscObjectSAWsTakeAccess((PetscObject)ksp);CHKERRQ(ierr);
ksp->its++;
ierr = PetscObjectSAWsGrantAccess((PetscObject)ksp);CHKERRQ(ierr);
/* Compute: asp = D^{-T}*A*D^{-1}*p */
ierr = PCApplySymmetricRight(pc,P,WA);CHKERRQ(ierr);
ierr = KSP_MatMult(ksp,Amat,WA,WA2);CHKERRQ(ierr);
ierr = PCApplySymmetricLeft(pc,WA2,ASP);CHKERRQ(ierr);
/* Check for negative curvature */
ierr = VecDotRealPart(P,ASP,&ptasp);CHKERRQ(ierr);
if (ptasp <= dzero) {
/* Scaled negative curvature direction: Compute a step so that
||w + step*p|| = delta and QS(w + step*p) is least */
if (!i) {
ierr = VecCopy(P,X);CHKERRQ(ierr);
ierr = VecNorm(X,NORM_2,&xnorm);CHKERRQ(ierr);
scal = pcgP->delta / xnorm;
ierr = VecScale(X,scal);CHKERRQ(ierr);
} else {
/* Compute roots of quadratic */
ierr = KSPQCGQuadraticRoots(W,P,pcgP->delta,&step1,&step2);CHKERRQ(ierr);
ierr = VecDotRealPart(W,ASP,&wtasp);CHKERRQ(ierr);
ierr = VecDotRealPart(BS,P,&bstp);CHKERRQ(ierr);
ierr = VecCopy(W,X);CHKERRQ(ierr);
q1 = step1*(bstp + wtasp + .5*step1*ptasp);
q2 = step2*(bstp + wtasp + .5*step2*ptasp);
if (q1 <= q2) {
ierr = VecAXPY(X,step1,P);CHKERRQ(ierr);
} else {
ierr = VecAXPY(X,step2,P);CHKERRQ(ierr);
}
}
pcgP->ltsnrm = pcgP->delta; /* convergence in direction of */
ksp->reason = KSP_CONVERGED_CG_NEG_CURVE; /* negative curvature */
if (!i) {
ierr = PetscInfo1(ksp,"negative curvature: delta=%g\n",(double)pcgP->delta);CHKERRQ(ierr);
} else {
ierr = PetscInfo3(ksp,"negative curvature: step1=%g, step2=%g, delta=%g\n",(double)step1,(double)step2,(double)pcgP->delta);CHKERRQ(ierr);
}
} else {
/* Compute step along p */
step = rtr/ptasp;
ierr = VecCopy(W,X);CHKERRQ(ierr); /* x = w */
ierr = VecAXPY(X,step,P);CHKERRQ(ierr); /* x <- step*p + x */
ierr = VecNorm(X,NORM_2,&pcgP->ltsnrm);CHKERRQ(ierr);
if (pcgP->ltsnrm > pcgP->delta) {
/* Since the trial iterate is outside the trust region,
evaluate a constrained step along p so that
||w + step*p|| = delta
The positive step is always better in this case. */
if (!i) {
scal = pcgP->delta / pcgP->ltsnrm;
ierr = VecScale(X,scal);CHKERRQ(ierr);
} else {
/* Compute roots of quadratic */
ierr = KSPQCGQuadraticRoots(W,P,pcgP->delta,&step1,&step2);CHKERRQ(ierr);
ierr = VecCopy(W,X);CHKERRQ(ierr);
ierr = VecAXPY(X,step1,P);CHKERRQ(ierr); /* x <- step1*p + x */
}
pcgP->ltsnrm = pcgP->delta;
ksp->reason = KSP_CONVERGED_CG_CONSTRAINED; /* convergence along constrained step */
if (!i) {
ierr = PetscInfo1(ksp,"constrained step: delta=%g\n",(double)pcgP->delta);CHKERRQ(ierr);
} else {
ierr = PetscInfo3(ksp,"constrained step: step1=%g, step2=%g, delta=%g\n",(double)step1,(double)step2,(double)pcgP->delta);CHKERRQ(ierr);
}
} else {
/* Evaluate the current step */
ierr = VecCopy(X,W);CHKERRQ(ierr); /* update interior iterate */
ierr = VecAXPY(R,-step,ASP);CHKERRQ(ierr); /* r <- -step*asp + r */
ierr = VecNorm(R,NORM_2,&rnrm);CHKERRQ(ierr);
ierr = PetscObjectSAWsTakeAccess((PetscObject)ksp);CHKERRQ(ierr);
ksp->rnorm = rnrm;
ierr = PetscObjectSAWsGrantAccess((PetscObject)ksp);CHKERRQ(ierr);
ierr = KSPLogResidualHistory(ksp,rnrm);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,i+1,rnrm);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,i+1,rnrm,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) { /* convergence for */
ierr = PetscInfo3(ksp,"truncated step: step=%g, rnrm=%g, delta=%g\n",(double)PetscRealPart(step),(double)rnrm,(double)pcgP->delta);CHKERRQ(ierr);
}
}
}
if (ksp->reason) break; /* Convergence has been attained */
else { /* Compute a new AS-orthogonal direction */
ierr = VecDot(R,R,&rntrn);CHKERRQ(ierr);
beta = rntrn/rtr;
ierr = VecAYPX(P,beta,R);CHKERRQ(ierr); /* p <- r + beta*p */
rtr = PetscRealPart(rntrn);
}
}
if (!ksp->reason) ksp->reason = KSP_DIVERGED_ITS;
/* Unscale x */
ierr = VecCopy(X,WA2);CHKERRQ(ierr);
ierr = PCApplySymmetricRight(pc,WA2,X);CHKERRQ(ierr);
ierr = KSP_MatMult(ksp,Amat,X,WA);CHKERRQ(ierr);
ierr = VecDotRealPart(B,X,&btx);CHKERRQ(ierr);
ierr = VecDotRealPart(X,WA,&xtax);CHKERRQ(ierr);
pcgP->quadratic = btx + .5*xtax;
PetscFunctionReturn(0);
}
PetscErrorCode KSPSolve_GROPPCG(KSP ksp)
{
PetscErrorCode ierr;
PetscInt i;
PetscScalar alpha,beta = 0.0,gamma,gammaNew,t;
PetscReal dp = 0.0;
Vec x,b,r,p,s,S,z,Z;
Mat Amat,Pmat;
PetscBool diagonalscale;
PetscFunctionBegin;
ierr = PCGetDiagonalScale(ksp->pc,&diagonalscale);CHKERRQ(ierr);
if (diagonalscale) SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"Krylov method %s does not support diagonal scaling",((PetscObject)ksp)->type_name);
x = ksp->vec_sol;
b = ksp->vec_rhs;
r = ksp->work[0];
p = ksp->work[1];
s = ksp->work[2];
S = ksp->work[3];
z = ksp->work[4];
Z = ksp->work[5];
ierr = PCGetOperators(ksp->pc,&Amat,&Pmat);CHKERRQ(ierr);
ksp->its = 0;
if (!ksp->guess_zero) {
ierr = KSP_MatMult(ksp,Amat,x,r);CHKERRQ(ierr); /* r <- b - Ax */
ierr = VecAYPX(r,-1.0,b);CHKERRQ(ierr);
} else {
ierr = VecCopy(b,r);CHKERRQ(ierr); /* r <- b (x is 0) */
}
ierr = KSP_PCApply(ksp,r,z);CHKERRQ(ierr); /* z <- Br */
ierr = VecCopy(z,p);CHKERRQ(ierr); /* p <- z */
ierr = VecDotBegin(r,z,&gamma);CHKERRQ(ierr); /* gamma <- z'*r */
ierr = PetscCommSplitReductionBegin(PetscObjectComm((PetscObject)r));CHKERRQ(ierr);
ierr = KSP_MatMult(ksp,Amat,p,s);CHKERRQ(ierr); /* s <- Ap */
ierr = VecDotEnd(r,z,&gamma);CHKERRQ(ierr); /* gamma <- z'*r */
switch (ksp->normtype) {
case KSP_NORM_PRECONDITIONED:
/* This could be merged with the computation of gamma above */
ierr = VecNorm(z,NORM_2,&dp);CHKERRQ(ierr); /* dp <- z'*z = e'*A'*B'*B*A'*e' */
break;
case KSP_NORM_UNPRECONDITIONED:
/* This could be merged with the computation of gamma above */
ierr = VecNorm(r,NORM_2,&dp);CHKERRQ(ierr); /* dp <- r'*r = e'*A'*A*e */
break;
case KSP_NORM_NATURAL:
if (PetscIsInfOrNanScalar(gamma)) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_FP,"Infinite or not-a-number generated in dot product");
dp = PetscSqrtReal(PetscAbsScalar(gamma)); /* dp <- r'*z = r'*B*r = e'*A'*B*A*e */
break;
case KSP_NORM_NONE:
dp = 0.0;
break;
default: SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"%s",KSPNormTypes[ksp->normtype]);
}
ierr = KSPLogResidualHistory(ksp,dp);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,0,dp);CHKERRQ(ierr);
ksp->rnorm = dp;
ierr = (*ksp->converged)(ksp,0,dp,&ksp->reason,ksp->cnvP);CHKERRQ(ierr); /* test for convergence */
if (ksp->reason) PetscFunctionReturn(0);
i = 0;
do {
ksp->its = i+1;
i++;
ierr = VecDotBegin(p,s,&t);CHKERRQ(ierr);
ierr = PetscCommSplitReductionBegin(PetscObjectComm((PetscObject)p));CHKERRQ(ierr);
ierr = KSP_PCApply(ksp,s,S);CHKERRQ(ierr); /* S <- Bs */
ierr = VecDotEnd(p,s,&t);CHKERRQ(ierr);
alpha = gamma / t;
ierr = VecAXPY(x, alpha,p);CHKERRQ(ierr); /* x <- x + alpha * p */
ierr = VecAXPY(r,-alpha,s);CHKERRQ(ierr); /* r <- r - alpha * s */
ierr = VecAXPY(z,-alpha,S);CHKERRQ(ierr); /* z <- z - alpha * S */
if (ksp->normtype == KSP_NORM_UNPRECONDITIONED) {
ierr = VecNormBegin(r,NORM_2,&dp);CHKERRQ(ierr);
} else if (ksp->normtype == KSP_NORM_PRECONDITIONED) {
ierr = VecNormBegin(z,NORM_2,&dp);CHKERRQ(ierr);
}
ierr = VecDotBegin(r,z,&gammaNew);CHKERRQ(ierr);
ierr = PetscCommSplitReductionBegin(PetscObjectComm((PetscObject)r));CHKERRQ(ierr);
ierr = KSP_MatMult(ksp,Amat,z,Z);CHKERRQ(ierr); /* Z <- Az */
if (ksp->normtype == KSP_NORM_UNPRECONDITIONED) {
ierr = VecNormEnd(r,NORM_2,&dp);CHKERRQ(ierr);
} else if (ksp->normtype == KSP_NORM_PRECONDITIONED) {
ierr = VecNormEnd(z,NORM_2,&dp);CHKERRQ(ierr);
}
ierr = VecDotEnd(r,z,&gammaNew);CHKERRQ(ierr);
if (ksp->normtype == KSP_NORM_NATURAL) {
if (PetscIsInfOrNanScalar(gammaNew)) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_FP,"Infinite or not-a-number generated in dot product");
dp = PetscSqrtReal(PetscAbsScalar(gammaNew)); /* dp <- r'*z = r'*B*r = e'*A'*B*A*e */
} else if (ksp->normtype == KSP_NORM_NONE) {
dp = 0.0;
}
ksp->rnorm = dp;
ierr = KSPLogResidualHistory(ksp,dp);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,i,dp);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,i,dp,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) break;
beta = gammaNew / gamma;
gamma = gammaNew;
ierr = VecAYPX(p,beta,z);CHKERRQ(ierr); /* p <- z + beta * p */
ierr = VecAYPX(s,beta,Z);CHKERRQ(ierr); /* s <- Z + beta * s */
} while (i<ksp->max_it);
if (i >= ksp->max_it) ksp->reason = KSP_DIVERGED_ITS;
PetscFunctionReturn(0);
}
PetscErrorCode SNESNGMRESSelect_Private(SNES snes,PetscInt k_restart,Vec XM,Vec FM,PetscReal fMnorm,Vec XA,Vec FA,PetscReal fAnorm,PetscReal dnorm,PetscReal fminnorm,PetscReal dminnorm,Vec X,Vec F,Vec Y,PetscReal *fnorm)
{
SNES_NGMRES *ngmres = (SNES_NGMRES*) snes->data;
PetscErrorCode ierr;
PetscBool lssucceed,selectA;
PetscFunctionBegin;
if (ngmres->select_type == SNES_NGMRES_SELECT_LINESEARCH) {
/* X = X + \lambda(XA - X) */
if (ngmres->monitor) {
ierr = PetscViewerASCIIPrintf(ngmres->monitor,"||F_A||_2 = %e, ||F_M||_2 = %e\n",fAnorm,fMnorm);CHKERRQ(ierr);
}
ierr = VecCopy(FM,F);CHKERRQ(ierr);
ierr = VecCopy(XM,X);CHKERRQ(ierr);
ierr = VecCopy(XA,Y);CHKERRQ(ierr);
ierr = VecAYPX(Y,-1.0,X);CHKERRQ(ierr);
*fnorm = fMnorm;
ierr = SNESLineSearchApply(ngmres->additive_linesearch,X,F,fnorm,Y);CHKERRQ(ierr);
ierr = SNESLineSearchGetSuccess(ngmres->additive_linesearch,&lssucceed);CHKERRQ(ierr);
if (!lssucceed) {
if (++snes->numFailures >= snes->maxFailures) {
snes->reason = SNES_DIVERGED_LINE_SEARCH;
PetscFunctionReturn(0);
}
}
if (ngmres->monitor) {
ierr = PetscViewerASCIIPrintf(ngmres->monitor,"Additive solution: ||F||_2 = %e\n",*fnorm);CHKERRQ(ierr);
}
} else if (ngmres->select_type == SNES_NGMRES_SELECT_DIFFERENCE) {
selectA = PETSC_TRUE;
/* Conditions for choosing the accelerated answer */
/* Criterion A -- the norm of the function isn't increased above the minimum by too much */
if (fAnorm >= ngmres->gammaA*fminnorm) selectA = PETSC_FALSE;
/* Criterion B -- the choice of x^A isn't too close to some other choice */
if (ngmres->epsilonB*dnorm<dminnorm || PetscSqrtReal(*fnorm)<ngmres->deltaB*PetscSqrtReal(fminnorm)) {
} else selectA=PETSC_FALSE;
if (selectA) {
if (ngmres->monitor) {
ierr = PetscViewerASCIIPrintf(ngmres->monitor,"picked X_A, ||F_A||_2 = %e, ||F_M||_2 = %e\n",fAnorm,fMnorm);CHKERRQ(ierr);
}
/* copy it over */
*fnorm = fAnorm;
ierr = VecCopy(FA,F);CHKERRQ(ierr);
ierr = VecCopy(XA,X);CHKERRQ(ierr);
} else {
if (ngmres->monitor) {
ierr = PetscViewerASCIIPrintf(ngmres->monitor,"picked X_M, ||F_A||_2 = %e, ||F_M||_2 = %e\n",fAnorm,fMnorm);CHKERRQ(ierr);
}
*fnorm = fMnorm;
ierr = VecCopy(XM,Y);CHKERRQ(ierr);
ierr = VecAXPY(Y,-1.0,X);CHKERRQ(ierr);
ierr = VecCopy(FM,F);CHKERRQ(ierr);
ierr = VecCopy(XM,X);CHKERRQ(ierr);
}
} else { /* none */
*fnorm = fAnorm;
ierr = VecCopy(FA,F);CHKERRQ(ierr);
ierr = VecCopy(XA,X);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
static PetscErrorCode KSPSolve_LSQR(KSP ksp)
{
PetscErrorCode ierr;
PetscInt i,size1,size2;
PetscScalar rho,rhobar,phi,phibar,theta,c,s,tmp,tau;
PetscReal beta,alpha,rnorm;
Vec X,B,V,V1,U,U1,TMP,W,W2,SE,Z = NULL;
Mat Amat,Pmat;
MatStructure pflag;
KSP_LSQR *lsqr = (KSP_LSQR*)ksp->data;
PetscBool diagonalscale,nopreconditioner;
PetscFunctionBegin;
ierr = PCGetDiagonalScale(ksp->pc,&diagonalscale);CHKERRQ(ierr);
if (diagonalscale) SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"Krylov method %s does not support diagonal scaling",((PetscObject)ksp)->type_name);
ierr = PCGetOperators(ksp->pc,&Amat,&Pmat,&pflag);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)ksp->pc,PCNONE,&nopreconditioner);CHKERRQ(ierr);
/* nopreconditioner =PETSC_FALSE; */
/* Calculate norm of right hand side */
ierr = VecNorm(ksp->vec_rhs,NORM_2,&lsqr->rhs_norm);CHKERRQ(ierr);
/* mark norm of matrix with negative number to indicate it has not yet been computed */
lsqr->anorm = -1.0;
/* vectors of length m, where system size is mxn */
B = ksp->vec_rhs;
U = lsqr->vwork_m[0];
U1 = lsqr->vwork_m[1];
/* vectors of length n */
X = ksp->vec_sol;
W = lsqr->vwork_n[0];
V = lsqr->vwork_n[1];
V1 = lsqr->vwork_n[2];
W2 = lsqr->vwork_n[3];
if (!nopreconditioner) Z = lsqr->vwork_n[4];
/* standard error vector */
SE = lsqr->se;
if (SE) {
ierr = VecGetSize(SE,&size1);CHKERRQ(ierr);
ierr = VecGetSize(X,&size2);CHKERRQ(ierr);
if (size1 != size2) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_SIZ,"Standard error vector (size %d) does not match solution vector (size %d)",size1,size2);
ierr = VecSet(SE,0.0);CHKERRQ(ierr);
}
/* Compute initial residual, temporarily use work vector u */
if (!ksp->guess_zero) {
ierr = KSP_MatMult(ksp,Amat,X,U);CHKERRQ(ierr); /* u <- b - Ax */
ierr = VecAYPX(U,-1.0,B);CHKERRQ(ierr);
} else {
ierr = VecCopy(B,U);CHKERRQ(ierr); /* u <- b (x is 0) */
}
/* Test for nothing to do */
ierr = VecNorm(U,NORM_2,&rnorm);CHKERRQ(ierr);
ierr = PetscObjectAMSTakeAccess((PetscObject)ksp);CHKERRQ(ierr);
ksp->its = 0;
ksp->rnorm = rnorm;
ierr = PetscObjectAMSGrantAccess((PetscObject)ksp);CHKERRQ(ierr);
ierr = KSPLogResidualHistory(ksp,rnorm);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,0,rnorm);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,0,rnorm,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) PetscFunctionReturn(0);
beta = rnorm;
ierr = VecScale(U,1.0/beta);CHKERRQ(ierr);
ierr = KSP_MatMultTranspose(ksp,Amat,U,V);CHKERRQ(ierr);
if (nopreconditioner) {
ierr = VecNorm(V,NORM_2,&alpha);CHKERRQ(ierr);
} else {
ierr = PCApply(ksp->pc,V,Z);CHKERRQ(ierr);
ierr = VecDotRealPart(V,Z,&alpha);CHKERRQ(ierr);
if (alpha <= 0.0) {
ksp->reason = KSP_DIVERGED_BREAKDOWN;
PetscFunctionReturn(0);
}
alpha = PetscSqrtReal(alpha);
ierr = VecScale(Z,1.0/alpha);CHKERRQ(ierr);
}
ierr = VecScale(V,1.0/alpha);CHKERRQ(ierr);
if (nopreconditioner) {
ierr = VecCopy(V,W);CHKERRQ(ierr);
} else {
ierr = VecCopy(Z,W);CHKERRQ(ierr);
}
lsqr->arnorm = alpha * beta;
phibar = beta;
rhobar = alpha;
i = 0;
do {
if (nopreconditioner) {
ierr = KSP_MatMult(ksp,Amat,V,U1);CHKERRQ(ierr);
} else {
ierr = KSP_MatMult(ksp,Amat,Z,U1);CHKERRQ(ierr);
}
ierr = VecAXPY(U1,-alpha,U);CHKERRQ(ierr);
ierr = VecNorm(U1,NORM_2,&beta);CHKERRQ(ierr);
if (beta == 0.0) {
ksp->reason = KSP_DIVERGED_BREAKDOWN;
break;
}
ierr = VecScale(U1,1.0/beta);CHKERRQ(ierr);
ierr = KSP_MatMultTranspose(ksp,Amat,U1,V1);CHKERRQ(ierr);
ierr = VecAXPY(V1,-beta,V);CHKERRQ(ierr);
if (nopreconditioner) {
ierr = VecNorm(V1,NORM_2,&alpha);CHKERRQ(ierr);
} else {
ierr = PCApply(ksp->pc,V1,Z);CHKERRQ(ierr);
ierr = VecDotRealPart(V1,Z,&alpha);CHKERRQ(ierr);
if (alpha <= 0.0) {
ksp->reason = KSP_DIVERGED_BREAKDOWN;
break;
}
alpha = PetscSqrtReal(alpha);
ierr = VecScale(Z,1.0/alpha);CHKERRQ(ierr);
}
ierr = VecScale(V1,1.0/alpha);CHKERRQ(ierr);
rho = PetscSqrtScalar(rhobar*rhobar + beta*beta);
c = rhobar / rho;
s = beta / rho;
theta = s * alpha;
rhobar = -c * alpha;
phi = c * phibar;
phibar = s * phibar;
tau = s * phi;
ierr = VecAXPY(X,phi/rho,W);CHKERRQ(ierr); /* x <- x + (phi/rho) w */
if (SE) {
ierr = VecCopy(W,W2);CHKERRQ(ierr);
ierr = VecSquare(W2);CHKERRQ(ierr);
ierr = VecScale(W2,1.0/(rho*rho));CHKERRQ(ierr);
ierr = VecAXPY(SE, 1.0, W2);CHKERRQ(ierr); /* SE <- SE + (w^2/rho^2) */
}
if (nopreconditioner) {
ierr = VecAYPX(W,-theta/rho,V1);CHKERRQ(ierr); /* w <- v - (theta/rho) w */
} else {
ierr = VecAYPX(W,-theta/rho,Z);CHKERRQ(ierr); /* w <- z - (theta/rho) w */
}
lsqr->arnorm = alpha*PetscAbsScalar(tau);
rnorm = PetscRealPart(phibar);
ierr = PetscObjectAMSTakeAccess((PetscObject)ksp);CHKERRQ(ierr);
ksp->its++;
ksp->rnorm = rnorm;
ierr = PetscObjectAMSGrantAccess((PetscObject)ksp);CHKERRQ(ierr);
ierr = KSPLogResidualHistory(ksp,rnorm);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,i+1,rnorm);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,i+1,rnorm,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) break;
SWAP(U1,U,TMP);
SWAP(V1,V,TMP);
i++;
} while (i<ksp->max_it);
if (i >= ksp->max_it && !ksp->reason) ksp->reason = KSP_DIVERGED_ITS;
/* Finish off the standard error estimates */
if (SE) {
tmp = 1.0;
ierr = MatGetSize(Amat,&size1,&size2);CHKERRQ(ierr);
if (size1 > size2) tmp = size1 - size2;
tmp = rnorm / PetscSqrtScalar(tmp);
ierr = VecSqrtAbs(SE);CHKERRQ(ierr);
ierr = VecScale(SE,tmp);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/*
The additive cycle looks like:
xhat = x
xhat = dS(x, b)
x = coarsecorrection(xhat, b_d)
x = x + nu*(xhat - x);
(optional) x = uS(x, b)
With the coarse RHS (defect correction) as below.
*/
PetscErrorCode SNESFASCycle_Additive(SNES snes, Vec X)
{
Vec F, B, Xhat;
Vec X_c, Xo_c, F_c, B_c;
PetscErrorCode ierr;
SNESConvergedReason reason;
PetscReal xnorm, fnorm, ynorm;
PetscBool lssuccess;
SNES next;
Mat restrct, interpolate;
SNES_FAS *fas = (SNES_FAS*)snes->data,*fasc;
PetscFunctionBegin;
ierr = SNESFASCycleGetCorrection(snes, &next);CHKERRQ(ierr);
F = snes->vec_func;
B = snes->vec_rhs;
Xhat = snes->work[1];
ierr = VecCopy(X, Xhat);CHKERRQ(ierr);
/* recurse first */
if (next) {
fasc = (SNES_FAS*)next->data;
ierr = SNESFASCycleGetRestriction(snes, &restrct);CHKERRQ(ierr);
ierr = SNESFASCycleGetInterpolation(snes, &interpolate);CHKERRQ(ierr);
if (fas->eventresidual) {ierr = PetscLogEventBegin(fas->eventresidual,0,0,0,0);CHKERRQ(ierr);}
ierr = SNESComputeFunction(snes, Xhat, F);CHKERRQ(ierr);
if (fas->eventresidual) {ierr = PetscLogEventEnd(fas->eventresidual,0,0,0,0);CHKERRQ(ierr);}
ierr = VecNorm(F, NORM_2, &fnorm);CHKERRQ(ierr);
X_c = next->vec_sol;
Xo_c = next->work[0];
F_c = next->vec_func;
B_c = next->vec_rhs;
ierr = SNESFASRestrict(snes,Xhat,Xo_c);CHKERRQ(ierr);
/* restrict the defect */
ierr = MatRestrict(restrct, F, B_c);CHKERRQ(ierr);
/* solve the coarse problem corresponding to F^c(x^c) = b^c = Rb + F^c(Rx) - RF(x) */
if (fasc->eventresidual) {ierr = PetscLogEventBegin(fasc->eventresidual,0,0,0,0);CHKERRQ(ierr);}
ierr = SNESComputeFunction(next, Xo_c, F_c);CHKERRQ(ierr);
if (fasc->eventresidual) {ierr = PetscLogEventEnd(fasc->eventresidual,0,0,0,0);CHKERRQ(ierr);}
ierr = VecCopy(B_c, X_c);CHKERRQ(ierr);
ierr = VecCopy(F_c, B_c);CHKERRQ(ierr);
ierr = VecCopy(X_c, F_c);CHKERRQ(ierr);
/* set initial guess of the coarse problem to the projected fine solution */
ierr = VecCopy(Xo_c, X_c);CHKERRQ(ierr);
/* recurse */
ierr = SNESSetInitialFunction(next, F_c);CHKERRQ(ierr);
ierr = SNESSolve(next, B_c, X_c);CHKERRQ(ierr);
/* smooth on this level */
ierr = SNESFASDownSmooth_Private(snes, B, X, F, &fnorm);CHKERRQ(ierr);
ierr = SNESGetConvergedReason(next,&reason);CHKERRQ(ierr);
if (reason < 0 && reason != SNES_DIVERGED_MAX_IT) {
snes->reason = SNES_DIVERGED_INNER;
PetscFunctionReturn(0);
}
/* correct as x <- x + I(x^c - Rx)*/
ierr = VecAYPX(X_c, -1.0, Xo_c);CHKERRQ(ierr);
ierr = MatInterpolate(interpolate, X_c, Xhat);CHKERRQ(ierr);
/* additive correction of the coarse direction*/
ierr = SNESLineSearchApply(snes->linesearch, X, F, &fnorm, Xhat);CHKERRQ(ierr);
ierr = SNESLineSearchGetSuccess(snes->linesearch, &lssuccess);CHKERRQ(ierr);
if (!lssuccess) {
if (++snes->numFailures >= snes->maxFailures) {
snes->reason = SNES_DIVERGED_LINE_SEARCH;
PetscFunctionReturn(0);
}
}
ierr = SNESLineSearchGetNorms(snes->linesearch, &xnorm, &snes->norm, &ynorm);CHKERRQ(ierr);
} else {
ierr = SNESFASDownSmooth_Private(snes, B, X, F, &snes->norm);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
PetscErrorCode KSPSolve_SYMMLQ(KSP ksp)
{
PetscErrorCode ierr;
PetscInt i;
PetscScalar alpha,beta,ibeta,betaold,beta1,ceta = 0,ceta_oold = 0.0, ceta_old = 0.0,ceta_bar;
PetscScalar c = 1.0,cold=1.0,s=0.0,sold=0.0,coold,soold,rho0,rho1,rho2,rho3;
PetscScalar dp = 0.0;
PetscReal np,s_prod;
Vec X,B,R,Z,U,V,W,UOLD,VOLD,Wbar;
Mat Amat,Pmat;
MatStructure pflag;
KSP_SYMMLQ *symmlq = (KSP_SYMMLQ*)ksp->data;
PetscBool diagonalscale;
PetscFunctionBegin;
ierr = PCGetDiagonalScale(ksp->pc,&diagonalscale);CHKERRQ(ierr);
if (diagonalscale) SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"Krylov method %s does not support diagonal scaling",((PetscObject)ksp)->type_name);
X = ksp->vec_sol;
B = ksp->vec_rhs;
R = ksp->work[0];
Z = ksp->work[1];
U = ksp->work[2];
V = ksp->work[3];
W = ksp->work[4];
UOLD = ksp->work[5];
VOLD = ksp->work[6];
Wbar = ksp->work[7];
ierr = PCGetOperators(ksp->pc,&Amat,&Pmat,&pflag);CHKERRQ(ierr);
ksp->its = 0;
ierr = VecSet(UOLD,0.0);CHKERRQ(ierr); /* u_old <- zeros; */
ierr = VecCopy(UOLD,VOLD);CHKERRQ(ierr); /* v_old <- u_old; */
ierr = VecCopy(UOLD,W);CHKERRQ(ierr); /* w <- u_old; */
ierr = VecCopy(UOLD,Wbar);CHKERRQ(ierr); /* w_bar <- u_old; */
if (!ksp->guess_zero) {
ierr = KSP_MatMult(ksp,Amat,X,R);CHKERRQ(ierr); /* r <- b - A*x */
ierr = VecAYPX(R,-1.0,B);CHKERRQ(ierr);
} else {
ierr = VecCopy(B,R);CHKERRQ(ierr); /* r <- b (x is 0) */
}
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- B*r */
ierr = VecDot(R,Z,&dp);CHKERRQ(ierr); /* dp = r'*z; */
if (PetscAbsScalar(dp) < symmlq->haptol) {
ierr = PetscInfo2(ksp,"Detected happy breakdown %G tolerance %G\n",PetscAbsScalar(dp),symmlq->haptol);CHKERRQ(ierr);
ksp->rnorm = 0.0; /* what should we really put here? */
ksp->reason = KSP_CONVERGED_HAPPY_BREAKDOWN; /* bugfix proposed by Lourens ([email protected]) */
PetscFunctionReturn(0);
}
#if !defined(PETSC_USE_COMPLEX)
if (dp < 0.0) {
ksp->reason = KSP_DIVERGED_INDEFINITE_PC;
PetscFunctionReturn(0);
}
#endif
dp = PetscSqrtScalar(dp);
beta = dp; /* beta <- sqrt(r'*z) */
beta1 = beta;
s_prod = PetscAbsScalar(beta1);
ierr = VecCopy(R,V);CHKERRQ(ierr); /* v <- r; */
ierr = VecCopy(Z,U);CHKERRQ(ierr); /* u <- z; */
ibeta = 1.0 / beta;
ierr = VecScale(V,ibeta);CHKERRQ(ierr); /* v <- ibeta*v; */
ierr = VecScale(U,ibeta);CHKERRQ(ierr); /* u <- ibeta*u; */
ierr = VecCopy(U,Wbar);CHKERRQ(ierr); /* w_bar <- u; */
ierr = VecNorm(Z,NORM_2,&np);CHKERRQ(ierr); /* np <- ||z|| */
ierr = KSPLogResidualHistory(ksp,np);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,0,np);CHKERRQ(ierr);
ksp->rnorm = np;
ierr = (*ksp->converged)(ksp,0,np,&ksp->reason,ksp->cnvP);CHKERRQ(ierr); /* test for convergence */
if (ksp->reason) PetscFunctionReturn(0);
i = 0; ceta = 0.;
do {
ksp->its = i+1;
/* Update */
if (ksp->its > 1) {
ierr = VecCopy(V,VOLD);CHKERRQ(ierr); /* v_old <- v; */
ierr = VecCopy(U,UOLD);CHKERRQ(ierr); /* u_old <- u; */
ierr = VecCopy(R,V);CHKERRQ(ierr);
ierr = VecScale(V,1.0/beta);CHKERRQ(ierr); /* v <- ibeta*r; */
ierr = VecCopy(Z,U);CHKERRQ(ierr);
ierr = VecScale(U,1.0/beta);CHKERRQ(ierr); /* u <- ibeta*z; */
ierr = VecCopy(Wbar,W);CHKERRQ(ierr);
ierr = VecScale(W,c);CHKERRQ(ierr);
ierr = VecAXPY(W,s,U);CHKERRQ(ierr); /* w <- c*w_bar + s*u; (w_k) */
ierr = VecScale(Wbar,-s);CHKERRQ(ierr);
ierr = VecAXPY(Wbar,c,U);CHKERRQ(ierr); /* w_bar <- -s*w_bar + c*u; (w_bar_(k+1)) */
ierr = VecAXPY(X,ceta,W);CHKERRQ(ierr); /* x <- x + ceta * w; (xL_k) */
ceta_oold = ceta_old;
ceta_old = ceta;
}
/* Lanczos */
ierr = KSP_MatMult(ksp,Amat,U,R);CHKERRQ(ierr); /* r <- Amat*u; */
ierr = VecDot(U,R,&alpha);CHKERRQ(ierr); /* alpha <- u'*r; */
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- B*r; */
ierr = VecAXPY(R,-alpha,V);CHKERRQ(ierr); /* r <- r - alpha* v; */
ierr = VecAXPY(Z,-alpha,U);CHKERRQ(ierr); /* z <- z - alpha* u; */
ierr = VecAXPY(R,-beta,VOLD);CHKERRQ(ierr); /* r <- r - beta * v_old; */
ierr = VecAXPY(Z,-beta,UOLD);CHKERRQ(ierr); /* z <- z - beta * u_old; */
betaold = beta; /* beta_k */
ierr = VecDot(R,Z,&dp);CHKERRQ(ierr); /* dp <- r'*z; */
if (PetscAbsScalar(dp) < symmlq->haptol) {
ierr = PetscInfo2(ksp,"Detected happy breakdown %G tolerance %G\n",PetscAbsScalar(dp),symmlq->haptol);CHKERRQ(ierr);
dp = 0.0;
}
#if !defined(PETSC_USE_COMPLEX)
if (dp < 0.0) {
ksp->reason = KSP_DIVERGED_INDEFINITE_PC;
break;
}
#endif
beta = PetscSqrtScalar(dp); /* beta = sqrt(dp); */
/* QR factorization */
coold = cold; cold = c; soold = sold; sold = s;
rho0 = cold * alpha - coold * sold * betaold; /* gamma_bar */
rho1 = PetscSqrtScalar(rho0*rho0 + beta*beta); /* gamma */
rho2 = sold * alpha + coold * cold * betaold; /* delta */
rho3 = soold * betaold; /* epsilon */
/* Givens rotation: [c -s; s c] (different from the Reference!) */
c = rho0 / rho1; s = beta / rho1;
if (ksp->its==1) ceta = beta1/rho1;
else ceta = -(rho2*ceta_old + rho3*ceta_oold)/rho1;
s_prod = s_prod*PetscAbsScalar(s);
if (c == 0.0) np = s_prod*1.e16;
else np = s_prod/PetscAbsScalar(c); /* residual norm for xc_k (CGNORM) */
ksp->rnorm = np;
ierr = KSPLogResidualHistory(ksp,np);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,i+1,np);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,i+1,np,&ksp->reason,ksp->cnvP);CHKERRQ(ierr); /* test for convergence */
if (ksp->reason) break;
i++;
} while (i<ksp->max_it);
/* move to the CG point: xc_(k+1) */
if (c == 0.0) ceta_bar = ceta*1.e15;
else ceta_bar = ceta/c;
ierr = VecAXPY(X,ceta_bar,Wbar);CHKERRQ(ierr); /* x <- x + ceta_bar*w_bar */
if (i >= ksp->max_it) ksp->reason = KSP_DIVERGED_ITS;
PetscFunctionReturn(0);
}
/*
MatMult_MFFD - Default matrix-free form for Jacobian-vector product, y = F'(u)*a:
y ~= (F(u + ha) - F(u))/h,
where F = nonlinear function, as set by SNESSetFunction()
u = current iterate
h = difference interval
*/
static PetscErrorCode MatMult_MFFD(Mat mat,Vec a,Vec y)
{
MatMFFD ctx = (MatMFFD)mat->data;
PetscScalar h;
Vec w,U,F;
PetscErrorCode ierr;
PetscBool zeroa;
PetscFunctionBegin;
if (!ctx->current_u) SETERRQ(PetscObjectComm((PetscObject)mat),PETSC_ERR_ARG_WRONGSTATE,"MatMFFDSetBase() has not been called, this is often caused by forgetting to call \n\t\tMatAssemblyBegin/End on the first Mat in the SNES compute function");
/* We log matrix-free matrix-vector products separately, so that we can
separate the performance monitoring from the cases that use conventional
storage. We may eventually modify event logging to associate events
with particular objects, hence alleviating the more general problem. */
ierr = PetscLogEventBegin(MATMFFD_Mult,a,y,0,0);CHKERRQ(ierr);
w = ctx->w;
U = ctx->current_u;
F = ctx->current_f;
/*
Compute differencing parameter
*/
if (!((PetscObject)ctx)->type_name) {
ierr = MatMFFDSetType(mat,MATMFFD_WP);CHKERRQ(ierr);
ierr = MatSetFromOptions(mat);CHKERRQ(ierr);
}
ierr = (*ctx->ops->compute)(ctx,U,a,&h,&zeroa);CHKERRQ(ierr);
if (zeroa) {
ierr = VecSet(y,0.0);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
if (mat->erroriffailure && PetscIsInfOrNanScalar(h)) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Computed Nan differencing parameter h");
if (ctx->checkh) {
ierr = (*ctx->checkh)(ctx->checkhctx,U,a,&h);CHKERRQ(ierr);
}
/* keep a record of the current differencing parameter h */
ctx->currenth = h;
#if defined(PETSC_USE_COMPLEX)
ierr = PetscInfo2(mat,"Current differencing parameter: %g + %g i\n",(double)PetscRealPart(h),(double)PetscImaginaryPart(h));CHKERRQ(ierr);
#else
ierr = PetscInfo1(mat,"Current differencing parameter: %15.12e\n",h);CHKERRQ(ierr);
#endif
if (ctx->historyh && ctx->ncurrenth < ctx->maxcurrenth) {
ctx->historyh[ctx->ncurrenth] = h;
}
ctx->ncurrenth++;
#if defined(PETSC_USE_COMPLEX)
if (ctx->usecomplex) h = PETSC_i*h;
#endif
/* w = u + ha */
if (ctx->drscale) {
ierr = VecPointwiseMult(ctx->drscale,a,U);CHKERRQ(ierr);
ierr = VecAYPX(U,h,w);CHKERRQ(ierr);
} else {
ierr = VecWAXPY(w,h,a,U);CHKERRQ(ierr);
}
/* compute func(U) as base for differencing; only needed first time in and not when provided by user */
if (ctx->ncurrenth == 1 && ctx->current_f_allocated) {
ierr = (*ctx->func)(ctx->funcctx,U,F);CHKERRQ(ierr);
}
ierr = (*ctx->func)(ctx->funcctx,w,y);CHKERRQ(ierr);
#if defined(PETSC_USE_COMPLEX)
if (ctx->usecomplex) {
ierr = VecImaginaryPart(y);CHKERRQ(ierr);
h = PetscImaginaryPart(h);
} else {
ierr = VecAXPY(y,-1.0,F);CHKERRQ(ierr);
}
#else
ierr = VecAXPY(y,-1.0,F);CHKERRQ(ierr);
#endif
ierr = VecScale(y,1.0/h);CHKERRQ(ierr);
ierr = VecAXPBY(y,ctx->vshift,ctx->vscale,a);CHKERRQ(ierr);
if (ctx->dlscale) {
ierr = VecPointwiseMult(y,ctx->dlscale,y);CHKERRQ(ierr);
}
if (ctx->dshift) {
if (!ctx->dshiftw) {
ierr = VecDuplicate(y,&ctx->dshiftw);CHKERRQ(ierr);
}
ierr = VecPointwiseMult(ctx->dshift,a,ctx->dshiftw);CHKERRQ(ierr);
ierr = VecAXPY(y,1.0,ctx->dshiftw);CHKERRQ(ierr);
}
if (mat->nullsp) {ierr = MatNullSpaceRemove(mat->nullsp,y);CHKERRQ(ierr);}
ierr = PetscLogEventEnd(MATMFFD_Mult,a,y,0,0);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
void _Stokes_SLE_UzawaSolver_Solve( void* solver, void* stokesSLE ) {
Stokes_SLE_UzawaSolver* self = (Stokes_SLE_UzawaSolver*)solver;
Stokes_SLE* sle = (Stokes_SLE*)stokesSLE;
/* Create shortcuts to stuff needed on sle */
Mat K_Mat = sle->kStiffMat->matrix;
Mat G_Mat = sle->gStiffMat->matrix;
Mat D_Mat = NULL;
Mat M_Mat = NULL;
Vec uVec = sle->uSolnVec->vector;
Vec qVec = sle->pSolnVec->vector;
Vec fVec = sle->fForceVec->vector;
Vec hVec = sle->hForceVec->vector;
/* Create shortcuts to solver related stuff */
Vec qTempVec = self->pTempVec;
Vec rVec = self->rVec;
Vec sVec = self->sVec;
Vec fTempVec = self->fTempVec;
Vec vStarVec = self->vStarVec;
KSP velSolver = self->velSolver; /* Inner velocity solver */
KSP pcSolver = self->pcSolver; /* Preconditioner */
Iteration_Index maxIterations = self->maxUzawaIterations;
Iteration_Index minIterations = self->minUzawaIterations;
Iteration_Index iteration_I = 0;
Iteration_Index outputInterval = 1;
double zdotr_current = 0.0;
double zdotr_previous = 1.0;
double sdotGTrans_v;
double alpha, beta;
double absResidual;
double relResidual;
double* chosenResidual; /* We can opt to use either the absolute or relative residual in termination condition */
double uzawaRhsScale;
double divU;
double weightedResidual;
double weightedVelocityScale;
double momentumEquationResidual;
Iteration_Index innerLoopIterations;
Stream* errorStream = Journal_Register( Error_Type, (Name)Stokes_SLE_UzawaSolver_Type );
PetscInt fVecSize, qTempVecSize, uVecSize, qVecSize;
PetscScalar fVecNorm, qTempVecNorm, uVecNorm, rVecNorm, fTempVecNorm, uVecNormInf, qVecNorm, qVecNormInf;
double qGlobalProblemScale;
double qReciprocalGlobalProblemScale;
int init_info_stream_rank;
PetscScalar p_sum;
/* Bool nullsp_present; */
Bool uzawa_summary;
double time,t0,rnorm0;
PetscTruth flg;
double ksptime;
VecGetSize( qTempVec, &qTempVecSize );
qGlobalProblemScale = sqrt( (double) qTempVecSize );
qReciprocalGlobalProblemScale = 1.0 / qGlobalProblemScale;
init_info_stream_rank = Stream_GetPrintingRank( self->info );
Stream_SetPrintingRank( self->info, 0 );
/* DEFINITIONS:
See accompanying documentation
u - the displacement / velocity solution (to which constraints are applied)
q - the pressure-like variable which constrains the divergence displacement / velocity (= pressure for incompressible)
F - standard FE force vector
Fhat - Uzawa RHS = K^{-1} G F - h
K - standard FE stiffness matrix
Khat - Uzawa transformed stiffness matrix = G^T K^{-1} G
G matrix - discrete gradient operator
D matrix - discrete divergence operator = G^T for this particular algorithm
C matrix - Mass matrix (M) for compressibility
LM & DAM
*/
/* CHOICE OF RESIDUAL:
we may opt to converge on the absolute value (self->useAbsoluteTolerance == True ... default)
or the relative value of the residual (self->useAbsoluteTolerance == False)
(another possibility would be always to improve the residual by a given tolerance)
The Moresi & Solomatov (Phys Fluids, 1995) approach is to use the relative tolerance
*/
VecNorm( fVec, NORM_2, &fVecNorm );
VecGetSize( fVec, &fVecSize );
if ( fVecNorm / sqrt( (double)fVecSize ) <= 1e-99 ) {
Journal_Printf( errorStream,
"Error in func %s: The momentum force vector \"%s\" is zero. "
"The force vector should be non-zero either because of your chosen boundary "
"conditions, or because of the element force vector assembly. You have %d "
"element force vectors attached.\n",
__func__, sle->fForceVec->name, sle->fForceVec->assembleForceVector->hooks->count );
if ( sle->fForceVec->assembleForceVector->hooks->count > 0 ) {
Journal_Printf( errorStream, "You used the following force vector assembly terms:\n" );
EntryPoint_PrintConcise( sle->fForceVec->assembleForceVector, errorStream );
/* TODO : need to print the elementForceVector assembly, not the global guy!! */
}
Journal_Printf( errorStream,
"Please check values for building the force vector.\n" );
Journal_Firewall( 0, errorStream, "Exiting.\n" );
}
Journal_DPrintf( self->debug, "In %s:\n", __func__ );
Journal_RPrintfL( self->debug, 2, "Conjugate Gradient Uzawa solver with:\n");
Stream_IndentBranch( StgFEM_Debug );
Journal_RPrintfL( self->debug, 2, "Compressibility %s\n", (sle->cStiffMat)? "on" : "off");
Journal_RPrintfL( self->debug, 2, "Preconditioning %s\n", (pcSolver)? "on" : "off" );
if ( sle->cStiffMat ) {
Journal_DPrintfL( self->debug, 2, "(compressibility active)\n" );
M_Mat = sle->cStiffMat->matrix;
}
else {
Journal_DPrintfL( self->debug, 2, "(compressibility inactive)\n" );
}
if ( sle->dStiffMat ) {
Journal_DPrintfL( self->debug, 2, "(asymmetric geometry: handling D Matrix [incorrectly - will be ignored])\n" );
D_Mat = sle->dStiffMat->matrix;
}
else {
Journal_DPrintfL( self->debug, 2, "(No D -> symmetric geometry: D = Gt)\n" );
}
#if DEBUG
if ( Stream_IsPrintableLevel( self->debug, 3 ) ) {
Journal_DPrintf( self->debug, "Matrices and Vectors to solve are:\n" );
Journal_DPrintf( self->debug, "K Matrix:\n" );
/* No nice way of viewing Matrices, so commented out as incompatible with
* new 3D decomp at present --Kathleen Humble 30-04-07
* Matrix_View( sle->kStiffMat->matrix, self->debug ); */
Journal_DPrintf( self->debug, "G Matrix:\n" );
if ( D_Mat ) {
Journal_DPrintf( self->debug, "D Matrix:\n" );
}
if ( M_Mat ) {
Journal_DPrintf( self->debug, "M Matrix:\n" );
}
Journal_DPrintf( self->debug, "Z (preconditioner) Matrix:\n" );
Journal_DPrintf( self->debug, "f Vector:\n" );
_SLE_VectorView( fVec, self->debug );
Journal_DPrintf( self->debug, "h Vector:\n" );
_SLE_VectorView( hVec, self->debug );
}
#endif
/* STEP 1: Estimate the magnitude of the RHS for the transformed problem
we compute (usually to lower accuracy than elsewhere) the RHS (Fhat - h)
and store the result in qTempVec.
LM & DAM
*/
Journal_DPrintfL( self->debug, 2, "Building Fhat - h.\n" );
PetscOptionsHasName(PETSC_NULL,"-uzawa_printksptimes",&flg);
KSPSetTolerances( velSolver, self->tolerance, PETSC_DEFAULT, PETSC_DEFAULT, PETSC_DEFAULT );
if (flg) {
ksptime = MPI_Wtime();
}
KSPSolve( velSolver, fVec, vStarVec );
if (flg) {
ksptime = MPI_Wtime() - ksptime;
PetscPrintf( PETSC_COMM_WORLD, "KSP on velSolver took %lf seconds in Building Fhat step\n", ksptime);
}
KSPGetIterationNumber( velSolver, &innerLoopIterations );
Journal_DPrintfL( self->debug, 2, "Fhat inner solution: Number of iterations: %d\n", innerLoopIterations );
if ( D_Mat ) {
MatMult( D_Mat, vStarVec, qTempVec );
}
else {
MatMultTranspose( G_Mat, vStarVec, qTempVec );
}
VecAXPY( qTempVec, -1.0, hVec );
/* WARNING:
If D != G^T then the resulting \hat{K} is not likely to be symmetric, positive definite as
required by this implementation of the Uzawa iteration. This next piece of code
is VERY unlikely to work properly so it's in the sin bin for the time being - LM.
if ( D_Mat ) {
MatrixMultiply( D_Mat, vStarVec, qTempVec );
}
else {
MatrixTransposeMultiply( G_Mat, vStarVec, qTempVec );
}
LM & DAM
*/
/* STEP 2: The problem scaling - optionally normalize the uzawa residual by the magnitude of the RHS (use a relative tolerance)
For the inner velocity solver, Citcom uses a relative tolerance equal to that used for the Uzawa iteration as a whole
LM & DAM
*/
if (self->useAbsoluteTolerance) {
chosenResidual = &absResidual;
Journal_PrintfL( self->info, 2, "Absolute residual < %g for Uzawa stopping condition\n", self->tolerance);
/* We should calculate the effective relative tolerance and insert that here !! */
KSPSetTolerances( velSolver, 0.1 * self->tolerance, PETSC_DEFAULT, PETSC_DEFAULT, PETSC_DEFAULT );
}
else { /* The CITCOM compatible choice */
chosenResidual = &relResidual;
Journal_PrintfL( self->info, 2, "Relative residual < %g for Uzawa stopping condition\n", self->tolerance);
KSPSetTolerances( velSolver, 0.1 * self->tolerance, PETSC_DEFAULT, PETSC_DEFAULT, PETSC_DEFAULT );
}
Journal_DPrintfL( self->debug, 2, "Determining scaling factor for residual:\n" );
VecNorm( qTempVec, NORM_2, &qTempVecNorm );
uzawaRhsScale = ((double)qTempVecNorm) * qReciprocalGlobalProblemScale;
Journal_DPrintfL( self->debug, 2, "uzawaRhsScale = %f\n", uzawaRhsScale );
Journal_Firewall( isGoodNumber( uzawaRhsScale ), errorStream,
"Error in func '%s' for %s '%s' - uzawaRhsScale has illegal value '%g'.\n", __func__, self->type, self->name, uzawaRhsScale );
/* STEP 3: Calculate initial residual for transformed equation (\hat{F} - h - \hat{K} q_0)
Compute the solution to K u_0 = F - G q_0 (u_0 unknown)
Then G^T u* = \hat{F} - \hat{K} q_0
u_0 is also the initial velocity solution to which the constraint is applied by the subsequent iteration
LM & DAM
*/
Journal_DPrintfL( self->debug, 2, "Solving for transformed Uzawa RHS.\n" );
VecCopy( fVec, fTempVec );
VecScale( fTempVec, -1.0 );
MatMultAdd( G_Mat, qVec, fTempVec, fTempVec );
VecScale( fTempVec, -1.0 );
KSPSolve( velSolver, fTempVec, uVec );
/* Handling for NON-SYMMETRIC: relegated to sin bin (see comment above) LM & DAM */
if ( D_Mat ) {
MatMult( D_Mat, uVec, rVec );
}
else {
MatMultTranspose( G_Mat, uVec, rVec );
}
VecNorm( rVec, NORM_2, &rnorm0 );
VecNorm( uVec, NORM_2, &uVecNorm );
divU = rnorm0 / uVecNorm;
Journal_PrintfL( self->info, 2, "Initial l2Norm( Div u ) / l2Norm( u ) = %f \n", divU);
Journal_Firewall( isGoodNumber( divU ), errorStream,
"Error in func '%s' for %s '%s' - l2Norm( Div u ) has illegal value '%g'.\n",
__func__, self->type, self->name, divU );
Journal_DPrintfL( self->debug, 2, "Adding compressibility and prescribed divergence terms.\n" );
if ( M_Mat ) {
MatMultAdd( M_Mat, qVec, rVec, rVec );
}
VecAXPY( rVec, -1.0, hVec );
/* Check for existence of constant null space */
#if 0
nullsp_present = _check_if_constant_nullsp_present( self, K_Mat,G_Mat,M_Mat, fTempVec,vStarVec,qTempVec,sVec, velSolver );
#endif
/* STEP 4: Preconditioned conjugate gradient iteration loop */
Journal_DPrintfL( self->debug, 1, "Beginning main Uzawa conjugate gradient loop:\n" );
iteration_I = 0;
/* outer_it, residual, time */
uzawa_summary = self->monitor;
time = 0.0;
t0 = MPI_Wtime();
// Journal_PrintfL( self->info, 1, " |r0| = %.8e \n", rnorm0 );
do{
/* reset initial time and end time for inner its back to 0 - probs don't need to do this but just in case */
self->outeritsinitialtime = 0;
self->outeritsendtime = 0;
//BEGINNING OF OUTER ITERATIONS!!!!!
/*get wall time for start of outer loop*/
self->outeritsinitialtime = MPI_Wtime();
Journal_DPrintfL( self->debug, 2, "Beginning solve '%u'.\n", iteration_I );
Stream_IndentBranch( StgFEM_Debug );
/* STEP 4.1: Preconditioner
Solve:
Q_\hat{K} z_1 = r_1
Q_\hat{K} is an approximation to \hat{K} which is simple / trivial / quick to invert
LM & DAM
*/
if ( pcSolver ) {
PetscOptionsHasName(PETSC_NULL,"-uzawa_printksptimes",&flg);
if (flg) {
ksptime = MPI_Wtime();
}
KSPSolve( pcSolver, rVec, qTempVec );
if (flg) {
ksptime = MPI_Wtime() - ksptime;
PetscPrintf( PETSC_COMM_WORLD, "KSP on pcSolver took %lf seconds\n", ksptime);
}
}
else {
VecCopy( rVec, qTempVec );
}
/* Remove the constant null space, but only if NOT compressible */
#if 0
if( nullsp_present == True ) {
_remove_constant_nullsp( qTempVec );
}
#endif
/* STEP 4.2: Calculate s_I, the pressure search direction
z_{I-1} . r_{I-1}
\beta = (z_{I-1} . r_{I-1}) / (z_{I-2} . r_{I-2})
\beta = 0 for the first iteration
s_I = z_(I-1) + \beta * s_(I-1)
LM & DAM
*/
VecDot( qTempVec, rVec, &zdotr_current );
VecNorm( qTempVec, NORM_2, &qTempVecNorm );
VecNorm( rVec, NORM_2, &rVecNorm );
Journal_DPrintfL( self->debug, 2, "l2Norm (qTempVec) %g; (rVec) %g \n",
qTempVecNorm * qReciprocalGlobalProblemScale,
rVecNorm * qReciprocalGlobalProblemScale );
if ( iteration_I == 0 ) {
VecCopy( qTempVec, sVec );
}
else {
beta = zdotr_current/zdotr_previous;
VecAYPX( sVec, beta, qTempVec );
}
/* STEP 4.3: Velocity search direction corresponding to s_I is found by solving
K u* = G s_I
LM & DAM
*/
MatMult( G_Mat, sVec, fTempVec );
Journal_DPrintfL( self->debug, 2, "Uzawa inner iteration step\n");
//START OF INNER ITERATIONS!!!!
PetscOptionsHasName(PETSC_NULL,"-uzawa_printksptimes",&flg);
/*get initial wall time for inner loop*/
self->inneritsinitialtime = MPI_Wtime();
if (flg) {
ksptime = MPI_Wtime();
}
KSPSolve( velSolver, fTempVec, vStarVec );
if (flg) {
ksptime = MPI_Wtime() - ksptime;
PetscPrintf( PETSC_COMM_WORLD, "KSP on velSolver took %lf seconds in Uzawa inner iteration step\n", ksptime);
}
/*get end wall time for inner loop*/
self->inneritsendtime = MPI_Wtime();
/* add time to total time inner its: */
self->totalinneritstime = self->totalinneritstime + (-self->inneritsinitialtime + self->inneritsendtime);
/* reset initial time and end time for inner its back to 0 - probs don't need to do this but just in case */
self->inneritsinitialtime = 0;
self->inneritsendtime = 0;
KSPGetIterationNumber( velSolver, &innerLoopIterations );
/* add the inner loop iterations to the total inner iterations */
self->totalnuminnerits = self->totalnuminnerits + innerLoopIterations;
Journal_DPrintfL( self->debug, 2, "Completed Uzawa inner iteration in '%u' iterations \n", innerLoopIterations );
/* STEP 4.4: Calculate the step size ( \alpha = z_{I-1} . r_{I-1} / (s_I . \hat{K} s_I) )
\hat{K} s_I = G^T u* - M s_I (u* from step 4.3)
LM & DAM
*/
if ( D_Mat ) {
MatMult( D_Mat, vStarVec, qTempVec );
}
else {
MatMultTranspose( G_Mat, vStarVec, qTempVec );
}
/* Handling for NON-SYMMETRIC: relegated to sin bin (see comment above)
if ( D_Mat ) {
MatrixMultiply( D_Mat, vStarVec, qTempVec );
}
else {
MatrixTransposeMultiply( G_Mat, vStarVec, qTempVec );
}
LM & DAM
*/
if ( M_Mat ) {
Journal_DPrintfL( self->debug, 2, "Correcting for Compressibility\n" );
VecScale( qTempVec, -1.0 );
MatMultAdd( M_Mat, sVec, qTempVec, qTempVec );
VecScale( qTempVec, -1.0 );
}
VecDot( sVec, qTempVec, &sdotGTrans_v );
alpha = zdotr_current/sdotGTrans_v;
/* STEP 4.5: Update pressure, velocity and value of residual
by \alpha times corresponding search direction
LM & DAM
*/
Journal_DPrintfL( self->debug, 2, "zdotr_current = %g \n", zdotr_current);
Journal_DPrintfL( self->debug, 2, "sdotGTrans_v = %g \n", sdotGTrans_v);
Journal_DPrintfL( self->debug, 2, "alpha = %g \n", alpha);
Journal_Firewall(
isGoodNumber( zdotr_current ) && isGoodNumber( sdotGTrans_v ) && isGoodNumber( alpha ),
errorStream,
"Error in func '%s' for %s '%s' - zdotr_current, sdotGTrans_v or alpha has an illegal value: '%g','%g' or '%g'\n",
__func__, self->type, self->name, zdotr_current, sdotGTrans_v, alpha );
VecAXPY( qVec, alpha, sVec );
VecAXPY( uVec, -alpha, vStarVec );
VecAXPY( rVec, -alpha, qTempVec );
/* STEP 4.6: store the value of z_{I-1} . r_{I-1} for the next iteration
LM & DAM
*/
zdotr_previous = zdotr_current;
VecNorm( rVec, NORM_2, &rVecNorm );
absResidual = rVecNorm * qReciprocalGlobalProblemScale;
relResidual = absResidual / uzawaRhsScale;
Stream_UnIndentBranch( StgFEM_Debug );
if( iteration_I % outputInterval == 0 ) {
Journal_PrintfL( self->info, 2, "\tLoop = %u, absResidual = %.8e, relResidual = %.8e\n",
iteration_I, absResidual, relResidual );
}
Journal_Firewall( isGoodNumber( absResidual ), errorStream,
"Error in func '%s' for %s '%s' - absResidual has an illegal value: '%g'\n",
__func__, self->type, self->name, absResidual );
Journal_Firewall( iteration_I < maxIterations,
errorStream, "In func %s: Reached maximum number of iterations %u without converging; absResidual = %.5g, relResidual = %.5g \n",
__func__, iteration_I, absResidual, relResidual );
/* TODO: test for small change in 10 iterations and if so restart? */
time = MPI_Wtime()-t0;
if (uzawa_summary) {
Journal_PrintfL( self->info, 1, " %1.4d uzawa residual norm %12.13e, cpu time %5.5e\n", iteration_I+1,*chosenResidual,time );
}
iteration_I++;
//END OF OUTER ITERATION LOOP!!!
/*get wall time for end of outer loop*/
self->outeritsendtime = MPI_Wtime();
/* add time to total time inner its: */
self->totalouteritstime = self->totalouteritstime + (-self->outeritsinitialtime + self->outeritsendtime);
/* reset initial time and end time for inner its back to 0 - probs don't need to do this but just in case */
self->outeritsinitialtime = 0;
self->outeritsendtime = 0;
/* add the outer loop iterations to the total outer iterations */
self->totalnumouterits++;
} while ( (*chosenResidual > self->tolerance) || (iteration_I<minIterations) );
// } while ( *chosenResidual > self->tolerance );
Journal_DPrintfL( self->debug, 1, "Pressure solution converged. Exiting uzawa \n ");
/* STEP 5: Check all the relevant residuals and report back */
if (Stream_IsEnable( self->info ) ) {
/* This information should be in an info stream */
Journal_PrintfL( self->info, 1, "Summary:\n");
Journal_PrintfL( self->info, 1, " Uzawa its. = %04d , Uzawa residual = %12.13e\n", iteration_I, relResidual );
MatMultTranspose( G_Mat, uVec, rVec );
VecNorm( rVec, NORM_2, &rVecNorm );
VecNorm( uVec, NORM_2, &uVecNorm );
divU = rVecNorm / uVecNorm;
Journal_PrintfL( self->info, 1, " |G^T u|/|u| = %.8e\n", divU);
/* Residual for the momentum equation
Compute r = || F - Ku - Gp || / || F ||
*/
MatMult( G_Mat, qVec, vStarVec );
MatMultAdd( K_Mat, uVec, vStarVec, fTempVec );
VecAYPX( fTempVec, -1.0, fVec );
VecNorm( fTempVec, NORM_2, &fTempVecNorm );
VecNorm( fVec, NORM_2, &fVecNorm );
momentumEquationResidual = fTempVecNorm / fVecNorm;
Journal_PrintfL( self->info, 1, " |f - K u - G p|/|f| = %.8e\n", momentumEquationResidual );
Journal_Firewall( isGoodNumber( momentumEquationResidual ), errorStream,
"Bad residual for the momentum equation (|| F - Ku - Gp || / || F || = %g):\n"
"\tCheck to see if forcing term is zero or nan - \n\t|| F - Ku - Gp || = %g \n\t|| F || = %g.\n",
momentumEquationResidual,
fTempVecNorm, fVecNorm );
/* "Preconditioned" residual for the momentum equation
r_{w} = || Q_{K}(r) || / || Q_{K}(F)
fTempVec contains the residual but is overwritten once used
vStarVec is used to hold the diagonal preconditioner Q_{K}
*/
MatGetDiagonal( K_Mat, vStarVec );
VecReciprocal( vStarVec );
VecPointwiseMult( vStarVec, fTempVec, fTempVec );
VecNorm( fTempVec, NORM_2, &weightedResidual );
VecPointwiseMult( vStarVec, fVec, fTempVec );
VecNorm( fTempVec, NORM_2, &weightedVelocityScale );
Journal_PrintfL( self->info, 1, " |f - K u - G p|_w/|f|_w = %.8e\n", weightedResidual / weightedVelocityScale );
/* Report back on the solution - velocity and pressure
Note - correction for dof in Vrms ??
*/
VecNorm( uVec, NORM_INFINITY, &uVecNormInf );
VecNorm( uVec, NORM_2, &uVecNorm );
VecGetSize( uVec, &uVecSize );
VecNorm( qVec, NORM_INFINITY, &qVecNormInf );
VecNorm( qVec, NORM_2, &qVecNorm );
VecGetSize( qVec, &qVecSize );
Journal_PrintfL( self->info, 1, " |u|_{\\infty} = %.8e , u_rms = %.8e\n",
uVecNormInf, uVecNorm / sqrt( (double)uVecSize ) );
Journal_PrintfL( self->info, 1, " |p|_{\\infty} = %.8e , p_rms = %.8e\n",
qVecNormInf, qVecNorm / sqrt( (double)qVecSize ) );
{ PetscInt lmin,lmax;
PetscReal min,max;
VecMax( uVec, &lmax, &max );
VecMin( uVec, &lmin, &min );
Journal_PrintfL( self->info, 1, " min/max(u) = %.8e [%d] / %.8e [%d]\n",min,lmin,max,lmax);
VecMax( qVec, &lmax, &max );
VecMin( qVec, &lmin, &min );
Journal_PrintfL( self->info, 1, " min/max(p) = %.8e [%d] / %.8e [%d]\n",min,lmin,max,lmax);
}
VecSum( qVec, &p_sum );
Journal_PrintfL( self->info, 1, " \\sum_i p_i = %.8e \n", p_sum );
} /* journal stream enabled */
#if DEBUG
if ( Stream_IsPrintableLevel( self->debug, 3 ) ) {
Journal_DPrintf( self->debug, "Velocity solution:\n" );
_SLE_VectorView( uVec, self->debug );
Journal_DPrintf( self->debug, "Pressure solution:\n" );
_SLE_VectorView( qVec, self->debug );
}
#endif
Stream_UnIndentBranch( StgFEM_Debug );
Stream_SetPrintingRank( self->info, init_info_stream_rank );
/* Now gather up data for printing out to FrequentOutput file: */
/*!!! if non-linear need to divide by number of nonlinear iterations and we do this in SystemLinearEquations */
if((sle->isNonLinear != True)){
self->avgnuminnerits = self->totalnuminnerits/self->totalnumouterits;
self->avgnumouterits = self->totalnumouterits;
self->avgtimeouterits = (self->totalouteritstime - self->totalinneritstime)/self->totalnumouterits;
self->avgtimeinnerits = self->totalinneritstime/self->totalnuminnerits;
}
}
EXTERN_C_END
/*
SNESSolve_NCG - Solves a nonlinear system with the Nonlinear Conjugate Gradient method.
Input Parameters:
. snes - the SNES context
Output Parameter:
. outits - number of iterations until termination
Application Interface Routine: SNESSolve()
*/
#undef __FUNCT__
#define __FUNCT__ "SNESSolve_NCG"
PetscErrorCode SNESSolve_NCG(SNES snes)
{
SNES_NCG *ncg = (SNES_NCG *)snes->data;
Vec X, dX, lX, F, B, Fold;
PetscReal fnorm, ynorm, xnorm, beta = 0.0;
PetscScalar dXdotF, dXolddotFold, dXdotFold, lXdotF, lXdotFold;
PetscInt maxits, i;
PetscErrorCode ierr;
SNESConvergedReason reason;
PetscBool lsSuccess = PETSC_TRUE;
SNESLineSearch linesearch;
PetscFunctionBegin;
snes->reason = SNES_CONVERGED_ITERATING;
maxits = snes->max_its; /* maximum number of iterations */
X = snes->vec_sol; /* X^n */
Fold = snes->work[0]; /* The previous iterate of X */
dX = snes->work[1]; /* the preconditioned direction */
lX = snes->vec_sol_update; /* the conjugate direction */
F = snes->vec_func; /* residual vector */
B = snes->vec_rhs; /* the right hand side */
ierr = SNESGetSNESLineSearch(snes, &linesearch);
CHKERRQ(ierr);
ierr = PetscObjectTakeAccess(snes);
CHKERRQ(ierr);
snes->iter = 0;
snes->norm = 0.;
ierr = PetscObjectGrantAccess(snes);
CHKERRQ(ierr);
/* compute the initial function and preconditioned update dX */
if (!snes->vec_func_init_set) {
ierr = SNESComputeFunction(snes,X,F);
CHKERRQ(ierr);
if (snes->domainerror) {
snes->reason = SNES_DIVERGED_FUNCTION_DOMAIN;
PetscFunctionReturn(0);
}
} else {
snes->vec_func_init_set = PETSC_FALSE;
}
if (!snes->norm_init_set) {
/* convergence test */
ierr = VecNorm(F, NORM_2, &fnorm);
CHKERRQ(ierr); /* fnorm <- ||F|| */
if (PetscIsInfOrNanReal(fnorm)) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_FP,"Infinite or not-a-number generated in norm");
} else {
fnorm = snes->norm_init;
snes->norm_init_set = PETSC_FALSE;
}
ierr = PetscObjectTakeAccess(snes);
CHKERRQ(ierr);
snes->norm = fnorm;
ierr = PetscObjectGrantAccess(snes);
CHKERRQ(ierr);
SNESLogConvHistory(snes,fnorm,0);
ierr = SNESMonitor(snes,0,fnorm);
CHKERRQ(ierr);
/* set parameter for default relative tolerance convergence test */
snes->ttol = fnorm*snes->rtol;
/* test convergence */
ierr = (*snes->ops->converged)(snes,0,0.0,0.0,fnorm,&snes->reason,snes->cnvP);
CHKERRQ(ierr);
if (snes->reason) PetscFunctionReturn(0);
/* Call general purpose update function */
if (snes->ops->update) {
ierr = (*snes->ops->update)(snes, snes->iter);
CHKERRQ(ierr);
}
/* first update -- just use the (preconditioned) residual direction for the initial conjugate direction */
if (snes->pc && snes->pcside == PC_RIGHT) {
ierr = VecCopy(X, dX);
CHKERRQ(ierr);
ierr = SNESSetInitialFunction(snes->pc, F);
CHKERRQ(ierr);
ierr = SNESSetInitialFunctionNorm(snes->pc, fnorm);
CHKERRQ(ierr);
ierr = SNESSolve(snes->pc, B, dX);
CHKERRQ(ierr);
ierr = SNESGetConvergedReason(snes->pc,&reason);
CHKERRQ(ierr);
if (reason < 0 && (reason != SNES_DIVERGED_MAX_IT)) {
snes->reason = SNES_DIVERGED_INNER;
PetscFunctionReturn(0);
}
ierr = VecAYPX(dX,-1.0,X);
CHKERRQ(ierr);
} else {
ierr = VecCopy(F, dX);
CHKERRQ(ierr);
}
ierr = VecCopy(dX, lX);
CHKERRQ(ierr);
ierr = VecDot(F, dX, &dXdotF);
CHKERRQ(ierr);
/*
} else {
ierr = SNESNCGComputeYtJtF_Private(snes, X, F, dX, W, G, &dXdotF);CHKERRQ(ierr);
}
*/
for (i = 1; i < maxits + 1; i++) {
lsSuccess = PETSC_TRUE;
/* some update types require the old update direction or conjugate direction */
if (ncg->type != SNES_NCG_FR) {
ierr = VecCopy(F, Fold);
CHKERRQ(ierr);
}
ierr = SNESLineSearchApply(linesearch, X, F, &fnorm, lX);
CHKERRQ(ierr);
ierr = SNESLineSearchGetSuccess(linesearch, &lsSuccess);
CHKERRQ(ierr);
if (!lsSuccess) {
if (++snes->numFailures >= snes->maxFailures) {
snes->reason = SNES_DIVERGED_LINE_SEARCH;
PetscFunctionReturn(0);
}
}
if (snes->nfuncs >= snes->max_funcs) {
snes->reason = SNES_DIVERGED_FUNCTION_COUNT;
PetscFunctionReturn(0);
}
if (snes->domainerror) {
snes->reason = SNES_DIVERGED_FUNCTION_DOMAIN;
PetscFunctionReturn(0);
}
ierr = SNESLineSearchGetNorms(linesearch, &xnorm, &fnorm, &ynorm);
CHKERRQ(ierr);
/* Monitor convergence */
ierr = PetscObjectTakeAccess(snes);
CHKERRQ(ierr);
snes->iter = i;
snes->norm = fnorm;
ierr = PetscObjectGrantAccess(snes);
CHKERRQ(ierr);
SNESLogConvHistory(snes,snes->norm,0);
ierr = SNESMonitor(snes,snes->iter,snes->norm);
CHKERRQ(ierr);
/* Test for convergence */
ierr = (*snes->ops->converged)(snes,snes->iter,xnorm,ynorm,fnorm,&snes->reason,snes->cnvP);
CHKERRQ(ierr);
if (snes->reason) PetscFunctionReturn(0);
/* Call general purpose update function */
if (snes->ops->update) {
ierr = (*snes->ops->update)(snes, snes->iter);
CHKERRQ(ierr);
}
if (snes->pc && snes->pcside == PC_RIGHT) {
ierr = VecCopy(X,dX);
CHKERRQ(ierr);
ierr = SNESSetInitialFunction(snes->pc, F);
CHKERRQ(ierr);
ierr = SNESSetInitialFunctionNorm(snes->pc, fnorm);
CHKERRQ(ierr);
ierr = SNESSolve(snes->pc, B, dX);
CHKERRQ(ierr);
ierr = SNESGetConvergedReason(snes->pc,&reason);
CHKERRQ(ierr);
if (reason < 0 && (reason != SNES_DIVERGED_MAX_IT)) {
snes->reason = SNES_DIVERGED_INNER;
PetscFunctionReturn(0);
}
ierr = VecAYPX(dX,-1.0,X);
CHKERRQ(ierr);
} else {
ierr = VecCopy(F, dX);
CHKERRQ(ierr);
}
/* compute the conjugate direction lX = dX + beta*lX with beta = ((dX, dX) / (dX_old, dX_old) (Fletcher-Reeves update)*/
switch(ncg->type) {
case SNES_NCG_FR: /* Fletcher-Reeves */
dXolddotFold = dXdotF;
ierr = VecDot(dX, dX, &dXdotF);
CHKERRQ(ierr);
beta = PetscRealPart(dXdotF / dXolddotFold);
break;
case SNES_NCG_PRP: /* Polak-Ribiere-Poylak */
dXolddotFold = dXdotF;
ierr = VecDotBegin(F, dX, &dXdotF);
CHKERRQ(ierr);
ierr = VecDotBegin(Fold, dX, &dXdotFold);
CHKERRQ(ierr);
ierr = VecDotEnd(F, dX, &dXdotF);
CHKERRQ(ierr);
ierr = VecDotEnd(Fold, dX, &dXdotFold);
CHKERRQ(ierr);
beta = PetscRealPart(((dXdotF - dXdotFold) / dXolddotFold));
if (beta < 0.0) beta = 0.0; /* restart */
break;
case SNES_NCG_HS: /* Hestenes-Stiefel */
ierr = VecDotBegin(dX, F, &dXdotF);
CHKERRQ(ierr);
ierr = VecDotBegin(dX, Fold, &dXdotFold);
CHKERRQ(ierr);
ierr = VecDotBegin(lX, F, &lXdotF);
CHKERRQ(ierr);
ierr = VecDotBegin(lX, Fold, &lXdotFold);
CHKERRQ(ierr);
ierr = VecDotEnd(dX, F, &dXdotF);
CHKERRQ(ierr);
ierr = VecDotEnd(dX, Fold, &dXdotFold);
CHKERRQ(ierr);
ierr = VecDotEnd(lX, F, &lXdotF);
CHKERRQ(ierr);
ierr = VecDotEnd(lX, Fold, &lXdotFold);
CHKERRQ(ierr);
beta = PetscRealPart((dXdotF - dXdotFold) / (lXdotF - lXdotFold));
break;
case SNES_NCG_DY: /* Dai-Yuan */
ierr = VecDotBegin(dX, F, &dXdotF);
CHKERRQ(ierr);
ierr = VecDotBegin(lX, F, &lXdotF);
CHKERRQ(ierr);
ierr = VecDotBegin(lX, Fold, &lXdotFold);
CHKERRQ(ierr);
ierr = VecDotEnd(dX, F, &dXdotF);
CHKERRQ(ierr);
ierr = VecDotEnd(lX, F, &lXdotF);
CHKERRQ(ierr);
ierr = VecDotEnd(lX, Fold, &lXdotFold);
CHKERRQ(ierr);
beta = PetscRealPart(dXdotF / (lXdotFold - lXdotF));
CHKERRQ(ierr);
break;
case SNES_NCG_CD: /* Conjugate Descent */
ierr = VecDotBegin(dX, F, &dXdotF);
CHKERRQ(ierr);
ierr = VecDotBegin(lX, Fold, &lXdotFold);
CHKERRQ(ierr);
ierr = VecDotEnd(dX, F, &dXdotF);
CHKERRQ(ierr);
ierr = VecDotEnd(lX, Fold, &lXdotFold);
CHKERRQ(ierr);
beta = PetscRealPart(dXdotF / lXdotFold);
CHKERRQ(ierr);
break;
}
if (ncg->monitor) {
ierr = PetscViewerASCIIPrintf(ncg->monitor, "beta = %e\n", beta);
CHKERRQ(ierr);
}
ierr = VecAYPX(lX, beta, dX);
CHKERRQ(ierr);
}
ierr = PetscInfo1(snes, "Maximum number of iterations has been reached: %D\n", maxits);
CHKERRQ(ierr);
if (!snes->reason) snes->reason = SNES_DIVERGED_MAX_IT;
PetscFunctionReturn(0);
}
PetscErrorCode KSPSolve_Chebyshev(KSP ksp)
{
KSP_Chebyshev *cheb = (KSP_Chebyshev*)ksp->data;
PetscErrorCode ierr;
PetscInt k,kp1,km1,maxit,ktmp,i;
PetscScalar alpha,omegaprod,mu,omega,Gamma,c[3],scale;
PetscReal rnorm = 0.0;
Vec sol_orig,b,p[3],r;
Mat Amat,Pmat;
PetscBool diagonalscale;
PetscFunctionBegin;
ierr = PCGetDiagonalScale(ksp->pc,&diagonalscale);CHKERRQ(ierr);
if (diagonalscale) SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"Krylov method %s does not support diagonal scaling",((PetscObject)ksp)->type_name);
if (cheb->kspest && !cheb->estimate_current) {
PetscReal max=0.0,min=0.0;
Vec X,B;
X = ksp->work[0];
if (cheb->random) {
B = ksp->work[1];
ierr = VecSetRandom(B,cheb->random);CHKERRQ(ierr);
} else {
B = ksp->vec_rhs;
}
ierr = KSPSolve(cheb->kspest,B,X);CHKERRQ(ierr);
if (ksp->guess_zero) {
ierr = VecZeroEntries(X);CHKERRQ(ierr);
}
ierr = KSPChebyshevComputeExtremeEigenvalues_Private(cheb->kspest,&min,&max);CHKERRQ(ierr);
cheb->emin = cheb->tform[0]*min + cheb->tform[1]*max;
cheb->emax = cheb->tform[2]*min + cheb->tform[3]*max;
cheb->estimate_current = PETSC_TRUE;
}
ksp->its = 0;
ierr = PCGetOperators(ksp->pc,&Amat,&Pmat);CHKERRQ(ierr);
maxit = ksp->max_it;
/* These three point to the three active solutions, we
rotate these three at each solution update */
km1 = 0; k = 1; kp1 = 2;
sol_orig = ksp->vec_sol; /* ksp->vec_sol will be asigned to rotating vector p[k], thus save its address */
b = ksp->vec_rhs;
p[km1] = sol_orig;
p[k] = ksp->work[0];
p[kp1] = ksp->work[1];
r = ksp->work[2];
/* use scale*B as our preconditioner */
scale = 2.0/(cheb->emax + cheb->emin);
/* -alpha <= scale*lambda(B^{-1}A) <= alpha */
alpha = 1.0 - scale*(cheb->emin);
Gamma = 1.0;
mu = 1.0/alpha;
omegaprod = 2.0/alpha;
c[km1] = 1.0;
c[k] = mu;
if (!ksp->guess_zero) {
ierr = KSP_MatMult(ksp,Amat,p[km1],r);CHKERRQ(ierr); /* r = b - A*p[km1] */
ierr = VecAYPX(r,-1.0,b);CHKERRQ(ierr);
} else {
ierr = VecCopy(b,r);CHKERRQ(ierr);
}
ierr = KSP_PCApply(ksp,r,p[k]);CHKERRQ(ierr); /* p[k] = scale B^{-1}r + p[km1] */
ierr = VecAYPX(p[k],scale,p[km1]);CHKERRQ(ierr);
for (i=0; i<maxit; i++) {
ierr = PetscObjectSAWsTakeAccess((PetscObject)ksp);CHKERRQ(ierr);
ksp->its++;
ierr = PetscObjectSAWsGrantAccess((PetscObject)ksp);CHKERRQ(ierr);
c[kp1] = 2.0*mu*c[k] - c[km1];
omega = omegaprod*c[k]/c[kp1];
ierr = KSP_MatMult(ksp,Amat,p[k],r);CHKERRQ(ierr); /* r = b - Ap[k] */
ierr = VecAYPX(r,-1.0,b);CHKERRQ(ierr);
ierr = KSP_PCApply(ksp,r,p[kp1]);CHKERRQ(ierr); /* p[kp1] = B^{-1}r */
ksp->vec_sol = p[k];
/* calculate residual norm if requested */
if (ksp->normtype != KSP_NORM_NONE || ksp->numbermonitors) {
if (ksp->normtype == KSP_NORM_UNPRECONDITIONED) {
ierr = VecNorm(r,NORM_2,&rnorm);CHKERRQ(ierr);
} else {
ierr = VecNorm(p[kp1],NORM_2,&rnorm);CHKERRQ(ierr);
}
ierr = PetscObjectSAWsTakeAccess((PetscObject)ksp);CHKERRQ(ierr);
ksp->rnorm = rnorm;
ierr = PetscObjectSAWsGrantAccess((PetscObject)ksp);CHKERRQ(ierr);
ierr = KSPLogResidualHistory(ksp,rnorm);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,i,rnorm);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,i,rnorm,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) break;
}
/* y^{k+1} = omega(y^{k} - y^{k-1} + Gamma*r^{k}) + y^{k-1} */
ierr = VecAXPBYPCZ(p[kp1],1.0-omega,omega,omega*Gamma*scale,p[km1],p[k]);CHKERRQ(ierr);
ktmp = km1;
km1 = k;
k = kp1;
kp1 = ktmp;
}
if (!ksp->reason) {
if (ksp->normtype != KSP_NORM_NONE) {
ierr = KSP_MatMult(ksp,Amat,p[k],r);CHKERRQ(ierr); /* r = b - Ap[k] */
ierr = VecAYPX(r,-1.0,b);CHKERRQ(ierr);
if (ksp->normtype == KSP_NORM_UNPRECONDITIONED) {
ierr = VecNorm(r,NORM_2,&rnorm);CHKERRQ(ierr);
} else {
ierr = KSP_PCApply(ksp,r,p[kp1]);CHKERRQ(ierr); /* p[kp1] = B^{-1}r */
ierr = VecNorm(p[kp1],NORM_2,&rnorm);CHKERRQ(ierr);
}
ierr = PetscObjectSAWsTakeAccess((PetscObject)ksp);CHKERRQ(ierr);
ksp->rnorm = rnorm;
ierr = PetscObjectSAWsGrantAccess((PetscObject)ksp);CHKERRQ(ierr);
ksp->vec_sol = p[k];
ierr = KSPLogResidualHistory(ksp,rnorm);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,i,rnorm);CHKERRQ(ierr);
}
if (ksp->its >= ksp->max_it) {
if (ksp->normtype != KSP_NORM_NONE) {
ierr = (*ksp->converged)(ksp,i,rnorm,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (!ksp->reason) ksp->reason = KSP_DIVERGED_ITS;
} else ksp->reason = KSP_CONVERGED_ITS;
}
}
/* make sure solution is in vector x */
ksp->vec_sol = sol_orig;
if (k) {
ierr = VecCopy(p[k],sol_orig);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
static PetscErrorCode KSPSolve_PIPEFCG(KSP ksp)
{
PetscErrorCode ierr;
KSP_PIPEFCG *pipefcg;
PetscScalar gamma;
PetscReal dp=0.0;
Vec B,R,Z,X;
Mat Amat,Pmat;
#define VecXDot(x,y,a) (((pipefcg->type) == (KSP_CG_HERMITIAN)) ? VecDot (x,y,a) : VecTDot (x,y,a))
PetscFunctionBegin;
ierr = PetscCitationsRegister(citation,&cited);CHKERRQ(ierr);
pipefcg = (KSP_PIPEFCG*)ksp->data;
X = ksp->vec_sol;
B = ksp->vec_rhs;
R = ksp->work[0];
Z = ksp->work[1];
ierr = PCGetOperators(ksp->pc,&Amat,&Pmat);CHKERRQ(ierr);
/* Compute initial residual needed for convergence check*/
ksp->its = 0;
if (!ksp->guess_zero) {
ierr = KSP_MatMult(ksp,Amat,X,R);CHKERRQ(ierr);
ierr = VecAYPX(R,-1.0,B);CHKERRQ(ierr); /* r <- b - Ax */
} else {
ierr = VecCopy(B,R);CHKERRQ(ierr); /* r <- b (x is 0) */
}
switch (ksp->normtype) {
case KSP_NORM_PRECONDITIONED:
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
ierr = VecNorm(Z,NORM_2,&dp);CHKERRQ(ierr); /* dp <- dqrt(z'*z) = sqrt(e'*A'*B'*B*A*e) */
break;
case KSP_NORM_UNPRECONDITIONED:
ierr = VecNorm(R,NORM_2,&dp);CHKERRQ(ierr); /* dp <- sqrt(r'*r) = sqrt(e'*A'*A*e) */
break;
case KSP_NORM_NATURAL:
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
ierr = VecXDot(Z,R,&gamma);CHKERRQ(ierr);
dp = PetscSqrtReal(PetscAbsScalar(gamma)); /* dp <- sqrt(r'*z) = sqrt(e'*A'*B*A*e) */
break;
case KSP_NORM_NONE:
dp = 0.0;
break;
default: SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"%s",KSPNormTypes[ksp->normtype]);
}
/* Initial Convergence Check */
ierr = KSPLogResidualHistory(ksp,dp);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,0,dp);CHKERRQ(ierr);
ksp->rnorm = dp;
if (ksp->normtype == KSP_NORM_NONE) {
ierr = KSPConvergedSkip (ksp,0,dp,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
} else {
ierr = (*ksp->converged)(ksp,0,dp,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
}
if (ksp->reason) PetscFunctionReturn(0);
do {
/* A cycle is broken only if a norm breakdown occurs. If not the entire solve happens in a single cycle.
This is coded this way to allow both truncation and truncation-restart strategy
(see KSPFCDGetNumOldDirections()) */
ierr = KSPSolve_PIPEFCG_cycle(ksp);CHKERRQ(ierr);
if (ksp->reason) break;
if (pipefcg->norm_breakdown) {
pipefcg->n_restarts++;
pipefcg->norm_breakdown = PETSC_FALSE;
}
} while (ksp->its < ksp->max_it);
if (ksp->its >= ksp->max_it) ksp->reason = KSP_DIVERGED_ITS;
PetscFunctionReturn(0);
}
/*
SNESSolve_NEWTONTR - Implements Newton's Method with a very simple trust
region approach for solving systems of nonlinear equations.
*/
static PetscErrorCode SNESSolve_NEWTONTR(SNES snes)
{
SNES_NEWTONTR *neP = (SNES_NEWTONTR*)snes->data;
Vec X,F,Y,G,Ytmp;
PetscErrorCode ierr;
PetscInt maxits,i,lits;
PetscReal rho,fnorm,gnorm,gpnorm,xnorm=0,delta,nrm,ynorm,norm1;
PetscScalar cnorm;
KSP ksp;
SNESConvergedReason reason = SNES_CONVERGED_ITERATING;
PetscBool conv = PETSC_FALSE,breakout = PETSC_FALSE;
PetscFunctionBegin;
if (snes->xl || snes->xu || snes->ops->computevariablebounds) SETERRQ1(PetscObjectComm((PetscObject)snes),PETSC_ERR_ARG_WRONGSTATE, "SNES solver %s does not support bounds", ((PetscObject)snes)->type_name);
maxits = snes->max_its; /* maximum number of iterations */
X = snes->vec_sol; /* solution vector */
F = snes->vec_func; /* residual vector */
Y = snes->work[0]; /* work vectors */
G = snes->work[1];
Ytmp = snes->work[2];
ierr = PetscObjectSAWsTakeAccess((PetscObject)snes);CHKERRQ(ierr);
snes->iter = 0;
ierr = PetscObjectSAWsGrantAccess((PetscObject)snes);CHKERRQ(ierr);
if (!snes->vec_func_init_set) {
ierr = SNESComputeFunction(snes,X,F);CHKERRQ(ierr); /* F(X) */
} else snes->vec_func_init_set = PETSC_FALSE;
ierr = VecNorm(F,NORM_2,&fnorm);CHKERRQ(ierr); /* fnorm <- || F || */
SNESCheckFunctionNorm(snes,fnorm);
ierr = VecNorm(X,NORM_2,&xnorm);CHKERRQ(ierr); /* fnorm <- || F || */
ierr = PetscObjectSAWsTakeAccess((PetscObject)snes);CHKERRQ(ierr);
snes->norm = fnorm;
ierr = PetscObjectSAWsGrantAccess((PetscObject)snes);CHKERRQ(ierr);
delta = xnorm ? neP->delta0*xnorm : neP->delta0;
neP->delta = delta;
ierr = SNESLogConvergenceHistory(snes,fnorm,0);CHKERRQ(ierr);
ierr = SNESMonitor(snes,0,fnorm);CHKERRQ(ierr);
/* test convergence */
ierr = (*snes->ops->converged)(snes,snes->iter,0.0,0.0,fnorm,&snes->reason,snes->cnvP);CHKERRQ(ierr);
if (snes->reason) PetscFunctionReturn(0);
/* Set the stopping criteria to use the More' trick. */
ierr = PetscOptionsGetBool(((PetscObject)snes)->options,((PetscObject)snes)->prefix,"-snes_tr_ksp_regular_convergence_test",&conv,NULL);CHKERRQ(ierr);
if (!conv) {
SNES_TR_KSPConverged_Ctx *ctx;
ierr = SNESGetKSP(snes,&ksp);CHKERRQ(ierr);
ierr = PetscNew(&ctx);CHKERRQ(ierr);
ctx->snes = snes;
ierr = KSPConvergedDefaultCreate(&ctx->ctx);CHKERRQ(ierr);
ierr = KSPSetConvergenceTest(ksp,SNESTR_KSPConverged_Private,ctx,SNESTR_KSPConverged_Destroy);CHKERRQ(ierr);
ierr = PetscInfo(snes,"Using Krylov convergence test SNESTR_KSPConverged_Private\n");CHKERRQ(ierr);
}
for (i=0; i<maxits; i++) {
/* Call general purpose update function */
if (snes->ops->update) {
ierr = (*snes->ops->update)(snes, snes->iter);CHKERRQ(ierr);
}
/* Solve J Y = F, where J is Jacobian matrix */
ierr = SNESComputeJacobian(snes,X,snes->jacobian,snes->jacobian_pre);CHKERRQ(ierr);
SNESCheckJacobianDomainerror(snes);
ierr = KSPSetOperators(snes->ksp,snes->jacobian,snes->jacobian_pre);CHKERRQ(ierr);
ierr = KSPSolve(snes->ksp,F,Ytmp);CHKERRQ(ierr);
ierr = KSPGetIterationNumber(snes->ksp,&lits);CHKERRQ(ierr);
snes->linear_its += lits;
ierr = PetscInfo2(snes,"iter=%D, linear solve iterations=%D\n",snes->iter,lits);CHKERRQ(ierr);
ierr = VecNorm(Ytmp,NORM_2,&nrm);CHKERRQ(ierr);
norm1 = nrm;
while (1) {
ierr = VecCopy(Ytmp,Y);CHKERRQ(ierr);
nrm = norm1;
/* Scale Y if need be and predict new value of F norm */
if (nrm >= delta) {
nrm = delta/nrm;
gpnorm = (1.0 - nrm)*fnorm;
cnorm = nrm;
ierr = PetscInfo1(snes,"Scaling direction by %g\n",(double)nrm);CHKERRQ(ierr);
ierr = VecScale(Y,cnorm);CHKERRQ(ierr);
nrm = gpnorm;
ynorm = delta;
} else {
gpnorm = 0.0;
ierr = PetscInfo(snes,"Direction is in Trust Region\n");CHKERRQ(ierr);
ynorm = nrm;
}
ierr = VecAYPX(Y,-1.0,X);CHKERRQ(ierr); /* Y <- X - Y */
ierr = VecCopy(X,snes->vec_sol_update);CHKERRQ(ierr);
ierr = SNESComputeFunction(snes,Y,G);CHKERRQ(ierr); /* F(X) */
ierr = VecNorm(G,NORM_2,&gnorm);CHKERRQ(ierr); /* gnorm <- || g || */
if (fnorm == gpnorm) rho = 0.0;
else rho = (fnorm*fnorm - gnorm*gnorm)/(fnorm*fnorm - gpnorm*gpnorm);
/* Update size of trust region */
if (rho < neP->mu) delta *= neP->delta1;
else if (rho < neP->eta) delta *= neP->delta2;
else delta *= neP->delta3;
ierr = PetscInfo3(snes,"fnorm=%g, gnorm=%g, ynorm=%g\n",(double)fnorm,(double)gnorm,(double)ynorm);CHKERRQ(ierr);
ierr = PetscInfo3(snes,"gpred=%g, rho=%g, delta=%g\n",(double)gpnorm,(double)rho,(double)delta);CHKERRQ(ierr);
neP->delta = delta;
if (rho > neP->sigma) break;
ierr = PetscInfo(snes,"Trying again in smaller region\n");CHKERRQ(ierr);
/* check to see if progress is hopeless */
neP->itflag = PETSC_FALSE;
ierr = SNESTR_Converged_Private(snes,snes->iter,xnorm,ynorm,fnorm,&reason,snes->cnvP);CHKERRQ(ierr);
if (!reason) { ierr = (*snes->ops->converged)(snes,snes->iter,xnorm,ynorm,fnorm,&reason,snes->cnvP);CHKERRQ(ierr); }
if (reason) {
/* We're not progressing, so return with the current iterate */
ierr = SNESMonitor(snes,i+1,fnorm);CHKERRQ(ierr);
breakout = PETSC_TRUE;
break;
}
snes->numFailures++;
}
if (!breakout) {
/* Update function and solution vectors */
fnorm = gnorm;
ierr = VecCopy(G,F);CHKERRQ(ierr);
ierr = VecCopy(Y,X);CHKERRQ(ierr);
/* Monitor convergence */
ierr = PetscObjectSAWsTakeAccess((PetscObject)snes);CHKERRQ(ierr);
snes->iter = i+1;
snes->norm = fnorm;
snes->xnorm = xnorm;
snes->ynorm = ynorm;
ierr = PetscObjectSAWsGrantAccess((PetscObject)snes);CHKERRQ(ierr);
ierr = SNESLogConvergenceHistory(snes,snes->norm,lits);CHKERRQ(ierr);
ierr = SNESMonitor(snes,snes->iter,snes->norm);CHKERRQ(ierr);
/* Test for convergence, xnorm = || X || */
neP->itflag = PETSC_TRUE;
if (snes->ops->converged != SNESConvergedSkip) { ierr = VecNorm(X,NORM_2,&xnorm);CHKERRQ(ierr); }
ierr = (*snes->ops->converged)(snes,snes->iter,xnorm,ynorm,fnorm,&reason,snes->cnvP);CHKERRQ(ierr);
if (reason) break;
} else break;
}
if (i == maxits) {
ierr = PetscInfo1(snes,"Maximum number of iterations has been reached: %D\n",maxits);CHKERRQ(ierr);
if (!reason) reason = SNES_DIVERGED_MAX_IT;
}
ierr = PetscObjectSAWsTakeAccess((PetscObject)snes);CHKERRQ(ierr);
snes->reason = reason;
ierr = PetscObjectSAWsGrantAccess((PetscObject)snes);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode KSPSolve_PIPEFCG_cycle(KSP ksp)
{
PetscErrorCode ierr;
PetscInt i,j,k,idx,kdx,mi;
KSP_PIPEFCG *pipefcg;
PetscScalar alpha=0.0,gamma,*betas,*dots;
PetscReal dp=0.0, delta,*eta,*etas;
Vec B,R,Z,X,Qcurr,W,ZETAcurr,M,N,Pcurr,Scurr,*redux;
Mat Amat,Pmat;
PetscFunctionBegin;
/* We have not checked these routines for use with complex numbers. The inner products
are likely not defined correctly for that case */
#if (defined(PETSC_USE_COMPLEX) && !defined(PETSC_SKIP_COMPLEX))
SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"PIPEFGMRES has not been implemented for use with complex scalars");
#endif
#define VecXDot(x,y,a) (((pipefcg->type) == (KSP_CG_HERMITIAN)) ? VecDot (x,y,a) : VecTDot (x,y,a))
#define VecXDotBegin(x,y,a) (((pipefcg->type) == (KSP_CG_HERMITIAN)) ? VecDotBegin (x,y,a) : VecTDotBegin (x,y,a))
#define VecXDotEnd(x,y,a) (((pipefcg->type) == (KSP_CG_HERMITIAN)) ? VecDotEnd (x,y,a) : VecTDotEnd (x,y,a))
#define VecMXDot(x,n,y,a) (((pipefcg->type) == (KSP_CG_HERMITIAN)) ? VecMDot (x,n,y,a) : VecMTDot (x,n,y,a))
#define VecMXDotBegin(x,n,y,a) (((pipefcg->type) == (KSP_CG_HERMITIAN)) ? VecMDotBegin (x,n,y,a) : VecMTDotBegin (x,n,y,a))
#define VecMXDotEnd(x,n,y,a) (((pipefcg->type) == (KSP_CG_HERMITIAN)) ? VecMDotEnd (x,n,y,a) : VecMTDotEnd (x,n,y,a))
pipefcg = (KSP_PIPEFCG*)ksp->data;
X = ksp->vec_sol;
B = ksp->vec_rhs;
R = ksp->work[0];
Z = ksp->work[1];
W = ksp->work[2];
M = ksp->work[3];
N = ksp->work[4];
redux = pipefcg->redux;
dots = pipefcg->dots;
etas = pipefcg->etas;
betas = dots; /* dots takes the result of all dot products of which the betas are a subset */
ierr = PCGetOperators(ksp->pc,&Amat,&Pmat);CHKERRQ(ierr);
/* Compute cycle initial residual */
ierr = KSP_MatMult(ksp,Amat,X,R);CHKERRQ(ierr);
ierr = VecAYPX(R,-1.0,B);CHKERRQ(ierr); /* r <- b - Ax */
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
Pcurr = pipefcg->Pvecs[0];
Scurr = pipefcg->Svecs[0];
Qcurr = pipefcg->Qvecs[0];
ZETAcurr = pipefcg->ZETAvecs[0];
ierr = VecCopy(Z,Pcurr);CHKERRQ(ierr);
ierr = KSP_MatMult(ksp,Amat,Pcurr,Scurr);CHKERRQ(ierr); /* S = Ap */
ierr = VecCopy(Scurr,W);CHKERRQ(ierr); /* w = s = Az */
/* Initial state of pipelining intermediates */
redux[0] = R;
redux[1] = W;
ierr = VecMXDotBegin(Z,2,redux,dots);CHKERRQ(ierr);
ierr = PetscCommSplitReductionBegin(PetscObjectComm((PetscObject)Z));CHKERRQ(ierr); /* perform asynchronous reduction */
ierr = KSP_PCApply(ksp,W,M);CHKERRQ(ierr); /* m = B(w) */
ierr = KSP_MatMult(ksp,Amat,M,N);CHKERRQ(ierr); /* n = Am */
ierr = VecCopy(M,Qcurr);CHKERRQ(ierr); /* q = m */
ierr = VecCopy(N,ZETAcurr);CHKERRQ(ierr); /* zeta = n */
ierr = VecMXDotEnd(Z,2,redux,dots);CHKERRQ(ierr);
gamma = dots[0];
delta = PetscRealPart(dots[1]);
etas[0] = delta;
alpha = gamma/delta;
i = 0;
do {
ksp->its++;
/* Update X, R, Z, W */
ierr = VecAXPY(X,+alpha,Pcurr);CHKERRQ(ierr); /* x <- x + alpha * pi */
ierr = VecAXPY(R,-alpha,Scurr);CHKERRQ(ierr); /* r <- r - alpha * si */
ierr = VecAXPY(Z,-alpha,Qcurr);CHKERRQ(ierr); /* z <- z - alpha * qi */
ierr = VecAXPY(W,-alpha,ZETAcurr);CHKERRQ(ierr); /* w <- w - alpha * zetai */
/* Compute norm for convergence check */
switch (ksp->normtype) {
case KSP_NORM_PRECONDITIONED:
ierr = VecNorm(Z,NORM_2,&dp);CHKERRQ(ierr); /* dp <- sqrt(z'*z) = sqrt(e'*A'*B'*B*A*e) */
break;
case KSP_NORM_UNPRECONDITIONED:
ierr = VecNorm(R,NORM_2,&dp);CHKERRQ(ierr); /* dp <- sqrt(r'*r) = sqrt(e'*A'*A*e) */
break;
case KSP_NORM_NATURAL:
dp = PetscSqrtReal(PetscAbsScalar(gamma)); /* dp <- sqrt(r'*z) = sqrt(e'*A'*B*A*e) */
break;
case KSP_NORM_NONE:
dp = 0.0;
break;
default: SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"%s",KSPNormTypes[ksp->normtype]);
}
/* Check for convergence */
ksp->rnorm = dp;
KSPLogResidualHistory(ksp,dp);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,ksp->its,dp);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,ksp->its+1,dp,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) break;
/* Computations of current iteration done */
++i;
/* If needbe, allocate a new chunk of vectors in P and C */
ierr = KSPAllocateVectors_PIPEFCG(ksp,i+1,pipefcg->vecb);CHKERRQ(ierr);
/* Note that we wrap around and start clobbering old vectors */
idx = i % (pipefcg->mmax+1);
Pcurr = pipefcg->Pvecs[idx];
Scurr = pipefcg->Svecs[idx];
Qcurr = pipefcg->Qvecs[idx];
ZETAcurr = pipefcg->ZETAvecs[idx];
eta = pipefcg->etas+idx;
/* number of old directions to orthogonalize against */
switch(pipefcg->truncstrat){
case KSP_FCD_TRUNC_TYPE_STANDARD:
mi = pipefcg->mmax;
break;
case KSP_FCD_TRUNC_TYPE_NOTAY:
mi = ((i-1) % pipefcg->mmax)+1;
break;
default:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Unrecognized Truncation Strategy");
}
/* Pick old p,s,q,zeta in a way suitable for VecMDot */
ierr = VecCopy(Z,Pcurr);CHKERRQ(ierr);
for(k=PetscMax(0,i-mi),j=0;k<i;++j,++k){
kdx = k % (pipefcg->mmax+1);
pipefcg->Pold[j] = pipefcg->Pvecs[kdx];
pipefcg->Sold[j] = pipefcg->Svecs[kdx];
pipefcg->Qold[j] = pipefcg->Qvecs[kdx];
pipefcg->ZETAold[j] = pipefcg->ZETAvecs[kdx];
redux[j] = pipefcg->Svecs[kdx];
}
redux[j] = R; /* If the above loop is not executed redux contains only R => all beta_k = 0, only gamma, delta != 0 */
redux[j+1] = W;
ierr = VecMXDotBegin(Z,j+2,redux,betas);CHKERRQ(ierr); /* Start split reductions for beta_k = (z,s_k), gamma = (z,r), delta = (z,w) */
ierr = PetscCommSplitReductionBegin(PetscObjectComm((PetscObject)Z));CHKERRQ(ierr); /* perform asynchronous reduction */
ierr = VecWAXPY(N,-1.0,R,W);CHKERRQ(ierr); /* m = u + B(w-r): (a) ntmp = w-r */
ierr = KSP_PCApply(ksp,N,M);CHKERRQ(ierr); /* m = u + B(w-r): (b) mtmp = B(ntmp) = B(w-r) */
ierr = VecAXPY(M,1.0,Z);CHKERRQ(ierr); /* m = u + B(w-r): (c) m = z + mtmp */
ierr = KSP_MatMult(ksp,Amat,M,N);CHKERRQ(ierr); /* n = Am */
ierr = VecMXDotEnd(Z,j+2,redux,betas);CHKERRQ(ierr); /* Finish split reductions */
gamma = betas[j];
delta = PetscRealPart(betas[j+1]);
*eta = 0.;
for(k=PetscMax(0,i-mi),j=0;k<i;++j,++k){
kdx = k % (pipefcg->mmax+1);
betas[j] /= -etas[kdx]; /* betak /= etak */
*eta -= ((PetscReal)(PetscAbsScalar(betas[j])*PetscAbsScalar(betas[j]))) * etas[kdx];
/* etaitmp = -betaik^2 * etak */
}
*eta += delta; /* etai = delta -betaik^2 * etak */
if(*eta < 0.) {
pipefcg->norm_breakdown = PETSC_TRUE;
ierr = PetscInfo1(ksp,"Restart due to square root breakdown at it = \n",ksp->its);CHKERRQ(ierr);
break;
} else {
alpha= gamma/(*eta); /* alpha = gamma/etai */
}
/* project out stored search directions using classical G-S */
ierr = VecCopy(Z,Pcurr);CHKERRQ(ierr);
ierr = VecCopy(W,Scurr);CHKERRQ(ierr);
ierr = VecCopy(M,Qcurr);CHKERRQ(ierr);
ierr = VecCopy(N,ZETAcurr);CHKERRQ(ierr);
ierr = VecMAXPY(Pcurr ,j,betas,pipefcg->Pold);CHKERRQ(ierr); /* pi <- ui - sum_k beta_k p_k */
ierr = VecMAXPY(Scurr ,j,betas,pipefcg->Sold);CHKERRQ(ierr); /* si <- wi - sum_k beta_k s_k */
ierr = VecMAXPY(Qcurr ,j,betas,pipefcg->Qold);CHKERRQ(ierr); /* qi <- m - sum_k beta_k q_k */
ierr = VecMAXPY(ZETAcurr,j,betas,pipefcg->ZETAold);CHKERRQ(ierr); /* zetai <- n - sum_k beta_k zeta_k */
} while (ksp->its < ksp->max_it);
PetscFunctionReturn(0);
}
static PetscErrorCode KSPSolve_TCQMR(KSP ksp)
{
PetscReal rnorm0,rnorm,dp1,Gamma;
PetscScalar theta,ep,cl1,sl1,cl,sl,sprod,tau_n1,f;
PetscScalar deltmp,rho,beta,eptmp,ta,s,c,tau_n,delta;
PetscScalar dp11,dp2,rhom1,alpha,tmp;
PetscErrorCode ierr;
PetscFunctionBegin;
ksp->its = 0;
ierr = KSPInitialResidual(ksp,x,u,v,r,b);CHKERRQ(ierr);
ierr = VecNorm(r,NORM_2,&rnorm0);CHKERRQ(ierr); /* rnorm0 = ||r|| */
KSPCheckNorm(ksp,rnorm0);
ierr = (*ksp->converged)(ksp,0,rnorm0,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) PetscFunctionReturn(0);
ierr = VecSet(um1,0.0);CHKERRQ(ierr);
ierr = VecCopy(r,u);CHKERRQ(ierr);
rnorm = rnorm0;
tmp = 1.0/rnorm; ierr = VecScale(u,tmp);CHKERRQ(ierr);
ierr = VecSet(vm1,0.0);CHKERRQ(ierr);
ierr = VecCopy(u,v);CHKERRQ(ierr);
ierr = VecCopy(u,v0);CHKERRQ(ierr);
ierr = VecSet(pvec1,0.0);CHKERRQ(ierr);
ierr = VecSet(pvec2,0.0);CHKERRQ(ierr);
ierr = VecSet(p,0.0);CHKERRQ(ierr);
theta = 0.0;
ep = 0.0;
cl1 = 0.0;
sl1 = 0.0;
cl = 0.0;
sl = 0.0;
sprod = 1.0;
tau_n1= rnorm0;
f = 1.0;
Gamma = 1.0;
rhom1 = 1.0;
/*
CALCULATE SQUARED LANCZOS vectors
*/
ierr = (*ksp->converged)(ksp,ksp->its,rnorm,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
while (!ksp->reason) {
ierr = KSPMonitor(ksp,ksp->its,rnorm);CHKERRQ(ierr);
ksp->its++;
ierr = KSP_PCApplyBAorAB(ksp,u,y,vtmp);CHKERRQ(ierr); /* y = A*u */
ierr = VecDot(y,v0,&dp11);CHKERRQ(ierr);
KSPCheckDot(ksp,dp11);
ierr = VecDot(u,v0,&dp2);CHKERRQ(ierr);
alpha = dp11 / dp2; /* alpha = v0'*y/v0'*u */
deltmp = alpha;
ierr = VecCopy(y,z);CHKERRQ(ierr);
ierr = VecAXPY(z,-alpha,u);CHKERRQ(ierr); /* z = y - alpha u */
ierr = VecDot(u,v0,&rho);CHKERRQ(ierr);
beta = rho / (f*rhom1);
rhom1 = rho;
ierr = VecCopy(z,utmp);CHKERRQ(ierr); /* up1 = (A-alpha*I)*
(z-2*beta*p) + f*beta*
beta*um1 */
ierr = VecAXPY(utmp,-2.0*beta,p);CHKERRQ(ierr);
ierr = KSP_PCApplyBAorAB(ksp,utmp,up1,vtmp);CHKERRQ(ierr);
ierr = VecAXPY(up1,-alpha,utmp);CHKERRQ(ierr);
ierr = VecAXPY(up1,f*beta*beta,um1);CHKERRQ(ierr);
ierr = VecNorm(up1,NORM_2,&dp1);CHKERRQ(ierr);
KSPCheckNorm(ksp,dp1);
f = 1.0 / dp1;
ierr = VecScale(up1,f);CHKERRQ(ierr);
ierr = VecAYPX(p,-beta,z);CHKERRQ(ierr); /* p = f*(z-beta*p) */
ierr = VecScale(p,f);CHKERRQ(ierr);
ierr = VecCopy(u,um1);CHKERRQ(ierr);
ierr = VecCopy(up1,u);CHKERRQ(ierr);
beta = beta/Gamma;
eptmp = beta;
ierr = KSP_PCApplyBAorAB(ksp,v,vp1,vtmp);CHKERRQ(ierr);
ierr = VecAXPY(vp1,-alpha,v);CHKERRQ(ierr);
ierr = VecAXPY(vp1,-beta,vm1);CHKERRQ(ierr);
ierr = VecNorm(vp1,NORM_2,&Gamma);CHKERRQ(ierr);
KSPCheckNorm(ksp,Gamma);
ierr = VecScale(vp1,1.0/Gamma);CHKERRQ(ierr);
ierr = VecCopy(v,vm1);CHKERRQ(ierr);
ierr = VecCopy(vp1,v);CHKERRQ(ierr);
/*
SOLVE Ax = b
*/
/* Apply last two Given's (Gl-1 and Gl) rotations to (beta,alpha,Gamma) */
if (ksp->its > 2) {
theta = sl1*beta;
eptmp = -cl1*beta;
}
if (ksp->its > 1) {
ep = -cl*eptmp + sl*alpha;
deltmp = -sl*eptmp - cl*alpha;
}
if (PetscAbsReal(Gamma) > PetscAbsScalar(deltmp)) {
ta = -deltmp / Gamma;
s = 1.0 / PetscSqrtScalar(1.0 + ta*ta);
c = s*ta;
} else {
ta = -Gamma/deltmp;
c = 1.0 / PetscSqrtScalar(1.0 + ta*ta);
s = c*ta;
}
delta = -c*deltmp + s*Gamma;
tau_n = -c*tau_n1; tau_n1 = -s*tau_n1;
ierr = VecCopy(vm1,pvec);CHKERRQ(ierr);
ierr = VecAXPY(pvec,-theta,pvec2);CHKERRQ(ierr);
ierr = VecAXPY(pvec,-ep,pvec1);CHKERRQ(ierr);
ierr = VecScale(pvec,1.0/delta);CHKERRQ(ierr);
ierr = VecAXPY(x,tau_n,pvec);CHKERRQ(ierr);
cl1 = cl; sl1 = sl; cl = c; sl = s;
ierr = VecCopy(pvec1,pvec2);CHKERRQ(ierr);
ierr = VecCopy(pvec,pvec1);CHKERRQ(ierr);
/* Compute the upper bound on the residual norm r (See QMR paper p. 13) */
sprod = sprod*PetscAbsScalar(s);
rnorm = rnorm0 * PetscSqrtReal((PetscReal)ksp->its+2.0) * PetscRealPart(sprod);
ierr = (*ksp->converged)(ksp,ksp->its,rnorm,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->its >= ksp->max_it) {
if (!ksp->reason) ksp->reason = KSP_DIVERGED_ITS;
break;
}
}
ierr = KSPMonitor(ksp,ksp->its,rnorm);CHKERRQ(ierr);
ierr = KSPUnwindPreconditioner(ksp,x,vtmp);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode SNESSolve_NRichardson(SNES snes)
{
Vec X, Y, F;
PetscReal xnorm, fnorm, ynorm;
PetscInt maxits, i;
PetscErrorCode ierr;
PetscBool lsSuccess;
SNESConvergedReason reason;
PetscFunctionBegin;
snes->reason = SNES_CONVERGED_ITERATING;
maxits = snes->max_its; /* maximum number of iterations */
X = snes->vec_sol; /* X^n */
Y = snes->vec_sol_update; /* \tilde X */
F = snes->vec_func; /* residual vector */
ierr = PetscObjectAMSTakeAccess((PetscObject)snes);CHKERRQ(ierr);
snes->iter = 0;
snes->norm = 0.;
ierr = PetscObjectAMSGrantAccess((PetscObject)snes);CHKERRQ(ierr);
if (!snes->vec_func_init_set) {
ierr = SNESComputeFunction(snes,X,F);CHKERRQ(ierr);
if (snes->domainerror) {
snes->reason = SNES_DIVERGED_FUNCTION_DOMAIN;
PetscFunctionReturn(0);
}
} else snes->vec_func_init_set = PETSC_FALSE;
if (!snes->norm_init_set) {
ierr = VecNorm(F,NORM_2,&fnorm);CHKERRQ(ierr); /* fnorm <- ||F|| */
if (PetscIsInfOrNanReal(fnorm)) {
snes->reason = SNES_DIVERGED_FNORM_NAN;
PetscFunctionReturn(0);
}
} else {
fnorm = snes->norm_init;
snes->norm_init_set = PETSC_FALSE;
}
ierr = PetscObjectAMSTakeAccess((PetscObject)snes);CHKERRQ(ierr);
snes->norm = fnorm;
ierr = PetscObjectAMSGrantAccess((PetscObject)snes);CHKERRQ(ierr);
ierr = SNESLogConvergenceHistory(snes,fnorm,0);CHKERRQ(ierr);
ierr = SNESMonitor(snes,0,fnorm);CHKERRQ(ierr);
/* set parameter for default relative tolerance convergence test */
snes->ttol = fnorm*snes->rtol;
/* test convergence */
ierr = (*snes->ops->converged)(snes,0,0.0,0.0,fnorm,&snes->reason,snes->cnvP);CHKERRQ(ierr);
if (snes->reason) PetscFunctionReturn(0);
for (i = 0; i < maxits; i++) {
lsSuccess = PETSC_TRUE;
/* Call general purpose update function */
if (snes->ops->update) {
ierr = (*snes->ops->update)(snes, snes->iter);CHKERRQ(ierr);
}
if (snes->pc && snes->pcside == PC_RIGHT) {
ierr = VecCopy(X,Y);CHKERRQ(ierr);
ierr = SNESSetInitialFunction(snes->pc, F);CHKERRQ(ierr);
ierr = SNESSetInitialFunctionNorm(snes->pc, fnorm);CHKERRQ(ierr);
ierr = PetscLogEventBegin(SNES_NPCSolve,snes->pc,Y,snes->vec_rhs,0);CHKERRQ(ierr);
ierr = SNESSolve(snes->pc, snes->vec_rhs, Y);CHKERRQ(ierr);
ierr = PetscLogEventEnd(SNES_NPCSolve,snes->pc,Y,snes->vec_rhs,0);CHKERRQ(ierr);
ierr = SNESGetConvergedReason(snes->pc,&reason);CHKERRQ(ierr);
if (reason < 0 && reason != SNES_DIVERGED_MAX_IT) {
snes->reason = SNES_DIVERGED_INNER;
PetscFunctionReturn(0);
}
ierr = VecAYPX(Y,-1.0,X);CHKERRQ(ierr);
} else {
ierr = VecCopy(F,Y);CHKERRQ(ierr);
}
ierr = SNESLineSearchApply(snes->linesearch, X, F, &fnorm, Y);CHKERRQ(ierr);
ierr = SNESLineSearchGetNorms(snes->linesearch, &xnorm, &fnorm, &ynorm);CHKERRQ(ierr);
ierr = SNESLineSearchGetSuccess(snes->linesearch, &lsSuccess);CHKERRQ(ierr);
if (!lsSuccess) {
if (++snes->numFailures >= snes->maxFailures) {
snes->reason = SNES_DIVERGED_LINE_SEARCH;
break;
}
}
if (snes->nfuncs >= snes->max_funcs) {
snes->reason = SNES_DIVERGED_FUNCTION_COUNT;
break;
}
if (snes->domainerror) {
snes->reason = SNES_DIVERGED_FUNCTION_DOMAIN;
PetscFunctionReturn(0);
}
/* Monitor convergence */
ierr = PetscObjectAMSTakeAccess((PetscObject)snes);CHKERRQ(ierr);
snes->iter = i+1;
snes->norm = fnorm;
ierr = PetscObjectAMSGrantAccess((PetscObject)snes);CHKERRQ(ierr);
ierr = SNESLogConvergenceHistory(snes,snes->norm,0);CHKERRQ(ierr);
ierr = SNESMonitor(snes,snes->iter,snes->norm);CHKERRQ(ierr);
/* Test for convergence */
ierr = (*snes->ops->converged)(snes,snes->iter,xnorm,ynorm,fnorm,&snes->reason,snes->cnvP);CHKERRQ(ierr);
if (snes->reason) break;
}
if (i == maxits) {
ierr = PetscInfo1(snes, "Maximum number of iterations has been reached: %D\n", maxits);CHKERRQ(ierr);
if (!snes->reason) snes->reason = SNES_DIVERGED_MAX_IT;
}
PetscFunctionReturn(0);
}
PetscErrorCode KSPSolve_STCG(KSP ksp)
{
#if defined(PETSC_USE_COMPLEX)
SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP, "STCG is not available for complex systems");
#else
KSP_STCG *cg = (KSP_STCG*)ksp->data;
PetscErrorCode ierr;
MatStructure pflag;
Mat Qmat, Mmat;
Vec r, z, p, d;
PC pc;
PetscReal norm_r, norm_d, norm_dp1, norm_p, dMp;
PetscReal alpha, beta, kappa, rz, rzm1;
PetscReal rr, r2, step;
PetscInt max_cg_its;
PetscBool diagonalscale;
/***************************************************************************/
/* Check the arguments and parameters. */
/***************************************************************************/
PetscFunctionBegin;
ierr = PCGetDiagonalScale(ksp->pc, &diagonalscale);CHKERRQ(ierr);
if (diagonalscale) SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP, "Krylov method %s does not support diagonal scaling", ((PetscObject)ksp)->type_name);
if (cg->radius < 0.0) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_ARG_OUTOFRANGE, "Input error: radius < 0");
/***************************************************************************/
/* Get the workspace vectors and initialize variables */
/***************************************************************************/
r2 = cg->radius * cg->radius;
r = ksp->work[0];
z = ksp->work[1];
p = ksp->work[2];
d = ksp->vec_sol;
pc = ksp->pc;
ierr = PCGetOperators(pc, &Qmat, &Mmat, &pflag);CHKERRQ(ierr);
ierr = VecGetSize(d, &max_cg_its);CHKERRQ(ierr);
max_cg_its = PetscMin(max_cg_its, ksp->max_it);
ksp->its = 0;
/***************************************************************************/
/* Initialize objective function and direction. */
/***************************************************************************/
cg->o_fcn = 0.0;
ierr = VecSet(d, 0.0);CHKERRQ(ierr); /* d = 0 */
cg->norm_d = 0.0;
/***************************************************************************/
/* Begin the conjugate gradient method. Check the right-hand side for */
/* numerical problems. The check for not-a-number and infinite values */
/* need be performed only once. */
/***************************************************************************/
ierr = VecCopy(ksp->vec_rhs, r);CHKERRQ(ierr); /* r = -grad */
ierr = VecDot(r, r, &rr);CHKERRQ(ierr); /* rr = r^T r */
if (PetscIsInfOrNanScalar(rr)) {
/*************************************************************************/
/* The right-hand side contains not-a-number or an infinite value. */
/* The gradient step does not work; return a zero value for the step. */
/*************************************************************************/
ksp->reason = KSP_DIVERGED_NANORINF;
ierr = PetscInfo1(ksp, "KSPSolve_STCG: bad right-hand side: rr=%g\n", rr);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/***************************************************************************/
/* Check the preconditioner for numerical problems and for positive */
/* definiteness. The check for not-a-number and infinite values need be */
/* performed only once. */
/***************************************************************************/
ierr = KSP_PCApply(ksp, r, z);CHKERRQ(ierr); /* z = inv(M) r */
ierr = VecDot(r, z, &rz);CHKERRQ(ierr); /* rz = r^T inv(M) r */
if (PetscIsInfOrNanScalar(rz)) {
/*************************************************************************/
/* The preconditioner contains not-a-number or an infinite value. */
/* Return the gradient direction intersected with the trust region. */
/*************************************************************************/
ksp->reason = KSP_DIVERGED_NANORINF;
ierr = PetscInfo1(ksp, "KSPSolve_STCG: bad preconditioner: rz=%g\n", rz);CHKERRQ(ierr);
if (cg->radius != 0) {
if (r2 >= rr) {
alpha = 1.0;
cg->norm_d = PetscSqrtReal(rr);
} else {
alpha = PetscSqrtReal(r2 / rr);
cg->norm_d = cg->radius;
}
ierr = VecAXPY(d, alpha, r);CHKERRQ(ierr); /* d = d + alpha r */
/***********************************************************************/
/* Compute objective function. */
/***********************************************************************/
ierr = KSP_MatMult(ksp, Qmat, d, z);CHKERRQ(ierr);
ierr = VecAYPX(z, -0.5, ksp->vec_rhs);CHKERRQ(ierr);
ierr = VecDot(d, z, &cg->o_fcn);CHKERRQ(ierr);
cg->o_fcn = -cg->o_fcn;
++ksp->its;
}
PetscFunctionReturn(0);
}
if (rz < 0.0) {
/*************************************************************************/
/* The preconditioner is indefinite. Because this is the first */
/* and we do not have a direction yet, we use the gradient step. Note */
/* that we cannot use the preconditioned norm when computing the step */
/* because the matrix is indefinite. */
/*************************************************************************/
ksp->reason = KSP_DIVERGED_INDEFINITE_PC;
ierr = PetscInfo1(ksp, "KSPSolve_STCG: indefinite preconditioner: rz=%g\n", rz);CHKERRQ(ierr);
if (cg->radius != 0.0) {
if (r2 >= rr) {
alpha = 1.0;
cg->norm_d = PetscSqrtReal(rr);
} else {
alpha = PetscSqrtReal(r2 / rr);
cg->norm_d = cg->radius;
}
ierr = VecAXPY(d, alpha, r);CHKERRQ(ierr); /* d = d + alpha r */
/***********************************************************************/
/* Compute objective function. */
/***********************************************************************/
ierr = KSP_MatMult(ksp, Qmat, d, z);CHKERRQ(ierr);
ierr = VecAYPX(z, -0.5, ksp->vec_rhs);CHKERRQ(ierr);
ierr = VecDot(d, z, &cg->o_fcn);CHKERRQ(ierr);
cg->o_fcn = -cg->o_fcn;
++ksp->its;
}
PetscFunctionReturn(0);
}
/***************************************************************************/
/* As far as we know, the preconditioner is positive semidefinite. */
/* Compute and log the residual. Check convergence because this */
/* initializes things, but do not terminate until at least one conjugate */
/* gradient iteration has been performed. */
/***************************************************************************/
switch (ksp->normtype) {
case KSP_NORM_PRECONDITIONED:
ierr = VecNorm(z, NORM_2, &norm_r);CHKERRQ(ierr); /* norm_r = |z| */
break;
case KSP_NORM_UNPRECONDITIONED:
norm_r = PetscSqrtReal(rr); /* norm_r = |r| */
break;
case KSP_NORM_NATURAL:
norm_r = PetscSqrtReal(rz); /* norm_r = |r|_M */
break;
default:
norm_r = 0.0;
break;
}
ierr = KSPLogResidualHistory(ksp, norm_r);CHKERRQ(ierr);
ierr = KSPMonitor(ksp, ksp->its, norm_r);CHKERRQ(ierr);
ksp->rnorm = norm_r;
ierr = (*ksp->converged)(ksp, ksp->its, norm_r, &ksp->reason, ksp->cnvP);CHKERRQ(ierr);
/***************************************************************************/
/* Compute the first direction and update the iteration. */
/***************************************************************************/
ierr = VecCopy(z, p);CHKERRQ(ierr); /* p = z */
ierr = KSP_MatMult(ksp, Qmat, p, z);CHKERRQ(ierr); /* z = Q * p */
++ksp->its;
/***************************************************************************/
/* Check the matrix for numerical problems. */
/***************************************************************************/
ierr = VecDot(p, z, &kappa);CHKERRQ(ierr); /* kappa = p^T Q p */
if (PetscIsInfOrNanScalar(kappa)) {
/*************************************************************************/
/* The matrix produced not-a-number or an infinite value. In this case, */
/* we must stop and use the gradient direction. This condition need */
/* only be checked once. */
/*************************************************************************/
ksp->reason = KSP_DIVERGED_NANORINF;
ierr = PetscInfo1(ksp, "KSPSolve_STCG: bad matrix: kappa=%g\n", kappa);CHKERRQ(ierr);
if (cg->radius) {
if (r2 >= rr) {
alpha = 1.0;
cg->norm_d = PetscSqrtReal(rr);
} else {
alpha = PetscSqrtReal(r2 / rr);
cg->norm_d = cg->radius;
}
ierr = VecAXPY(d, alpha, r);CHKERRQ(ierr); /* d = d + alpha r */
/***********************************************************************/
/* Compute objective function. */
/***********************************************************************/
ierr = KSP_MatMult(ksp, Qmat, d, z);CHKERRQ(ierr);
ierr = VecAYPX(z, -0.5, ksp->vec_rhs);CHKERRQ(ierr);
ierr = VecDot(d, z, &cg->o_fcn);CHKERRQ(ierr);
cg->o_fcn = -cg->o_fcn;
++ksp->its;
}
PetscFunctionReturn(0);
}
/***************************************************************************/
/* Initialize variables for calculating the norm of the direction. */
/***************************************************************************/
dMp = 0.0;
norm_d = 0.0;
switch (cg->dtype) {
case STCG_PRECONDITIONED_DIRECTION:
norm_p = rz;
break;
default:
ierr = VecDot(p, p, &norm_p);CHKERRQ(ierr);
break;
}
/***************************************************************************/
/* Check for negative curvature. */
/***************************************************************************/
if (kappa <= 0.0) {
/*************************************************************************/
/* In this case, the matrix is indefinite and we have encountered a */
/* direction of negative curvature. Because negative curvature occurs */
/* during the first step, we must follow a direction. */
/*************************************************************************/
ksp->reason = KSP_CONVERGED_CG_NEG_CURVE;
ierr = PetscInfo1(ksp, "KSPSolve_STCG: negative curvature: kappa=%g\n", kappa);CHKERRQ(ierr);
if (cg->radius != 0.0 && norm_p > 0.0) {
/***********************************************************************/
/* Follow direction of negative curvature to the boundary of the */
/* trust region. */
/***********************************************************************/
step = PetscSqrtReal(r2 / norm_p);
cg->norm_d = cg->radius;
ierr = VecAXPY(d, step, p);CHKERRQ(ierr); /* d = d + step p */
/***********************************************************************/
/* Update objective function. */
/***********************************************************************/
cg->o_fcn += step * (0.5 * step * kappa - rz);
} else if (cg->radius != 0.0) {
/***********************************************************************/
/* The norm of the preconditioned direction is zero; use the gradient */
/* step. */
/***********************************************************************/
if (r2 >= rr) {
alpha = 1.0;
cg->norm_d = PetscSqrtReal(rr);
} else {
alpha = PetscSqrtReal(r2 / rr);
cg->norm_d = cg->radius;
}
ierr = VecAXPY(d, alpha, r);CHKERRQ(ierr); /* d = d + alpha r */
/***********************************************************************/
/* Compute objective function. */
/***********************************************************************/
ierr = KSP_MatMult(ksp, Qmat, d, z);CHKERRQ(ierr);
ierr = VecAYPX(z, -0.5, ksp->vec_rhs);CHKERRQ(ierr);
ierr = VecDot(d, z, &cg->o_fcn);CHKERRQ(ierr);
cg->o_fcn = -cg->o_fcn;
++ksp->its;
}
PetscFunctionReturn(0);
}
/***************************************************************************/
/* Run the conjugate gradient method until either the problem is solved, */
/* we encounter the boundary of the trust region, or the conjugate */
/* gradient method breaks down. */
/***************************************************************************/
while (1) {
/*************************************************************************/
/* Know that kappa is nonzero, because we have not broken down, so we */
/* can compute the steplength. */
/*************************************************************************/
alpha = rz / kappa;
/*************************************************************************/
/* Compute the steplength and check for intersection with the trust */
/* region. */
/*************************************************************************/
norm_dp1 = norm_d + alpha*(2.0*dMp + alpha*norm_p);
if (cg->radius != 0.0 && norm_dp1 >= r2) {
/***********************************************************************/
/* In this case, the matrix is positive definite as far as we know. */
/* However, the full step goes beyond the trust region. */
/***********************************************************************/
ksp->reason = KSP_CONVERGED_CG_CONSTRAINED;
ierr = PetscInfo1(ksp, "KSPSolve_STCG: constrained step: radius=%g\n", cg->radius);CHKERRQ(ierr);
if (norm_p > 0.0) {
/*********************************************************************/
/* Follow the direction to the boundary of the trust region. */
/*********************************************************************/
step = (PetscSqrtReal(dMp*dMp+norm_p*(r2-norm_d))-dMp)/norm_p;
cg->norm_d = cg->radius;
ierr = VecAXPY(d, step, p);CHKERRQ(ierr); /* d = d + step p */
/*********************************************************************/
/* Update objective function. */
/*********************************************************************/
cg->o_fcn += step * (0.5 * step * kappa - rz);
} else {
/*********************************************************************/
/* The norm of the direction is zero; there is nothing to follow. */
/*********************************************************************/
}
break;
}
/*************************************************************************/
/* Now we can update the direction and residual. */
/*************************************************************************/
ierr = VecAXPY(d, alpha, p);CHKERRQ(ierr); /* d = d + alpha p */
ierr = VecAXPY(r, -alpha, z);CHKERRQ(ierr); /* r = r - alpha Q p */
ierr = KSP_PCApply(ksp, r, z);CHKERRQ(ierr); /* z = inv(M) r */
switch (cg->dtype) {
case STCG_PRECONDITIONED_DIRECTION:
norm_d = norm_dp1;
break;
default:
ierr = VecDot(d, d, &norm_d);CHKERRQ(ierr);
break;
}
cg->norm_d = PetscSqrtReal(norm_d);
/*************************************************************************/
/* Update objective function. */
/*************************************************************************/
cg->o_fcn -= 0.5 * alpha * rz;
/*************************************************************************/
/* Check that the preconditioner appears positive semidefinite. */
/*************************************************************************/
rzm1 = rz;
ierr = VecDot(r, z, &rz);CHKERRQ(ierr); /* rz = r^T z */
if (rz < 0.0) {
/***********************************************************************/
/* The preconditioner is indefinite. */
/***********************************************************************/
ksp->reason = KSP_DIVERGED_INDEFINITE_PC;
ierr = PetscInfo1(ksp, "KSPSolve_STCG: cg indefinite preconditioner: rz=%g\n", rz);CHKERRQ(ierr);
break;
}
/*************************************************************************/
/* As far as we know, the preconditioner is positive semidefinite. */
/* Compute the residual and check for convergence. */
/*************************************************************************/
switch (ksp->normtype) {
case KSP_NORM_PRECONDITIONED:
ierr = VecNorm(z, NORM_2, &norm_r);CHKERRQ(ierr); /* norm_r = |z| */
break;
case KSP_NORM_UNPRECONDITIONED:
ierr = VecNorm(r, NORM_2, &norm_r);CHKERRQ(ierr); /* norm_r = |r| */
break;
case KSP_NORM_NATURAL:
norm_r = PetscSqrtReal(rz); /* norm_r = |r|_M */
break;
default:
norm_r = 0.0;
break;
}
ierr = KSPLogResidualHistory(ksp, norm_r);CHKERRQ(ierr);
ierr = KSPMonitor(ksp, ksp->its, norm_r);CHKERRQ(ierr);
ksp->rnorm = norm_r;
ierr = (*ksp->converged)(ksp, ksp->its, norm_r, &ksp->reason, ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) {
/***********************************************************************/
/* The method has converged. */
/***********************************************************************/
ierr = PetscInfo2(ksp, "KSPSolve_STCG: truncated step: rnorm=%g, radius=%g\n", norm_r, cg->radius);CHKERRQ(ierr);
break;
}
/*************************************************************************/
/* We have not converged yet. Check for breakdown. */
/*************************************************************************/
beta = rz / rzm1;
if (fabs(beta) <= 0.0) {
/***********************************************************************/
/* Conjugate gradients has broken down. */
/***********************************************************************/
ksp->reason = KSP_DIVERGED_BREAKDOWN;
ierr = PetscInfo1(ksp, "KSPSolve_STCG: breakdown: beta=%g\n", beta);CHKERRQ(ierr);
break;
}
/*************************************************************************/
/* Check iteration limit. */
/*************************************************************************/
if (ksp->its >= max_cg_its) {
ksp->reason = KSP_DIVERGED_ITS;
ierr = PetscInfo1(ksp, "KSPSolve_STCG: iterlim: its=%d\n", ksp->its);CHKERRQ(ierr);
break;
}
/*************************************************************************/
/* Update p and the norms. */
/*************************************************************************/
ierr = VecAYPX(p, beta, z);CHKERRQ(ierr); /* p = z + beta p */
switch (cg->dtype) {
case STCG_PRECONDITIONED_DIRECTION:
dMp = beta*(dMp + alpha*norm_p);
norm_p = beta*(rzm1 + beta*norm_p);
break;
default:
ierr = VecDot(d, p, &dMp);CHKERRQ(ierr);
ierr = VecDot(p, p, &norm_p);CHKERRQ(ierr);
break;
}
/*************************************************************************/
/* Compute the new direction and update the iteration. */
/*************************************************************************/
ierr = KSP_MatMult(ksp, Qmat, p, z);CHKERRQ(ierr); /* z = Q * p */
ierr = VecDot(p, z, &kappa);CHKERRQ(ierr); /* kappa = p^T Q p */
++ksp->its;
/*************************************************************************/
/* Check for negative curvature. */
/*************************************************************************/
if (kappa <= 0.0) {
/***********************************************************************/
/* In this case, the matrix is indefinite and we have encountered */
/* a direction of negative curvature. Follow the direction to the */
/* boundary of the trust region. */
/***********************************************************************/
ksp->reason = KSP_CONVERGED_CG_NEG_CURVE;
ierr = PetscInfo1(ksp, "KSPSolve_STCG: negative curvature: kappa=%g\n", kappa);CHKERRQ(ierr);
if (cg->radius != 0.0 && norm_p > 0.0) {
/*********************************************************************/
/* Follow direction of negative curvature to boundary. */
/*********************************************************************/
step = (PetscSqrtReal(dMp*dMp+norm_p*(r2-norm_d))-dMp)/norm_p;
cg->norm_d = cg->radius;
ierr = VecAXPY(d, step, p);CHKERRQ(ierr); /* d = d + step p */
/*********************************************************************/
/* Update objective function. */
/*********************************************************************/
cg->o_fcn += step * (0.5 * step * kappa - rz);
} else if (cg->radius != 0.0) {
/*********************************************************************/
/* The norm of the direction is zero; there is nothing to follow. */
/*********************************************************************/
}
break;
}
}
PetscFunctionReturn(0);
#endif
}
