Actual source code: posindep.c

petsc-master 2019-07-18
Report Typos and Errors
  1: /*
  2:        Code for Timestepping with implicit backwards Euler.
  3: */
  4:  #include <petsc/private/tsimpl.h>

  6: typedef struct {
  7:   Vec update;       /* work vector where new solution is formed */
  8:   Vec func;         /* work vector where F(t[i],u[i]) is stored */
  9:   Vec xdot;         /* work vector for time derivative of state */

 11:   /* information used for Pseudo-timestepping */

 13:   PetscErrorCode (*dt)(TS,PetscReal*,void*);              /* compute next timestep, and related context */
 14:   void *dtctx;
 15:   PetscErrorCode (*verify)(TS,Vec,void*,PetscReal*,PetscBool*);  /* verify previous timestep and related context */
 16:   void *verifyctx;

 18:   PetscReal fnorm_initial,fnorm;                   /* original and current norm of F(u) */
 19:   PetscReal fnorm_previous;

 21:   PetscReal dt_initial;                     /* initial time-step */
 22:   PetscReal dt_increment;                   /* scaling that dt is incremented each time-step */
 23:   PetscReal dt_max;                         /* maximum time step */
 24:   PetscBool increment_dt_from_initial_dt;
 25:   PetscReal fatol,frtol;
 26: } TS_Pseudo;

 28: /* ------------------------------------------------------------------------------*/

 30: /*@C
 31:     TSPseudoComputeTimeStep - Computes the next timestep for a currently running
 32:     pseudo-timestepping process.

 34:     Collective on TS

 36:     Input Parameter:
 37: .   ts - timestep context

 39:     Output Parameter:
 40: .   dt - newly computed timestep

 42:     Level: developer

 44:     Notes:
 45:     The routine to be called here to compute the timestep should be
 46:     set by calling TSPseudoSetTimeStep().

 48: .seealso: TSPseudoTimeStepDefault(), TSPseudoSetTimeStep()
 49: @*/
 50: PetscErrorCode  TSPseudoComputeTimeStep(TS ts,PetscReal *dt)
 51: {
 52:   TS_Pseudo      *pseudo = (TS_Pseudo*)ts->data;

 56:   PetscLogEventBegin(TS_PseudoComputeTimeStep,ts,0,0,0);
 57:   (*pseudo->dt)(ts,dt,pseudo->dtctx);
 58:   PetscLogEventEnd(TS_PseudoComputeTimeStep,ts,0,0,0);
 59:   return(0);
 60: }


 63: /* ------------------------------------------------------------------------------*/
 64: /*@C
 65:    TSPseudoVerifyTimeStepDefault - Default code to verify the quality of the last timestep.

 67:    Collective on TS

 69:    Input Parameters:
 70: +  ts - the timestep context
 71: .  dtctx - unused timestep context
 72: -  update - latest solution vector

 74:    Output Parameters:
 75: +  newdt - the timestep to use for the next step
 76: -  flag - flag indicating whether the last time step was acceptable

 78:    Level: advanced

 80:    Note:
 81:    This routine always returns a flag of 1, indicating an acceptable
 82:    timestep.

 84: .seealso: TSPseudoSetVerifyTimeStep(), TSPseudoVerifyTimeStep()
 85: @*/
 86: PetscErrorCode  TSPseudoVerifyTimeStepDefault(TS ts,Vec update,void *dtctx,PetscReal *newdt,PetscBool  *flag)
 87: {
 89:   *flag = PETSC_TRUE;
 90:   return(0);
 91: }


 94: /*@
 95:     TSPseudoVerifyTimeStep - Verifies whether the last timestep was acceptable.

 97:     Collective on TS

 99:     Input Parameters:
100: +   ts - timestep context
101: -   update - latest solution vector

103:     Output Parameters:
104: +   dt - newly computed timestep (if it had to shrink)
105: -   flag - indicates if current timestep was ok

107:     Level: advanced

109:     Notes:
110:     The routine to be called here to compute the timestep should be
111:     set by calling TSPseudoSetVerifyTimeStep().

113: .seealso: TSPseudoSetVerifyTimeStep(), TSPseudoVerifyTimeStepDefault()
114: @*/
115: PetscErrorCode  TSPseudoVerifyTimeStep(TS ts,Vec update,PetscReal *dt,PetscBool *flag)
116: {
117:   TS_Pseudo      *pseudo = (TS_Pseudo*)ts->data;

121:   *flag = PETSC_TRUE;
122:   if(pseudo->verify) {
123:     (*pseudo->verify)(ts,update,pseudo->verifyctx,dt,flag);
124:   }
125:   return(0);
126: }

