Actual source code: fas.c

petsc-3.6.0 2015-06-09
Report Typos and Errors
  1: /* Defines the basic SNES object */
  2: #include <../src/snes/impls/fas/fasimpls.h>    /*I  "petscsnes.h"  I*/

  4: const char *const SNESFASTypes[] = {"MULTIPLICATIVE","ADDITIVE","FULL","KASKADE","SNESFASType","SNES_FAS",0};

  6: extern PetscErrorCode SNESDestroy_FAS(SNES snes);
  7: extern PetscErrorCode SNESSetUp_FAS(SNES snes);
  8: extern PetscErrorCode SNESSetFromOptions_FAS(PetscOptions *PetscOptionsObject,SNES snes);
  9: extern PetscErrorCode SNESView_FAS(SNES snes, PetscViewer viewer);
 10: extern PetscErrorCode SNESSolve_FAS(SNES snes);
 11: extern PetscErrorCode SNESReset_FAS(SNES snes);
 12: extern PetscErrorCode SNESFASGalerkinDefaultFunction(SNES, Vec, Vec, void*);
 13: extern PetscErrorCode SNESFASCycleCreateSmoother_Private(SNES, SNES*);

 15: /*MC

 17: SNESFAS - Full Approximation Scheme nonlinear multigrid solver.

 19:    The nonlinear problem is solved by correction using coarse versions
 20:    of the nonlinear problem.  This problem is perturbed so that a projected
 21:    solution of the fine problem elicits no correction from the coarse problem.

 23: Options Database:
 24: +   -snes_fas_levels -  The number of levels
 25: .   -snes_fas_cycles<1> -  The number of cycles -- 1 for V, 2 for W
 26: .   -snes_fas_type<additive,multiplicative,full,kaskade>  -  Additive or multiplicative cycle
 27: .   -snes_fas_galerkin<PETSC_FALSE> -  Form coarse problems by projection back upon the fine problem
 28: .   -snes_fas_smoothup<1> -  The number of iterations of the post-smoother
 29: .   -snes_fas_smoothdown<1> -  The number of iterations of the pre-smoother
 30: .   -snes_fas_monitor -  Monitor progress of all of the levels
 31: .   -snes_fas_full_downsweepsmooth<PETSC_FALSE> - call the downsmooth on the initial downsweep of full FAS
 32: .   -fas_levels_snes_ -  SNES options for all smoothers
 33: .   -fas_levels_cycle_snes_ -  SNES options for all cycles
 34: .   -fas_levels_i_snes_ -  SNES options for the smoothers on level i
 35: .   -fas_levels_i_cycle_snes_ - SNES options for the cycle on level i
 36: -   -fas_coarse_snes_ -  SNES options for the coarsest smoother

 38: Notes:
 39:    The organization of the FAS solver is slightly different from the organization of PCMG
 40:    As each level has smoother SNES instances(down and potentially up) and a cycle SNES instance.
 41:    The cycle SNES instance may be used for monitoring convergence on a particular level.

 43: Level: beginner

 45: .seealso: PCMG, SNESCreate(), SNES, SNESSetType(), SNESType (for list of available types)
 46: M*/

 50: PETSC_EXTERN PetscErrorCode SNESCreate_FAS(SNES snes)
 51: {
 52:   SNES_FAS       *fas;

 56:   snes->ops->destroy        = SNESDestroy_FAS;
 57:   snes->ops->setup          = SNESSetUp_FAS;
 58:   snes->ops->setfromoptions = SNESSetFromOptions_FAS;
 59:   snes->ops->view           = SNESView_FAS;
 60:   snes->ops->solve          = SNESSolve_FAS;
 61:   snes->ops->reset          = SNESReset_FAS;

 63:   snes->usesksp = PETSC_FALSE;
 64:   snes->usespc  = PETSC_FALSE;

 66:   if (!snes->tolerancesset) {
 67:     snes->max_funcs = 30000;
 68:     snes->max_its   = 10000;
 69:   }

 71:   PetscNewLog(snes,&fas);

 73:   snes->data                  = (void*) fas;
 74:   fas->level                  = 0;
 75:   fas->levels                 = 1;
 76:   fas->n_cycles               = 1;
 77:   fas->max_up_it              = 1;
 78:   fas->max_down_it            = 1;
 79:   fas->smoothu                = NULL;
 80:   fas->smoothd                = NULL;
 81:   fas->next                   = NULL;
 82:   fas->previous               = NULL;
 83:   fas->fine                   = snes;
 84:   fas->interpolate            = NULL;
 85:   fas->restrct                = NULL;
 86:   fas->inject                 = NULL;
 87:   fas->monitor                = NULL;
 88:   fas->usedmfornumberoflevels = PETSC_FALSE;
 89:   fas->fastype                = SNES_FAS_MULTIPLICATIVE;
 90:   fas->full_downsweep         = PETSC_FALSE;

 92:   fas->eventsmoothsetup    = 0;
 93:   fas->eventsmoothsolve    = 0;
 94:   fas->eventresidual       = 0;
 95:   fas->eventinterprestrict = 0;
 96:   return(0);
 97: }

101: PetscErrorCode SNESReset_FAS(SNES snes)
102: {
103:   PetscErrorCode 0;
104:   SNES_FAS       * fas = (SNES_FAS*)snes->data;

107:   SNESDestroy(&fas->smoothu);
108:   SNESDestroy(&fas->smoothd);
109:   MatDestroy(&fas->inject);
110:   MatDestroy(&fas->interpolate);
111:   MatDestroy(&fas->restrct);
112:   VecDestroy(&fas->rscale);
113:   if (fas->galerkin) {
114:     VecDestroy(&fas->Xg);
115:     VecDestroy(&fas->Fg);
116:   }
117:   if (fas->next) {SNESReset(fas->next);}
118:   return(0);
119: }

