PetscErrorCode BSSCR_KSPSetConvergenceMinIts(KSP ksp, PetscInt n, KSP_BSSCR * bsscr)
{
BSSCR_KSPConverged_Ctx *ctx;
PetscErrorCode ierr;
PetscFunctionBegin;
bsscr->min_it = n; /* set minimum its */
#if ( (PETSC_VERSION_MAJOR == 3) && (PETSC_VERSION_MINOR >= 5 ) )
ierr = Stg_PetscNew(BSSCR_KSPConverged_Ctx,&ctx);CHKERRQ(ierr);
ierr = KSPConvergedDefaultCreate(&ctx->ctx);CHKERRQ(ierr);
ctx->bsscr=bsscr;
ierr = KSPSetConvergenceTest(ksp,BSSCR_KSPConverged,ctx,BSSCR_KSPConverged_Destroy);CHKERRQ(ierr);
#endif
#if ( (PETSC_VERSION_MAJOR == 3) && (PETSC_VERSION_MINOR <=4 ) )
ierr = Stg_PetscNew(BSSCR_KSPConverged_Ctx,&ctx);CHKERRQ(ierr);
ierr = KSPDefaultConvergedCreate(&ctx->ctx);CHKERRQ(ierr);
ctx->bsscr=bsscr;
ierr = KSPSetConvergenceTest(ksp,BSSCR_KSPConverged,ctx,BSSCR_KSPConverged_Destroy);CHKERRQ(ierr);
#endif
#if ( PETSC_VERSION_MAJOR < 3)
ierr = KSPSetConvergenceTest(ksp,BSSCR_KSPConverged,(void*)bsscr);CHKERRQ(ierr);
#endif
PetscFunctionReturn(0);
}
PetscErrorCode petscConverged(KSP ksp, PetscInt n, PetscReal rnorm, KSPConvergedReason * reason, void * ctx)
{
// Cast the context pointer coming from PETSc to an FEProblem& and
// get a reference to the System from it.
FEProblem & problem = *static_cast<FEProblem *>(ctx);
// Let's be nice and always check PETSc error codes.
PetscErrorCode ierr = 0;
// We want the default behavior of the KSPDefaultConverged test, but
// we don't want PETSc to die in that function with a CHKERRQ
// call... that is probably extremely unlikely/impossible, but just
// to be on the safe side, we push a different error handler before
// calling KSPDefaultConverged().
ierr = PetscPushErrorHandler(PetscReturnErrorHandler, /*void* ctx=*/ PETSC_NULL);
CHKERRABORT(problem.comm().get(),ierr);
#if PETSC_VERSION_LESS_THAN(3,0,0)
// Prior to PETSc 3.0.0, you could call KSPDefaultConverged with a NULL context
// pointer, as it was unused.
KSPDefaultConverged(ksp, n, rnorm, reason, PETSC_NULL);
#elif PETSC_RELEASE_LESS_THAN(3,5,0)
// As of PETSc 3.0.0, you must call KSPDefaultConverged with a
// non-NULL context pointer which must be created with
// KSPDefaultConvergedCreate(), and destroyed with
// KSPDefaultConvergedDestroy().
void* default_ctx = NULL;
KSPDefaultConvergedCreate(&default_ctx);
KSPDefaultConverged(ksp, n, rnorm, reason, default_ctx);
KSPDefaultConvergedDestroy(default_ctx);
#else
// As of PETSc 3.5.0, use KSPConvergedDefaultXXX
void* default_ctx = NULL;
KSPConvergedDefaultCreate(&default_ctx);
KSPConvergedDefault(ksp, n, rnorm, reason, default_ctx);
KSPConvergedDefaultDestroy(default_ctx);
#endif
// Pop the Error handler we pushed on the stack to go back
// to default PETSc error handling behavior.
ierr = PetscPopErrorHandler();
CHKERRABORT(problem.comm().get(),ierr);
// Get tolerances from the KSP object
PetscReal rtol = 0.;
PetscReal atol = 0.;
PetscReal dtol = 0.;
PetscInt maxits = 0;
ierr = KSPGetTolerances(ksp, &rtol, &atol, &dtol, &maxits);
CHKERRABORT(problem.comm().get(),ierr);
// Now do some additional MOOSE-specific tests...
std::string msg;
MooseLinearConvergenceReason moose_reason = problem.checkLinearConvergence(msg, n, rnorm, rtol, atol, dtol, maxits);
switch (moose_reason)
{
case MOOSE_CONVERGED_RTOL:
*reason = KSP_CONVERGED_RTOL;
break;
case MOOSE_CONVERGED_ITS:
*reason = KSP_CONVERGED_ITS;
break;
default:
{
// If it's not either of the two specific cases we handle, just go
// with whatever PETSc decided in KSPDefaultConverged.
break;
}
}
return 0;
}
static PetscErrorCode SNESSolve_TR(SNES snes)
{
SNES_TR *neP = (SNES_TR*)snes->data;
Vec X,F,Y,G,Ytmp;
PetscErrorCode ierr;
PetscInt maxits,i,lits;
MatStructure flg = DIFFERENT_NONZERO_PATTERN;
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;
PetscBool domainerror;
PetscFunctionBegin;
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 = PetscObjectTakeAccess(snes);CHKERRQ(ierr);
snes->iter = 0;
ierr = PetscObjectGrantAccess(snes);CHKERRQ(ierr);
if (!snes->vec_func_init_set) {
ierr = SNESComputeFunction(snes,X,F);CHKERRQ(ierr); /* F(X) */
ierr = SNESGetFunctionDomainError(snes, &domainerror);CHKERRQ(ierr);
if (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)) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_FP,"User provided compute function generated a Not-a-Number");
} else {
fnorm = snes->norm_init;
snes->norm_init_set = PETSC_FALSE;
}
ierr = PetscObjectTakeAccess(snes);CHKERRQ(ierr);
snes->norm = fnorm;
ierr = PetscObjectGrantAccess(snes);CHKERRQ(ierr);
delta = neP->delta0*fnorm;
neP->delta = delta;
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,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(PETSC_NULL,"-snes_tr_ksp_regular_convergence_test",&conv,PETSC_NULL);CHKERRQ(ierr);
if (!conv) {
SNES_TR_KSPConverged_Ctx *ctx;
ierr = SNESGetKSP(snes,&ksp);CHKERRQ(ierr);
ierr = PetscNew(SNES_TR_KSPConverged_Ctx,&ctx);CHKERRQ(ierr);
ctx->snes = snes;
ierr = KSPDefaultConvergedCreate(&ctx->ctx);CHKERRQ(ierr);
ierr = KSPSetConvergenceTest(ksp,SNES_TR_KSPConverged_Private,ctx,SNES_TR_KSPConverged_Destroy);CHKERRQ(ierr);
ierr = PetscInfo(snes,"Using Krylov convergence test SNES_TR_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,&flg);CHKERRQ(ierr);
ierr = KSPSetOperators(snes->ksp,snes->jacobian,snes->jacobian_pre,flg);CHKERRQ(ierr);
ierr = SNES_KSPSolve(snes,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",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",fnorm,gnorm,ynorm);CHKERRQ(ierr);
ierr = PetscInfo3(snes,"gpred=%G, rho=%G, delta=%G\n",gpnorm,rho,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 = SNES_TR_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 = PetscObjectTakeAccess(snes);CHKERRQ(ierr);
snes->iter = i+1;
snes->norm = fnorm;
ierr = PetscObjectGrantAccess(snes);CHKERRQ(ierr);
SNESLogConvHistory(snes,snes->norm,lits);
ierr = SNESMonitor(snes,snes->iter,snes->norm);CHKERRQ(ierr);
/* Test for convergence, xnorm = || X || */
neP->itflag = PETSC_TRUE;
if (snes->ops->converged != SNESSkipConverged) { 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 = PetscObjectTakeAccess(snes);CHKERRQ(ierr);
snes->reason = reason;
ierr = PetscObjectGrantAccess(snes);CHKERRQ(ierr);
PetscFunctionReturn(0);
}