128: /* --------------------------------------------------------------------------------*/

130: static PetscErrorCode TSStep_Pseudo(TS ts)
131: {
132:   TS_Pseudo           *pseudo = (TS_Pseudo*)ts->data;
133:   PetscInt            nits,lits,reject;
134:   PetscBool           stepok;
135:   PetscReal           next_time_step = ts->time_step;
136:   PetscErrorCode      ierr;

139:   if (ts->steps == 0) pseudo->dt_initial = ts->time_step;
140:   VecCopy(ts->vec_sol,pseudo->update);
141:   TSPseudoComputeTimeStep(ts,&next_time_step);
142:   for (reject=0; reject<ts->max_reject; reject++,ts->reject++) {
143:     ts->time_step = next_time_step;
144:     TSPreStage(ts,ts->ptime+ts->time_step);
145:     SNESSolve(ts->snes,NULL,pseudo->update);
146:     SNESGetIterationNumber(ts->snes,&nits);
147:     SNESGetLinearSolveIterations(ts->snes,&lits);
148:     ts->snes_its += nits; ts->ksp_its += lits;
149:     TSPostStage(ts,ts->ptime+ts->time_step,0,&(pseudo->update));
150:     TSAdaptCheckStage(ts->adapt,ts,ts->ptime+ts->time_step,pseudo->update,&stepok);
151:     if (!stepok) {next_time_step = ts->time_step; continue;}
152:     pseudo->fnorm = -1; /* The current norm is no longer valid, monitor must recompute it. */
153:     TSPseudoVerifyTimeStep(ts,pseudo->update,&next_time_step,&stepok);
154:     if (stepok) break;
155:   }
156:   if (reject >= ts->max_reject) {
157:     ts->reason = TS_DIVERGED_STEP_REJECTED;
158:     PetscInfo2(ts,"Step=%D, step rejections %D greater than current TS allowed, stopping solve\n",ts->steps,reject);
159:     return(0);
160:   }

162:   VecCopy(pseudo->update,ts->vec_sol);
163:   ts->ptime += ts->time_step;
164:   ts->time_step = next_time_step;

166:   if (pseudo->fnorm < 0) {
167:     VecZeroEntries(pseudo->xdot);
168:     TSComputeIFunction(ts,ts->ptime,ts->vec_sol,pseudo->xdot,pseudo->func,PETSC_FALSE);
169:     VecNorm(pseudo->func,NORM_2,&pseudo->fnorm);
170:   }
171:   if (pseudo->fnorm < pseudo->fatol) {
172:     ts->reason = TS_CONVERGED_PSEUDO_FATOL;
173:     PetscInfo3(ts,"Step=%D, converged since fnorm %g < fatol %g\n",ts->steps,pseudo->fnorm,pseudo->frtol);
174:     return(0);
175:   }
176:   if (pseudo->fnorm/pseudo->fnorm_initial < pseudo->frtol) {
177:     ts->reason = TS_CONVERGED_PSEUDO_FRTOL;
178:     PetscInfo4(ts,"Step=%D, converged since fnorm %g / fnorm_initial %g < frtol %g\n",ts->steps,pseudo->fnorm,pseudo->fnorm_initial,pseudo->fatol);
179:     return(0);
180:   }
181:   return(0);
182: }

184: /*------------------------------------------------------------*/
185: static PetscErrorCode TSReset_Pseudo(TS ts)
186: {
187:   TS_Pseudo      *pseudo = (TS_Pseudo*)ts->data;

191:   VecDestroy(&pseudo->update);
192:   VecDestroy(&pseudo->func);
193:   VecDestroy(&pseudo->xdot);
194:   return(0);
195: }

197: static PetscErrorCode TSDestroy_Pseudo(TS ts)
198: {

202:   TSReset_Pseudo(ts);
203:   PetscFree(ts->data);
204:   PetscObjectComposeFunction((PetscObject)ts,"TSPseudoSetVerifyTimeStep_C",NULL);
205:   PetscObjectComposeFunction((PetscObject)ts,"TSPseudoSetTimeStepIncrement_C",NULL);
206:   PetscObjectComposeFunction((PetscObject)ts,"TSPseudoSetMaxTimeStep_C",NULL);
207:   PetscObjectComposeFunction((PetscObject)ts,"TSPseudoIncrementDtFromInitialDt_C",NULL);
208:   PetscObjectComposeFunction((PetscObject)ts,"TSPseudoSetTimeStep_C",NULL);
209:   return(0);
210: }