123: PetscErrorCode SNESDestroy_FAS(SNES snes)
124: {
125:   SNES_FAS       * fas = (SNES_FAS*)snes->data;
126:   PetscErrorCode 0;

129:   /* recursively resets and then destroys */
130:   SNESReset(snes);
131:   if (fas->next) {
132:     SNESDestroy(&fas->next);
133:   }
134:   PetscFree(fas);
135:   return(0);
136: }

140: PetscErrorCode SNESSetUp_FAS(SNES snes)
141: {
142:   SNES_FAS       *fas = (SNES_FAS*) snes->data;
144:   PetscInt       dm_levels;
145:   Vec            vec_sol, vec_func, vec_sol_update, vec_rhs; /* preserve these if they're set through the reset */
146:   SNES           next;
147:   PetscBool      isFine;
148:   SNESLineSearch linesearch;
149:   SNESLineSearch slinesearch;
150:   void           *lsprectx,*lspostctx;
151:   PetscErrorCode (*precheck)(SNESLineSearch,Vec,Vec,PetscBool*,void*);
152:   PetscErrorCode (*postcheck)(SNESLineSearch,Vec,Vec,Vec,PetscBool*,PetscBool*,void*);

155:   SNESFASCycleIsFine(snes, &isFine);
156:   if (fas->usedmfornumberoflevels && isFine) {
157:     DMGetRefineLevel(snes->dm,&dm_levels);
158:     dm_levels++;
159:     if (dm_levels > fas->levels) {
160:       /* we don't want the solution and func vectors to be destroyed in the SNESReset when it's called in SNESFASSetLevels_FAS*/
161:       vec_sol              = snes->vec_sol;
162:       vec_func             = snes->vec_func;
163:       vec_sol_update       = snes->vec_sol_update;
164:       vec_rhs              = snes->vec_rhs;
165:       snes->vec_sol        = NULL;
166:       snes->vec_func       = NULL;
167:       snes->vec_sol_update = NULL;
168:       snes->vec_rhs        = NULL;

170:       /* reset the number of levels */
171:       SNESFASSetLevels(snes,dm_levels,NULL);
172:       SNESSetFromOptions(snes);

174:       snes->vec_sol        = vec_sol;
175:       snes->vec_func       = vec_func;
176:       snes->vec_rhs        = vec_rhs;
177:       snes->vec_sol_update = vec_sol_update;
178:     }
179:   }
180:   SNESFASCycleGetCorrection(snes, &next);
181:   if (!isFine) snes->gridsequence = 0; /* no grid sequencing inside the multigrid hierarchy! */

183:   SNESSetWorkVecs(snes, 2); /* work vectors used for intergrid transfers */

185:   /* set up the smoothers if they haven't already been set up */
186:   if (!fas->smoothd) {
187:     SNESFASCycleCreateSmoother_Private(snes, &fas->smoothd);
188:   }

190:   if (snes->dm) {
191:     /* set the smoother DMs properly */
192:     if (fas->smoothu) SNESSetDM(fas->smoothu, snes->dm);
193:     SNESSetDM(fas->smoothd, snes->dm);
194:     /* construct EVERYTHING from the DM -- including the progressive set of smoothers */
195:     if (next) {
196:       /* for now -- assume the DM and the evaluation functions have been set externally */
197:       if (!next->dm) {
198:         DMCoarsen(snes->dm, PetscObjectComm((PetscObject)next), &next->dm);
199:         SNESSetDM(next, next->dm);
200:       }
201:       /* set the interpolation and restriction from the DM */
202:       if (!fas->interpolate) {
203:         DMCreateInterpolation(next->dm, snes->dm, &fas->interpolate, &fas->rscale);
204:         if (!fas->restrct) {
205:           PetscObjectReference((PetscObject)fas->interpolate);
206:           fas->restrct = fas->interpolate;
207:         }
208:       }
209:       /* set the injection from the DM */
210:       if (!fas->inject) {
211:         DMCreateInjection(next->dm, snes->dm, &fas->inject);
212:       }
213:     }
214:   }
215:   /*pass the smoother, function, and jacobian up to the next level if it's not user set already */
216:   if (fas->galerkin) {
217:     if (next) {
218:       SNESSetFunction(next, NULL, SNESFASGalerkinDefaultFunction, next);
219:     }
220:     if (fas->smoothd && fas->level != fas->levels - 1) {
221:       SNESSetFunction(fas->smoothd, NULL, SNESFASGalerkinDefaultFunction, snes);
222:     }
223:     if (fas->smoothu && fas->level != fas->levels - 1) {
224:       SNESSetFunction(fas->smoothu, NULL, SNESFASGalerkinDefaultFunction, snes);
225:     }
226:   }

228:   /* sets the down (pre) smoother's default norm and sets it from options */
229:   if (fas->smoothd) {
230:     if (fas->level == 0 && fas->levels != 1) {
231:       SNESSetNormSchedule(fas->smoothd, SNES_NORM_NONE);
232:     } else {
233:       SNESSetNormSchedule(fas->smoothd, SNES_NORM_FINAL_ONLY);
234:     }
235:     PetscObjectCopyFortranFunctionPointers((PetscObject)snes, (PetscObject)fas->smoothd);
236:     SNESSetFromOptions(fas->smoothd);
237:     SNESGetLineSearch(snes,&linesearch);
238:     SNESGetLineSearch(fas->smoothd,&slinesearch);
239:     SNESLineSearchGetPreCheck(linesearch,&precheck,&lsprectx);
240:     SNESLineSearchGetPostCheck(linesearch,&postcheck,&lspostctx);
241:     SNESLineSearchSetPreCheck(slinesearch,precheck,lsprectx);
242:     SNESLineSearchSetPostCheck(slinesearch,postcheck,lspostctx);
243:     PetscObjectCopyFortranFunctionPointers((PetscObject)linesearch, (PetscObject)slinesearch);

245:     fas->smoothd->vec_sol        = snes->vec_sol;
246:     PetscObjectReference((PetscObject)snes->vec_sol);
247:     fas->smoothd->vec_sol_update = snes->vec_sol_update;
248:     PetscObjectReference((PetscObject)snes->vec_sol_update);
249:     fas->smoothd->vec_func       = snes->vec_func;
250:     PetscObjectReference((PetscObject)snes->vec_func);

252:     if (fas->eventsmoothsetup) {PetscLogEventBegin(fas->eventsmoothsetup,0,0,0,0);}
253:     SNESSetUp(fas->smoothd);
254:     if (fas->eventsmoothsetup) {PetscLogEventEnd(fas->eventsmoothsetup,0,0,0,0);}
255:   }

257:   /* sets the up (post) smoother's default norm and sets it from options */
258:   if (fas->smoothu) {
259:     if (fas->level != fas->levels - 1) {
260:       SNESSetNormSchedule(fas->smoothu, SNES_NORM_NONE);
261:     } else {
262:       SNESSetNormSchedule(fas->smoothu, SNES_NORM_FINAL_ONLY);
263:     }
264:     PetscObjectCopyFortranFunctionPointers((PetscObject)snes, (PetscObject)fas->smoothu);
265:     SNESSetFromOptions(fas->smoothu);
266:     SNESGetLineSearch(snes,&linesearch);
267:     SNESGetLineSearch(fas->smoothu,&slinesearch);
268:     SNESLineSearchGetPreCheck(linesearch,&precheck,&lsprectx);
269:     SNESLineSearchGetPostCheck(linesearch,&postcheck,&lspostctx);
270:     SNESLineSearchSetPreCheck(slinesearch,precheck,lsprectx);
271:     SNESLineSearchSetPostCheck(slinesearch,postcheck,lspostctx);
272:     PetscObjectCopyFortranFunctionPointers((PetscObject)linesearch, (PetscObject)slinesearch);

274:     fas->smoothu->vec_sol        = snes->vec_sol;
275:     PetscObjectReference((PetscObject)snes->vec_sol);
276:     fas->smoothu->vec_sol_update = snes->vec_sol_update;
277:     PetscObjectReference((PetscObject)snes->vec_sol_update);
278:     fas->smoothu->vec_func       = snes->vec_func;
279:     PetscObjectReference((PetscObject)snes->vec_func);

281:     if (fas->eventsmoothsetup) {PetscLogEventBegin(fas->eventsmoothsetup,0,0,0,0);}
282:     SNESSetUp(fas->smoothu);
283:     if (fas->eventsmoothsetup) {PetscLogEventEnd(fas->eventsmoothsetup,0,0,0,0);}

285:   }

287:   if (next) {
288:     /* gotta set up the solution vector for this to work */
289:     if (!next->vec_sol) {SNESFASCreateCoarseVec(snes,&next->vec_sol);}
290:     if (!next->vec_rhs) {SNESFASCreateCoarseVec(snes,&next->vec_rhs);}
291:     PetscObjectCopyFortranFunctionPointers((PetscObject)snes, (PetscObject)next);
292:     SNESGetLineSearch(snes,&linesearch);
293:     SNESGetLineSearch(fas->next,&slinesearch);
294:     SNESLineSearchGetPreCheck(linesearch,&precheck,&lsprectx);
295:     SNESLineSearchGetPostCheck(linesearch,&postcheck,&lspostctx);
296:     SNESLineSearchSetPreCheck(slinesearch,precheck,lsprectx);
297:     SNESLineSearchSetPostCheck(slinesearch,postcheck,lspostctx);
298:     PetscObjectCopyFortranFunctionPointers((PetscObject)linesearch, (PetscObject)slinesearch);
299:     SNESSetUp(next);
300:   }
301:   /* setup FAS work vectors */
302:   if (fas->galerkin) {
303:     VecDuplicate(snes->vec_sol, &fas->Xg);
304:     VecDuplicate(snes->vec_sol, &fas->Fg);
305:   }
306:   return(0);
307: }

