Date: 2013-07-02T14:51:59+00:00

Actual source code: petsc-tsimpl.h
petsc-3.4.2 2013-07-02

      2: #ifndef __TSIMPL_H

      5: #include <petscts.h>
      6: #include <petsc-private/petscimpl.h>

      8: /*
      9:     Timesteping context.
     10:       General DAE: F(t,U,U_t) = 0, required Jacobian is G'(U) where G(U) = F(t,U,U0+a*U)
     11:       General ODE: U_t = F(t,U) <-- the right-hand-side function
     12:       Linear  ODE: U_t = A(t) U <-- the right-hand-side matrix
     13:       Linear (no time) ODE: U_t = A U <-- the right-hand-side matrix
     14: */

     16: /*
     17:      Maximum number of monitors you can run with a single TS
     18: */
     19: #define MAXTSMONITORS 5

     21: typedef struct _TSOps *TSOps;

     23: struct _TSOps {
     24:   PetscErrorCode (*snesfunction)(SNES,Vec,Vec,TS);
     25:   PetscErrorCode (*snesjacobian)(SNES,Vec,Mat*,Mat*,MatStructure*,TS);
     26:   PetscErrorCode (*setup)(TS);
     27:   PetscErrorCode (*step)(TS);
     28:   PetscErrorCode (*solve)(TS);
     29:   PetscErrorCode (*interpolate)(TS,PetscReal,Vec);
     30:   PetscErrorCode (*evaluatestep)(TS,PetscInt,Vec,PetscBool*);
     31:   PetscErrorCode (*setfromoptions)(TS);
     32:   PetscErrorCode (*destroy)(TS);
     33:   PetscErrorCode (*view)(TS,PetscViewer);
     34:   PetscErrorCode (*reset)(TS);
     35:   PetscErrorCode (*linearstability)(TS,PetscReal,PetscReal,PetscReal*,PetscReal*);
     36:   PetscErrorCode (*load)(TS,PetscViewer);
     37: };

     39: struct _p_TS {
     40:   PETSCHEADER(struct _TSOps);
     41:   DM            dm;
     42:   TSProblemType problem_type;
     43:   Vec           vec_sol;
     44:   TSAdapt       adapt;

     46:   /* ---------------- User (or PETSc) Provided stuff ---------------------*/
     47:   PetscErrorCode (*monitor[MAXTSMONITORS])(TS,PetscInt,PetscReal,Vec,void*); /* returns control to user after */
     48:   PetscErrorCode (*monitordestroy[MAXTSMONITORS])(void**);
     49:   void *monitorcontext[MAXTSMONITORS];                 /* residual calculation, allows user */
     50:   PetscInt  numbermonitors;                                 /* to, for instance, print residual norm, etc. */

     52:   PetscErrorCode (*prestep)(TS);
     53:   PetscErrorCode (*prestage)(TS,PetscReal);
     54:   PetscErrorCode (*poststep)(TS);

     56:   /* ---------------------- IMEX support ---------------------------------*/
     57:   /* These extra slots are only used when the user provides both Implicit and RHS */
     58:   Mat Arhs;     /* Right hand side matrix */
     59:   Mat Brhs;     /* Right hand side preconditioning matrix */
     60:   Vec Frhs;     /* Right hand side function value */

     62:   /* This is a general caching scheme to avoid recomputing the Jacobian at a place that has been previously been evaluated.
     63:    * The present use case is that TSComputeRHSFunctionLinear() evaluates the Jacobian once and we don't want it to be immeditely re-evaluated.
     64:    */
     65:   struct {
     66:     PetscReal time;             /* The time at which the matrices were last evaluated */
     67:     Vec X;                      /* Solution vector at which the Jacobian was last evaluated */
     68:     PetscInt Xstate;            /* State of the solution vector */
     69:     MatStructure mstructure;    /* The structure returned */
     70:   } rhsjacobian;

     72:   struct {
     73:     PetscReal time;             /* The time at which the matrices were last evaluated */
     74:     Vec X;                      /* Solution vector at which the Jacobian was last evaluated */
     75:     Vec Xdot;                   /* Time derivative of the state vector at which the Jacobian was last evaluated */
     76:     PetscInt Xstate;            /* State of the solution vector */
     77:     PetscInt Xdotstate;         /* State of the solution vector */
     78:     MatStructure mstructure;    /* The structure returned */
     79:     PetscReal shift;            /* The derivative of the lhs wrt to Xdot */
     80:     PetscBool imex;             /* Flag of the method if it was started as an imex method */
     81:   } ijacobian;

     83:   /* ---------------------Nonlinear Iteration------------------------------*/
     84:   SNES  snes;

     86:   /* --- Data that is unique to each particular solver --- */
     87:   PetscInt setupcalled;             /* true if setup has been called */
     88:   void     *data;                   /* implementationspecific data */
     89:   void     *user;                   /* user context */

     91:   /* ------------------  Parameters -------------------------------------- */
     92:   PetscInt  max_steps;              /* max number of steps */
     93:   PetscReal max_time;               /* max time allowed */
     94:   PetscReal time_step;              /* current/completed time increment */
     95:   PetscReal time_step_prev;         /* previous time step  */

     97:   /*
     98:      these are temporary to support increasing the time step if nonlinear solver convergence remains good
     99:      and time_step was previously cut due to failed nonlinear solver
    100:   */
    101:   PetscReal time_step_orig;            /* original time step requested by user */
    102:   PetscInt  time_steps_since_decrease; /* number of timesteps since timestep was decreased due to lack of convergence */
    103:   /* ----------------------------------------------------------------------------------------------------------------*/

    105:   PetscInt  steps;                  /* steps taken so far */
    106:   PetscReal ptime;                  /* time at the start of the current step (stage time is internal if it exists) */
    107:   PetscReal solvetime;              /* time at the conclusion of TSSolve() */
    108:   PetscInt  ksp_its;                /* total number of linear solver iterations */
    109:   PetscInt  snes_its;               /* total number of nonlinear solver iterations */

    111:   PetscInt num_snes_failures;
    112:   PetscInt max_snes_failures;
    113:   TSConvergedReason reason;
    114:   TSEquationType equation_type;
    115:   PetscBool errorifstepfailed;
    116:   TSExactFinalTimeOption  exact_final_time;
    117:   PetscBool retain_stages;
    118:   PetscInt reject,max_reject;

    120:   PetscReal atol,rtol;          /* Relative and absolute tolerance for local truncation error */
    121:   Vec       vatol,vrtol;        /* Relative and absolute tolerance in vector form */
    122:   PetscReal cfltime,cfltime_local;

    124:   /* ------------------- Default work-area management ------------------ */
    125:   PetscInt nwork;
    126:   Vec      *work;
    127: };

    129: struct _TSAdaptOps {
    130:   PetscErrorCode (*choose)(TSAdapt,TS,PetscReal,PetscInt*,PetscReal*,PetscBool*,PetscReal*);
    131:   PetscErrorCode (*checkstage)(TSAdapt,TS,PetscBool*);
    132:   PetscErrorCode (*destroy)(TSAdapt);
    133:   PetscErrorCode (*view)(TSAdapt,PetscViewer);
    134:   PetscErrorCode (*setfromoptions)(TSAdapt);
    135:   PetscErrorCode (*load)(TSAdapt,PetscViewer);
    136: };

    138: struct _p_TSAdapt {
    139:   PETSCHEADER(struct _TSAdaptOps);
    140:   void *data;
    141:   struct {
    142:     PetscInt   n;                /* number of candidate schemes, including the one currently in use */
    143:     PetscBool  inuse_set;        /* the current scheme has been set */
    144:     const char *name[16];        /* name of the scheme */
    145:     PetscInt   order[16];        /* classical order of each scheme */
    146:     PetscInt   stageorder[16];   /* stage order of each scheme */
    147:     PetscReal  ccfl[16];         /* stability limit relative to explicit Euler */
    148:     PetscReal  cost[16];         /* relative measure of the amount of work required for each scheme */
    149:   } candidates;
    150:   PetscReal   dt_min,dt_max;
    151:   PetscReal   scale_solve_failed; /* Scale step by this factor if solver (linear or nonlinear) fails. */
    152:   PetscViewer monitor;
    153: };

    155: typedef struct _p_DMTS *DMTS;
    156: typedef struct _DMTSOps *DMTSOps;
    157: struct _DMTSOps {
    158:   TSRHSFunction rhsfunction;
    159:   TSRHSJacobian rhsjacobian;

    161:   TSIFunction ifunction;
    162:   PetscErrorCode (*ifunctionview)(void*,PetscViewer);
    163:   PetscErrorCode (*ifunctionload)(void**,PetscViewer);

    165:   TSIJacobian ijacobian;
    166:   PetscErrorCode (*ijacobianview)(void*,PetscViewer);
    167:   PetscErrorCode (*ijacobianload)(void**,PetscViewer);

    169:   TSSolutionFunction solution;
    170:   PetscErrorCode (*forcing)(TS,PetscReal,Vec,void*);

    172:   PetscErrorCode (*destroy)(DMTS);
    173:   PetscErrorCode (*duplicate)(DMTS,DMTS);
    174: };

    176: struct _p_DMTS {
    177:   PETSCHEADER(struct _DMTSOps);
    178:   void *rhsfunctionctx;
    179:   void *rhsjacobianctx;

    181:   void *ifunctionctx;
    182:   void *ijacobianctx;

    184:   void *solutionctx;
    185:   void *forcingctx;

    187:   void *data;

    189:   /* This is NOT reference counted. The DM on which this context was first created is cached here to implement one-way
    190:    * copy-on-write. When DMGetDMTSWrite() sees a request using a different DM, it makes a copy. Thus, if a user
    191:    * only interacts directly with one level, e.g., using TSSetIFunction(), then coarse levels of a multilevel item
    192:    * integrator are built, then the user changes the routine with another call to TSSetIFunction(), it automatically
    193:    * propagates to all the levels. If instead, they get out a specific level and set the function on that level,
    194:    * subsequent changes to the original level will no longer propagate to that level.
    195:    */
    196:   DM originaldm;
    197: };

    199: PETSC_EXTERN PetscErrorCode DMGetDMTS(DM,DMTS*);
    200: PETSC_EXTERN PetscErrorCode DMGetDMTSWrite(DM,DMTS*);
    201: PETSC_EXTERN PetscErrorCode DMCopyDMTS(DM,DM);
    202: PETSC_EXTERN PetscErrorCode DMTSView(DMTS,PetscViewer);
    203: PETSC_EXTERN PetscErrorCode DMTSLoad(DMTS,PetscViewer);

    206: PETSC_EXTERN PetscLogEvent TS_Step, TS_PseudoComputeTimeStep, TS_FunctionEval, TS_JacobianEval;

    208: typedef enum {TS_STEP_INCOMPLETE, /* vec_sol, ptime, etc point to beginning of step */
    209:               TS_STEP_PENDING,    /* vec_sol advanced, but step has not been accepted yet */
    210:               TS_STEP_COMPLETE    /* step accepted and ptime, steps, etc have been advanced */
    211: } TSStepStatus;

    213: #endif