212: /*------------------------------------------------------------*/

214: /*
215:     Compute Xdot = (X^{n+1}-X^n)/dt) = 0
216: */
217: static PetscErrorCode TSPseudoGetXdot(TS ts,Vec X,Vec *Xdot)
218: {
219:   TS_Pseudo         *pseudo = (TS_Pseudo*)ts->data;
220:   const PetscScalar mdt     = 1.0/ts->time_step,*xnp1,*xn;
221:   PetscScalar       *xdot;
222:   PetscErrorCode    ierr;
223:   PetscInt          i,n;

226:   *Xdot = NULL;
227:   VecGetArrayRead(ts->vec_sol,&xn);
228:   VecGetArrayRead(X,&xnp1);
229:   VecGetArray(pseudo->xdot,&xdot);
230:   VecGetLocalSize(X,&n);
231:   for (i=0; i<n; i++) xdot[i] = mdt*(xnp1[i] - xn[i]);
232:   VecRestoreArrayRead(ts->vec_sol,&xn);
233:   VecRestoreArrayRead(X,&xnp1);
234:   VecRestoreArray(pseudo->xdot,&xdot);
235:   *Xdot = pseudo->xdot;
236:   return(0);
237: }

239: /*
240:     The transient residual is

242:         F(U^{n+1},(U^{n+1}-U^n)/dt) = 0

244:     or for ODE,

246:         (U^{n+1} - U^{n})/dt - F(U^{n+1}) = 0

248:     This is the function that must be evaluated for transient simulation and for
249:     finite difference Jacobians.  On the first Newton step, this algorithm uses
250:     a guess of U^{n+1} = U^n in which case the transient term vanishes and the
251:     residual is actually the steady state residual.  Pseudotransient
252:     continuation as described in the literature is a linearly implicit
253:     algorithm, it only takes this one Newton step with the steady state
254:     residual, and then advances to the next time step.
255: */
256: static PetscErrorCode SNESTSFormFunction_Pseudo(SNES snes,Vec X,Vec Y,TS ts)
257: {
258:   Vec            Xdot;

262:   TSPseudoGetXdot(ts,X,&Xdot);
263:   TSComputeIFunction(ts,ts->ptime+ts->time_step,X,Xdot,Y,PETSC_FALSE);
264:   return(0);
265: }

267: /*
268:    This constructs the Jacobian needed for SNES.  For DAE, this is

270:        dF(X,Xdot)/dX + shift*dF(X,Xdot)/dXdot

272:     and for ODE:

274:        J = I/dt - J_{Frhs}   where J_{Frhs} is the given Jacobian of Frhs.
275: */
276: static PetscErrorCode SNESTSFormJacobian_Pseudo(SNES snes,Vec X,Mat AA,Mat BB,TS ts)
277: {
278:   Vec            Xdot;

282:   TSPseudoGetXdot(ts,X,&Xdot);
283:   TSComputeIJacobian(ts,ts->ptime+ts->time_step,X,Xdot,1./ts->time_step,AA,BB,PETSC_FALSE);
284:   return(0);
285: }


288: static PetscErrorCode TSSetUp_Pseudo(TS ts)
289: {
290:   TS_Pseudo      *pseudo = (TS_Pseudo*)ts->data;

294:   VecDuplicate(ts->vec_sol,&pseudo->update);
295:   VecDuplicate(ts->vec_sol,&pseudo->func);
296:   VecDuplicate(ts->vec_sol,&pseudo->xdot);
297:   return(0);
298: }
299: /*------------------------------------------------------------*/