311: PetscErrorCode SNESSetFromOptions_FAS(PetscOptions *PetscOptionsObject,SNES snes)
312: {
313:   SNES_FAS       *fas   = (SNES_FAS*) snes->data;
314:   PetscInt       levels = 1;
315:   PetscBool      flg    = PETSC_FALSE, upflg = PETSC_FALSE, downflg = PETSC_FALSE, monflg = PETSC_FALSE, galerkinflg = PETSC_FALSE,continuationflg = PETSC_FALSE;
317:   char           monfilename[PETSC_MAX_PATH_LEN];
318:   SNESFASType    fastype;
319:   const char     *optionsprefix;
320:   SNESLineSearch linesearch;
321:   PetscInt       m, n_up, n_down;
322:   SNES           next;
323:   PetscBool      isFine;

326:   SNESFASCycleIsFine(snes, &isFine);
327:   PetscOptionsHead(PetscOptionsObject,"SNESFAS Options-----------------------------------");

329:   /* number of levels -- only process most options on the finest level */
330:   if (isFine) {
331:     PetscOptionsInt("-snes_fas_levels", "Number of Levels", "SNESFASSetLevels", levels, &levels, &flg);
332:     if (!flg && snes->dm) {
333:       DMGetRefineLevel(snes->dm,&levels);
334:       levels++;
335:       fas->usedmfornumberoflevels = PETSC_TRUE;
336:     }
337:     SNESFASSetLevels(snes, levels, NULL);
338:     fastype = fas->fastype;
339:     PetscOptionsEnum("-snes_fas_type","FAS correction type","SNESFASSetType",SNESFASTypes,(PetscEnum)fastype,(PetscEnum*)&fastype,&flg);
340:     if (flg) {
341:       SNESFASSetType(snes, fastype);
342:     }

344:     SNESGetOptionsPrefix(snes, &optionsprefix);
345:     PetscOptionsInt("-snes_fas_cycles","Number of cycles","SNESFASSetCycles",fas->n_cycles,&m,&flg);
346:     if (flg) {
347:       SNESFASSetCycles(snes, m);
348:     }
349:     PetscOptionsBool("-snes_fas_continuation","Corrected grid-sequence continuation","SNESFASSetContinuation",fas->continuation,&continuationflg,&flg);
350:     if (flg) {
351:       SNESFASSetContinuation(snes,continuationflg);
352:     }

354:     PetscOptionsBool("-snes_fas_galerkin", "Form coarse problems with Galerkin","SNESFASSetGalerkin",fas->galerkin,&galerkinflg,&flg);
355:     if (flg) {
356:       SNESFASSetGalerkin(snes, galerkinflg);
357:     }

359:     if (fas->fastype == SNES_FAS_FULL) {
360:       PetscOptionsBool("-snes_fas_full_downsweep","Smooth on the initial upsweep for full FAS cycles","SNESFASFullSetDownSweep",fas->full_downsweep,&fas->full_downsweep,&flg);
361:       if (flg) {SNESFASFullSetDownSweep(snes,fas->full_downsweep);}
362:     }

364:     PetscOptionsInt("-snes_fas_smoothup","Number of post-smoothing steps","SNESFASSetNumberSmoothUp",fas->max_up_it,&n_up,&upflg);

366:     PetscOptionsInt("-snes_fas_smoothdown","Number of pre-smoothing steps","SNESFASSetNumberSmoothDown",fas->max_down_it,&n_down,&downflg);

368:     PetscOptionsString("-snes_fas_monitor","Monitor FAS progress","SNESFASSetMonitor","stdout",monfilename,PETSC_MAX_PATH_LEN,&monflg);
369:     if (monflg) SNESFASSetMonitor(snes, PETSC_TRUE);

371:     flg    = PETSC_FALSE;
372:     monflg = PETSC_TRUE;
373:     PetscOptionsBool("-snes_fas_log","Log times for each FAS level","SNESFASSetLog",monflg,&monflg,&flg);
374:     if (flg) {SNESFASSetLog(snes,monflg);}
375:   }

377:   PetscOptionsTail();
378:   /* setup from the determined types if there is no pointwise procedure or smoother defined */
379:   if (upflg) {
380:     SNESFASSetNumberSmoothUp(snes,n_up);
381:   }
382:   if (downflg) {
383:     SNESFASSetNumberSmoothDown(snes,n_down);
384:   }

386:   /* set up the default line search for coarse grid corrections */
387:   if (fas->fastype == SNES_FAS_ADDITIVE) {
388:     if (!snes->linesearch) {
389:       SNESGetLineSearch(snes, &linesearch);
390:       SNESLineSearchSetType(linesearch, SNESLINESEARCHL2);
391:     }
392:   }

394:   SNESFASCycleGetCorrection(snes, &next);
395:   /* recursive option setting for the smoothers */
396:   if (next) {SNESSetFromOptions(next);}
397:   return(0);
398: }

