Actual source code: snesut.c
petsc-3.7.1 2016-05-15
Report Typos and Errors

      2: #include <petsc/private/snesimpl.h>       /*I   "petsc/private/snesimpl.h"   I*/
      3: #include <petscdm.h>
      4: #include <petscblaslapack.h>

      8: /*@C
      9:    SNESMonitorSolution - Monitors progress of the SNES solvers by calling
     10:    VecView() for the approximate solution at each iteration.

     12:    Collective on SNES

     14:    Input Parameters:
     15: +  snes - the SNES context
     16: .  its - iteration number
     17: .  fgnorm - 2-norm of residual
     18: -  dummy -  a viewer

     20:    Level: intermediate

     22: .keywords: SNES, nonlinear, vector, monitor, view

     24: .seealso: SNESMonitorSet(), SNESMonitorDefault(), VecView()
     25: @*/
     26: PetscErrorCode  SNESMonitorSolution(SNES snes,PetscInt its,PetscReal fgnorm,PetscViewerAndFormat *vf)
     27: {
     29:   Vec            x;
     30:   PetscViewer    viewer = vf->viewer;

     34:   SNESGetSolution(snes,&x);
     35:   PetscViewerPushFormat(viewer,vf->format);
     36:   VecView(x,viewer);
     37:   PetscViewerPopFormat(viewer);
     38:   return(0);
     39: }

     43: /*@C
     44:    SNESMonitorResidual - Monitors progress of the SNES solvers by calling
     45:    VecView() for the residual at each iteration.

     47:    Collective on SNES

     49:    Input Parameters:
     50: +  snes - the SNES context
     51: .  its - iteration number
     52: .  fgnorm - 2-norm of residual
     53: -  dummy -  a viewer

     55:    Level: intermediate

     57: .keywords: SNES, nonlinear, vector, monitor, view

     59: .seealso: SNESMonitorSet(), SNESMonitorDefault(), VecView()
     60: @*/
     61: PetscErrorCode  SNESMonitorResidual(SNES snes,PetscInt its,PetscReal fgnorm,PetscViewerAndFormat *vf)
     62: {
     64:   Vec            x;
     65:   PetscViewer    viewer = vf->viewer;

     69:   SNESGetFunction(snes,&x,0,0);
     70:   PetscViewerPushFormat(viewer,vf->format);
     71:   VecView(x,viewer);
     72:   PetscViewerPopFormat(viewer);
     73:   return(0);
     74: }

     78: /*@C
     79:    SNESMonitorSolutionUpdate - Monitors progress of the SNES solvers by calling
     80:    VecView() for the UPDATE to the solution at each iteration.

     82:    Collective on SNES

     84:    Input Parameters:
     85: +  snes - the SNES context
     86: .  its - iteration number
     87: .  fgnorm - 2-norm of residual
     88: -  dummy - a viewer

     90:    Level: intermediate

     92: .keywords: SNES, nonlinear, vector, monitor, view

     94: .seealso: SNESMonitorSet(), SNESMonitorDefault(), VecView()
     95: @*/
     96: PetscErrorCode  SNESMonitorSolutionUpdate(SNES snes,PetscInt its,PetscReal fgnorm,PetscViewerAndFormat *vf)
     97: {
     99:   Vec            x;
    100:   PetscViewer    viewer = vf->viewer;

    104:   SNESGetSolutionUpdate(snes,&x);
    105:   PetscViewerPushFormat(viewer,vf->format);
    106:   VecView(x,viewer);
    107:   PetscViewerPopFormat(viewer);
    108:   return(0);
    109: }

    113: /*@C
    114:    KSPMonitorSNES - Print the residual norm of the nonlinear function at each iteration of the linear iterative solver.

    116:    Collective on KSP

    118:    Input Parameters:
    119: +  ksp   - iterative context
    120: .  n     - iteration number
    121: .  rnorm - 2-norm (preconditioned) residual value (may be estimated).
    122: -  dummy - unused monitor context

    124:    Level: intermediate

    126: .keywords: KSP, default, monitor, residual

    128: .seealso: KSPMonitorSet(), KSPMonitorTrueResidualNorm(), KSPMonitorLGResidualNormCreate()
    129: @*/
    130: PetscErrorCode  KSPMonitorSNES(KSP ksp,PetscInt n,PetscReal rnorm,void *dummy)
    131: {
    133:   PetscViewer    viewer;
    134:   SNES           snes = (SNES) dummy;
    135:   Vec            snes_solution,work1,work2;
    136:   PetscReal      snorm;

    139:   SNESGetSolution(snes,&snes_solution);
    140:   VecDuplicate(snes_solution,&work1);
    141:   VecDuplicate(snes_solution,&work2);
    142:   KSPBuildSolution(ksp,work1,NULL);
    143:   VecAYPX(work1,-1.0,snes_solution);
    144:   SNESComputeFunction(snes,work1,work2);
    145:   VecNorm(work2,NORM_2,&snorm);
    146:   VecDestroy(&work1);
    147:   VecDestroy(&work2);

    149:   PetscViewerASCIIGetStdout(PetscObjectComm((PetscObject)ksp),&viewer);
    150:   PetscViewerASCIIAddTab(viewer,((PetscObject)ksp)->tablevel);
    151:   if (n == 0 && ((PetscObject)ksp)->prefix) {
    152:     PetscViewerASCIIPrintf(viewer,"  Residual norms for %s solve.\n",((PetscObject)ksp)->prefix);
    153:   }
    154:   PetscViewerASCIIPrintf(viewer,"%3D SNES Residual norm %5.3e KSP Residual norm %5.3e \n",n,(double)snorm,(double)rnorm);
    155:   PetscViewerASCIISubtractTab(viewer,((PetscObject)ksp)->tablevel);
    156:   return(0);
    157: }

    159: #include <petscdraw.h>

    163: /*@C
    164:    KSPMonitorSNESLGResidualNormCreate - Creates a line graph context for use with
    165:    KSP to monitor convergence of preconditioned residual norms.

    167:    Collective on KSP

    169:    Input Parameters:
    170: +  comm - communicator context
    171: .  host - the X display to open, or null for the local machine
    172: .  label - the title to put in the title bar
    173: .  x, y - the screen coordinates of the upper left coordinate of
    174:           the window
    175: -  m, n - the screen width and height in pixels

    177:    Output Parameter:
    178: .  draw - the drawing context

    180:    Options Database Key:
    181: .  -ksp_monitor_lg_residualnorm - Sets line graph monitor

    183:    Notes:
    184:    Use KSPMonitorSNESLGResidualNormDestroy() to destroy this line graph; do not use PetscDrawLGDestroy().

    186:    Level: intermediate

    188: .keywords: KSP, monitor, line graph, residual, create

    190: .seealso: KSPMonitorSNESLGResidualNormDestroy(), KSPMonitorSet(), KSPMonitorSNESLGTrueResidualCreate()
    191: @*/
    192: PetscErrorCode  KSPMonitorSNESLGResidualNormCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscObject **objs)
    193: {
    194:   PetscDraw      draw;
    196:   PetscDrawAxis  axis;
    197:   PetscDrawLG    lg;
    198:   const char     *names[] = {"Linear residual","Nonlinear residual"};

    201:   PetscDrawCreate(comm,host,label,x,y,m,n,&draw);
    202:   PetscDrawSetFromOptions(draw);
    203:   PetscDrawLGCreate(draw,2,&lg);
    204:   PetscDrawLGSetLegend(lg,names);
    205:   PetscDrawLGSetFromOptions(lg);
    206:   PetscDrawLGGetAxis(lg,&axis);
    207:   PetscDrawAxisSetLabels(axis,"Convergence of Residual Norm","Iteration","Residual Norm");
    208:   PetscDrawDestroy(&draw);

    210:   PetscMalloc1(2,objs);
    211:   (*objs)[1] = (PetscObject)lg;
    212:   return(0);
    213: }

    217: PetscErrorCode  KSPMonitorSNESLGResidualNorm(KSP ksp,PetscInt n,PetscReal rnorm,PetscObject *objs)
    218: {
    219:   SNES           snes = (SNES) objs[0];
    220:   PetscDrawLG    lg   = (PetscDrawLG) objs[1];
    222:   PetscReal      y[2];
    223:   Vec            snes_solution,work1,work2;

    226:   if (rnorm > 0.0) y[0] = PetscLog10Real(rnorm);
    227:   else y[0] = -15.0;

    229:   SNESGetSolution(snes,&snes_solution);
    230:   VecDuplicate(snes_solution,&work1);
    231:   VecDuplicate(snes_solution,&work2);
    232:   KSPBuildSolution(ksp,work1,NULL);
    233:   VecAYPX(work1,-1.0,snes_solution);
    234:   SNESComputeFunction(snes,work1,work2);
    235:   VecNorm(work2,NORM_2,y+1);
    236:   if (y[1] > 0.0) y[1] = PetscLog10Real(y[1]);
    237:   else y[1] = -15.0;
    238:   VecDestroy(&work1);
    239:   VecDestroy(&work2);

    241:   PetscDrawLGAddPoint(lg,NULL,y);
    242:   if (n < 20 || !(n % 5) || snes->reason) {
    243:     PetscDrawLGDraw(lg);
    244:     PetscDrawLGSave(lg);
    245:   }
    246:   return(0);
    247: }

    251: /*@
    252:    KSPMonitorSNESLGResidualNormDestroy - Destroys a line graph context that was created
    253:    with KSPMonitorSNESLGResidualNormCreate().

    255:    Collective on KSP

    257:    Input Parameter:
    258: .  draw - the drawing context

    260:    Level: intermediate

    262: .keywords: KSP, monitor, line graph, destroy

    264: .seealso: KSPMonitorSNESLGResidualNormCreate(), KSPMonitorSNESLGTrueResidualDestroy(), KSPMonitorSet()
    265: @*/
    266: PetscErrorCode  KSPMonitorSNESLGResidualNormDestroy(PetscObject **objs)
    267: {
    269:   PetscDrawLG    lg = (PetscDrawLG) (*objs)[1];

    272:   PetscDrawLGDestroy(&lg);
    273:   PetscFree(*objs);
    274:   return(0);
    275: }

    279: /*@C
    280:    SNESMonitorDefault - Monitors progress of the SNES solvers (default).

    282:    Collective on SNES

    284:    Input Parameters:
    285: +  snes - the SNES context
    286: .  its - iteration number
    287: .  fgnorm - 2-norm of residual
    288: -  vf - viewer and format structure

    290:    Notes:
    291:    This routine prints the residual norm at each iteration.

    293:    Level: intermediate

    295: .keywords: SNES, nonlinear, default, monitor, norm

    297: .seealso: SNESMonitorSet(), SNESMonitorSolution()
    298: @*/
    299: PetscErrorCode  SNESMonitorDefault(SNES snes,PetscInt its,PetscReal fgnorm,PetscViewerAndFormat *vf)
    300: {
    302:   PetscViewer    viewer = vf->viewer;

    306:   PetscViewerPushFormat(viewer,vf->format);
    307:   PetscViewerASCIIAddTab(viewer,((PetscObject)snes)->tablevel);
    308:   PetscViewerASCIIPrintf(viewer,"%3D SNES Function norm %14.12e \n",its,(double)fgnorm);
    309:   PetscViewerASCIISubtractTab(viewer,((PetscObject)snes)->tablevel);
    310:   PetscViewerPopFormat(viewer);CHKERRQ(ierr) ;
    311:   return(0);
    312: }

    316: PetscErrorCode SNESMonitorJacUpdateSpectrum(SNES snes,PetscInt it,PetscReal fnorm,PetscViewerAndFormat *vf)
    317: {
    318: #if defined(PETSC_MISSING_LAPACK_GEEV)
    319:   SETERRQ(PetscObjectComm((PetscObject)snes),PETSC_ERR_SUP,"GEEV - Lapack routine is unavailable\nNot able to provide eigen values.");
    320: #elif defined(PETSC_HAVE_ESSL)
    321:   SETERRQ(PetscObjectComm((PetscObject)snes),PETSC_ERR_SUP,"GEEV - No support for ESSL Lapack Routines");
    322: #else
    323:   Vec            X;
    324:   Mat            J,dJ,dJdense;
    326:   PetscErrorCode (*func)(SNES,Vec,Mat,Mat,void*);
    327:   PetscInt       n,i;
    328:   PetscBLASInt   nb,lwork;
    329:   PetscReal      *eigr,*eigi;
    330:   PetscScalar    *work;
    331:   PetscScalar    *a;

    334:   if (it == 0) return(0);
    335:   /* create the difference between the current update and the current jacobian */
    336:   SNESGetSolution(snes,&X);
    337:   SNESGetJacobian(snes,NULL,&J,&func,NULL);
    338:   MatDuplicate(J,MAT_COPY_VALUES,&dJ);
    339:   SNESComputeJacobian(snes,X,dJ,dJ);
    340:   MatAXPY(dJ,-1.0,J,SAME_NONZERO_PATTERN);

    342:   /* compute the spectrum directly */
    343:   MatConvert(dJ,MATSEQDENSE,MAT_INITIAL_MATRIX,&dJdense);
    344:   MatGetSize(dJ,&n,NULL);
    345:   PetscBLASIntCast(n,&nb);
    346:   lwork = 3*nb;
    347:   PetscMalloc1(n,&eigr);
    348:   PetscMalloc1(n,&eigi);
    349:   PetscMalloc1(lwork,&work);
    350:   MatDenseGetArray(dJdense,&a);
    351: #if !defined(PETSC_USE_COMPLEX)
    352:   {
    353:     PetscBLASInt lierr;
    354:     PetscFPTrapPush(PETSC_FP_TRAP_OFF);
    355:     PetscStackCallBLAS("LAPACKgeev",LAPACKgeev_("N","N",&nb,a,&nb,eigr,eigi,NULL,&nb,NULL,&nb,work,&lwork,&lierr));
    356:     if (lierr) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"geev() error %d",lierr);
    357:     PetscFPTrapPop();
    358:   }
    359: #else
    360:   SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Not coded for complex");
    361: #endif
    362:   PetscPrintf(PetscObjectComm((PetscObject)snes),"Eigenvalues of J_%d - J_%d:\n",it,it-1);
    363:   for (i=0;i<n;i++) {
    364:     PetscPrintf(PetscObjectComm((PetscObject)snes),"%5d: %20.5g + %20.5gi\n",i,(double)eigr[i],(double)eigi[i]);
    365:   }
    366:   MatDenseRestoreArray(dJdense,&a);
    367:   MatDestroy(&dJ);
    368:   MatDestroy(&dJdense);
    369:   PetscFree(eigr);
    370:   PetscFree(eigi);
    371:   PetscFree(work);
    372:   return(0);
    373: #endif
    374: }

    376: PETSC_INTERN PetscErrorCode  SNESMonitorRange_Private(SNES,PetscInt,PetscReal*);

    380: PetscErrorCode  SNESMonitorRange_Private(SNES snes,PetscInt it,PetscReal *per)
    381: {
    383:   Vec            resid;
    384:   PetscReal      rmax,pwork;
    385:   PetscInt       i,n,N;
    386:   PetscScalar    *r;

    389:   SNESGetFunction(snes,&resid,0,0);
    390:   VecNorm(resid,NORM_INFINITY,&rmax);
    391:   VecGetLocalSize(resid,&n);
    392:   VecGetSize(resid,&N);
    393:   VecGetArray(resid,&r);
    394:   pwork = 0.0;
    395:   for (i=0; i<n; i++) {
    396:     pwork += (PetscAbsScalar(r[i]) > .20*rmax);
    397:   }
    398:   MPIU_Allreduce(&pwork,per,1,MPIU_REAL,MPIU_SUM,PetscObjectComm((PetscObject)snes));
    399:   VecRestoreArray(resid,&r);
    400:   *per = *per/N;
    401:   return(0);
    402: }

    406: /*@C
    407:    SNESMonitorRange - Prints the percentage of residual elements that are more then 10 percent of the maximum value.

    409:    Collective on SNES

    411:    Input Parameters:
    412: +  snes   - iterative context
    413: .  it    - iteration number
    414: .  rnorm - 2-norm (preconditioned) residual value (may be estimated).
    415: -  dummy - unused monitor context

    417:    Options Database Key:
    418: .  -snes_monitor_range - Activates SNESMonitorRange()

    420:    Level: intermediate

    422: .keywords: SNES, default, monitor, residual

    424: .seealso: SNESMonitorSet(), SNESMonitorDefault(), SNESMonitorLGCreate()
    425: @*/
    426: PetscErrorCode  SNESMonitorRange(SNES snes,PetscInt it,PetscReal rnorm,PetscViewerAndFormat *vf)
    427: {
    429:   PetscReal      perc,rel;
    430:   PetscViewer    viewer = vf->viewer;
    431:   /* should be in a MonitorRangeContext */
    432:   static PetscReal prev;

    436:   if (!it) prev = rnorm;
    437:   SNESMonitorRange_Private(snes,it,&perc);

    439:   rel  = (prev - rnorm)/prev;
    440:   prev = rnorm;
    441:   PetscViewerPushFormat(viewer,vf->format);
    442:   PetscViewerASCIIAddTab(viewer,((PetscObject)snes)->tablevel);
    443:   PetscViewerASCIIPrintf(viewer,"%3D SNES preconditioned resid norm %14.12e Percent values above 20 percent of maximum %5.2f relative decrease %5.2e ratio %5.2e \n",it,(double)rnorm,(double)(100.0*perc),(double)rel,(double)(rel/perc));
    444:   PetscViewerASCIISubtractTab(viewer,((PetscObject)snes)->tablevel);
    445:   PetscViewerPopFormat(viewer);
    446:   return(0);
    447: }

    451: /*@C
    452:    SNESMonitorRatio - Monitors progress of the SNES solvers by printing the ratio
    453:    of residual norm at each iteration to the previous.

    455:    Collective on SNES

    457:    Input Parameters:
    458: +  snes - the SNES context
    459: .  its - iteration number
    460: .  fgnorm - 2-norm of residual (or gradient)
    461: -  dummy -  context of monitor

    463:    Level: intermediate

    465:    Notes: Insure that SNESMonitorRatio() is called when you set this monitor
    466: .keywords: SNES, nonlinear, monitor, norm

    468: .seealso: SNESMonitorSet(), SNESMonitorSolution(), SNESMonitorRatio()
    469: @*/
    470: PetscErrorCode  SNESMonitorRatio(SNES snes,PetscInt its,PetscReal fgnorm,PetscViewerAndFormat *vf)
    471: {
    472:   PetscErrorCode          ierr;
    473:   PetscInt                len;
    474:   PetscReal               *history;
    475:   PetscViewer             viewer = vf->viewer;
    476:
    478:   SNESGetConvergenceHistory(snes,&history,NULL,&len);
    479:   PetscViewerPushFormat(viewer,vf->format);
    480:   PetscViewerASCIIAddTab(viewer,((PetscObject)snes)->tablevel);
    481:   if (!its || !history || its > len) {
    482:     PetscViewerASCIIPrintf(viewer,"%3D SNES Function norm %14.12e \n",its,(double)fgnorm);
    483:   } else {
    484:     PetscReal ratio = fgnorm/history[its-1];
    485:     PetscViewerASCIIPrintf(viewer,"%3D SNES Function norm %14.12e %14.12e \n",its,(double)fgnorm,(double)ratio);
    486:   }
    487:   PetscViewerASCIISubtractTab(viewer,((PetscObject)snes)->tablevel);
    488:   PetscViewerPopFormat(viewer);
    489:   return(0);
    490: }

    494: /*@C
    495:    SNESMonitorRatioSetUp - Insures the SNES object is saving its history since this monitor needs access to it

    497:    Collective on SNES

    499:    Input Parameters:
    500: +   snes - the SNES context
    501: -   viewer - the PetscViewer object (ignored)

    503:    Level: intermediate

    505: .keywords: SNES, nonlinear, monitor, norm

    507: .seealso: SNESMonitorSet(), SNESMonitorSolution(), SNESMonitorDefault(), SNESMonitorRatio()
    508: @*/
    509: PetscErrorCode  SNESMonitorRatioSetUp(SNES snes,PetscViewerAndFormat *vf)
    510: {
    511:   PetscErrorCode          ierr;
    512:   PetscReal               *history;

    515:   SNESGetConvergenceHistory(snes,&history,NULL,NULL);
    516:   if (!history) {
    517:     SNESSetConvergenceHistory(snes,NULL,NULL,100,PETSC_TRUE);
    518:   }
    519:   return(0);
    520: }

    522: /* ---------------------------------------------------------------- */
    525: /*
    526:      Default (short) SNES Monitor, same as SNESMonitorDefault() except
    527:   it prints fewer digits of the residual as the residual gets smaller.
    528:   This is because the later digits are meaningless and are often
    529:   different on different machines; by using this routine different
    530:   machines will usually generate the same output.
    531: */
    532: PetscErrorCode  SNESMonitorDefaultShort(SNES snes,PetscInt its,PetscReal fgnorm,PetscViewerAndFormat *vf)
    533: {
    535:   PetscViewer    viewer = vf->viewer;

    539:   PetscViewerPushFormat(viewer,vf->format);
    540:   PetscViewerASCIIAddTab(viewer,((PetscObject)snes)->tablevel);
    541:   if (fgnorm > 1.e-9) {
    542:     PetscViewerASCIIPrintf(viewer,"%3D SNES Function norm %g \n",its,(double)fgnorm);
    543:   } else if (fgnorm > 1.e-11) {
    544:     PetscViewerASCIIPrintf(viewer,"%3D SNES Function norm %5.3e \n",its,(double)fgnorm);
    545:   } else {
    546:     PetscViewerASCIIPrintf(viewer,"%3D SNES Function norm < 1.e-11\n",its);
    547:   }
    548:   PetscViewerASCIISubtractTab(viewer,((PetscObject)snes)->tablevel);
    549:   PetscViewerPopFormat(viewer);
    550:   return(0);
    551: }

    555: /*@C
    556:   SNESMonitorDefaultField - Monitors progress of the SNES solvers, separated into fields.

    558:   Collective on SNES

    560:   Input Parameters:
    561: + snes   - the SNES context
    562: . its    - iteration number
    563: . fgnorm - 2-norm of residual
    564: - ctx    - the PetscViewer

    566:   Notes:
    567:   This routine uses the DM attached to the residual vector

    569:   Level: intermediate

    571: .keywords: SNES, nonlinear, field, monitor, norm
    572: .seealso: SNESMonitorSet(), SNESMonitorSolution(), SNESMonitorDefault(), SNESMonitorDefaultShort()
    573: @*/
    574: PetscErrorCode SNESMonitorDefaultField(SNES snes, PetscInt its, PetscReal fgnorm, PetscViewerAndFormat *vf)
    575: {
    576:   PetscViewer    viewer = vf->viewer;
    577:   Vec            r;
    578:   DM             dm;
    579:   PetscReal      res[256];
    580:   PetscInt       tablevel;

    585:   SNESGetFunction(snes, &r, NULL, NULL);
    586:   VecGetDM(r, &dm);
    587:   if (!dm) {SNESMonitorDefault(snes, its, fgnorm, vf);}
    588:   else {
    589:     PetscSection s, gs;
    590:     PetscInt     Nf, f;

    592:     DMGetDefaultSection(dm, &s);
    593:     DMGetDefaultGlobalSection(dm, &gs);
    594:     if (!s || !gs) {SNESMonitorDefault(snes, its, fgnorm, vf);}
    595:     PetscSectionGetNumFields(s, &Nf);
    596:     if (Nf > 256) SETERRQ1(PetscObjectComm((PetscObject) snes), PETSC_ERR_SUP, "Do not support %d fields > 256", Nf);
    597:     PetscSectionVecNorm(s, gs, r, NORM_2, res);
    598:     PetscObjectGetTabLevel((PetscObject) snes, &tablevel);
    599:     PetscViewerPushFormat(viewer,vf->format);
    600:     PetscViewerASCIIAddTab(viewer, tablevel);
    601:     PetscViewerASCIIPrintf(viewer, "%3D SNES Function norm %14.12e [", its, (double) fgnorm);
    602:     for (f = 0; f < Nf; ++f) {
    603:       if (f) {PetscViewerASCIIPrintf(viewer, ", ");}
    604:       PetscViewerASCIIPrintf(viewer, "%14.12e", res[f]);
    605:     }
    606:     PetscViewerASCIIPrintf(viewer, "] \n");
    607:     PetscViewerASCIISubtractTab(viewer, tablevel);
    608:     PetscViewerPopFormat(viewer);
    609:   }
    610:   return(0);
    611: }
    612: /* ---------------------------------------------------------------- */
    615: /*@C
    616:    SNESConvergedDefault - Convergence test of the solvers for
    617:    systems of nonlinear equations (default).

    619:    Collective on SNES

    621:    Input Parameters:
    622: +  snes - the SNES context
    623: .  it - the iteration (0 indicates before any Newton steps)
    624: .  xnorm - 2-norm of current iterate
    625: .  snorm - 2-norm of current step
    626: .  fnorm - 2-norm of function at current iterate
    627: -  dummy - unused context

    629:    Output Parameter:
    630: .   reason  - one of
    631: $  SNES_CONVERGED_FNORM_ABS       - (fnorm < abstol),
    632: $  SNES_CONVERGED_SNORM_RELATIVE  - (snorm < stol*xnorm),
    633: $  SNES_CONVERGED_FNORM_RELATIVE  - (fnorm < rtol*fnorm0),
    634: $  SNES_DIVERGED_FUNCTION_COUNT   - (nfct > maxf),
    635: $  SNES_DIVERGED_FNORM_NAN        - (fnorm == NaN),
    636: $  SNES_CONVERGED_ITERATING       - (otherwise),

    638:    where
    639: +    maxf - maximum number of function evaluations,
    640:             set with SNESSetTolerances()
    641: .    nfct - number of function evaluations,
    642: .    abstol - absolute function norm tolerance,
    643:             set with SNESSetTolerances()
    644: -    rtol - relative function norm tolerance, set with SNESSetTolerances()

    646:    Level: intermediate

    648: .keywords: SNES, nonlinear, default, converged, convergence

    650: .seealso: SNESSetConvergenceTest()
    651: @*/
    652: PetscErrorCode  SNESConvergedDefault(SNES snes,PetscInt it,PetscReal xnorm,PetscReal snorm,PetscReal fnorm,SNESConvergedReason *reason,void *dummy)
    653: {

    660:   *reason = SNES_CONVERGED_ITERATING;

    662:   if (!it) {
    663:     /* set parameter for default relative tolerance convergence test */
    664:     snes->ttol = fnorm*snes->rtol;
    665:   }
    666:   if (PetscIsInfOrNanReal(fnorm)) {
    667:     PetscInfo(snes,"Failed to converged, function norm is NaN\n");
    668:     *reason = SNES_DIVERGED_FNORM_NAN;
    669:   } else if (fnorm < snes->abstol) {
    670:     PetscInfo2(snes,"Converged due to function norm %14.12e < %14.12e\n",(double)fnorm,(double)snes->abstol);
    671:     *reason = SNES_CONVERGED_FNORM_ABS;
    672:   } else if (snes->nfuncs >= snes->max_funcs) {
    673:     PetscInfo2(snes,"Exceeded maximum number of function evaluations: %D > %D\n",snes->nfuncs,snes->max_funcs);
    674:     *reason = SNES_DIVERGED_FUNCTION_COUNT;
    675:   }

    677:   if (it && !*reason) {
    678:     if (fnorm <= snes->ttol) {
    679:       PetscInfo2(snes,"Converged due to function norm %14.12e < %14.12e (relative tolerance)\n",(double)fnorm,(double)snes->ttol);
    680:       *reason = SNES_CONVERGED_FNORM_RELATIVE;
    681:     } else if (snorm < snes->stol*xnorm) {
    682:       PetscInfo3(snes,"Converged due to small update length: %14.12e < %14.12e * %14.12e\n",(double)snorm,(double)snes->stol,(double)xnorm);
    683:       *reason = SNES_CONVERGED_SNORM_RELATIVE;
    684:     }
    685:   }
    686:   return(0);
    687: }

    691: /*@C
    692:    SNESConvergedSkip - Convergence test for SNES that NEVER returns as
    693:    converged, UNLESS the maximum number of iteration have been reached.

    695:    Logically Collective on SNES

    697:    Input Parameters:
    698: +  snes - the SNES context
    699: .  it - the iteration (0 indicates before any Newton steps)
    700: .  xnorm - 2-norm of current iterate
    701: .  snorm - 2-norm of current step
    702: .  fnorm - 2-norm of function at current iterate
    703: -  dummy - unused context

    705:    Output Parameter:
    706: .   reason  - SNES_CONVERGED_ITERATING, SNES_CONVERGED_ITS, or SNES_DIVERGED_FNORM_NAN

    708:    Notes:
    709:    Convergence is then declared after a fixed number of iterations have been used.

    711:    Level: advanced

    713: .keywords: SNES, nonlinear, skip, converged, convergence

    715: .seealso: SNESSetConvergenceTest()
    716: @*/
    717: PetscErrorCode  SNESConvergedSkip(SNES snes,PetscInt it,PetscReal xnorm,PetscReal snorm,PetscReal fnorm,SNESConvergedReason *reason,void *dummy)
    718: {

    725:   *reason = SNES_CONVERGED_ITERATING;

    727:   if (fnorm != fnorm) {
    728:     PetscInfo(snes,"Failed to converged, function norm is NaN\n");
    729:     *reason = SNES_DIVERGED_FNORM_NAN;
    730:   } else if (it == snes->max_its) {
    731:     *reason = SNES_CONVERGED_ITS;
    732:   }
    733:   return(0);
    734: }

    738: /*@C
    739:   SNESSetWorkVecs - Gets a number of work vectors.

    741:   Input Parameters:
    742: . snes  - the SNES context
    743: . nw - number of work vectors to allocate

    745:    Level: developer

    747:    Developers Note: This is PETSC_EXTERN because it may be used by user written plugin SNES implementations

    749: @*/
    750: PetscErrorCode SNESSetWorkVecs(SNES snes,PetscInt nw)
    751: {
    752:   DM             dm;
    753:   Vec            v;

    757:   if (snes->work) {VecDestroyVecs(snes->nwork,&snes->work);}
    758:   snes->nwork = nw;

    760:   SNESGetDM(snes, &dm);
    761:   DMGetGlobalVector(dm, &v);
    762:   VecDuplicateVecs(v,snes->nwork,&snes->work);
    763:   DMRestoreGlobalVector(dm, &v);
    764:   PetscLogObjectParents(snes,nw,snes->work);
    765:   return(0);
    766: }