301: static PetscErrorCode TSPseudoMonitorDefault(TS ts,PetscInt step,PetscReal ptime,Vec v,void *dummy)
302: {
303:   TS_Pseudo      *pseudo = (TS_Pseudo*)ts->data;
305:   PetscViewer    viewer = (PetscViewer) dummy;

308:   if (pseudo->fnorm < 0) { /* The last computed norm is stale, recompute */
309:     VecZeroEntries(pseudo->xdot);
310:     TSComputeIFunction(ts,ts->ptime,ts->vec_sol,pseudo->xdot,pseudo->func,PETSC_FALSE);
311:     VecNorm(pseudo->func,NORM_2,&pseudo->fnorm);
312:   }
313:   PetscViewerASCIIAddTab(viewer,((PetscObject)ts)->tablevel);
314:   PetscViewerASCIIPrintf(viewer,"TS %D dt %g time %g fnorm %g\n",step,(double)ts->time_step,(double)ptime,(double)pseudo->fnorm);
315:   PetscViewerASCIISubtractTab(viewer,((PetscObject)ts)->tablevel);
316:   return(0);
317: }

319: static PetscErrorCode TSSetFromOptions_Pseudo(PetscOptionItems *PetscOptionsObject,TS ts)
320: {
321:   TS_Pseudo      *pseudo = (TS_Pseudo*)ts->data;
323:   PetscBool      flg = PETSC_FALSE;
324:   PetscViewer    viewer;

327:   PetscOptionsHead(PetscOptionsObject,"Pseudo-timestepping options");
328:   PetscOptionsBool("-ts_monitor_pseudo","Monitor convergence","",flg,&flg,NULL);
329:   if (flg) {
330:     PetscViewerASCIIOpen(PetscObjectComm((PetscObject)ts),"stdout",&viewer);
331:     TSMonitorSet(ts,TSPseudoMonitorDefault,viewer,(PetscErrorCode (*)(void**))PetscViewerDestroy);
332:   }
333:   flg  = pseudo->increment_dt_from_initial_dt;
334:   PetscOptionsBool("-ts_pseudo_increment_dt_from_initial_dt","Increase dt as a ratio from original dt","TSPseudoIncrementDtFromInitialDt",flg,&flg,NULL);
335:   pseudo->increment_dt_from_initial_dt = flg;
336:   PetscOptionsReal("-ts_pseudo_increment","Ratio to increase dt","TSPseudoSetTimeStepIncrement",pseudo->dt_increment,&pseudo->dt_increment,NULL);
337:   PetscOptionsReal("-ts_pseudo_max_dt","Maximum value for dt","TSPseudoSetMaxTimeStep",pseudo->dt_max,&pseudo->dt_max,NULL);
338:   PetscOptionsReal("-ts_pseudo_fatol","Tolerance for norm of function","",pseudo->fatol,&pseudo->fatol,NULL);
339:   PetscOptionsReal("-ts_pseudo_frtol","Relative tolerance for norm of function","",pseudo->frtol,&pseudo->frtol,NULL);
340:   PetscOptionsTail();
341:   return(0);
342: }

344: static PetscErrorCode TSView_Pseudo(TS ts,PetscViewer viewer)
345: {
347:   PetscBool      isascii;

350:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&isascii);
351:   if (isascii) {
352:     TS_Pseudo *pseudo = (TS_Pseudo*) ts->data;
353:     PetscViewerASCIIPrintf(viewer,"  frtol - relative tolerance in function value %g\n",(double)pseudo->frtol);
354:     PetscViewerASCIIPrintf(viewer,"  fatol - absolute tolerance in function value %g\n",(double)pseudo->fatol);
355:     PetscViewerASCIIPrintf(viewer,"  dt_initial - initial timestep %g\n",(double)pseudo->dt_initial);
356:     PetscViewerASCIIPrintf(viewer,"  dt_increment - increase in timestep on successful step %g\n",(double)pseudo->dt_increment);
357:     PetscViewerASCIIPrintf(viewer,"  dt_max - maximum time %g\n",(double)pseudo->dt_max);
358:   }
359:   return(0);
360: }