400: #include <petscdraw.h>
403: PetscErrorCode SNESView_FAS(SNES snes, PetscViewer viewer)
404: {
405:   SNES_FAS       *fas = (SNES_FAS*) snes->data;
406:   PetscBool      isFine,iascii,isdraw;
407:   PetscInt       i;
409:   SNES           smoothu, smoothd, levelsnes;

412:   SNESFASCycleIsFine(snes, &isFine);
413:   if (isFine) {
414:     PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
415:     PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERDRAW,&isdraw);
416:     if (iascii) {
417:       PetscViewerASCIIPrintf(viewer, "FAS: type is %s, levels=%D, cycles=%D\n",  SNESFASTypes[fas->fastype], fas->levels, fas->n_cycles);
418:       if (fas->galerkin) {
419:         PetscViewerASCIIPrintf(viewer,"    Using Galerkin computed coarse grid function evaluation\n");
420:       } else {
421:         PetscViewerASCIIPrintf(viewer,"    Not using Galerkin computed coarse grid function evaluation\n");
422:       }
423:       for (i=0; i<fas->levels; i++) {
424:         SNESFASGetCycleSNES(snes, i, &levelsnes);
425:         SNESFASCycleGetSmootherUp(levelsnes, &smoothu);
426:         SNESFASCycleGetSmootherDown(levelsnes, &smoothd);
427:         if (!i) {
428:           PetscViewerASCIIPrintf(viewer,"Coarse grid solver -- level %D -------------------------------\n",i);
429:         } else {
430:           PetscViewerASCIIPrintf(viewer,"Down solver (pre-smoother) on level %D -------------------------------\n",i);
431:         }
432:         PetscViewerASCIIPushTab(viewer);
433:         if (smoothd) {
434:           SNESView(smoothd,viewer);
435:         } else {
436:           PetscViewerASCIIPrintf(viewer,"Not yet available\n");
437:         }
438:         PetscViewerASCIIPopTab(viewer);
439:         if (i && (smoothd == smoothu)) {
440:           PetscViewerASCIIPrintf(viewer,"Up solver (post-smoother) same as down solver (pre-smoother)\n");
441:         } else if (i) {
442:           PetscViewerASCIIPrintf(viewer,"Up solver (post-smoother) on level %D -------------------------------\n",i);
443:           PetscViewerASCIIPushTab(viewer);
444:           if (smoothu) {
445:             SNESView(smoothu,viewer);
446:           } else {
447:             PetscViewerASCIIPrintf(viewer,"Not yet available\n");
448:           }
449:           PetscViewerASCIIPopTab(viewer);
450:         }
451:       }
452:     } else if (isdraw) {
453:       PetscDraw draw;
454:       PetscReal x,w,y,bottom,th,wth;
455:       SNES_FAS  *curfas = fas;
456:       PetscViewerDrawGetDraw(viewer,0,&draw);
457:       PetscDrawGetCurrentPoint(draw,&x,&y);
458:       PetscDrawStringGetSize(draw,&wth,&th);
459:       bottom = y - th;
460:       while (curfas) {
461:         if (!curfas->smoothu) {
462:           PetscDrawPushCurrentPoint(draw,x,bottom);
463:           if (curfas->smoothd) SNESView(curfas->smoothd,viewer);
464:           PetscDrawPopCurrentPoint(draw);
465:         } else {
466:           w    = 0.5*PetscMin(1.0-x,x);
467:           PetscDrawPushCurrentPoint(draw,x-w,bottom);
468:           if (curfas->smoothd) SNESView(curfas->smoothd,viewer);
469:           PetscDrawPopCurrentPoint(draw);
470:           PetscDrawPushCurrentPoint(draw,x+w,bottom);
471:           if (curfas->smoothu) SNESView(curfas->smoothu,viewer);
472:           PetscDrawPopCurrentPoint(draw);
473:         }
474:         /* this is totally bogus but we have no way of knowing how low the previous one was draw to */
475:         bottom -= 5*th;
476:         if (curfas->next) curfas = (SNES_FAS*)curfas->next->data;
477:         else curfas = NULL;
478:       }
479:     }
480:   }
481:   return(0);
482: }