362: /* ----------------------------------------------------------------------------- */
363: /*@C
364:    TSPseudoSetVerifyTimeStep - Sets a user-defined routine to verify the quality of the
365:    last timestep.

367:    Logically Collective on TS

369:    Input Parameters:
370: +  ts - timestep context
371: .  dt - user-defined function to verify timestep
372: -  ctx - [optional] user-defined context for private data
373:          for the timestep verification routine (may be NULL)

375:    Level: advanced

377:    Calling sequence of func:
378: $  func (TS ts,Vec update,void *ctx,PetscReal *newdt,PetscBool  *flag);

380: +  update - latest solution vector
381: .  ctx - [optional] timestep context
382: .  newdt - the timestep to use for the next step
383: -  flag - flag indicating whether the last time step was acceptable

385:    Notes:
386:    The routine set here will be called by TSPseudoVerifyTimeStep()
387:    during the timestepping process.

389: .seealso: TSPseudoVerifyTimeStepDefault(), TSPseudoVerifyTimeStep()
390: @*/
391: PetscErrorCode  TSPseudoSetVerifyTimeStep(TS ts,PetscErrorCode (*dt)(TS,Vec,void*,PetscReal*,PetscBool*),void *ctx)
392: {

397:   PetscTryMethod(ts,"TSPseudoSetVerifyTimeStep_C",(TS,PetscErrorCode (*)(TS,Vec,void*,PetscReal*,PetscBool*),void*),(ts,dt,ctx));
398:   return(0);
399: }

401: /*@
402:     TSPseudoSetTimeStepIncrement - Sets the scaling increment applied to
403:     dt when using the TSPseudoTimeStepDefault() routine.

405:    Logically Collective on TS

407:     Input Parameters:
408: +   ts - the timestep context
409: -   inc - the scaling factor >= 1.0

411:     Options Database Key:
412: .    -ts_pseudo_increment <increment>

414:     Level: advanced

416: .seealso: TSPseudoSetTimeStep(), TSPseudoTimeStepDefault()
417: @*/
418: PetscErrorCode  TSPseudoSetTimeStepIncrement(TS ts,PetscReal inc)
419: {

425:   PetscTryMethod(ts,"TSPseudoSetTimeStepIncrement_C",(TS,PetscReal),(ts,inc));
426:   return(0);
427: }

429: /*@
430:     TSPseudoSetMaxTimeStep - Sets the maximum time step
431:     when using the TSPseudoTimeStepDefault() routine.

433:    Logically Collective on TS

435:     Input Parameters:
436: +   ts - the timestep context
437: -   maxdt - the maximum time step, use a non-positive value to deactivate

439:     Options Database Key:
440: .    -ts_pseudo_max_dt <increment>

442:     Level: advanced

444: .seealso: TSPseudoSetTimeStep(), TSPseudoTimeStepDefault()
445: @*/
446: PetscErrorCode  TSPseudoSetMaxTimeStep(TS ts,PetscReal maxdt)
447: {

453:   PetscTryMethod(ts,"TSPseudoSetMaxTimeStep_C",(TS,PetscReal),(ts,maxdt));
454:   return(0);
455: }

457: /*@
458:     TSPseudoIncrementDtFromInitialDt - Indicates that a new timestep
459:     is computed via the formula
460: $         dt = initial_dt*initial_fnorm/current_fnorm
461:       rather than the default update,
462: $         dt = current_dt*previous_fnorm/current_fnorm.

464:    Logically Collective on TS

466:     Input Parameter:
467: .   ts - the timestep context

469:     Options Database Key:
470: .    -ts_pseudo_increment_dt_from_initial_dt

472:     Level: advanced

474: .seealso: TSPseudoSetTimeStep(), TSPseudoTimeStepDefault()
475: @*/
476: PetscErrorCode  TSPseudoIncrementDtFromInitialDt(TS ts)
477: {

482:   PetscTryMethod(ts,"TSPseudoIncrementDtFromInitialDt_C",(TS),(ts));
483:   return(0);
484: }


487: /*@C
488:    TSPseudoSetTimeStep - Sets the user-defined routine to be
489:    called at each pseudo-timestep to update the timestep.

491:    Logically Collective on TS

493:    Input Parameters:
494: +  ts - timestep context
495: .  dt - function to compute timestep
496: -  ctx - [optional] user-defined context for private data
497:          required by the function (may be NULL)

499:    Level: intermediate

501:    Calling sequence of func:
502: $  func (TS ts,PetscReal *newdt,void *ctx);

504: +  newdt - the newly computed timestep
505: -  ctx - [optional] timestep context

507:    Notes:
508:    The routine set here will be called by TSPseudoComputeTimeStep()
509:    during the timestepping process.
510:    If not set then TSPseudoTimeStepDefault() is automatically used

512: .seealso: TSPseudoTimeStepDefault(), TSPseudoComputeTimeStep()
513: @*/
514: PetscErrorCode  TSPseudoSetTimeStep(TS ts,PetscErrorCode (*dt)(TS,PetscReal*,void*),void *ctx)
515: {

520:   PetscTryMethod(ts,"TSPseudoSetTimeStep_C",(TS,PetscErrorCode (*)(TS,PetscReal*,void*),void*),(ts,dt,ctx));
521:   return(0);
522: }

524: /* ----------------------------------------------------------------------------- */

526: typedef PetscErrorCode (*FCN1)(TS,Vec,void*,PetscReal*,PetscBool*);  /* force argument to next function to not be extern C*/
527: static PetscErrorCode  TSPseudoSetVerifyTimeStep_Pseudo(TS ts,FCN1 dt,void *ctx)
528: {
529:   TS_Pseudo *pseudo = (TS_Pseudo*)ts->data;

532:   pseudo->verify    = dt;
533:   pseudo->verifyctx = ctx;
534:   return(0);
535: }

537: static PetscErrorCode  TSPseudoSetTimeStepIncrement_Pseudo(TS ts,PetscReal inc)
538: {
539:   TS_Pseudo *pseudo = (TS_Pseudo*)ts->data;

542:   pseudo->dt_increment = inc;
543:   return(0);
544: }

546: static PetscErrorCode  TSPseudoSetMaxTimeStep_Pseudo(TS ts,PetscReal maxdt)
547: {
548:   TS_Pseudo *pseudo = (TS_Pseudo*)ts->data;

551:   pseudo->dt_max = maxdt;
552:   return(0);
553: }

555: static PetscErrorCode  TSPseudoIncrementDtFromInitialDt_Pseudo(TS ts)
556: {
557:   TS_Pseudo *pseudo = (TS_Pseudo*)ts->data;

560:   pseudo->increment_dt_from_initial_dt = PETSC_TRUE;
561:   return(0);
562: }

564: typedef PetscErrorCode (*FCN2)(TS,PetscReal*,void*); /* force argument to next function to not be extern C*/
565: static PetscErrorCode  TSPseudoSetTimeStep_Pseudo(TS ts,FCN2 dt,void *ctx)
566: {
567:   TS_Pseudo *pseudo = (TS_Pseudo*)ts->data;

570:   pseudo->dt    = dt;
571:   pseudo->dtctx = ctx;
572:   return(0);
573: }