486: /*
487: Defines the action of the downsmoother
488:  */
489: PetscErrorCode SNESFASDownSmooth_Private(SNES snes, Vec B, Vec X, Vec F, PetscReal *fnorm)
490: {
491:   PetscErrorCode      0;
492:   SNESConvergedReason reason;
493:   Vec                 FPC;
494:   SNES                smoothd;
495:   SNES_FAS            *fas = (SNES_FAS*) snes->data;

498:   SNESFASCycleGetSmootherDown(snes, &smoothd);
499:   SNESSetInitialFunction(smoothd, F);
500:   if (fas->eventsmoothsolve) {PetscLogEventBegin(fas->eventsmoothsolve,0,0,0,0);}
501:   SNESSolve(smoothd, B, X);
502:   if (fas->eventsmoothsolve) {PetscLogEventEnd(fas->eventsmoothsolve,0,0,0,0);}
503:   /* check convergence reason for the smoother */
504:   SNESGetConvergedReason(smoothd,&reason);
505:   if (reason < 0 && !(reason == SNES_DIVERGED_MAX_IT || reason == SNES_DIVERGED_LOCAL_MIN || reason == SNES_DIVERGED_LINE_SEARCH)) {
506:     snes->reason = SNES_DIVERGED_INNER;
507:     return(0);
508:   }
509:   SNESGetFunction(smoothd, &FPC, NULL, NULL);
510:   VecCopy(FPC, F);
511:   if (fnorm) {VecNorm(F,NORM_2,fnorm);}
512:   return(0);
513: }


518: /*
519: Defines the action of the upsmoother
520:  */
521: PetscErrorCode SNESFASUpSmooth_Private(SNES snes, Vec B, Vec X, Vec F, PetscReal *fnorm)
522: {
523:   PetscErrorCode      0;
524:   SNESConvergedReason reason;
525:   Vec                 FPC;
526:   SNES                smoothu;
527:   SNES_FAS            *fas = (SNES_FAS*) snes->data;

530:   SNESFASCycleGetSmootherUp(snes, &smoothu);
531:   if (fas->eventsmoothsolve) {PetscLogEventBegin(fas->eventsmoothsolve,0,0,0,0);}
532:   SNESSolve(smoothu, B, X);
533:   if (fas->eventsmoothsolve) {PetscLogEventEnd(fas->eventsmoothsolve,0,0,0,0);}
534:   /* check convergence reason for the smoother */
535:   SNESGetConvergedReason(smoothu,&reason);
536:   if (reason < 0 && !(reason == SNES_DIVERGED_MAX_IT || reason == SNES_DIVERGED_LOCAL_MIN || reason == SNES_DIVERGED_LINE_SEARCH)) {
537:     snes->reason = SNES_DIVERGED_INNER;
538:     return(0);
539:   }
540:   SNESGetFunction(smoothu, &FPC, NULL, NULL);
541:   VecCopy(FPC, F);
542:   if (fnorm) {VecNorm(F,NORM_2,fnorm);}
543:   return(0);
544: }

548: /*@
549:    SNESFASCreateCoarseVec - create Vec corresponding to a state vector on one level coarser than current level

551:    Collective

553:    Input Arguments:
554: .  snes - SNESFAS

556:    Output Arguments:
557: .  Xcoarse - vector on level one coarser than snes

559:    Level: developer

561: .seealso: SNESFASSetRestriction(), SNESFASRestrict()
562: @*/
563: PetscErrorCode SNESFASCreateCoarseVec(SNES snes,Vec *Xcoarse)
564: {
566:   SNES_FAS       *fas = (SNES_FAS*)snes->data;

569:   if (fas->rscale) {
570:     VecDuplicate(fas->rscale,Xcoarse);
571:   } else if (fas->inject) {
572:     MatCreateVecs(fas->inject,Xcoarse,NULL);
573:   } else SETERRQ(PetscObjectComm((PetscObject)snes),PETSC_ERR_ARG_WRONGSTATE,"Must set restriction or injection");
574:   return(0);
575: }

579: /*@
580:    SNESFASRestrict - restrict a Vec to the next coarser level

582:    Collective

584:    Input Arguments:
585: +  fine - SNES from which to restrict
586: -  Xfine - vector to restrict

588:    Output Arguments:
589: .  Xcoarse - result of restriction

591:    Level: developer

593: .seealso: SNESFASSetRestriction(), SNESFASSetInjection()
594: @*/
595: PetscErrorCode SNESFASRestrict(SNES fine,Vec Xfine,Vec Xcoarse)
596: {
598:   SNES_FAS       *fas = (SNES_FAS*)fine->data;

604:   if (fas->inject) {
605:     MatRestrict(fas->inject,Xfine,Xcoarse);
606:   } else {
607:     MatRestrict(fas->restrct,Xfine,Xcoarse);
608:     VecPointwiseMult(Xcoarse,fas->rscale,Xcoarse);
609:   }
610:   return(0);
611: }

615: /*

617: Performs the FAS coarse correction as:

619: fine problem:   F(x) = b
620: coarse problem: F^c(x^c) = b^c

622: b^c = F^c(Rx) - R(F(x) - b)

624:  */
625: PetscErrorCode SNESFASCoarseCorrection(SNES snes, Vec X, Vec F, Vec X_new)
626: {
627:   PetscErrorCode      ierr;
628:   Vec                 X_c, Xo_c, F_c, B_c;
629:   SNESConvergedReason reason;
630:   SNES                next;
631:   Mat                 restrct, interpolate;
632:   SNES_FAS            *fasc;

635:   SNESFASCycleGetCorrection(snes, &next);
636:   if (next) {
637:     fasc = (SNES_FAS*)next->data;

639:     SNESFASCycleGetRestriction(snes, &restrct);
640:     SNESFASCycleGetInterpolation(snes, &interpolate);

642:     X_c  = next->vec_sol;
643:     Xo_c = next->work[0];
644:     F_c  = next->vec_func;
645:     B_c  = next->vec_rhs;

647:     if (fasc->eventinterprestrict) {PetscLogEventBegin(fasc->eventinterprestrict,0,0,0,0);}
648:     SNESFASRestrict(snes,X,Xo_c);
649:     /* restrict the defect: R(F(x) - b) */
650:     MatRestrict(restrct, F, B_c);
651:     if (fasc->eventinterprestrict) {PetscLogEventEnd(fasc->eventinterprestrict,0,0,0,0);}

653:     if (fasc->eventresidual) {PetscLogEventBegin(fasc->eventresidual,0,0,0,0);}
654:     /* F_c = F^c(Rx) - R(F(x) - b) since the second term was sitting in next->vec_rhs */
655:     SNESComputeFunction(next, Xo_c, F_c);
656:     if (fasc->eventresidual) {PetscLogEventEnd(fasc->eventresidual,0,0,0,0);}

658:     /* solve the coarse problem corresponding to F^c(x^c) = b^c = F^c(Rx) - R(F(x) - b) */
659:     VecCopy(B_c, X_c);
660:     VecCopy(F_c, B_c);
661:     VecCopy(X_c, F_c);
662:     /* set initial guess of the coarse problem to the projected fine solution */
663:     VecCopy(Xo_c, X_c);

665:     /* recurse to the next level */
666:     SNESSetInitialFunction(next, F_c);
667:     SNESSolve(next, B_c, X_c);
668:     SNESGetConvergedReason(next,&reason);
669:     if (reason < 0 && reason != SNES_DIVERGED_MAX_IT) {
670:       snes->reason = SNES_DIVERGED_INNER;
671:       return(0);
672:     }
673:     /* correct as x <- x + I(x^c - Rx)*/
674:     VecAXPY(X_c, -1.0, Xo_c);

676:     if (fasc->eventinterprestrict) {PetscLogEventBegin(fasc->eventinterprestrict,0,0,0,0);}
677:     MatInterpolateAdd(interpolate, X_c, X, X_new);
678:     if (fasc->eventinterprestrict) {PetscLogEventEnd(fasc->eventinterprestrict,0,0,0,0);}
679:   }
680:   return(0);
681: }