575: /* ----------------------------------------------------------------------------- */
576: /*MC
577:       TSPSEUDO - Solve steady state ODE and DAE problems with pseudo time stepping

579:   This method solves equations of the form

581: $    F(X,Xdot) = 0

583:   for steady state using the iteration

585: $    [G'] S = -F(X,0)
586: $    X += S

588:   where

590: $    G(Y) = F(Y,(Y-X)/dt)

592:   This is linearly-implicit Euler with the residual always evaluated "at steady
593:   state".  See note below.

595:   Options database keys:
596: +  -ts_pseudo_increment <real> - ratio of increase dt
597: .  -ts_pseudo_increment_dt_from_initial_dt <truth> - Increase dt as a ratio from original dt
598: .  -ts_pseudo_fatol <atol> - stop iterating when the function norm is less than atol
599: -  -ts_pseudo_frtol <rtol> - stop iterating when the function norm divided by the initial function norm is less than rtol

601:   Level: beginner

603:   References:
604: +  1. - Todd S. Coffey and C. T. Kelley and David E. Keyes, Pseudotransient Continuation and Differential Algebraic Equations, 2003.
605: -  2. - C. T. Kelley and David E. Keyes, Convergence analysis of Pseudotransient Continuation, 1998.

607:   Notes:
608:   The residual computed by this method includes the transient term (Xdot is computed instead of
609:   always being zero), but since the prediction from the last step is always the solution from the
610:   last step, on the first Newton iteration we have

612: $  Xdot = (Xpredicted - Xold)/dt = (Xold-Xold)/dt = 0

614:   Therefore, the linear system solved by the first Newton iteration is equivalent to the one
615:   described above and in the papers.  If the user chooses to perform multiple Newton iterations, the
616:   algorithm is no longer the one described in the referenced papers.

618: .seealso:  TSCreate(), TS, TSSetType()

620: M*/
621: PETSC_EXTERN PetscErrorCode TSCreate_Pseudo(TS ts)
622: {
623:   TS_Pseudo      *pseudo;
625:   SNES           snes;
626:   SNESType       stype;

629:   ts->ops->reset          = TSReset_Pseudo;
630:   ts->ops->destroy        = TSDestroy_Pseudo;
631:   ts->ops->view           = TSView_Pseudo;
632:   ts->ops->setup          = TSSetUp_Pseudo;
633:   ts->ops->step           = TSStep_Pseudo;
634:   ts->ops->setfromoptions = TSSetFromOptions_Pseudo;
635:   ts->ops->snesfunction   = SNESTSFormFunction_Pseudo;
636:   ts->ops->snesjacobian   = SNESTSFormJacobian_Pseudo;
637:   ts->default_adapt_type  = TSADAPTNONE;
638:   ts->usessnes            = PETSC_TRUE;

640:   TSGetSNES(ts,&snes);
641:   SNESGetType(snes,&stype);
642:   if (!stype) {SNESSetType(snes,SNESKSPONLY);}

644:   PetscNewLog(ts,&pseudo);
645:   ts->data = (void*)pseudo;

647:   pseudo->dt                           = TSPseudoTimeStepDefault;
648:   pseudo->dtctx                        = NULL;
649:   pseudo->dt_increment                 = 1.1;
650:   pseudo->increment_dt_from_initial_dt = PETSC_FALSE;
651:   pseudo->fnorm                        = -1;
652:   pseudo->fnorm_initial                = -1;
653:   pseudo->fnorm_previous               = -1;
654:  #if defined(PETSC_USE_REAL_SINGLE)
655:   pseudo->fatol                        = 1.e-25;
656:   pseudo->frtol                        = 1.e-5;
657: #else
658:   pseudo->fatol                        = 1.e-50;
659:   pseudo->frtol                        = 1.e-12;
660: #endif
661:   PetscObjectComposeFunction((PetscObject)ts,"TSPseudoSetVerifyTimeStep_C",TSPseudoSetVerifyTimeStep_Pseudo);
662:   PetscObjectComposeFunction((PetscObject)ts,"TSPseudoSetTimeStepIncrement_C",TSPseudoSetTimeStepIncrement_Pseudo);
663:   PetscObjectComposeFunction((PetscObject)ts,"TSPseudoSetMaxTimeStep_C",TSPseudoSetMaxTimeStep_Pseudo);
664:   PetscObjectComposeFunction((PetscObject)ts,"TSPseudoIncrementDtFromInitialDt_C",TSPseudoIncrementDtFromInitialDt_Pseudo);
665:   PetscObjectComposeFunction((PetscObject)ts,"TSPseudoSetTimeStep_C",TSPseudoSetTimeStep_Pseudo);
666:   return(0);
667: }

669: /*@C
670:    TSPseudoTimeStepDefault - Default code to compute pseudo-timestepping.
671:    Use with TSPseudoSetTimeStep().

673:    Collective on TS

675:    Input Parameters:
676: +  ts - the timestep context
677: -  dtctx - unused timestep context

679:    Output Parameter:
680: .  newdt - the timestep to use for the next step

682:    Level: advanced

684: .seealso: TSPseudoSetTimeStep(), TSPseudoComputeTimeStep()
685: @*/
686: PetscErrorCode  TSPseudoTimeStepDefault(TS ts,PetscReal *newdt,void *dtctx)
687: {
688:   TS_Pseudo      *pseudo = (TS_Pseudo*)ts->data;
689:   PetscReal      inc = pseudo->dt_increment;

693:   VecZeroEntries(pseudo->xdot);
694:   TSComputeIFunction(ts,ts->ptime,ts->vec_sol,pseudo->xdot,pseudo->func,PETSC_FALSE);
695:   VecNorm(pseudo->func,NORM_2,&pseudo->fnorm);
696:   if (pseudo->fnorm_initial < 0) {
697:     /* first time through so compute initial function norm */
698:     pseudo->fnorm_initial  = pseudo->fnorm;
699:     pseudo->fnorm_previous = pseudo->fnorm;
700:   }
701:   if (pseudo->fnorm == 0.0)                      *newdt = 1.e12*inc*ts->time_step;
702:   else if (pseudo->increment_dt_from_initial_dt) *newdt = inc*pseudo->dt_initial*pseudo->fnorm_initial/pseudo->fnorm;
703:   else                                           *newdt = inc*ts->time_step*pseudo->fnorm_previous/pseudo->fnorm;
704:   if (pseudo->dt_max > 0) *newdt = PetscMin(*newdt,pseudo->dt_max);
705:   pseudo->fnorm_previous = pseudo->fnorm;
706:   return(0);
707: }