685: /*

687: The additive cycle looks like:

689: xhat = x
690: xhat = dS(x, b)
691: x = coarsecorrection(xhat, b_d)
692: x = x + nu*(xhat - x);
693: (optional) x = uS(x, b)

695: With the coarse RHS (defect correction) as below.

697:  */
698: PetscErrorCode SNESFASCycle_Additive(SNES snes, Vec X)
699: {
700:   Vec                  F, B, Xhat;
701:   Vec                  X_c, Xo_c, F_c, B_c;
702:   PetscErrorCode       ierr;
703:   SNESConvergedReason  reason;
704:   PetscReal            xnorm, fnorm, ynorm;
705:   SNESLineSearchReason lsresult;
706:   SNES                 next;
707:   Mat                  restrct, interpolate;
708:   SNES_FAS             *fas = (SNES_FAS*)snes->data,*fasc;

711:   SNESFASCycleGetCorrection(snes, &next);
712:   F    = snes->vec_func;
713:   B    = snes->vec_rhs;
714:   Xhat = snes->work[1];
715:   VecCopy(X, Xhat);
716:   /* recurse first */
717:   if (next) {
718:     fasc = (SNES_FAS*)next->data;
719:     SNESFASCycleGetRestriction(snes, &restrct);
720:     SNESFASCycleGetInterpolation(snes, &interpolate);
721:     if (fas->eventresidual) {PetscLogEventBegin(fas->eventresidual,0,0,0,0);}
722:     SNESComputeFunction(snes, Xhat, F);
723:     if (fas->eventresidual) {PetscLogEventEnd(fas->eventresidual,0,0,0,0);}
724:     VecNorm(F, NORM_2, &fnorm);
725:     X_c  = next->vec_sol;
726:     Xo_c = next->work[0];
727:     F_c  = next->vec_func;
728:     B_c  = next->vec_rhs;

730:     SNESFASRestrict(snes,Xhat,Xo_c);
731:     /* restrict the defect */
732:     MatRestrict(restrct, F, B_c);

734:     /* solve the coarse problem corresponding to F^c(x^c) = b^c = Rb + F^c(Rx) - RF(x) */
735:     if (fasc->eventresidual) {PetscLogEventBegin(fasc->eventresidual,0,0,0,0);}
736:     SNESComputeFunction(next, Xo_c, F_c);
737:     if (fasc->eventresidual) {PetscLogEventEnd(fasc->eventresidual,0,0,0,0);}
738:     VecCopy(B_c, X_c);
739:     VecCopy(F_c, B_c);
740:     VecCopy(X_c, F_c);
741:     /* set initial guess of the coarse problem to the projected fine solution */
742:     VecCopy(Xo_c, X_c);

744:     /* recurse */
745:     SNESSetInitialFunction(next, F_c);
746:     SNESSolve(next, B_c, X_c);

748:     /* smooth on this level */
749:     SNESFASDownSmooth_Private(snes, B, X, F, &fnorm);

751:     SNESGetConvergedReason(next,&reason);
752:     if (reason < 0 && reason != SNES_DIVERGED_MAX_IT) {
753:       snes->reason = SNES_DIVERGED_INNER;
754:       return(0);
755:     }

757:     /* correct as x <- x + I(x^c - Rx)*/
758:     VecAYPX(X_c, -1.0, Xo_c);
759:     MatInterpolate(interpolate, X_c, Xhat);

761:     /* additive correction of the coarse direction*/
762:     SNESLineSearchApply(snes->linesearch, X, F, &fnorm, Xhat);
763:     SNESLineSearchGetReason(snes->linesearch, &lsresult);
764:     SNESLineSearchGetNorms(snes->linesearch, &xnorm, &snes->norm, &ynorm);
765:     if (lsresult) {
766:       if (++snes->numFailures >= snes->maxFailures) {
767:         snes->reason = SNES_DIVERGED_LINE_SEARCH;
768:         return(0);
769:       }
770:     }
771:   } else {
772:     SNESFASDownSmooth_Private(snes, B, X, F, &snes->norm);
773:   }
774:   return(0);
775: }

779: /*

781: Defines the FAS cycle as:

783: fine problem: F(x) = b
784: coarse problem: F^c(x) = b^c

786: b^c = F^c(Rx) - R(F(x) - b)

788: correction:

790: x = x + I(x^c - Rx)

792:  */
793: PetscErrorCode SNESFASCycle_Multiplicative(SNES snes, Vec X)
794: {

797:   Vec            F,B;
798:   SNES           next;

801:   F = snes->vec_func;
802:   B = snes->vec_rhs;
803:   /* pre-smooth -- just update using the pre-smoother */
804:   SNESFASCycleGetCorrection(snes,&next);
805:   SNESFASDownSmooth_Private(snes, B, X, F, &snes->norm);
806:   if (next) {
807:     SNESFASCoarseCorrection(snes, X, F, X);
808:     SNESFASUpSmooth_Private(snes, B, X, F, &snes->norm);
809:   }
810:   return(0);
811: }

815: PetscErrorCode SNESFASCycleSetupPhase_Full(SNES snes)
816: {
817:   SNES           next;
818:   SNES_FAS       *fas = (SNES_FAS*)snes->data;
819:   PetscBool      isFine;

823:   /* pre-smooth -- just update using the pre-smoother */
824:   SNESFASCycleIsFine(snes,&isFine);
825:   SNESFASCycleGetCorrection(snes,&next);
826:   fas->full_stage = 0;
827:   if (next) {SNESFASCycleSetupPhase_Full(next);}
828:   return(0);
829: }

833: PetscErrorCode SNESFASCycle_Full(SNES snes, Vec X)
834: {
836:   Vec            F,B;
837:   SNES_FAS       *fas = (SNES_FAS*)snes->data;
838:   PetscBool      isFine;
839:   SNES           next;

842:   F = snes->vec_func;
843:   B = snes->vec_rhs;
844:   SNESFASCycleIsFine(snes,&isFine);
845:   SNESFASCycleGetCorrection(snes,&next);

847:   if (isFine) {
848:     SNESFASCycleSetupPhase_Full(snes);
849:   }

851:   if (fas->full_stage == 0) {
852:     /* downsweep */
853:     if (next) {
854:       if (fas->level != 1) next->max_its += 1;
855:       if (fas->full_downsweep||isFine) {SNESFASDownSmooth_Private(snes,B,X,F,&snes->norm);}
856:       SNESFASCoarseCorrection(snes,X,F,X);
857:       SNESFASUpSmooth_Private(snes,B,X,F,&snes->norm);
858:       if (fas->level != 1) next->max_its -= 1;
859:     } else {
860:       SNESFASDownSmooth_Private(snes,B,X,F,&snes->norm);
861:     }
862:     fas->full_stage = 1;
863:   } else if (fas->full_stage == 1) {
864:     if (snes->iter == 0) {SNESFASDownSmooth_Private(snes,B,X,F,&snes->norm);}
865:     if (next) {
866:       SNESFASCoarseCorrection(snes,X,F,X);
867:       SNESFASUpSmooth_Private(snes,B,X,F,&snes->norm);
868:     }
869:   }
870:   /* final v-cycle */
871:   if (isFine) {
872:     if (next) {
873:       SNESFASCoarseCorrection(snes,X,F,X);
874:       SNESFASUpSmooth_Private(snes,B,X,F,&snes->norm);
875:     }
876:   }
877:   return(0);
878: }

882: PetscErrorCode SNESFASCycle_Kaskade(SNES snes, Vec X)
883: {
885:   Vec            F,B;
886:   SNES           next;

889:   F = snes->vec_func;
890:   B = snes->vec_rhs;
891:   SNESFASCycleGetCorrection(snes,&next);
892:   if (next) {
893:     SNESFASCoarseCorrection(snes,X,F,X);
894:     SNESFASUpSmooth_Private(snes,B,X,F,&snes->norm);
895:   } else {
896:     SNESFASDownSmooth_Private(snes,B,X,F,&snes->norm);
897:   }
898:   return(0);
899: }

901: PetscBool SNEScite = PETSC_FALSE;
902: const char SNESCitation[] = "@techreport{pbmkbsxt2012,\n"
903:                             "  title = {Composing Scalable Nonlinear Algebraic Solvers},\n"
904:                             "  author = {Peter Brune and Mathew Knepley and Barry Smith and Xuemin Tu},\n"
905:                             "  year = 2013,\n"
906:                             "  type = Preprint,\n"
907:                             "  number = {ANL/MCS-P2010-0112},\n"
908:                             "  institution = {Argonne National Laboratory}\n}\n";

912: PetscErrorCode SNESSolve_FAS(SNES snes)
913: {
915:   PetscInt       i, maxits;
916:   Vec            X, F;
917:   PetscReal      fnorm;
918:   SNES_FAS       *fas = (SNES_FAS*)snes->data,*ffas;
919:   DM             dm;
920:   PetscBool      isFine;


924:   if (snes->xl || snes->xu || snes->ops->computevariablebounds) {
925:     SETERRQ1(PetscObjectComm((PetscObject)snes),PETSC_ERR_ARG_WRONGSTATE, "SNES solver %s does not support bounds", ((PetscObject)snes)->type_name);
926:   }

928:   PetscCitationsRegister(SNESCitation,&SNEScite);
929:   maxits       = snes->max_its;      /* maximum number of iterations */
930:   snes->reason = SNES_CONVERGED_ITERATING;
931:   X            = snes->vec_sol;
932:   F            = snes->vec_func;

934:   SNESFASCycleIsFine(snes, &isFine);
935:   /*norm setup */
936:   PetscObjectSAWsTakeAccess((PetscObject)snes);
937:   snes->iter = 0;
938:   snes->norm = 0.;
939:   PetscObjectSAWsGrantAccess((PetscObject)snes);
940:   if (!snes->vec_func_init_set) {
941:     if (fas->eventresidual) {PetscLogEventBegin(fas->eventresidual,0,0,0,0);}
942:     SNESComputeFunction(snes,X,F);
943:     if (fas->eventresidual) {PetscLogEventEnd(fas->eventresidual,0,0,0,0);}
944:   } else snes->vec_func_init_set = PETSC_FALSE;

946:   VecNorm(F, NORM_2, &fnorm); /* fnorm <- ||F||  */
947:   SNESCheckFunctionNorm(snes,fnorm);
948:   PetscObjectSAWsTakeAccess((PetscObject)snes);
949:   snes->norm = fnorm;
950:   PetscObjectSAWsGrantAccess((PetscObject)snes);
951:   SNESLogConvergenceHistory(snes,fnorm,0);
952:   SNESMonitor(snes,0,fnorm);

954:   /* test convergence */
955:   (*snes->ops->converged)(snes,0,0.0,0.0,fnorm,&snes->reason,snes->cnvP);
956:   if (snes->reason) return(0);


959:   if (isFine) {
960:     /* propagate scale-dependent data up the hierarchy */
961:     SNESGetDM(snes,&dm);
962:     for (ffas=fas; ffas->next; ffas=(SNES_FAS*)ffas->next->data) {
963:       DM dmcoarse;
964:       SNESGetDM(ffas->next,&dmcoarse);
965:       DMRestrict(dm,ffas->restrct,ffas->rscale,ffas->inject,dmcoarse);
966:       dm   = dmcoarse;
967:     }
968:   }

970:   for (i = 0; i < maxits; i++) {
971:     /* Call general purpose update function */

973:     if (snes->ops->update) {
974:       (*snes->ops->update)(snes, snes->iter);
975:     }
976:     if (fas->fastype == SNES_FAS_MULTIPLICATIVE) {
977:       SNESFASCycle_Multiplicative(snes, X);
978:     } else if (fas->fastype == SNES_FAS_ADDITIVE) {
979:       SNESFASCycle_Additive(snes, X);
980:     } else if (fas->fastype == SNES_FAS_FULL) {
981:       SNESFASCycle_Full(snes, X);
982:     } else if (fas->fastype ==SNES_FAS_KASKADE) {
983:       SNESFASCycle_Kaskade(snes, X);
984:     } else {
985:       SETERRQ(PetscObjectComm((PetscObject)snes),PETSC_ERR_ARG_WRONGSTATE,"Unsupported FAS type");
986:     }

988:     /* check for FAS cycle divergence */
989:     if (snes->reason != SNES_CONVERGED_ITERATING) return(0);

991:     /* Monitor convergence */
992:     PetscObjectSAWsTakeAccess((PetscObject)snes);
993:     snes->iter = i+1;
994:     PetscObjectSAWsGrantAccess((PetscObject)snes);
995:     SNESLogConvergenceHistory(snes,snes->norm,0);
996:     SNESMonitor(snes,snes->iter,snes->norm);
997:     /* Test for convergence */
998:     if (isFine) {
999:       (*snes->ops->converged)(snes,snes->iter,0.0,0.0,snes->norm,&snes->reason,snes->cnvP);
1000:       if (snes->reason) break;
1001:     }
1002:   }
1003:   if (i == maxits) {
1004:     PetscInfo1(snes, "Maximum number of iterations has been reached: %D\n", maxits);
1005:     if (!snes->reason) snes->reason = SNES_DIVERGED_MAX_IT;
1006:   }
1007:   return(0);
1008: }