1 2 #include <petsc-private/tsimpl.h> /*I "petscts.h" I*/ 3 #include <petscdmshell.h> 4 #include <petscdmda.h> 5 #include <petscviewer.h> 6 #include <petscdraw.h> 7 8 /* Logging support */ 9 PetscClassId TS_CLASSID, DMTS_CLASSID; 10 PetscLogEvent TS_Step, TS_PseudoComputeTimeStep, TS_FunctionEval, TS_JacobianEval; 11 12 const char *const TSExactFinalTimeOptions[] = {"STEPOVER","INTERPOLATE","MATCHSTEP","TSExactFinalTimeOption","TS_EXACTFINALTIME_",0}; 13 14 #undef __FUNCT__ 15 #define __FUNCT__ "TSSetTypeFromOptions" 16 /* 17 TSSetTypeFromOptions - Sets the type of ts from user options. 18 19 Collective on TS 20 21 Input Parameter: 22 . ts - The ts 23 24 Level: intermediate 25 26 .keywords: TS, set, options, database, type 27 .seealso: TSSetFromOptions(), TSSetType() 28 */ 29 static PetscErrorCode TSSetTypeFromOptions(TS ts) 30 { 31 PetscBool opt; 32 const char *defaultType; 33 char typeName[256]; 34 PetscErrorCode ierr; 35 36 PetscFunctionBegin; 37 if (((PetscObject)ts)->type_name) defaultType = ((PetscObject)ts)->type_name; 38 else defaultType = TSEULER; 39 40 if (!TSRegisterAllCalled) {ierr = TSRegisterAll();CHKERRQ(ierr);} 41 ierr = PetscOptionsList("-ts_type", "TS method"," TSSetType", TSList, defaultType, typeName, 256, &opt);CHKERRQ(ierr); 42 if (opt) { 43 ierr = TSSetType(ts, typeName);CHKERRQ(ierr); 44 } else { 45 ierr = TSSetType(ts, defaultType);CHKERRQ(ierr); 46 } 47 PetscFunctionReturn(0); 48 } 49 50 struct _n_TSMonitorDrawCtx { 51 PetscViewer viewer; 52 PetscDrawAxis axis; 53 Vec initialsolution; 54 PetscBool showinitial; 55 PetscInt howoften; /* when > 0 uses step % howoften, when negative only final solution plotted */ 56 PetscBool showtimestepandtime; 57 int color; 58 }; 59 60 #undef __FUNCT__ 61 #define __FUNCT__ "TSSetFromOptions" 62 /*@ 63 TSSetFromOptions - Sets various TS parameters from user options. 64 65 Collective on TS 66 67 Input Parameter: 68 . ts - the TS context obtained from TSCreate() 69 70 Options Database Keys: 71 + -ts_type <type> - TSEULER, TSBEULER, TSSUNDIALS, TSPSEUDO, TSCN, TSRK, TSTHETA, TSGL, TSSSP 72 . -ts_max_steps maxsteps - maximum number of time-steps to take 73 . -ts_final_time time - maximum time to compute to 74 . -ts_dt dt - initial time step 75 . -ts_monitor - print information at each timestep 76 . -ts_monitor_lg_timestep - Monitor timestep size graphically 77 . -ts_monitor_lg_solution - Monitor solution graphically 78 . -ts_monitor_lg_error - Monitor error graphically 79 . -ts_monitor_lg_snes_iterations - Monitor number nonlinear iterations for each timestep graphically 80 . -ts_monitor_lg_ksp_iterations - Monitor number nonlinear iterations for each timestep graphically 81 . -ts_monitor_sp_eig - Monitor eigenvalues of linearized operator graphically 82 . -ts_monitor_draw_solution - Monitor solution graphically 83 . -ts_monitor_draw_solution_phase - Monitor solution graphically with phase diagram 84 . -ts_monitor_draw_error - Monitor error graphically 85 . -ts_monitor_solution_binary <filename> - Save each solution to a binary file 86 - -ts_monitor_solution_vtk <filename.vts> - Save each time step to a binary file, use filename-%%03D.vts 87 88 Developer Note: We should unify all the -ts_monitor options in the way that -xxx_view has been unified 89 90 Level: beginner 91 92 .keywords: TS, timestep, set, options, database 93 94 .seealso: TSGetType() 95 @*/ 96 PetscErrorCode TSSetFromOptions(TS ts) 97 { 98 PetscBool opt,flg; 99 PetscErrorCode ierr; 100 PetscViewer monviewer; 101 char monfilename[PETSC_MAX_PATH_LEN]; 102 SNES snes; 103 TSAdapt adapt; 104 PetscReal time_step; 105 TSExactFinalTimeOption eftopt; 106 char dir[16]; 107 108 PetscFunctionBegin; 109 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 110 ierr = PetscObjectOptionsBegin((PetscObject)ts);CHKERRQ(ierr); 111 /* Handle TS type options */ 112 ierr = TSSetTypeFromOptions(ts);CHKERRQ(ierr); 113 114 /* Handle generic TS options */ 115 ierr = PetscOptionsInt("-ts_max_steps","Maximum number of time steps","TSSetDuration",ts->max_steps,&ts->max_steps,NULL);CHKERRQ(ierr); 116 ierr = PetscOptionsReal("-ts_final_time","Time to run to","TSSetDuration",ts->max_time,&ts->max_time,NULL);CHKERRQ(ierr); 117 ierr = PetscOptionsReal("-ts_init_time","Initial time","TSSetTime",ts->ptime,&ts->ptime,NULL);CHKERRQ(ierr); 118 ierr = PetscOptionsReal("-ts_dt","Initial time step","TSSetTimeStep",ts->time_step,&time_step,&flg);CHKERRQ(ierr); 119 if (flg) { 120 ierr = TSSetTimeStep(ts,time_step);CHKERRQ(ierr); 121 } 122 ierr = PetscOptionsEnum("-ts_exact_final_time","Option for handling of final time step","TSSetExactFinalTime",TSExactFinalTimeOptions,(PetscEnum)ts->exact_final_time,(PetscEnum*)&eftopt,&flg);CHKERRQ(ierr); 123 if (flg) {ierr = TSSetExactFinalTime(ts,eftopt);CHKERRQ(ierr);} 124 ierr = PetscOptionsInt("-ts_max_snes_failures","Maximum number of nonlinear solve failures","TSSetMaxSNESFailures",ts->max_snes_failures,&ts->max_snes_failures,NULL);CHKERRQ(ierr); 125 ierr = PetscOptionsInt("-ts_max_reject","Maximum number of step rejections before step fails","TSSetMaxStepRejections",ts->max_reject,&ts->max_reject,NULL);CHKERRQ(ierr); 126 ierr = PetscOptionsBool("-ts_error_if_step_fails","Error if no step succeeds","TSSetErrorIfStepFails",ts->errorifstepfailed,&ts->errorifstepfailed,NULL);CHKERRQ(ierr); 127 ierr = PetscOptionsReal("-ts_rtol","Relative tolerance for local truncation error","TSSetTolerances",ts->rtol,&ts->rtol,NULL);CHKERRQ(ierr); 128 ierr = PetscOptionsReal("-ts_atol","Absolute tolerance for local truncation error","TSSetTolerances",ts->atol,&ts->atol,NULL);CHKERRQ(ierr); 129 130 /* Monitor options */ 131 ierr = PetscOptionsString("-ts_monitor","Monitor timestep size","TSMonitorDefault","stdout",monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr); 132 if (flg) { 133 ierr = PetscViewerASCIIOpen(PetscObjectComm((PetscObject)ts),monfilename,&monviewer);CHKERRQ(ierr); 134 ierr = TSMonitorSet(ts,TSMonitorDefault,monviewer,(PetscErrorCode (*)(void**))PetscViewerDestroy);CHKERRQ(ierr); 135 } 136 ierr = PetscOptionsString("-ts_monitor_python","Use Python function","TSMonitorSet",0,monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr); 137 if (flg) {ierr = PetscPythonMonitorSet((PetscObject)ts,monfilename);CHKERRQ(ierr);} 138 139 ierr = PetscOptionsName("-ts_monitor_lg_timestep","Monitor timestep size graphically","TSMonitorLGTimeStep",&opt);CHKERRQ(ierr); 140 if (opt) { 141 TSMonitorLGCtx ctx; 142 PetscInt howoften = 1; 143 144 ierr = PetscOptionsInt("-ts_monitor_lg_timestep","Monitor timestep size graphically","TSMonitorLGTimeStep",howoften,&howoften,NULL);CHKERRQ(ierr); 145 ierr = TSMonitorLGCtxCreate(PetscObjectComm((PetscObject)ts),0,0,PETSC_DECIDE,PETSC_DECIDE,300,300,howoften,&ctx);CHKERRQ(ierr); 146 ierr = TSMonitorSet(ts,TSMonitorLGTimeStep,ctx,(PetscErrorCode (*)(void**))TSMonitorLGCtxDestroy);CHKERRQ(ierr); 147 } 148 ierr = PetscOptionsName("-ts_monitor_lg_solution","Monitor solution graphically","TSMonitorLGSolution",&opt);CHKERRQ(ierr); 149 if (opt) { 150 TSMonitorLGCtx ctx; 151 PetscInt howoften = 1; 152 153 ierr = PetscOptionsInt("-ts_monitor_lg_solution","Monitor solution graphically","TSMonitorLGSolution",howoften,&howoften,NULL);CHKERRQ(ierr); 154 ierr = TSMonitorLGCtxCreate(PETSC_COMM_SELF,0,0,PETSC_DECIDE,PETSC_DECIDE,600,400,howoften,&ctx);CHKERRQ(ierr); 155 ierr = TSMonitorSet(ts,TSMonitorLGSolution,ctx,(PetscErrorCode (*)(void**))TSMonitorLGCtxDestroy);CHKERRQ(ierr); 156 } 157 ierr = PetscOptionsName("-ts_monitor_lg_error","Monitor error graphically","TSMonitorLGError",&opt);CHKERRQ(ierr); 158 if (opt) { 159 TSMonitorLGCtx ctx; 160 PetscInt howoften = 1; 161 162 ierr = PetscOptionsInt("-ts_monitor_lg_error","Monitor error graphically","TSMonitorLGError",howoften,&howoften,NULL);CHKERRQ(ierr); 163 ierr = TSMonitorLGCtxCreate(PETSC_COMM_SELF,0,0,PETSC_DECIDE,PETSC_DECIDE,600,400,howoften,&ctx);CHKERRQ(ierr); 164 ierr = TSMonitorSet(ts,TSMonitorLGError,ctx,(PetscErrorCode (*)(void**))TSMonitorLGCtxDestroy);CHKERRQ(ierr); 165 } 166 ierr = PetscOptionsName("-ts_monitor_lg_snes_iterations","Monitor number nonlinear iterations for each timestep graphically","TSMonitorLGSNESIterations",&opt);CHKERRQ(ierr); 167 if (opt) { 168 TSMonitorLGCtx ctx; 169 PetscInt howoften = 1; 170 171 ierr = PetscOptionsInt("-ts_monitor_lg_snes_iterations","Monitor number nonlinear iterations for each timestep graphically","TSMonitorLGSNESIterations",howoften,&howoften,NULL);CHKERRQ(ierr); 172 ierr = TSMonitorLGCtxCreate(PETSC_COMM_SELF,0,0,PETSC_DECIDE,PETSC_DECIDE,300,300,howoften,&ctx);CHKERRQ(ierr); 173 ierr = TSMonitorSet(ts,TSMonitorLGSNESIterations,ctx,(PetscErrorCode (*)(void**))TSMonitorLGCtxDestroy);CHKERRQ(ierr); 174 } 175 ierr = PetscOptionsName("-ts_monitor_lg_ksp_iterations","Monitor number nonlinear iterations for each timestep graphically","TSMonitorLGKSPIterations",&opt);CHKERRQ(ierr); 176 if (opt) { 177 TSMonitorLGCtx ctx; 178 PetscInt howoften = 1; 179 180 ierr = PetscOptionsInt("-ts_monitor_lg_ksp_iterations","Monitor number nonlinear iterations for each timestep graphically","TSMonitorLGKSPIterations",howoften,&howoften,NULL);CHKERRQ(ierr); 181 ierr = TSMonitorLGCtxCreate(PETSC_COMM_SELF,0,0,PETSC_DECIDE,PETSC_DECIDE,300,300,howoften,&ctx);CHKERRQ(ierr); 182 ierr = TSMonitorSet(ts,TSMonitorLGKSPIterations,ctx,(PetscErrorCode (*)(void**))TSMonitorLGCtxDestroy);CHKERRQ(ierr); 183 } 184 ierr = PetscOptionsName("-ts_monitor_sp_eig","Monitor eigenvalues of linearized operator graphically","TSMonitorSPEig",&opt);CHKERRQ(ierr); 185 if (opt) { 186 TSMonitorSPEigCtx ctx; 187 PetscInt howoften = 1; 188 189 ierr = PetscOptionsInt("-ts_monitor_sp_eig","Monitor eigenvalues of linearized operator graphically","TSMonitorSPEig",howoften,&howoften,NULL);CHKERRQ(ierr); 190 ierr = TSMonitorSPEigCtxCreate(PETSC_COMM_SELF,0,0,PETSC_DECIDE,PETSC_DECIDE,600,400,howoften,&ctx);CHKERRQ(ierr); 191 ierr = TSMonitorSet(ts,TSMonitorSPEig,ctx,(PetscErrorCode (*)(void**))TSMonitorSPEigCtxDestroy);CHKERRQ(ierr); 192 } 193 opt = PETSC_FALSE; 194 ierr = PetscOptionsName("-ts_monitor_draw_solution","Monitor solution graphically","TSMonitorDrawSolution",&opt);CHKERRQ(ierr); 195 if (opt) { 196 TSMonitorDrawCtx ctx; 197 PetscInt howoften = 1; 198 199 ierr = PetscOptionsInt("-ts_monitor_draw_solution","Monitor solution graphically","TSMonitorDrawSolution",howoften,&howoften,NULL);CHKERRQ(ierr); 200 ierr = TSMonitorDrawCtxCreate(PetscObjectComm((PetscObject)ts),0,0,PETSC_DECIDE,PETSC_DECIDE,600,400,howoften,&ctx);CHKERRQ(ierr); 201 ierr = TSMonitorSet(ts,TSMonitorDrawSolution,ctx,(PetscErrorCode (*)(void**))TSMonitorDrawCtxDestroy);CHKERRQ(ierr); 202 } 203 opt = PETSC_FALSE; 204 ierr = PetscOptionsName("-ts_monitor_draw_solution_phase","Monitor solution graphically","TSMonitorDrawSolutionPhase",&opt);CHKERRQ(ierr); 205 if (opt) { 206 TSMonitorDrawCtx ctx; 207 PetscReal bounds[4]; 208 PetscInt n = 4; 209 PetscDraw draw; 210 211 ierr = PetscOptionsRealArray("-ts_monitor_draw_solution_phase","Monitor solution graphically","TSMonitorDrawSolutionPhase",bounds,&n,NULL);CHKERRQ(ierr); 212 if (n != 4) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_WRONG,"Must provide bounding box of phase field"); 213 ierr = TSMonitorDrawCtxCreate(PetscObjectComm((PetscObject)ts),0,0,PETSC_DECIDE,PETSC_DECIDE,600,400,1,&ctx);CHKERRQ(ierr); 214 ierr = PetscViewerDrawGetDraw(ctx->viewer,0,&draw);CHKERRQ(ierr); 215 ierr = PetscDrawClear(draw);CHKERRQ(ierr); 216 ierr = PetscDrawAxisCreate(draw,&ctx->axis);CHKERRQ(ierr); 217 ierr = PetscDrawAxisSetLimits(ctx->axis,bounds[0],bounds[2],bounds[1],bounds[3]);CHKERRQ(ierr); 218 ierr = PetscDrawAxisSetLabels(ctx->axis,"Phase Diagram","Variable 1","Variable 2");CHKERRQ(ierr); 219 ierr = PetscDrawAxisDraw(ctx->axis);CHKERRQ(ierr); 220 /* ierr = PetscDrawSetCoordinates(draw,bounds[0],bounds[1],bounds[2],bounds[3]);CHKERRQ(ierr); */ 221 ierr = TSMonitorSet(ts,TSMonitorDrawSolutionPhase,ctx,(PetscErrorCode (*)(void**))TSMonitorDrawCtxDestroy);CHKERRQ(ierr); 222 } 223 opt = PETSC_FALSE; 224 ierr = PetscOptionsName("-ts_monitor_draw_error","Monitor error graphically","TSMonitorDrawError",&opt);CHKERRQ(ierr); 225 if (opt) { 226 TSMonitorDrawCtx ctx; 227 PetscInt howoften = 1; 228 229 ierr = PetscOptionsInt("-ts_monitor_draw_error","Monitor error graphically","TSMonitorDrawError",howoften,&howoften,NULL);CHKERRQ(ierr); 230 ierr = TSMonitorDrawCtxCreate(PetscObjectComm((PetscObject)ts),0,0,PETSC_DECIDE,PETSC_DECIDE,600,400,howoften,&ctx);CHKERRQ(ierr); 231 ierr = TSMonitorSet(ts,TSMonitorDrawError,ctx,(PetscErrorCode (*)(void**))TSMonitorDrawCtxDestroy);CHKERRQ(ierr); 232 } 233 opt = PETSC_FALSE; 234 ierr = PetscOptionsString("-ts_monitor_solution_binary","Save each solution to a binary file","TSMonitorSolutionBinary",0,monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr); 235 if (flg) { 236 PetscViewer ctx; 237 if (monfilename[0]) { 238 ierr = PetscViewerBinaryOpen(PetscObjectComm((PetscObject)ts),monfilename,FILE_MODE_WRITE,&ctx);CHKERRQ(ierr); 239 ierr = TSMonitorSet(ts,TSMonitorSolutionBinary,ctx,(PetscErrorCode (*)(void**))PetscViewerDestroy);CHKERRQ(ierr); 240 } else { 241 ctx = PETSC_VIEWER_BINARY_(PetscObjectComm((PetscObject)ts)); 242 ierr = TSMonitorSet(ts,TSMonitorSolutionBinary,ctx,(PetscErrorCode (*)(void**))NULL);CHKERRQ(ierr); 243 } 244 } 245 opt = PETSC_FALSE; 246 ierr = PetscOptionsString("-ts_monitor_solution_vtk","Save each time step to a binary file, use filename-%%03D.vts","TSMonitorSolutionVTK",0,monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr); 247 if (flg) { 248 const char *ptr,*ptr2; 249 char *filetemplate; 250 if (!monfilename[0]) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_USER,"-ts_monitor_solution_vtk requires a file template, e.g. filename-%%03D.vts"); 251 /* Do some cursory validation of the input. */ 252 ierr = PetscStrstr(monfilename,"%",(char**)&ptr);CHKERRQ(ierr); 253 if (!ptr) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_USER,"-ts_monitor_solution_vtk requires a file template, e.g. filename-%%03D.vts"); 254 for (ptr++; ptr && *ptr; ptr++) { 255 ierr = PetscStrchr("DdiouxX",*ptr,(char**)&ptr2);CHKERRQ(ierr); 256 if (!ptr2 && (*ptr < '0' || '9' < *ptr)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_USER,"Invalid file template argument to -ts_monitor_solution_vtk, should look like filename-%%03D.vts"); 257 if (ptr2) break; 258 } 259 ierr = PetscStrallocpy(monfilename,&filetemplate);CHKERRQ(ierr); 260 ierr = TSMonitorSet(ts,TSMonitorSolutionVTK,filetemplate,(PetscErrorCode (*)(void**))TSMonitorSolutionVTKDestroy);CHKERRQ(ierr); 261 } 262 263 ierr = PetscOptionsString("-ts_monitor_dmda_ray","Display a ray of the solution","None","y=0",dir,16,&flg);CHKERRQ(ierr); 264 if (flg) { 265 TSMonitorDMDARayCtx *rayctx; 266 int ray = 0; 267 DMDADirection ddir; 268 DM da; 269 PetscMPIInt rank; 270 271 if (dir[1] != '=') SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_WRONG,"Unknown ray %s",dir); 272 if (dir[0] == 'x') ddir = DMDA_X; 273 else if (dir[0] == 'y') ddir = DMDA_Y; 274 else SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_WRONG,"Unknown ray %s",dir); 275 sscanf(dir+2,"%d",&ray); 276 277 ierr = PetscInfo2(((PetscObject)ts),"Displaying DMDA ray %c = %D\n",dir[0],ray);CHKERRQ(ierr); 278 ierr = PetscNew(TSMonitorDMDARayCtx,&rayctx);CHKERRQ(ierr); 279 ierr = TSGetDM(ts,&da);CHKERRQ(ierr); 280 ierr = DMDAGetRay(da,ddir,ray,&rayctx->ray,&rayctx->scatter);CHKERRQ(ierr); 281 ierr = MPI_Comm_rank(PetscObjectComm((PetscObject)ts),&rank);CHKERRQ(ierr); 282 if (!rank) { 283 ierr = PetscViewerDrawOpen(PETSC_COMM_SELF,0,0,0,0,600,300,&rayctx->viewer);CHKERRQ(ierr); 284 } 285 ierr = TSMonitorSet(ts,TSMonitorDMDARay,rayctx,TSMonitorDMDARayDestroy);CHKERRQ(ierr); 286 } 287 288 ierr = TSGetAdapt(ts,&adapt);CHKERRQ(ierr); 289 ierr = TSAdaptSetFromOptions(adapt);CHKERRQ(ierr); 290 291 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 292 if (ts->problem_type == TS_LINEAR) {ierr = SNESSetType(snes,SNESKSPONLY);CHKERRQ(ierr);} 293 294 /* Handle specific TS options */ 295 if (ts->ops->setfromoptions) { 296 ierr = (*ts->ops->setfromoptions)(ts);CHKERRQ(ierr); 297 } 298 299 /* process any options handlers added with PetscObjectAddOptionsHandler() */ 300 ierr = PetscObjectProcessOptionsHandlers((PetscObject)ts);CHKERRQ(ierr); 301 ierr = PetscOptionsEnd();CHKERRQ(ierr); 302 PetscFunctionReturn(0); 303 } 304 305 #undef __FUNCT__ 306 #undef __FUNCT__ 307 #define __FUNCT__ "TSComputeRHSJacobian" 308 /*@ 309 TSComputeRHSJacobian - Computes the Jacobian matrix that has been 310 set with TSSetRHSJacobian(). 311 312 Collective on TS and Vec 313 314 Input Parameters: 315 + ts - the TS context 316 . t - current timestep 317 - U - input vector 318 319 Output Parameters: 320 + A - Jacobian matrix 321 . B - optional preconditioning matrix 322 - flag - flag indicating matrix structure 323 324 Notes: 325 Most users should not need to explicitly call this routine, as it 326 is used internally within the nonlinear solvers. 327 328 See KSPSetOperators() for important information about setting the 329 flag parameter. 330 331 Level: developer 332 333 .keywords: SNES, compute, Jacobian, matrix 334 335 .seealso: TSSetRHSJacobian(), KSPSetOperators() 336 @*/ 337 PetscErrorCode TSComputeRHSJacobian(TS ts,PetscReal t,Vec U,Mat *A,Mat *B,MatStructure *flg) 338 { 339 PetscErrorCode ierr; 340 PetscInt Ustate; 341 DM dm; 342 DMTS tsdm; 343 TSRHSJacobian rhsjacobianfunc; 344 void *ctx; 345 TSIJacobian ijacobianfunc; 346 347 PetscFunctionBegin; 348 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 349 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 350 PetscCheckSameComm(ts,1,U,3); 351 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 352 ierr = DMGetDMTS(dm,&tsdm);CHKERRQ(ierr); 353 ierr = DMTSGetRHSJacobian(dm,&rhsjacobianfunc,&ctx);CHKERRQ(ierr); 354 ierr = DMTSGetIJacobian(dm,&ijacobianfunc,NULL);CHKERRQ(ierr); 355 ierr = PetscObjectStateQuery((PetscObject)U,&Ustate);CHKERRQ(ierr); 356 if (ts->rhsjacobian.time == t && (ts->problem_type == TS_LINEAR || (ts->rhsjacobian.X == U && ts->rhsjacobian.Xstate == Ustate))) { 357 *flg = ts->rhsjacobian.mstructure; 358 PetscFunctionReturn(0); 359 } 360 361 if (!rhsjacobianfunc && !ijacobianfunc) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_USER,"Must call TSSetRHSJacobian() and / or TSSetIJacobian()"); 362 363 if (ts->rhsjacobian.reuse) { 364 ierr = MatShift(*A,-ts->rhsjacobian.shift);CHKERRQ(ierr); 365 ierr = MatScale(*A,1./ts->rhsjacobian.scale);CHKERRQ(ierr); 366 if (*A != *B) { 367 ierr = MatShift(*B,-ts->rhsjacobian.shift);CHKERRQ(ierr); 368 ierr = MatScale(*B,1./ts->rhsjacobian.scale);CHKERRQ(ierr); 369 } 370 ts->rhsjacobian.shift = 0; 371 ts->rhsjacobian.scale = 1.; 372 } 373 374 if (rhsjacobianfunc) { 375 ierr = PetscLogEventBegin(TS_JacobianEval,ts,U,*A,*B);CHKERRQ(ierr); 376 *flg = DIFFERENT_NONZERO_PATTERN; 377 PetscStackPush("TS user Jacobian function"); 378 ierr = (*rhsjacobianfunc)(ts,t,U,A,B,flg,ctx);CHKERRQ(ierr); 379 PetscStackPop; 380 ierr = PetscLogEventEnd(TS_JacobianEval,ts,U,*A,*B);CHKERRQ(ierr); 381 /* make sure user returned a correct Jacobian and preconditioner */ 382 PetscValidHeaderSpecific(*A,MAT_CLASSID,4); 383 PetscValidHeaderSpecific(*B,MAT_CLASSID,5); 384 } else { 385 ierr = MatZeroEntries(*A);CHKERRQ(ierr); 386 if (*A != *B) {ierr = MatZeroEntries(*B);CHKERRQ(ierr);} 387 *flg = SAME_NONZERO_PATTERN; 388 } 389 ts->rhsjacobian.time = t; 390 ts->rhsjacobian.X = U; 391 ierr = PetscObjectStateQuery((PetscObject)U,&ts->rhsjacobian.Xstate);CHKERRQ(ierr); 392 ts->rhsjacobian.mstructure = *flg; 393 PetscFunctionReturn(0); 394 } 395 396 #undef __FUNCT__ 397 #define __FUNCT__ "TSComputeRHSFunction" 398 /*@ 399 TSComputeRHSFunction - Evaluates the right-hand-side function. 400 401 Collective on TS and Vec 402 403 Input Parameters: 404 + ts - the TS context 405 . t - current time 406 - U - state vector 407 408 Output Parameter: 409 . y - right hand side 410 411 Note: 412 Most users should not need to explicitly call this routine, as it 413 is used internally within the nonlinear solvers. 414 415 Level: developer 416 417 .keywords: TS, compute 418 419 .seealso: TSSetRHSFunction(), TSComputeIFunction() 420 @*/ 421 PetscErrorCode TSComputeRHSFunction(TS ts,PetscReal t,Vec U,Vec y) 422 { 423 PetscErrorCode ierr; 424 TSRHSFunction rhsfunction; 425 TSIFunction ifunction; 426 void *ctx; 427 DM dm; 428 429 PetscFunctionBegin; 430 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 431 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 432 PetscValidHeaderSpecific(y,VEC_CLASSID,4); 433 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 434 ierr = DMTSGetRHSFunction(dm,&rhsfunction,&ctx);CHKERRQ(ierr); 435 ierr = DMTSGetIFunction(dm,&ifunction,NULL);CHKERRQ(ierr); 436 437 if (!rhsfunction && !ifunction) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_USER,"Must call TSSetRHSFunction() and / or TSSetIFunction()"); 438 439 ierr = PetscLogEventBegin(TS_FunctionEval,ts,U,y,0);CHKERRQ(ierr); 440 if (rhsfunction) { 441 PetscStackPush("TS user right-hand-side function"); 442 ierr = (*rhsfunction)(ts,t,U,y,ctx);CHKERRQ(ierr); 443 PetscStackPop; 444 } else { 445 ierr = VecZeroEntries(y);CHKERRQ(ierr); 446 } 447 448 ierr = PetscLogEventEnd(TS_FunctionEval,ts,U,y,0);CHKERRQ(ierr); 449 PetscFunctionReturn(0); 450 } 451 452 #undef __FUNCT__ 453 #define __FUNCT__ "TSComputeSolutionFunction" 454 /*@ 455 TSComputeSolutionFunction - Evaluates the solution function. 456 457 Collective on TS and Vec 458 459 Input Parameters: 460 + ts - the TS context 461 - t - current time 462 463 Output Parameter: 464 . U - the solution 465 466 Note: 467 Most users should not need to explicitly call this routine, as it 468 is used internally within the nonlinear solvers. 469 470 Level: developer 471 472 .keywords: TS, compute 473 474 .seealso: TSSetSolutionFunction(), TSSetRHSFunction(), TSComputeIFunction() 475 @*/ 476 PetscErrorCode TSComputeSolutionFunction(TS ts,PetscReal t,Vec U) 477 { 478 PetscErrorCode ierr; 479 TSSolutionFunction solutionfunction; 480 void *ctx; 481 DM dm; 482 483 PetscFunctionBegin; 484 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 485 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 486 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 487 ierr = DMTSGetSolutionFunction(dm,&solutionfunction,&ctx);CHKERRQ(ierr); 488 489 if (solutionfunction) { 490 PetscStackPush("TS user solution function"); 491 ierr = (*solutionfunction)(ts,t,U,ctx);CHKERRQ(ierr); 492 PetscStackPop; 493 } 494 PetscFunctionReturn(0); 495 } 496 #undef __FUNCT__ 497 #define __FUNCT__ "TSComputeForcingFunction" 498 /*@ 499 TSComputeForcingFunction - Evaluates the forcing function. 500 501 Collective on TS and Vec 502 503 Input Parameters: 504 + ts - the TS context 505 - t - current time 506 507 Output Parameter: 508 . U - the function value 509 510 Note: 511 Most users should not need to explicitly call this routine, as it 512 is used internally within the nonlinear solvers. 513 514 Level: developer 515 516 .keywords: TS, compute 517 518 .seealso: TSSetSolutionFunction(), TSSetRHSFunction(), TSComputeIFunction() 519 @*/ 520 PetscErrorCode TSComputeForcingFunction(TS ts,PetscReal t,Vec U) 521 { 522 PetscErrorCode ierr, (*forcing)(TS,PetscReal,Vec,void*); 523 void *ctx; 524 DM dm; 525 526 PetscFunctionBegin; 527 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 528 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 529 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 530 ierr = DMTSGetForcingFunction(dm,&forcing,&ctx);CHKERRQ(ierr); 531 532 if (forcing) { 533 PetscStackPush("TS user forcing function"); 534 ierr = (*forcing)(ts,t,U,ctx);CHKERRQ(ierr); 535 PetscStackPop; 536 } 537 PetscFunctionReturn(0); 538 } 539 540 #undef __FUNCT__ 541 #define __FUNCT__ "TSGetRHSVec_Private" 542 static PetscErrorCode TSGetRHSVec_Private(TS ts,Vec *Frhs) 543 { 544 Vec F; 545 PetscErrorCode ierr; 546 547 PetscFunctionBegin; 548 *Frhs = NULL; 549 ierr = TSGetIFunction(ts,&F,NULL,NULL);CHKERRQ(ierr); 550 if (!ts->Frhs) { 551 ierr = VecDuplicate(F,&ts->Frhs);CHKERRQ(ierr); 552 } 553 *Frhs = ts->Frhs; 554 PetscFunctionReturn(0); 555 } 556 557 #undef __FUNCT__ 558 #define __FUNCT__ "TSGetRHSMats_Private" 559 static PetscErrorCode TSGetRHSMats_Private(TS ts,Mat *Arhs,Mat *Brhs) 560 { 561 Mat A,B; 562 PetscErrorCode ierr; 563 564 PetscFunctionBegin; 565 ierr = TSGetIJacobian(ts,&A,&B,NULL,NULL);CHKERRQ(ierr); 566 if (Arhs) { 567 if (!ts->Arhs) { 568 ierr = MatDuplicate(A,MAT_DO_NOT_COPY_VALUES,&ts->Arhs);CHKERRQ(ierr); 569 } 570 *Arhs = ts->Arhs; 571 } 572 if (Brhs) { 573 if (!ts->Brhs) { 574 ierr = MatDuplicate(B,MAT_DO_NOT_COPY_VALUES,&ts->Brhs);CHKERRQ(ierr); 575 } 576 *Brhs = ts->Brhs; 577 } 578 PetscFunctionReturn(0); 579 } 580 581 #undef __FUNCT__ 582 #define __FUNCT__ "TSComputeIFunction" 583 /*@ 584 TSComputeIFunction - Evaluates the DAE residual written in implicit form F(t,U,Udot)=0 585 586 Collective on TS and Vec 587 588 Input Parameters: 589 + ts - the TS context 590 . t - current time 591 . U - state vector 592 . Udot - time derivative of state vector 593 - imex - flag indicates if the method is IMEX so that the RHSFunction should be kept separate 594 595 Output Parameter: 596 . Y - right hand side 597 598 Note: 599 Most users should not need to explicitly call this routine, as it 600 is used internally within the nonlinear solvers. 601 602 If the user did did not write their equations in implicit form, this 603 function recasts them in implicit form. 604 605 Level: developer 606 607 .keywords: TS, compute 608 609 .seealso: TSSetIFunction(), TSComputeRHSFunction() 610 @*/ 611 PetscErrorCode TSComputeIFunction(TS ts,PetscReal t,Vec U,Vec Udot,Vec Y,PetscBool imex) 612 { 613 PetscErrorCode ierr; 614 TSIFunction ifunction; 615 TSRHSFunction rhsfunction; 616 void *ctx; 617 DM dm; 618 619 PetscFunctionBegin; 620 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 621 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 622 PetscValidHeaderSpecific(Udot,VEC_CLASSID,4); 623 PetscValidHeaderSpecific(Y,VEC_CLASSID,5); 624 625 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 626 ierr = DMTSGetIFunction(dm,&ifunction,&ctx);CHKERRQ(ierr); 627 ierr = DMTSGetRHSFunction(dm,&rhsfunction,NULL);CHKERRQ(ierr); 628 629 if (!rhsfunction && !ifunction) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_USER,"Must call TSSetRHSFunction() and / or TSSetIFunction()"); 630 631 ierr = PetscLogEventBegin(TS_FunctionEval,ts,U,Udot,Y);CHKERRQ(ierr); 632 if (ifunction) { 633 PetscStackPush("TS user implicit function"); 634 ierr = (*ifunction)(ts,t,U,Udot,Y,ctx);CHKERRQ(ierr); 635 PetscStackPop; 636 } 637 if (imex) { 638 if (!ifunction) { 639 ierr = VecCopy(Udot,Y);CHKERRQ(ierr); 640 } 641 } else if (rhsfunction) { 642 if (ifunction) { 643 Vec Frhs; 644 ierr = TSGetRHSVec_Private(ts,&Frhs);CHKERRQ(ierr); 645 ierr = TSComputeRHSFunction(ts,t,U,Frhs);CHKERRQ(ierr); 646 ierr = VecAXPY(Y,-1,Frhs);CHKERRQ(ierr); 647 } else { 648 ierr = TSComputeRHSFunction(ts,t,U,Y);CHKERRQ(ierr); 649 ierr = VecAYPX(Y,-1,Udot);CHKERRQ(ierr); 650 } 651 } 652 ierr = PetscLogEventEnd(TS_FunctionEval,ts,U,Udot,Y);CHKERRQ(ierr); 653 PetscFunctionReturn(0); 654 } 655 656 #undef __FUNCT__ 657 #define __FUNCT__ "TSComputeIJacobian" 658 /*@ 659 TSComputeIJacobian - Evaluates the Jacobian of the DAE 660 661 Collective on TS and Vec 662 663 Input 664 Input Parameters: 665 + ts - the TS context 666 . t - current timestep 667 . U - state vector 668 . Udot - time derivative of state vector 669 . shift - shift to apply, see note below 670 - imex - flag indicates if the method is IMEX so that the RHSJacobian should be kept separate 671 672 Output Parameters: 673 + A - Jacobian matrix 674 . B - optional preconditioning matrix 675 - flag - flag indicating matrix structure 676 677 Notes: 678 If F(t,U,Udot)=0 is the DAE, the required Jacobian is 679 680 dF/dU + shift*dF/dUdot 681 682 Most users should not need to explicitly call this routine, as it 683 is used internally within the nonlinear solvers. 684 685 Level: developer 686 687 .keywords: TS, compute, Jacobian, matrix 688 689 .seealso: TSSetIJacobian() 690 @*/ 691 PetscErrorCode TSComputeIJacobian(TS ts,PetscReal t,Vec U,Vec Udot,PetscReal shift,Mat *A,Mat *B,MatStructure *flg,PetscBool imex) 692 { 693 PetscErrorCode ierr; 694 TSIJacobian ijacobian; 695 TSRHSJacobian rhsjacobian; 696 DM dm; 697 void *ctx; 698 699 PetscFunctionBegin; 700 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 701 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 702 PetscValidHeaderSpecific(Udot,VEC_CLASSID,4); 703 PetscValidPointer(A,6); 704 PetscValidHeaderSpecific(*A,MAT_CLASSID,6); 705 PetscValidPointer(B,7); 706 PetscValidHeaderSpecific(*B,MAT_CLASSID,7); 707 PetscValidPointer(flg,8); 708 709 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 710 ierr = DMTSGetIJacobian(dm,&ijacobian,&ctx);CHKERRQ(ierr); 711 ierr = DMTSGetRHSJacobian(dm,&rhsjacobian,NULL);CHKERRQ(ierr); 712 713 if (!rhsjacobian && !ijacobian) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_USER,"Must call TSSetRHSJacobian() and / or TSSetIJacobian()"); 714 715 *flg = SAME_NONZERO_PATTERN; /* In case we're solving a linear problem in which case it wouldn't get initialized below. */ 716 ierr = PetscLogEventBegin(TS_JacobianEval,ts,U,*A,*B);CHKERRQ(ierr); 717 if (ijacobian) { 718 *flg = DIFFERENT_NONZERO_PATTERN; 719 PetscStackPush("TS user implicit Jacobian"); 720 ierr = (*ijacobian)(ts,t,U,Udot,shift,A,B,flg,ctx);CHKERRQ(ierr); 721 PetscStackPop; 722 /* make sure user returned a correct Jacobian and preconditioner */ 723 PetscValidHeaderSpecific(*A,MAT_CLASSID,4); 724 PetscValidHeaderSpecific(*B,MAT_CLASSID,5); 725 } 726 if (imex) { 727 if (!ijacobian) { /* system was written as Udot = G(t,U) */ 728 ierr = MatZeroEntries(*A);CHKERRQ(ierr); 729 ierr = MatShift(*A,shift);CHKERRQ(ierr); 730 if (*A != *B) { 731 ierr = MatZeroEntries(*B);CHKERRQ(ierr); 732 ierr = MatShift(*B,shift);CHKERRQ(ierr); 733 } 734 *flg = SAME_PRECONDITIONER; 735 } 736 } else { 737 Mat Arhs = NULL,Brhs = NULL; 738 MatStructure flg2; 739 if (rhsjacobian) { 740 ierr = TSGetRHSMats_Private(ts,&Arhs,&Brhs);CHKERRQ(ierr); 741 ierr = TSComputeRHSJacobian(ts,t,U,&Arhs,&Brhs,&flg2);CHKERRQ(ierr); 742 } 743 if (Arhs == *A) { /* No IJacobian, so we only have the RHS matrix */ 744 ts->rhsjacobian.scale = -1; 745 ts->rhsjacobian.shift = shift; 746 ierr = MatScale(*A,-1);CHKERRQ(ierr); 747 ierr = MatShift(*A,shift);CHKERRQ(ierr); 748 if (*A != *B) { 749 ierr = MatScale(*B,-1);CHKERRQ(ierr); 750 ierr = MatShift(*B,shift);CHKERRQ(ierr); 751 } 752 } else if (Arhs) { /* Both IJacobian and RHSJacobian */ 753 MatStructure axpy = DIFFERENT_NONZERO_PATTERN; 754 if (!ijacobian) { /* No IJacobian provided, but we have a separate RHS matrix */ 755 ierr = MatZeroEntries(*A);CHKERRQ(ierr); 756 ierr = MatShift(*A,shift);CHKERRQ(ierr); 757 if (*A != *B) { 758 ierr = MatZeroEntries(*B);CHKERRQ(ierr); 759 ierr = MatShift(*B,shift);CHKERRQ(ierr); 760 } 761 } 762 ierr = MatAXPY(*A,-1,Arhs,axpy);CHKERRQ(ierr); 763 if (*A != *B) { 764 ierr = MatAXPY(*B,-1,Brhs,axpy);CHKERRQ(ierr); 765 } 766 *flg = PetscMin(*flg,flg2); 767 } 768 } 769 770 ierr = PetscLogEventEnd(TS_JacobianEval,ts,U,*A,*B);CHKERRQ(ierr); 771 PetscFunctionReturn(0); 772 } 773 774 #undef __FUNCT__ 775 #define __FUNCT__ "TSSetRHSFunction" 776 /*@C 777 TSSetRHSFunction - Sets the routine for evaluating the function, 778 where U_t = G(t,u). 779 780 Logically Collective on TS 781 782 Input Parameters: 783 + ts - the TS context obtained from TSCreate() 784 . r - vector to put the computed right hand side (or NULL to have it created) 785 . f - routine for evaluating the right-hand-side function 786 - ctx - [optional] user-defined context for private data for the 787 function evaluation routine (may be NULL) 788 789 Calling sequence of func: 790 $ func (TS ts,PetscReal t,Vec u,Vec F,void *ctx); 791 792 + t - current timestep 793 . u - input vector 794 . F - function vector 795 - ctx - [optional] user-defined function context 796 797 Level: beginner 798 799 .keywords: TS, timestep, set, right-hand-side, function 800 801 .seealso: TSSetRHSJacobian(), TSSetIJacobian() 802 @*/ 803 PetscErrorCode TSSetRHSFunction(TS ts,Vec r,PetscErrorCode (*f)(TS,PetscReal,Vec,Vec,void*),void *ctx) 804 { 805 PetscErrorCode ierr; 806 SNES snes; 807 Vec ralloc = NULL; 808 DM dm; 809 810 PetscFunctionBegin; 811 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 812 if (r) PetscValidHeaderSpecific(r,VEC_CLASSID,2); 813 814 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 815 ierr = DMTSSetRHSFunction(dm,f,ctx);CHKERRQ(ierr); 816 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 817 if (!r && !ts->dm && ts->vec_sol) { 818 ierr = VecDuplicate(ts->vec_sol,&ralloc);CHKERRQ(ierr); 819 r = ralloc; 820 } 821 ierr = SNESSetFunction(snes,r,SNESTSFormFunction,ts);CHKERRQ(ierr); 822 ierr = VecDestroy(&ralloc);CHKERRQ(ierr); 823 PetscFunctionReturn(0); 824 } 825 826 #undef __FUNCT__ 827 #define __FUNCT__ "TSSetSolutionFunction" 828 /*@C 829 TSSetSolutionFunction - Provide a function that computes the solution of the ODE or DAE 830 831 Logically Collective on TS 832 833 Input Parameters: 834 + ts - the TS context obtained from TSCreate() 835 . f - routine for evaluating the solution 836 - ctx - [optional] user-defined context for private data for the 837 function evaluation routine (may be NULL) 838 839 Calling sequence of func: 840 $ func (TS ts,PetscReal t,Vec u,void *ctx); 841 842 + t - current timestep 843 . u - output vector 844 - ctx - [optional] user-defined function context 845 846 Notes: 847 This routine is used for testing accuracy of time integration schemes when you already know the solution. 848 If analytic solutions are not known for your system, consider using the Method of Manufactured Solutions to 849 create closed-form solutions with non-physical forcing terms. 850 851 For low-dimensional problems solved in serial, such as small discrete systems, TSMonitorLGError() can be used to monitor the error history. 852 853 Level: beginner 854 855 .keywords: TS, timestep, set, right-hand-side, function 856 857 .seealso: TSSetRHSJacobian(), TSSetIJacobian(), TSComputeSolutionFunction(), TSSetForcingFunction() 858 @*/ 859 PetscErrorCode TSSetSolutionFunction(TS ts,PetscErrorCode (*f)(TS,PetscReal,Vec,void*),void *ctx) 860 { 861 PetscErrorCode ierr; 862 DM dm; 863 864 PetscFunctionBegin; 865 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 866 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 867 ierr = DMTSSetSolutionFunction(dm,f,ctx);CHKERRQ(ierr); 868 PetscFunctionReturn(0); 869 } 870 871 #undef __FUNCT__ 872 #define __FUNCT__ "TSSetForcingFunction" 873 /*@C 874 TSSetForcingFunction - Provide a function that computes a forcing term for a ODE or PDE 875 876 Logically Collective on TS 877 878 Input Parameters: 879 + ts - the TS context obtained from TSCreate() 880 . f - routine for evaluating the forcing function 881 - ctx - [optional] user-defined context for private data for the 882 function evaluation routine (may be NULL) 883 884 Calling sequence of func: 885 $ func (TS ts,PetscReal t,Vec u,void *ctx); 886 887 + t - current timestep 888 . u - output vector 889 - ctx - [optional] user-defined function context 890 891 Notes: 892 This routine is useful for testing accuracy of time integration schemes when using the Method of Manufactured Solutions to 893 create closed-form solutions with a non-physical forcing term. 894 895 For low-dimensional problems solved in serial, such as small discrete systems, TSMonitorLGError() can be used to monitor the error history. 896 897 Level: beginner 898 899 .keywords: TS, timestep, set, right-hand-side, function 900 901 .seealso: TSSetRHSJacobian(), TSSetIJacobian(), TSComputeSolutionFunction(), TSSetSolutionFunction() 902 @*/ 903 PetscErrorCode TSSetForcingFunction(TS ts,PetscErrorCode (*f)(TS,PetscReal,Vec,void*),void *ctx) 904 { 905 PetscErrorCode ierr; 906 DM dm; 907 908 PetscFunctionBegin; 909 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 910 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 911 ierr = DMTSSetForcingFunction(dm,f,ctx);CHKERRQ(ierr); 912 PetscFunctionReturn(0); 913 } 914 915 #undef __FUNCT__ 916 #define __FUNCT__ "TSSetRHSJacobian" 917 /*@C 918 TSSetRHSJacobian - Sets the function to compute the Jacobian of F, 919 where U_t = G(U,t), as well as the location to store the matrix. 920 921 Logically Collective on TS 922 923 Input Parameters: 924 + ts - the TS context obtained from TSCreate() 925 . Amat - (approximate) Jacobian matrix 926 . Pmat - matrix from which preconditioner is to be constructed (usually the same as Amat) 927 . f - the Jacobian evaluation routine 928 - ctx - [optional] user-defined context for private data for the 929 Jacobian evaluation routine (may be NULL) 930 931 Calling sequence of func: 932 $ func (TS ts,PetscReal t,Vec u,Mat *A,Mat *B,MatStructure *flag,void *ctx); 933 934 + t - current timestep 935 . u - input vector 936 . Amat - (approximate) Jacobian matrix 937 . Pmat - matrix from which preconditioner is to be constructed (usually the same as Amat) 938 . flag - flag indicating information about the preconditioner matrix 939 structure (same as flag in KSPSetOperators()) 940 - ctx - [optional] user-defined context for matrix evaluation routine 941 942 Notes: 943 See KSPSetOperators() for important information about setting the flag 944 output parameter in the routine func(). Be sure to read this information! 945 946 The routine func() takes Mat * as the matrix arguments rather than Mat. 947 This allows the matrix evaluation routine to replace A and/or B with a 948 completely new matrix structure (not just different matrix elements) 949 when appropriate, for instance, if the nonzero structure is changing 950 throughout the global iterations. 951 952 Level: beginner 953 954 .keywords: TS, timestep, set, right-hand-side, Jacobian 955 956 .seealso: SNESComputeJacobianDefaultColor(), TSSetRHSFunction(), TSRHSJacobianSetReuse() 957 958 @*/ 959 PetscErrorCode TSSetRHSJacobian(TS ts,Mat Amat,Mat Pmat,TSRHSJacobian f,void *ctx) 960 { 961 PetscErrorCode ierr; 962 SNES snes; 963 DM dm; 964 TSIJacobian ijacobian; 965 966 PetscFunctionBegin; 967 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 968 if (Amat) PetscValidHeaderSpecific(Amat,MAT_CLASSID,2); 969 if (Pmat) PetscValidHeaderSpecific(Pmat,MAT_CLASSID,3); 970 if (Amat) PetscCheckSameComm(ts,1,Amat,2); 971 if (Pmat) PetscCheckSameComm(ts,1,Pmat,3); 972 973 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 974 ierr = DMTSSetRHSJacobian(dm,f,ctx);CHKERRQ(ierr); 975 if (f == TSComputeRHSJacobianConstant) { 976 /* Handle this case automatically for the user; otherwise user should call themselves. */ 977 ierr = TSRHSJacobianSetReuse(ts,PETSC_TRUE);CHKERRQ(ierr); 978 } 979 ierr = DMTSGetIJacobian(dm,&ijacobian,NULL);CHKERRQ(ierr); 980 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 981 if (!ijacobian) { 982 ierr = SNESSetJacobian(snes,Amat,Pmat,SNESTSFormJacobian,ts);CHKERRQ(ierr); 983 } 984 if (Amat) { 985 ierr = PetscObjectReference((PetscObject)Amat);CHKERRQ(ierr); 986 ierr = MatDestroy(&ts->Arhs);CHKERRQ(ierr); 987 988 ts->Arhs = Amat; 989 } 990 if (Pmat) { 991 ierr = PetscObjectReference((PetscObject)Pmat);CHKERRQ(ierr); 992 ierr = MatDestroy(&ts->Brhs);CHKERRQ(ierr); 993 994 ts->Brhs = Pmat; 995 } 996 PetscFunctionReturn(0); 997 } 998 999 1000 #undef __FUNCT__ 1001 #define __FUNCT__ "TSSetIFunction" 1002 /*@C 1003 TSSetIFunction - Set the function to compute F(t,U,U_t) where F() = 0 is the DAE to be solved. 1004 1005 Logically Collective on TS 1006 1007 Input Parameters: 1008 + ts - the TS context obtained from TSCreate() 1009 . r - vector to hold the residual (or NULL to have it created internally) 1010 . f - the function evaluation routine 1011 - ctx - user-defined context for private data for the function evaluation routine (may be NULL) 1012 1013 Calling sequence of f: 1014 $ f(TS ts,PetscReal t,Vec u,Vec u_t,Vec F,ctx); 1015 1016 + t - time at step/stage being solved 1017 . u - state vector 1018 . u_t - time derivative of state vector 1019 . F - function vector 1020 - ctx - [optional] user-defined context for matrix evaluation routine 1021 1022 Important: 1023 The user MUST call either this routine, TSSetRHSFunction(). This routine must be used when not solving an ODE, for example a DAE. 1024 1025 Level: beginner 1026 1027 .keywords: TS, timestep, set, DAE, Jacobian 1028 1029 .seealso: TSSetRHSJacobian(), TSSetRHSFunction(), TSSetIJacobian() 1030 @*/ 1031 PetscErrorCode TSSetIFunction(TS ts,Vec res,TSIFunction f,void *ctx) 1032 { 1033 PetscErrorCode ierr; 1034 SNES snes; 1035 Vec resalloc = NULL; 1036 DM dm; 1037 1038 PetscFunctionBegin; 1039 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1040 if (res) PetscValidHeaderSpecific(res,VEC_CLASSID,2); 1041 1042 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1043 ierr = DMTSSetIFunction(dm,f,ctx);CHKERRQ(ierr); 1044 1045 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 1046 if (!res && !ts->dm && ts->vec_sol) { 1047 ierr = VecDuplicate(ts->vec_sol,&resalloc);CHKERRQ(ierr); 1048 res = resalloc; 1049 } 1050 ierr = SNESSetFunction(snes,res,SNESTSFormFunction,ts);CHKERRQ(ierr); 1051 ierr = VecDestroy(&resalloc);CHKERRQ(ierr); 1052 PetscFunctionReturn(0); 1053 } 1054 1055 #undef __FUNCT__ 1056 #define __FUNCT__ "TSGetIFunction" 1057 /*@C 1058 TSGetIFunction - Returns the vector where the implicit residual is stored and the function/contex to compute it. 1059 1060 Not Collective 1061 1062 Input Parameter: 1063 . ts - the TS context 1064 1065 Output Parameter: 1066 + r - vector to hold residual (or NULL) 1067 . func - the function to compute residual (or NULL) 1068 - ctx - the function context (or NULL) 1069 1070 Level: advanced 1071 1072 .keywords: TS, nonlinear, get, function 1073 1074 .seealso: TSSetIFunction(), SNESGetFunction() 1075 @*/ 1076 PetscErrorCode TSGetIFunction(TS ts,Vec *r,TSIFunction *func,void **ctx) 1077 { 1078 PetscErrorCode ierr; 1079 SNES snes; 1080 DM dm; 1081 1082 PetscFunctionBegin; 1083 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1084 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 1085 ierr = SNESGetFunction(snes,r,NULL,NULL);CHKERRQ(ierr); 1086 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1087 ierr = DMTSGetIFunction(dm,func,ctx);CHKERRQ(ierr); 1088 PetscFunctionReturn(0); 1089 } 1090 1091 #undef __FUNCT__ 1092 #define __FUNCT__ "TSGetRHSFunction" 1093 /*@C 1094 TSGetRHSFunction - Returns the vector where the right hand side is stored and the function/context to compute it. 1095 1096 Not Collective 1097 1098 Input Parameter: 1099 . ts - the TS context 1100 1101 Output Parameter: 1102 + r - vector to hold computed right hand side (or NULL) 1103 . func - the function to compute right hand side (or NULL) 1104 - ctx - the function context (or NULL) 1105 1106 Level: advanced 1107 1108 .keywords: TS, nonlinear, get, function 1109 1110 .seealso: TSSetRhsfunction(), SNESGetFunction() 1111 @*/ 1112 PetscErrorCode TSGetRHSFunction(TS ts,Vec *r,TSRHSFunction *func,void **ctx) 1113 { 1114 PetscErrorCode ierr; 1115 SNES snes; 1116 DM dm; 1117 1118 PetscFunctionBegin; 1119 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1120 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 1121 ierr = SNESGetFunction(snes,r,NULL,NULL);CHKERRQ(ierr); 1122 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1123 ierr = DMTSGetRHSFunction(dm,func,ctx);CHKERRQ(ierr); 1124 PetscFunctionReturn(0); 1125 } 1126 1127 #undef __FUNCT__ 1128 #define __FUNCT__ "TSSetIJacobian" 1129 /*@C 1130 TSSetIJacobian - Set the function to compute the matrix dF/dU + a*dF/dU_t where F(t,U,U_t) is the function 1131 you provided with TSSetIFunction(). 1132 1133 Logically Collective on TS 1134 1135 Input Parameters: 1136 + ts - the TS context obtained from TSCreate() 1137 . Amat - (approximate) Jacobian matrix 1138 . Pmat - matrix used to compute preconditioner (usually the same as Amat) 1139 . f - the Jacobian evaluation routine 1140 - ctx - user-defined context for private data for the Jacobian evaluation routine (may be NULL) 1141 1142 Calling sequence of f: 1143 $ f(TS ts,PetscReal t,Vec U,Vec U_t,PetscReal a,Mat *Amat,Mat *Pmat,MatStructure *flag,void *ctx); 1144 1145 + t - time at step/stage being solved 1146 . U - state vector 1147 . U_t - time derivative of state vector 1148 . a - shift 1149 . Amat - (approximate) Jacobian of F(t,U,W+a*U), equivalent to dF/dU + a*dF/dU_t 1150 . Pmat - matrix used for constructing preconditioner, usually the same as Amat 1151 . flag - flag indicating information about the preconditioner matrix 1152 structure (same as flag in KSPSetOperators()) 1153 - ctx - [optional] user-defined context for matrix evaluation routine 1154 1155 Notes: 1156 The matrices Amat and Pmat are exactly the matrices that are used by SNES for the nonlinear solve. 1157 1158 The matrix dF/dU + a*dF/dU_t you provide turns out to be 1159 the Jacobian of F(t,U,W+a*U) where F(t,U,U_t) = 0 is the DAE to be solved. 1160 The time integrator internally approximates U_t by W+a*U where the positive "shift" 1161 a and vector W depend on the integration method, step size, and past states. For example with 1162 the backward Euler method a = 1/dt and W = -a*U(previous timestep) so 1163 W + a*U = a*(U - U(previous timestep)) = (U - U(previous timestep))/dt 1164 1165 Level: beginner 1166 1167 .keywords: TS, timestep, DAE, Jacobian 1168 1169 .seealso: TSSetIFunction(), TSSetRHSJacobian(), SNESComputeJacobianDefaultColor(), SNESComputeJacobianDefault() 1170 1171 @*/ 1172 PetscErrorCode TSSetIJacobian(TS ts,Mat Amat,Mat Pmat,TSIJacobian f,void *ctx) 1173 { 1174 PetscErrorCode ierr; 1175 SNES snes; 1176 DM dm; 1177 1178 PetscFunctionBegin; 1179 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1180 if (Amat) PetscValidHeaderSpecific(Amat,MAT_CLASSID,2); 1181 if (Pmat) PetscValidHeaderSpecific(Pmat,MAT_CLASSID,3); 1182 if (Amat) PetscCheckSameComm(ts,1,Amat,2); 1183 if (Pmat) PetscCheckSameComm(ts,1,Pmat,3); 1184 1185 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1186 ierr = DMTSSetIJacobian(dm,f,ctx);CHKERRQ(ierr); 1187 1188 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 1189 ierr = SNESSetJacobian(snes,Amat,Pmat,SNESTSFormJacobian,ts);CHKERRQ(ierr); 1190 PetscFunctionReturn(0); 1191 } 1192 1193 #undef __FUNCT__ 1194 #define __FUNCT__ "TSRHSJacobianSetReuse" 1195 /*@ 1196 TSRHSJacobianSetReuse - restore RHS Jacobian before re-evaluating. Without this flag, TS will change the sign and 1197 shift the RHS Jacobian for a finite-time-step implicit solve, in which case the user function will need to recompute 1198 the entire Jacobian. The reuse flag must be set if the evaluation function will assume that the matrix entries have 1199 not been changed by the TS. 1200 1201 Logically Collective 1202 1203 Input Arguments: 1204 + ts - TS context obtained from TSCreate() 1205 - reuse - PETSC_TRUE if the RHS Jacobian 1206 1207 Level: intermediate 1208 1209 .seealso: TSSetRHSJacobian(), TSComputeRHSJacobianConstant() 1210 @*/ 1211 PetscErrorCode TSRHSJacobianSetReuse(TS ts,PetscBool reuse) 1212 { 1213 PetscFunctionBegin; 1214 ts->rhsjacobian.reuse = reuse; 1215 PetscFunctionReturn(0); 1216 } 1217 1218 #undef __FUNCT__ 1219 #define __FUNCT__ "TSLoad" 1220 /*@C 1221 TSLoad - Loads a KSP that has been stored in binary with KSPView(). 1222 1223 Collective on PetscViewer 1224 1225 Input Parameters: 1226 + newdm - the newly loaded TS, this needs to have been created with TSCreate() or 1227 some related function before a call to TSLoad(). 1228 - viewer - binary file viewer, obtained from PetscViewerBinaryOpen() 1229 1230 Level: intermediate 1231 1232 Notes: 1233 The type is determined by the data in the file, any type set into the TS before this call is ignored. 1234 1235 Notes for advanced users: 1236 Most users should not need to know the details of the binary storage 1237 format, since TSLoad() and TSView() completely hide these details. 1238 But for anyone who's interested, the standard binary matrix storage 1239 format is 1240 .vb 1241 has not yet been determined 1242 .ve 1243 1244 .seealso: PetscViewerBinaryOpen(), TSView(), MatLoad(), VecLoad() 1245 @*/ 1246 PetscErrorCode TSLoad(TS ts, PetscViewer viewer) 1247 { 1248 PetscErrorCode ierr; 1249 PetscBool isbinary; 1250 PetscInt classid; 1251 char type[256]; 1252 DMTS sdm; 1253 DM dm; 1254 1255 PetscFunctionBegin; 1256 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1257 PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,2); 1258 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERBINARY,&isbinary);CHKERRQ(ierr); 1259 if (!isbinary) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Invalid viewer; open viewer with PetscViewerBinaryOpen()"); 1260 1261 ierr = PetscViewerBinaryRead(viewer,&classid,1,PETSC_INT);CHKERRQ(ierr); 1262 if (classid != TS_FILE_CLASSID) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_WRONG,"Not TS next in file"); 1263 ierr = PetscViewerBinaryRead(viewer,type,256,PETSC_CHAR);CHKERRQ(ierr); 1264 ierr = TSSetType(ts, type);CHKERRQ(ierr); 1265 if (ts->ops->load) { 1266 ierr = (*ts->ops->load)(ts,viewer);CHKERRQ(ierr); 1267 } 1268 ierr = DMCreate(PetscObjectComm((PetscObject)ts),&dm);CHKERRQ(ierr); 1269 ierr = DMLoad(dm,viewer);CHKERRQ(ierr); 1270 ierr = TSSetDM(ts,dm);CHKERRQ(ierr); 1271 ierr = DMCreateGlobalVector(ts->dm,&ts->vec_sol);CHKERRQ(ierr); 1272 ierr = VecLoad(ts->vec_sol,viewer);CHKERRQ(ierr); 1273 ierr = DMGetDMTS(ts->dm,&sdm);CHKERRQ(ierr); 1274 ierr = DMTSLoad(sdm,viewer);CHKERRQ(ierr); 1275 PetscFunctionReturn(0); 1276 } 1277 1278 #include <petscdraw.h> 1279 #if defined(PETSC_HAVE_AMS) 1280 #include <petscviewerams.h> 1281 #endif 1282 #undef __FUNCT__ 1283 #define __FUNCT__ "TSView" 1284 /*@C 1285 TSView - Prints the TS data structure. 1286 1287 Collective on TS 1288 1289 Input Parameters: 1290 + ts - the TS context obtained from TSCreate() 1291 - viewer - visualization context 1292 1293 Options Database Key: 1294 . -ts_view - calls TSView() at end of TSStep() 1295 1296 Notes: 1297 The available visualization contexts include 1298 + PETSC_VIEWER_STDOUT_SELF - standard output (default) 1299 - PETSC_VIEWER_STDOUT_WORLD - synchronized standard 1300 output where only the first processor opens 1301 the file. All other processors send their 1302 data to the first processor to print. 1303 1304 The user can open an alternative visualization context with 1305 PetscViewerASCIIOpen() - output to a specified file. 1306 1307 Level: beginner 1308 1309 .keywords: TS, timestep, view 1310 1311 .seealso: PetscViewerASCIIOpen() 1312 @*/ 1313 PetscErrorCode TSView(TS ts,PetscViewer viewer) 1314 { 1315 PetscErrorCode ierr; 1316 TSType type; 1317 PetscBool iascii,isstring,isundials,isbinary,isdraw; 1318 DMTS sdm; 1319 #if defined(PETSC_HAVE_AMS) 1320 PetscBool isams; 1321 #endif 1322 1323 PetscFunctionBegin; 1324 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1325 if (!viewer) { 1326 ierr = PetscViewerASCIIGetStdout(PetscObjectComm((PetscObject)ts),&viewer);CHKERRQ(ierr); 1327 } 1328 PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,2); 1329 PetscCheckSameComm(ts,1,viewer,2); 1330 1331 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr); 1332 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSTRING,&isstring);CHKERRQ(ierr); 1333 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERBINARY,&isbinary);CHKERRQ(ierr); 1334 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERDRAW,&isdraw);CHKERRQ(ierr); 1335 #if defined(PETSC_HAVE_AMS) 1336 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERAMS,&isams);CHKERRQ(ierr); 1337 #endif 1338 if (iascii) { 1339 ierr = PetscObjectPrintClassNamePrefixType((PetscObject)ts,viewer,"TS Object");CHKERRQ(ierr); 1340 ierr = PetscViewerASCIIPrintf(viewer," maximum steps=%D\n",ts->max_steps);CHKERRQ(ierr); 1341 ierr = PetscViewerASCIIPrintf(viewer," maximum time=%G\n",ts->max_time);CHKERRQ(ierr); 1342 if (ts->problem_type == TS_NONLINEAR) { 1343 ierr = PetscViewerASCIIPrintf(viewer," total number of nonlinear solver iterations=%D\n",ts->snes_its);CHKERRQ(ierr); 1344 ierr = PetscViewerASCIIPrintf(viewer," total number of nonlinear solve failures=%D\n",ts->num_snes_failures);CHKERRQ(ierr); 1345 } 1346 ierr = PetscViewerASCIIPrintf(viewer," total number of linear solver iterations=%D\n",ts->ksp_its);CHKERRQ(ierr); 1347 ierr = PetscViewerASCIIPrintf(viewer," total number of rejected steps=%D\n",ts->reject);CHKERRQ(ierr); 1348 ierr = DMGetDMTS(ts->dm,&sdm);CHKERRQ(ierr); 1349 ierr = DMTSView(sdm,viewer);CHKERRQ(ierr); 1350 if (ts->ops->view) { 1351 ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); 1352 ierr = (*ts->ops->view)(ts,viewer);CHKERRQ(ierr); 1353 ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); 1354 } 1355 } else if (isstring) { 1356 ierr = TSGetType(ts,&type);CHKERRQ(ierr); 1357 ierr = PetscViewerStringSPrintf(viewer," %-7.7s",type);CHKERRQ(ierr); 1358 } else if (isbinary) { 1359 PetscInt classid = TS_FILE_CLASSID; 1360 MPI_Comm comm; 1361 PetscMPIInt rank; 1362 char type[256]; 1363 1364 ierr = PetscObjectGetComm((PetscObject)ts,&comm);CHKERRQ(ierr); 1365 ierr = MPI_Comm_rank(comm,&rank);CHKERRQ(ierr); 1366 if (!rank) { 1367 ierr = PetscViewerBinaryWrite(viewer,&classid,1,PETSC_INT,PETSC_FALSE);CHKERRQ(ierr); 1368 ierr = PetscStrncpy(type,((PetscObject)ts)->type_name,256);CHKERRQ(ierr); 1369 ierr = PetscViewerBinaryWrite(viewer,type,256,PETSC_CHAR,PETSC_FALSE);CHKERRQ(ierr); 1370 } 1371 if (ts->ops->view) { 1372 ierr = (*ts->ops->view)(ts,viewer);CHKERRQ(ierr); 1373 } 1374 ierr = DMView(ts->dm,viewer);CHKERRQ(ierr); 1375 ierr = VecView(ts->vec_sol,viewer);CHKERRQ(ierr); 1376 ierr = DMGetDMTS(ts->dm,&sdm);CHKERRQ(ierr); 1377 ierr = DMTSView(sdm,viewer);CHKERRQ(ierr); 1378 } else if (isdraw) { 1379 PetscDraw draw; 1380 char str[36]; 1381 PetscReal x,y,bottom,h; 1382 1383 ierr = PetscViewerDrawGetDraw(viewer,0,&draw);CHKERRQ(ierr); 1384 ierr = PetscDrawGetCurrentPoint(draw,&x,&y);CHKERRQ(ierr); 1385 ierr = PetscStrcpy(str,"TS: ");CHKERRQ(ierr); 1386 ierr = PetscStrcat(str,((PetscObject)ts)->type_name);CHKERRQ(ierr); 1387 ierr = PetscDrawBoxedString(draw,x,y,PETSC_DRAW_BLACK,PETSC_DRAW_BLACK,str,NULL,&h);CHKERRQ(ierr); 1388 bottom = y - h; 1389 ierr = PetscDrawPushCurrentPoint(draw,x,bottom);CHKERRQ(ierr); 1390 if (ts->ops->view) { 1391 ierr = (*ts->ops->view)(ts,viewer);CHKERRQ(ierr); 1392 } 1393 ierr = PetscDrawPopCurrentPoint(draw);CHKERRQ(ierr); 1394 #if defined(PETSC_HAVE_AMS) 1395 } else if (isams) { 1396 if (((PetscObject)ts)->amsmem == -1) { 1397 ierr = PetscObjectViewAMS((PetscObject)ts,viewer);CHKERRQ(ierr); 1398 PetscStackCallAMS(AMS_Memory_take_access,(((PetscObject)ts)->amsmem)); 1399 PetscStackCallAMS(AMS_Memory_add_field,(((PetscObject)ts)->amsmem,"time step",&ts->steps,1,AMS_INT,AMS_READ,AMS_COMMON,AMS_REDUCT_UNDEF)); 1400 PetscStackCallAMS(AMS_Memory_add_field,(((PetscObject)ts)->amsmem,"time",&ts->ptime,1,AMS_DOUBLE,AMS_READ,AMS_COMMON,AMS_REDUCT_UNDEF)); 1401 PetscStackCallAMS(AMS_Memory_grant_access,(((PetscObject)ts)->amsmem)); 1402 } 1403 if (ts->ops->view) { 1404 ierr = (*ts->ops->view)(ts,viewer);CHKERRQ(ierr); 1405 } 1406 #endif 1407 } 1408 1409 ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); 1410 ierr = PetscObjectTypeCompare((PetscObject)ts,TSSUNDIALS,&isundials);CHKERRQ(ierr); 1411 ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); 1412 PetscFunctionReturn(0); 1413 } 1414 1415 1416 #undef __FUNCT__ 1417 #define __FUNCT__ "TSSetApplicationContext" 1418 /*@ 1419 TSSetApplicationContext - Sets an optional user-defined context for 1420 the timesteppers. 1421 1422 Logically Collective on TS 1423 1424 Input Parameters: 1425 + ts - the TS context obtained from TSCreate() 1426 - usrP - optional user context 1427 1428 Level: intermediate 1429 1430 .keywords: TS, timestep, set, application, context 1431 1432 .seealso: TSGetApplicationContext() 1433 @*/ 1434 PetscErrorCode TSSetApplicationContext(TS ts,void *usrP) 1435 { 1436 PetscFunctionBegin; 1437 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1438 ts->user = usrP; 1439 PetscFunctionReturn(0); 1440 } 1441 1442 #undef __FUNCT__ 1443 #define __FUNCT__ "TSGetApplicationContext" 1444 /*@ 1445 TSGetApplicationContext - Gets the user-defined context for the 1446 timestepper. 1447 1448 Not Collective 1449 1450 Input Parameter: 1451 . ts - the TS context obtained from TSCreate() 1452 1453 Output Parameter: 1454 . usrP - user context 1455 1456 Level: intermediate 1457 1458 .keywords: TS, timestep, get, application, context 1459 1460 .seealso: TSSetApplicationContext() 1461 @*/ 1462 PetscErrorCode TSGetApplicationContext(TS ts,void *usrP) 1463 { 1464 PetscFunctionBegin; 1465 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1466 *(void**)usrP = ts->user; 1467 PetscFunctionReturn(0); 1468 } 1469 1470 #undef __FUNCT__ 1471 #define __FUNCT__ "TSGetTimeStepNumber" 1472 /*@ 1473 TSGetTimeStepNumber - Gets the number of time steps completed. 1474 1475 Not Collective 1476 1477 Input Parameter: 1478 . ts - the TS context obtained from TSCreate() 1479 1480 Output Parameter: 1481 . iter - number of steps completed so far 1482 1483 Level: intermediate 1484 1485 .keywords: TS, timestep, get, iteration, number 1486 .seealso: TSGetTime(), TSGetTimeStep(), TSSetPreStep(), TSSetPreStage(), TSSetPostStep() 1487 @*/ 1488 PetscErrorCode TSGetTimeStepNumber(TS ts,PetscInt *iter) 1489 { 1490 PetscFunctionBegin; 1491 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1492 PetscValidIntPointer(iter,2); 1493 *iter = ts->steps; 1494 PetscFunctionReturn(0); 1495 } 1496 1497 #undef __FUNCT__ 1498 #define __FUNCT__ "TSSetInitialTimeStep" 1499 /*@ 1500 TSSetInitialTimeStep - Sets the initial timestep to be used, 1501 as well as the initial time. 1502 1503 Logically Collective on TS 1504 1505 Input Parameters: 1506 + ts - the TS context obtained from TSCreate() 1507 . initial_time - the initial time 1508 - time_step - the size of the timestep 1509 1510 Level: intermediate 1511 1512 .seealso: TSSetTimeStep(), TSGetTimeStep() 1513 1514 .keywords: TS, set, initial, timestep 1515 @*/ 1516 PetscErrorCode TSSetInitialTimeStep(TS ts,PetscReal initial_time,PetscReal time_step) 1517 { 1518 PetscErrorCode ierr; 1519 1520 PetscFunctionBegin; 1521 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1522 ierr = TSSetTimeStep(ts,time_step);CHKERRQ(ierr); 1523 ierr = TSSetTime(ts,initial_time);CHKERRQ(ierr); 1524 PetscFunctionReturn(0); 1525 } 1526 1527 #undef __FUNCT__ 1528 #define __FUNCT__ "TSSetTimeStep" 1529 /*@ 1530 TSSetTimeStep - Allows one to reset the timestep at any time, 1531 useful for simple pseudo-timestepping codes. 1532 1533 Logically Collective on TS 1534 1535 Input Parameters: 1536 + ts - the TS context obtained from TSCreate() 1537 - time_step - the size of the timestep 1538 1539 Level: intermediate 1540 1541 .seealso: TSSetInitialTimeStep(), TSGetTimeStep() 1542 1543 .keywords: TS, set, timestep 1544 @*/ 1545 PetscErrorCode TSSetTimeStep(TS ts,PetscReal time_step) 1546 { 1547 PetscFunctionBegin; 1548 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1549 PetscValidLogicalCollectiveReal(ts,time_step,2); 1550 ts->time_step = time_step; 1551 ts->time_step_orig = time_step; 1552 PetscFunctionReturn(0); 1553 } 1554 1555 #undef __FUNCT__ 1556 #define __FUNCT__ "TSSetExactFinalTime" 1557 /*@ 1558 TSSetExactFinalTime - Determines whether to adapt the final time step to 1559 match the exact final time, interpolate solution to the exact final time, 1560 or just return at the final time TS computed. 1561 1562 Logically Collective on TS 1563 1564 Input Parameter: 1565 + ts - the time-step context 1566 - eftopt - exact final time option 1567 1568 Level: beginner 1569 1570 .seealso: TSExactFinalTimeOption 1571 @*/ 1572 PetscErrorCode TSSetExactFinalTime(TS ts,TSExactFinalTimeOption eftopt) 1573 { 1574 PetscFunctionBegin; 1575 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1576 PetscValidLogicalCollectiveEnum(ts,eftopt,2); 1577 ts->exact_final_time = eftopt; 1578 PetscFunctionReturn(0); 1579 } 1580 1581 #undef __FUNCT__ 1582 #define __FUNCT__ "TSGetTimeStep" 1583 /*@ 1584 TSGetTimeStep - Gets the current timestep size. 1585 1586 Not Collective 1587 1588 Input Parameter: 1589 . ts - the TS context obtained from TSCreate() 1590 1591 Output Parameter: 1592 . dt - the current timestep size 1593 1594 Level: intermediate 1595 1596 .seealso: TSSetInitialTimeStep(), TSGetTimeStep() 1597 1598 .keywords: TS, get, timestep 1599 @*/ 1600 PetscErrorCode TSGetTimeStep(TS ts,PetscReal *dt) 1601 { 1602 PetscFunctionBegin; 1603 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1604 PetscValidRealPointer(dt,2); 1605 *dt = ts->time_step; 1606 PetscFunctionReturn(0); 1607 } 1608 1609 #undef __FUNCT__ 1610 #define __FUNCT__ "TSGetSolution" 1611 /*@ 1612 TSGetSolution - Returns the solution at the present timestep. It 1613 is valid to call this routine inside the function that you are evaluating 1614 in order to move to the new timestep. This vector not changed until 1615 the solution at the next timestep has been calculated. 1616 1617 Not Collective, but Vec returned is parallel if TS is parallel 1618 1619 Input Parameter: 1620 . ts - the TS context obtained from TSCreate() 1621 1622 Output Parameter: 1623 . v - the vector containing the solution 1624 1625 Level: intermediate 1626 1627 .seealso: TSGetTimeStep() 1628 1629 .keywords: TS, timestep, get, solution 1630 @*/ 1631 PetscErrorCode TSGetSolution(TS ts,Vec *v) 1632 { 1633 PetscFunctionBegin; 1634 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1635 PetscValidPointer(v,2); 1636 *v = ts->vec_sol; 1637 PetscFunctionReturn(0); 1638 } 1639 1640 /* ----- Routines to initialize and destroy a timestepper ---- */ 1641 #undef __FUNCT__ 1642 #define __FUNCT__ "TSSetProblemType" 1643 /*@ 1644 TSSetProblemType - Sets the type of problem to be solved. 1645 1646 Not collective 1647 1648 Input Parameters: 1649 + ts - The TS 1650 - type - One of TS_LINEAR, TS_NONLINEAR where these types refer to problems of the forms 1651 .vb 1652 U_t - A U = 0 (linear) 1653 U_t - A(t) U = 0 (linear) 1654 F(t,U,U_t) = 0 (nonlinear) 1655 .ve 1656 1657 Level: beginner 1658 1659 .keywords: TS, problem type 1660 .seealso: TSSetUp(), TSProblemType, TS 1661 @*/ 1662 PetscErrorCode TSSetProblemType(TS ts, TSProblemType type) 1663 { 1664 PetscErrorCode ierr; 1665 1666 PetscFunctionBegin; 1667 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 1668 ts->problem_type = type; 1669 if (type == TS_LINEAR) { 1670 SNES snes; 1671 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 1672 ierr = SNESSetType(snes,SNESKSPONLY);CHKERRQ(ierr); 1673 } 1674 PetscFunctionReturn(0); 1675 } 1676 1677 #undef __FUNCT__ 1678 #define __FUNCT__ "TSGetProblemType" 1679 /*@C 1680 TSGetProblemType - Gets the type of problem to be solved. 1681 1682 Not collective 1683 1684 Input Parameter: 1685 . ts - The TS 1686 1687 Output Parameter: 1688 . type - One of TS_LINEAR, TS_NONLINEAR where these types refer to problems of the forms 1689 .vb 1690 M U_t = A U 1691 M(t) U_t = A(t) U 1692 F(t,U,U_t) 1693 .ve 1694 1695 Level: beginner 1696 1697 .keywords: TS, problem type 1698 .seealso: TSSetUp(), TSProblemType, TS 1699 @*/ 1700 PetscErrorCode TSGetProblemType(TS ts, TSProblemType *type) 1701 { 1702 PetscFunctionBegin; 1703 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 1704 PetscValidIntPointer(type,2); 1705 *type = ts->problem_type; 1706 PetscFunctionReturn(0); 1707 } 1708 1709 #undef __FUNCT__ 1710 #define __FUNCT__ "TSSetUp" 1711 /*@ 1712 TSSetUp - Sets up the internal data structures for the later use 1713 of a timestepper. 1714 1715 Collective on TS 1716 1717 Input Parameter: 1718 . ts - the TS context obtained from TSCreate() 1719 1720 Notes: 1721 For basic use of the TS solvers the user need not explicitly call 1722 TSSetUp(), since these actions will automatically occur during 1723 the call to TSStep(). However, if one wishes to control this 1724 phase separately, TSSetUp() should be called after TSCreate() 1725 and optional routines of the form TSSetXXX(), but before TSStep(). 1726 1727 Level: advanced 1728 1729 .keywords: TS, timestep, setup 1730 1731 .seealso: TSCreate(), TSStep(), TSDestroy() 1732 @*/ 1733 PetscErrorCode TSSetUp(TS ts) 1734 { 1735 PetscErrorCode ierr; 1736 DM dm; 1737 PetscErrorCode (*func)(SNES,Vec,Vec,void*); 1738 PetscErrorCode (*jac)(SNES,Vec,Mat*,Mat*,MatStructure*,void*); 1739 TSIJacobian ijac; 1740 TSRHSJacobian rhsjac; 1741 1742 PetscFunctionBegin; 1743 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1744 if (ts->setupcalled) PetscFunctionReturn(0); 1745 1746 if (!((PetscObject)ts)->type_name) { 1747 ierr = TSSetType(ts,TSEULER);CHKERRQ(ierr); 1748 } 1749 1750 if (!ts->vec_sol) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"Must call TSSetSolution() first"); 1751 1752 ierr = TSGetAdapt(ts,&ts->adapt);CHKERRQ(ierr); 1753 1754 if (ts->rhsjacobian.reuse) { 1755 Mat Amat,Pmat; 1756 SNES snes; 1757 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 1758 ierr = SNESGetJacobian(snes,&Amat,&Pmat,NULL,NULL);CHKERRQ(ierr); 1759 /* Matching matrices implies that an IJacobian is NOT set, because if it had been set, the IJacobian's matrix would 1760 * have displaced the RHS matrix */ 1761 if (Amat == ts->Arhs) { 1762 ierr = MatDuplicate(ts->Arhs,MAT_DO_NOT_COPY_VALUES,&Amat);CHKERRQ(ierr); 1763 ierr = SNESSetJacobian(snes,Amat,NULL,NULL,NULL);CHKERRQ(ierr); 1764 ierr = MatDestroy(&Amat);CHKERRQ(ierr); 1765 } 1766 if (Pmat == ts->Brhs) { 1767 ierr = MatDuplicate(ts->Brhs,MAT_DO_NOT_COPY_VALUES,&Pmat);CHKERRQ(ierr); 1768 ierr = SNESSetJacobian(snes,NULL,Pmat,NULL,NULL);CHKERRQ(ierr); 1769 ierr = MatDestroy(&Pmat);CHKERRQ(ierr); 1770 } 1771 } 1772 1773 if (ts->ops->setup) { 1774 ierr = (*ts->ops->setup)(ts);CHKERRQ(ierr); 1775 } 1776 1777 /* in the case where we've set a DMTSFunction or what have you, we need the default SNESFunction 1778 to be set right but can't do it elsewhere due to the overreliance on ctx=ts. 1779 */ 1780 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1781 ierr = DMSNESGetFunction(dm,&func,NULL);CHKERRQ(ierr); 1782 if (!func) { 1783 ierr =DMSNESSetFunction(dm,SNESTSFormFunction,ts);CHKERRQ(ierr); 1784 } 1785 /* if the SNES doesn't have a jacobian set and the TS has an ijacobian or rhsjacobian set, set the SNES to use it. 1786 Otherwise, the SNES will use coloring internally to form the Jacobian. 1787 */ 1788 ierr = DMSNESGetJacobian(dm,&jac,NULL);CHKERRQ(ierr); 1789 ierr = DMTSGetIJacobian(dm,&ijac,NULL);CHKERRQ(ierr); 1790 ierr = DMTSGetRHSJacobian(dm,&rhsjac,NULL);CHKERRQ(ierr); 1791 if (!jac && (ijac || rhsjac)) { 1792 ierr = DMSNESSetJacobian(dm,SNESTSFormJacobian,ts);CHKERRQ(ierr); 1793 } 1794 ts->setupcalled = PETSC_TRUE; 1795 PetscFunctionReturn(0); 1796 } 1797 1798 #undef __FUNCT__ 1799 #define __FUNCT__ "TSReset" 1800 /*@ 1801 TSReset - Resets a TS context and removes any allocated Vecs and Mats. 1802 1803 Collective on TS 1804 1805 Input Parameter: 1806 . ts - the TS context obtained from TSCreate() 1807 1808 Level: beginner 1809 1810 .keywords: TS, timestep, reset 1811 1812 .seealso: TSCreate(), TSSetup(), TSDestroy() 1813 @*/ 1814 PetscErrorCode TSReset(TS ts) 1815 { 1816 PetscErrorCode ierr; 1817 1818 PetscFunctionBegin; 1819 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1820 if (ts->ops->reset) { 1821 ierr = (*ts->ops->reset)(ts);CHKERRQ(ierr); 1822 } 1823 if (ts->snes) {ierr = SNESReset(ts->snes);CHKERRQ(ierr);} 1824 1825 ierr = MatDestroy(&ts->Arhs);CHKERRQ(ierr); 1826 ierr = MatDestroy(&ts->Brhs);CHKERRQ(ierr); 1827 ierr = VecDestroy(&ts->Frhs);CHKERRQ(ierr); 1828 ierr = VecDestroy(&ts->vec_sol);CHKERRQ(ierr); 1829 ierr = VecDestroy(&ts->vatol);CHKERRQ(ierr); 1830 ierr = VecDestroy(&ts->vrtol);CHKERRQ(ierr); 1831 ierr = VecDestroyVecs(ts->nwork,&ts->work);CHKERRQ(ierr); 1832 1833 ts->setupcalled = PETSC_FALSE; 1834 PetscFunctionReturn(0); 1835 } 1836 1837 #undef __FUNCT__ 1838 #define __FUNCT__ "TSDestroy" 1839 /*@ 1840 TSDestroy - Destroys the timestepper context that was created 1841 with TSCreate(). 1842 1843 Collective on TS 1844 1845 Input Parameter: 1846 . ts - the TS context obtained from TSCreate() 1847 1848 Level: beginner 1849 1850 .keywords: TS, timestepper, destroy 1851 1852 .seealso: TSCreate(), TSSetUp(), TSSolve() 1853 @*/ 1854 PetscErrorCode TSDestroy(TS *ts) 1855 { 1856 PetscErrorCode ierr; 1857 1858 PetscFunctionBegin; 1859 if (!*ts) PetscFunctionReturn(0); 1860 PetscValidHeaderSpecific((*ts),TS_CLASSID,1); 1861 if (--((PetscObject)(*ts))->refct > 0) {*ts = 0; PetscFunctionReturn(0);} 1862 1863 ierr = TSReset((*ts));CHKERRQ(ierr); 1864 1865 /* if memory was published with AMS then destroy it */ 1866 ierr = PetscObjectAMSViewOff((PetscObject)*ts);CHKERRQ(ierr); 1867 if ((*ts)->ops->destroy) {ierr = (*(*ts)->ops->destroy)((*ts));CHKERRQ(ierr);} 1868 1869 ierr = TSAdaptDestroy(&(*ts)->adapt);CHKERRQ(ierr); 1870 ierr = SNESDestroy(&(*ts)->snes);CHKERRQ(ierr); 1871 ierr = DMDestroy(&(*ts)->dm);CHKERRQ(ierr); 1872 ierr = TSMonitorCancel((*ts));CHKERRQ(ierr); 1873 1874 ierr = PetscHeaderDestroy(ts);CHKERRQ(ierr); 1875 PetscFunctionReturn(0); 1876 } 1877 1878 #undef __FUNCT__ 1879 #define __FUNCT__ "TSGetSNES" 1880 /*@ 1881 TSGetSNES - Returns the SNES (nonlinear solver) associated with 1882 a TS (timestepper) context. Valid only for nonlinear problems. 1883 1884 Not Collective, but SNES is parallel if TS is parallel 1885 1886 Input Parameter: 1887 . ts - the TS context obtained from TSCreate() 1888 1889 Output Parameter: 1890 . snes - the nonlinear solver context 1891 1892 Notes: 1893 The user can then directly manipulate the SNES context to set various 1894 options, etc. Likewise, the user can then extract and manipulate the 1895 KSP, KSP, and PC contexts as well. 1896 1897 TSGetSNES() does not work for integrators that do not use SNES; in 1898 this case TSGetSNES() returns NULL in snes. 1899 1900 Level: beginner 1901 1902 .keywords: timestep, get, SNES 1903 @*/ 1904 PetscErrorCode TSGetSNES(TS ts,SNES *snes) 1905 { 1906 PetscErrorCode ierr; 1907 1908 PetscFunctionBegin; 1909 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1910 PetscValidPointer(snes,2); 1911 if (!ts->snes) { 1912 ierr = SNESCreate(PetscObjectComm((PetscObject)ts),&ts->snes);CHKERRQ(ierr); 1913 ierr = SNESSetFunction(ts->snes,NULL,SNESTSFormFunction,ts);CHKERRQ(ierr); 1914 ierr = PetscLogObjectParent(ts,ts->snes);CHKERRQ(ierr); 1915 ierr = PetscObjectIncrementTabLevel((PetscObject)ts->snes,(PetscObject)ts,1);CHKERRQ(ierr); 1916 if (ts->dm) {ierr = SNESSetDM(ts->snes,ts->dm);CHKERRQ(ierr);} 1917 if (ts->problem_type == TS_LINEAR) { 1918 ierr = SNESSetType(ts->snes,SNESKSPONLY);CHKERRQ(ierr); 1919 } 1920 } 1921 *snes = ts->snes; 1922 PetscFunctionReturn(0); 1923 } 1924 1925 #undef __FUNCT__ 1926 #define __FUNCT__ "TSSetSNES" 1927 /*@ 1928 TSSetSNES - Set the SNES (nonlinear solver) to be used by the timestepping context 1929 1930 Collective 1931 1932 Input Parameter: 1933 + ts - the TS context obtained from TSCreate() 1934 - snes - the nonlinear solver context 1935 1936 Notes: 1937 Most users should have the TS created by calling TSGetSNES() 1938 1939 Level: developer 1940 1941 .keywords: timestep, set, SNES 1942 @*/ 1943 PetscErrorCode TSSetSNES(TS ts,SNES snes) 1944 { 1945 PetscErrorCode ierr; 1946 PetscErrorCode (*func)(SNES,Vec,Mat*,Mat*,MatStructure*,void*); 1947 1948 PetscFunctionBegin; 1949 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1950 PetscValidHeaderSpecific(snes,SNES_CLASSID,2); 1951 ierr = PetscObjectReference((PetscObject)snes);CHKERRQ(ierr); 1952 ierr = SNESDestroy(&ts->snes);CHKERRQ(ierr); 1953 1954 ts->snes = snes; 1955 1956 ierr = SNESSetFunction(ts->snes,NULL,SNESTSFormFunction,ts);CHKERRQ(ierr); 1957 ierr = SNESGetJacobian(ts->snes,NULL,NULL,&func,NULL);CHKERRQ(ierr); 1958 if (func == SNESTSFormJacobian) { 1959 ierr = SNESSetJacobian(ts->snes,NULL,NULL,SNESTSFormJacobian,ts);CHKERRQ(ierr); 1960 } 1961 PetscFunctionReturn(0); 1962 } 1963 1964 #undef __FUNCT__ 1965 #define __FUNCT__ "TSGetKSP" 1966 /*@ 1967 TSGetKSP - Returns the KSP (linear solver) associated with 1968 a TS (timestepper) context. 1969 1970 Not Collective, but KSP is parallel if TS is parallel 1971 1972 Input Parameter: 1973 . ts - the TS context obtained from TSCreate() 1974 1975 Output Parameter: 1976 . ksp - the nonlinear solver context 1977 1978 Notes: 1979 The user can then directly manipulate the KSP context to set various 1980 options, etc. Likewise, the user can then extract and manipulate the 1981 KSP and PC contexts as well. 1982 1983 TSGetKSP() does not work for integrators that do not use KSP; 1984 in this case TSGetKSP() returns NULL in ksp. 1985 1986 Level: beginner 1987 1988 .keywords: timestep, get, KSP 1989 @*/ 1990 PetscErrorCode TSGetKSP(TS ts,KSP *ksp) 1991 { 1992 PetscErrorCode ierr; 1993 SNES snes; 1994 1995 PetscFunctionBegin; 1996 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1997 PetscValidPointer(ksp,2); 1998 if (!((PetscObject)ts)->type_name) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NULL,"KSP is not created yet. Call TSSetType() first"); 1999 if (ts->problem_type != TS_LINEAR) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Linear only; use TSGetSNES()"); 2000 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 2001 ierr = SNESGetKSP(snes,ksp);CHKERRQ(ierr); 2002 PetscFunctionReturn(0); 2003 } 2004 2005 /* ----------- Routines to set solver parameters ---------- */ 2006 2007 #undef __FUNCT__ 2008 #define __FUNCT__ "TSGetDuration" 2009 /*@ 2010 TSGetDuration - Gets the maximum number of timesteps to use and 2011 maximum time for iteration. 2012 2013 Not Collective 2014 2015 Input Parameters: 2016 + ts - the TS context obtained from TSCreate() 2017 . maxsteps - maximum number of iterations to use, or NULL 2018 - maxtime - final time to iterate to, or NULL 2019 2020 Level: intermediate 2021 2022 .keywords: TS, timestep, get, maximum, iterations, time 2023 @*/ 2024 PetscErrorCode TSGetDuration(TS ts, PetscInt *maxsteps, PetscReal *maxtime) 2025 { 2026 PetscFunctionBegin; 2027 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 2028 if (maxsteps) { 2029 PetscValidIntPointer(maxsteps,2); 2030 *maxsteps = ts->max_steps; 2031 } 2032 if (maxtime) { 2033 PetscValidScalarPointer(maxtime,3); 2034 *maxtime = ts->max_time; 2035 } 2036 PetscFunctionReturn(0); 2037 } 2038 2039 #undef __FUNCT__ 2040 #define __FUNCT__ "TSSetDuration" 2041 /*@ 2042 TSSetDuration - Sets the maximum number of timesteps to use and 2043 maximum time for iteration. 2044 2045 Logically Collective on TS 2046 2047 Input Parameters: 2048 + ts - the TS context obtained from TSCreate() 2049 . maxsteps - maximum number of iterations to use 2050 - maxtime - final time to iterate to 2051 2052 Options Database Keys: 2053 . -ts_max_steps <maxsteps> - Sets maxsteps 2054 . -ts_final_time <maxtime> - Sets maxtime 2055 2056 Notes: 2057 The default maximum number of iterations is 5000. Default time is 5.0 2058 2059 Level: intermediate 2060 2061 .keywords: TS, timestep, set, maximum, iterations 2062 2063 .seealso: TSSetExactFinalTime() 2064 @*/ 2065 PetscErrorCode TSSetDuration(TS ts,PetscInt maxsteps,PetscReal maxtime) 2066 { 2067 PetscFunctionBegin; 2068 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2069 PetscValidLogicalCollectiveInt(ts,maxsteps,2); 2070 PetscValidLogicalCollectiveReal(ts,maxtime,2); 2071 if (maxsteps >= 0) ts->max_steps = maxsteps; 2072 if (maxtime != PETSC_DEFAULT) ts->max_time = maxtime; 2073 PetscFunctionReturn(0); 2074 } 2075 2076 #undef __FUNCT__ 2077 #define __FUNCT__ "TSSetSolution" 2078 /*@ 2079 TSSetSolution - Sets the initial solution vector 2080 for use by the TS routines. 2081 2082 Logically Collective on TS and Vec 2083 2084 Input Parameters: 2085 + ts - the TS context obtained from TSCreate() 2086 - u - the solution vector 2087 2088 Level: beginner 2089 2090 .keywords: TS, timestep, set, solution, initial conditions 2091 @*/ 2092 PetscErrorCode TSSetSolution(TS ts,Vec u) 2093 { 2094 PetscErrorCode ierr; 2095 DM dm; 2096 2097 PetscFunctionBegin; 2098 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2099 PetscValidHeaderSpecific(u,VEC_CLASSID,2); 2100 ierr = PetscObjectReference((PetscObject)u);CHKERRQ(ierr); 2101 ierr = VecDestroy(&ts->vec_sol);CHKERRQ(ierr); 2102 2103 ts->vec_sol = u; 2104 2105 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 2106 ierr = DMShellSetGlobalVector(dm,u);CHKERRQ(ierr); 2107 PetscFunctionReturn(0); 2108 } 2109 2110 #undef __FUNCT__ 2111 #define __FUNCT__ "TSSetPreStep" 2112 /*@C 2113 TSSetPreStep - Sets the general-purpose function 2114 called once at the beginning of each time step. 2115 2116 Logically Collective on TS 2117 2118 Input Parameters: 2119 + ts - The TS context obtained from TSCreate() 2120 - func - The function 2121 2122 Calling sequence of func: 2123 . func (TS ts); 2124 2125 Level: intermediate 2126 2127 Note: 2128 If a step is rejected, TSStep() will call this routine again before each attempt. 2129 The last completed time step number can be queried using TSGetTimeStepNumber(), the 2130 size of the step being attempted can be obtained using TSGetTimeStep(). 2131 2132 .keywords: TS, timestep 2133 .seealso: TSSetPreStage(), TSSetPostStep(), TSStep() 2134 @*/ 2135 PetscErrorCode TSSetPreStep(TS ts, PetscErrorCode (*func)(TS)) 2136 { 2137 PetscFunctionBegin; 2138 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 2139 ts->prestep = func; 2140 PetscFunctionReturn(0); 2141 } 2142 2143 #undef __FUNCT__ 2144 #define __FUNCT__ "TSPreStep" 2145 /*@ 2146 TSPreStep - Runs the user-defined pre-step function. 2147 2148 Collective on TS 2149 2150 Input Parameters: 2151 . ts - The TS context obtained from TSCreate() 2152 2153 Notes: 2154 TSPreStep() is typically used within time stepping implementations, 2155 so most users would not generally call this routine themselves. 2156 2157 Level: developer 2158 2159 .keywords: TS, timestep 2160 .seealso: TSSetPreStep(), TSPreStage(), TSPostStep() 2161 @*/ 2162 PetscErrorCode TSPreStep(TS ts) 2163 { 2164 PetscErrorCode ierr; 2165 2166 PetscFunctionBegin; 2167 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2168 if (ts->prestep) { 2169 PetscStackCallStandard((*ts->prestep),(ts)); 2170 } 2171 PetscFunctionReturn(0); 2172 } 2173 2174 #undef __FUNCT__ 2175 #define __FUNCT__ "TSSetPreStage" 2176 /*@C 2177 TSSetPreStage - Sets the general-purpose function 2178 called once at the beginning of each stage. 2179 2180 Logically Collective on TS 2181 2182 Input Parameters: 2183 + ts - The TS context obtained from TSCreate() 2184 - func - The function 2185 2186 Calling sequence of func: 2187 . PetscErrorCode func(TS ts, PetscReal stagetime); 2188 2189 Level: intermediate 2190 2191 Note: 2192 There may be several stages per time step. If the solve for a given stage fails, the step may be rejected and retried. 2193 The time step number being computed can be queried using TSGetTimeStepNumber() and the total size of the step being 2194 attempted can be obtained using TSGetTimeStep(). The time at the start of the step is available via TSGetTime(). 2195 2196 .keywords: TS, timestep 2197 .seealso: TSSetPreStep(), TSSetPostStep(), TSGetApplicationContext() 2198 @*/ 2199 PetscErrorCode TSSetPreStage(TS ts, PetscErrorCode (*func)(TS,PetscReal)) 2200 { 2201 PetscFunctionBegin; 2202 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 2203 ts->prestage = func; 2204 PetscFunctionReturn(0); 2205 } 2206 2207 #undef __FUNCT__ 2208 #define __FUNCT__ "TSPreStage" 2209 /*@ 2210 TSPreStage - Runs the user-defined pre-stage function set using TSSetPreStage() 2211 2212 Collective on TS 2213 2214 Input Parameters: 2215 . ts - The TS context obtained from TSCreate() 2216 2217 Notes: 2218 TSPreStage() is typically used within time stepping implementations, 2219 most users would not generally call this routine themselves. 2220 2221 Level: developer 2222 2223 .keywords: TS, timestep 2224 .seealso: TSSetPreStep(), TSPreStep(), TSPostStep() 2225 @*/ 2226 PetscErrorCode TSPreStage(TS ts, PetscReal stagetime) 2227 { 2228 PetscErrorCode ierr; 2229 2230 PetscFunctionBegin; 2231 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2232 if (ts->prestage) { 2233 PetscStackCallStandard((*ts->prestage),(ts,stagetime)); 2234 } 2235 PetscFunctionReturn(0); 2236 } 2237 2238 #undef __FUNCT__ 2239 #define __FUNCT__ "TSSetPostStep" 2240 /*@C 2241 TSSetPostStep - Sets the general-purpose function 2242 called once at the end of each time step. 2243 2244 Logically Collective on TS 2245 2246 Input Parameters: 2247 + ts - The TS context obtained from TSCreate() 2248 - func - The function 2249 2250 Calling sequence of func: 2251 $ func (TS ts); 2252 2253 Level: intermediate 2254 2255 .keywords: TS, timestep 2256 .seealso: TSSetPreStep(), TSSetPreStage(), TSGetTimeStep(), TSGetTimeStepNumber(), TSGetTime() 2257 @*/ 2258 PetscErrorCode TSSetPostStep(TS ts, PetscErrorCode (*func)(TS)) 2259 { 2260 PetscFunctionBegin; 2261 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 2262 ts->poststep = func; 2263 PetscFunctionReturn(0); 2264 } 2265 2266 #undef __FUNCT__ 2267 #define __FUNCT__ "TSPostStep" 2268 /*@ 2269 TSPostStep - Runs the user-defined post-step function. 2270 2271 Collective on TS 2272 2273 Input Parameters: 2274 . ts - The TS context obtained from TSCreate() 2275 2276 Notes: 2277 TSPostStep() is typically used within time stepping implementations, 2278 so most users would not generally call this routine themselves. 2279 2280 Level: developer 2281 2282 .keywords: TS, timestep 2283 @*/ 2284 PetscErrorCode TSPostStep(TS ts) 2285 { 2286 PetscErrorCode ierr; 2287 2288 PetscFunctionBegin; 2289 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2290 if (ts->poststep) { 2291 PetscStackCallStandard((*ts->poststep),(ts)); 2292 } 2293 PetscFunctionReturn(0); 2294 } 2295 2296 /* ------------ Routines to set performance monitoring options ----------- */ 2297 2298 #undef __FUNCT__ 2299 #define __FUNCT__ "TSMonitorSet" 2300 /*@C 2301 TSMonitorSet - Sets an ADDITIONAL function that is to be used at every 2302 timestep to display the iteration's progress. 2303 2304 Logically Collective on TS 2305 2306 Input Parameters: 2307 + ts - the TS context obtained from TSCreate() 2308 . monitor - monitoring routine 2309 . mctx - [optional] user-defined context for private data for the 2310 monitor routine (use NULL if no context is desired) 2311 - monitordestroy - [optional] routine that frees monitor context 2312 (may be NULL) 2313 2314 Calling sequence of monitor: 2315 $ int monitor(TS ts,PetscInt steps,PetscReal time,Vec u,void *mctx) 2316 2317 + ts - the TS context 2318 . steps - iteration number (after the final time step the monitor routine is called with a step of -1, this is at the final time which may have 2319 been interpolated to) 2320 . time - current time 2321 . u - current iterate 2322 - mctx - [optional] monitoring context 2323 2324 Notes: 2325 This routine adds an additional monitor to the list of monitors that 2326 already has been loaded. 2327 2328 Fortran notes: Only a single monitor function can be set for each TS object 2329 2330 Level: intermediate 2331 2332 .keywords: TS, timestep, set, monitor 2333 2334 .seealso: TSMonitorDefault(), TSMonitorCancel() 2335 @*/ 2336 PetscErrorCode TSMonitorSet(TS ts,PetscErrorCode (*monitor)(TS,PetscInt,PetscReal,Vec,void*),void *mctx,PetscErrorCode (*mdestroy)(void**)) 2337 { 2338 PetscFunctionBegin; 2339 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2340 if (ts->numbermonitors >= MAXTSMONITORS) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Too many monitors set"); 2341 ts->monitor[ts->numbermonitors] = monitor; 2342 ts->monitordestroy[ts->numbermonitors] = mdestroy; 2343 ts->monitorcontext[ts->numbermonitors++] = (void*)mctx; 2344 PetscFunctionReturn(0); 2345 } 2346 2347 #undef __FUNCT__ 2348 #define __FUNCT__ "TSMonitorCancel" 2349 /*@C 2350 TSMonitorCancel - Clears all the monitors that have been set on a time-step object. 2351 2352 Logically Collective on TS 2353 2354 Input Parameters: 2355 . ts - the TS context obtained from TSCreate() 2356 2357 Notes: 2358 There is no way to remove a single, specific monitor. 2359 2360 Level: intermediate 2361 2362 .keywords: TS, timestep, set, monitor 2363 2364 .seealso: TSMonitorDefault(), TSMonitorSet() 2365 @*/ 2366 PetscErrorCode TSMonitorCancel(TS ts) 2367 { 2368 PetscErrorCode ierr; 2369 PetscInt i; 2370 2371 PetscFunctionBegin; 2372 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2373 for (i=0; i<ts->numbermonitors; i++) { 2374 if (ts->monitordestroy[i]) { 2375 ierr = (*ts->monitordestroy[i])(&ts->monitorcontext[i]);CHKERRQ(ierr); 2376 } 2377 } 2378 ts->numbermonitors = 0; 2379 PetscFunctionReturn(0); 2380 } 2381 2382 #undef __FUNCT__ 2383 #define __FUNCT__ "TSMonitorDefault" 2384 /*@ 2385 TSMonitorDefault - Sets the Default monitor 2386 2387 Level: intermediate 2388 2389 .keywords: TS, set, monitor 2390 2391 .seealso: TSMonitorDefault(), TSMonitorSet() 2392 @*/ 2393 PetscErrorCode TSMonitorDefault(TS ts,PetscInt step,PetscReal ptime,Vec v,void *dummy) 2394 { 2395 PetscErrorCode ierr; 2396 PetscViewer viewer = dummy ? (PetscViewer) dummy : PETSC_VIEWER_STDOUT_(PetscObjectComm((PetscObject)ts)); 2397 2398 PetscFunctionBegin; 2399 ierr = PetscViewerASCIIAddTab(viewer,((PetscObject)ts)->tablevel);CHKERRQ(ierr); 2400 ierr = PetscViewerASCIIPrintf(viewer,"%D TS dt %g time %g\n",step,(double)ts->time_step,(double)ptime);CHKERRQ(ierr); 2401 ierr = PetscViewerASCIISubtractTab(viewer,((PetscObject)ts)->tablevel);CHKERRQ(ierr); 2402 PetscFunctionReturn(0); 2403 } 2404 2405 #undef __FUNCT__ 2406 #define __FUNCT__ "TSSetRetainStages" 2407 /*@ 2408 TSSetRetainStages - Request that all stages in the upcoming step be stored so that interpolation will be available. 2409 2410 Logically Collective on TS 2411 2412 Input Argument: 2413 . ts - time stepping context 2414 2415 Output Argument: 2416 . flg - PETSC_TRUE or PETSC_FALSE 2417 2418 Level: intermediate 2419 2420 .keywords: TS, set 2421 2422 .seealso: TSInterpolate(), TSSetPostStep() 2423 @*/ 2424 PetscErrorCode TSSetRetainStages(TS ts,PetscBool flg) 2425 { 2426 PetscFunctionBegin; 2427 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2428 ts->retain_stages = flg; 2429 PetscFunctionReturn(0); 2430 } 2431 2432 #undef __FUNCT__ 2433 #define __FUNCT__ "TSInterpolate" 2434 /*@ 2435 TSInterpolate - Interpolate the solution computed during the previous step to an arbitrary location in the interval 2436 2437 Collective on TS 2438 2439 Input Argument: 2440 + ts - time stepping context 2441 - t - time to interpolate to 2442 2443 Output Argument: 2444 . U - state at given time 2445 2446 Notes: 2447 The user should call TSSetRetainStages() before taking a step in which interpolation will be requested. 2448 2449 Level: intermediate 2450 2451 Developer Notes: 2452 TSInterpolate() and the storing of previous steps/stages should be generalized to support delay differential equations and continuous adjoints. 2453 2454 .keywords: TS, set 2455 2456 .seealso: TSSetRetainStages(), TSSetPostStep() 2457 @*/ 2458 PetscErrorCode TSInterpolate(TS ts,PetscReal t,Vec U) 2459 { 2460 PetscErrorCode ierr; 2461 2462 PetscFunctionBegin; 2463 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2464 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 2465 if (t < ts->ptime - ts->time_step_prev || t > ts->ptime) SETERRQ3(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_OUTOFRANGE,"Requested time %G not in last time steps [%G,%G]",t,ts->ptime-ts->time_step_prev,ts->ptime); 2466 if (!ts->ops->interpolate) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"%s does not provide interpolation",((PetscObject)ts)->type_name); 2467 ierr = (*ts->ops->interpolate)(ts,t,U);CHKERRQ(ierr); 2468 PetscFunctionReturn(0); 2469 } 2470 2471 #undef __FUNCT__ 2472 #define __FUNCT__ "TSStep" 2473 /*@ 2474 TSStep - Steps one time step 2475 2476 Collective on TS 2477 2478 Input Parameter: 2479 . ts - the TS context obtained from TSCreate() 2480 2481 Level: intermediate 2482 2483 Notes: 2484 The hook set using TSSetPreStep() is called before each attempt to take the step. In general, the time step size may 2485 be changed due to adaptive error controller or solve failures. Note that steps may contain multiple stages. 2486 2487 This may over-step the final time provided in TSSetDuration() depending on the time-step used. TSSolve() interpolates to exactly the 2488 time provided in TSSetDuration(). One can use TSInterpolate() to determine an interpolated solution within the final timestep. 2489 2490 .keywords: TS, timestep, solve 2491 2492 .seealso: TSCreate(), TSSetUp(), TSDestroy(), TSSolve(), TSSetPreStep(), TSSetPreStage(), TSInterpolate() 2493 @*/ 2494 PetscErrorCode TSStep(TS ts) 2495 { 2496 PetscErrorCode ierr; 2497 2498 PetscFunctionBegin; 2499 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 2500 ierr = TSSetUp(ts);CHKERRQ(ierr); 2501 2502 ts->reason = TS_CONVERGED_ITERATING; 2503 ts->ptime_prev = ts->ptime; 2504 2505 ierr = PetscLogEventBegin(TS_Step,ts,0,0,0);CHKERRQ(ierr); 2506 ierr = (*ts->ops->step)(ts);CHKERRQ(ierr); 2507 ierr = PetscLogEventEnd(TS_Step,ts,0,0,0);CHKERRQ(ierr); 2508 2509 ts->time_step_prev = ts->ptime - ts->ptime_prev; 2510 2511 if (ts->reason < 0) { 2512 if (ts->errorifstepfailed) { 2513 if (ts->reason == TS_DIVERGED_NONLINEAR_SOLVE) { 2514 SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_NOT_CONVERGED,"TSStep has failed due to %s, increase -ts_max_snes_failures or make negative to attempt recovery",TSConvergedReasons[ts->reason]); 2515 } else SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_NOT_CONVERGED,"TSStep has failed due to %s",TSConvergedReasons[ts->reason]); 2516 } 2517 } else if (!ts->reason) { 2518 if (ts->steps >= ts->max_steps) ts->reason = TS_CONVERGED_ITS; 2519 else if (ts->ptime >= ts->max_time) ts->reason = TS_CONVERGED_TIME; 2520 } 2521 PetscFunctionReturn(0); 2522 } 2523 2524 #undef __FUNCT__ 2525 #define __FUNCT__ "TSEvaluateStep" 2526 /*@ 2527 TSEvaluateStep - Evaluate the solution at the end of a time step with a given order of accuracy. 2528 2529 Collective on TS 2530 2531 Input Arguments: 2532 + ts - time stepping context 2533 . order - desired order of accuracy 2534 - done - whether the step was evaluated at this order (pass NULL to generate an error if not available) 2535 2536 Output Arguments: 2537 . U - state at the end of the current step 2538 2539 Level: advanced 2540 2541 Notes: 2542 This function cannot be called until all stages have been evaluated. 2543 It is normally called by adaptive controllers before a step has been accepted and may also be called by the user after TSStep() has returned. 2544 2545 .seealso: TSStep(), TSAdapt 2546 @*/ 2547 PetscErrorCode TSEvaluateStep(TS ts,PetscInt order,Vec U,PetscBool *done) 2548 { 2549 PetscErrorCode ierr; 2550 2551 PetscFunctionBegin; 2552 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2553 PetscValidType(ts,1); 2554 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 2555 if (!ts->ops->evaluatestep) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"TSEvaluateStep not implemented for type '%s'",((PetscObject)ts)->type_name); 2556 ierr = (*ts->ops->evaluatestep)(ts,order,U,done);CHKERRQ(ierr); 2557 PetscFunctionReturn(0); 2558 } 2559 2560 #undef __FUNCT__ 2561 #define __FUNCT__ "TSSolve" 2562 /*@ 2563 TSSolve - Steps the requested number of timesteps. 2564 2565 Collective on TS 2566 2567 Input Parameter: 2568 + ts - the TS context obtained from TSCreate() 2569 - u - the solution vector (can be null if TSSetSolution() was used, otherwise must contain the initial conditions) 2570 2571 Level: beginner 2572 2573 Notes: 2574 The final time returned by this function may be different from the time of the internally 2575 held state accessible by TSGetSolution() and TSGetTime() because the method may have 2576 stepped over the final time. 2577 2578 .keywords: TS, timestep, solve 2579 2580 .seealso: TSCreate(), TSSetSolution(), TSStep() 2581 @*/ 2582 PetscErrorCode TSSolve(TS ts,Vec u) 2583 { 2584 PetscBool flg; 2585 PetscViewer viewer; 2586 Vec solution; 2587 PetscErrorCode ierr; 2588 PetscViewerFormat format; 2589 2590 PetscFunctionBegin; 2591 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2592 if (u) PetscValidHeaderSpecific(u,VEC_CLASSID,2); 2593 if (ts->exact_final_time == TS_EXACTFINALTIME_INTERPOLATE) { /* Need ts->vec_sol to be distinct so it is not overwritten when we interpolate at the end */ 2594 PetscValidHeaderSpecific(u,VEC_CLASSID,2); 2595 if (!ts->vec_sol || u == ts->vec_sol) { 2596 ierr = VecDuplicate(u,&solution);CHKERRQ(ierr); 2597 ierr = TSSetSolution(ts,solution);CHKERRQ(ierr); 2598 ierr = VecDestroy(&solution);CHKERRQ(ierr); /* grant ownership */ 2599 } 2600 ierr = VecCopy(u,ts->vec_sol);CHKERRQ(ierr); 2601 } else if (u) { 2602 ierr = TSSetSolution(ts,u);CHKERRQ(ierr); 2603 } 2604 ierr = TSSetUp(ts);CHKERRQ(ierr); 2605 /* reset time step and iteration counters */ 2606 ts->steps = 0; 2607 ts->ksp_its = 0; 2608 ts->snes_its = 0; 2609 ts->num_snes_failures = 0; 2610 ts->reject = 0; 2611 ts->reason = TS_CONVERGED_ITERATING; 2612 2613 ierr = PetscOptionsGetViewer(PetscObjectComm((PetscObject)ts),((PetscObject)ts)->prefix,"-ts_view_pre",&viewer,&format,&flg);CHKERRQ(ierr); 2614 if (flg && !PetscPreLoadingOn) { 2615 ierr = PetscViewerPushFormat(viewer,format);CHKERRQ(ierr); 2616 ierr = TSView(ts,viewer);CHKERRQ(ierr); 2617 ierr = PetscViewerPopFormat(viewer);CHKERRQ(ierr); 2618 ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr); 2619 } 2620 2621 if (ts->ops->solve) { /* This private interface is transitional and should be removed when all implementations are updated. */ 2622 ierr = (*ts->ops->solve)(ts);CHKERRQ(ierr); 2623 ierr = VecCopy(ts->vec_sol,u);CHKERRQ(ierr); 2624 ts->solvetime = ts->ptime; 2625 } else { 2626 /* steps the requested number of timesteps. */ 2627 if (ts->steps >= ts->max_steps) ts->reason = TS_CONVERGED_ITS; 2628 else if (ts->ptime >= ts->max_time) ts->reason = TS_CONVERGED_TIME; 2629 while (!ts->reason) { 2630 ierr = TSMonitor(ts,ts->steps,ts->ptime,ts->vec_sol);CHKERRQ(ierr); 2631 ierr = TSStep(ts);CHKERRQ(ierr); 2632 ierr = TSPostStep(ts);CHKERRQ(ierr); 2633 } 2634 if (ts->exact_final_time == TS_EXACTFINALTIME_INTERPOLATE && ts->ptime > ts->max_time) { 2635 ierr = TSInterpolate(ts,ts->max_time,u);CHKERRQ(ierr); 2636 ts->solvetime = ts->max_time; 2637 solution = u; 2638 } else { 2639 if (u) {ierr = VecCopy(ts->vec_sol,u);CHKERRQ(ierr);} 2640 ts->solvetime = ts->ptime; 2641 solution = ts->vec_sol; 2642 } 2643 ierr = TSMonitor(ts,ts->steps,ts->solvetime,solution);CHKERRQ(ierr); 2644 } 2645 ierr = PetscOptionsGetViewer(PetscObjectComm((PetscObject)ts),((PetscObject)ts)->prefix,"-ts_view",&viewer,&format,&flg);CHKERRQ(ierr); 2646 if (flg && !PetscPreLoadingOn) { 2647 ierr = PetscViewerPushFormat(viewer,format);CHKERRQ(ierr); 2648 ierr = TSView(ts,viewer);CHKERRQ(ierr); 2649 ierr = PetscViewerPopFormat(viewer);CHKERRQ(ierr); 2650 ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr); 2651 } 2652 PetscFunctionReturn(0); 2653 } 2654 2655 #undef __FUNCT__ 2656 #define __FUNCT__ "TSMonitor" 2657 /*@ 2658 TSMonitor - Runs all user-provided monitor routines set using TSMonitorSet() 2659 2660 Collective on TS 2661 2662 Input Parameters: 2663 + ts - time stepping context obtained from TSCreate() 2664 . step - step number that has just completed 2665 . ptime - model time of the state 2666 - u - state at the current model time 2667 2668 Notes: 2669 TSMonitor() is typically used within the time stepping implementations. 2670 Users might call this function when using the TSStep() interface instead of TSSolve(). 2671 2672 Level: advanced 2673 2674 .keywords: TS, timestep 2675 @*/ 2676 PetscErrorCode TSMonitor(TS ts,PetscInt step,PetscReal ptime,Vec u) 2677 { 2678 PetscErrorCode ierr; 2679 PetscInt i,n = ts->numbermonitors; 2680 2681 PetscFunctionBegin; 2682 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2683 PetscValidHeaderSpecific(u,VEC_CLASSID,4); 2684 for (i=0; i<n; i++) { 2685 ierr = (*ts->monitor[i])(ts,step,ptime,u,ts->monitorcontext[i]);CHKERRQ(ierr); 2686 } 2687 PetscFunctionReturn(0); 2688 } 2689 2690 /* ------------------------------------------------------------------------*/ 2691 struct _n_TSMonitorLGCtx { 2692 PetscDrawLG lg; 2693 PetscInt howoften; /* when > 0 uses step % howoften, when negative only final solution plotted */ 2694 PetscInt ksp_its,snes_its; 2695 }; 2696 2697 2698 #undef __FUNCT__ 2699 #define __FUNCT__ "TSMonitorLGCtxCreate" 2700 /*@C 2701 TSMonitorLGCtxCreate - Creates a line graph context for use with 2702 TS to monitor the solution process graphically in various ways 2703 2704 Collective on TS 2705 2706 Input Parameters: 2707 + host - the X display to open, or null for the local machine 2708 . label - the title to put in the title bar 2709 . x, y - the screen coordinates of the upper left coordinate of the window 2710 . m, n - the screen width and height in pixels 2711 - howoften - if positive then determines the frequency of the plotting, if -1 then only at the final time 2712 2713 Output Parameter: 2714 . ctx - the context 2715 2716 Options Database Key: 2717 + -ts_monitor_lg_timestep - automatically sets line graph monitor 2718 . -ts_monitor_lg_solution - 2719 . -ts_monitor_lg_error - 2720 . -ts_monitor_lg_ksp_iterations - 2721 . -ts_monitor_lg_snes_iterations - 2722 - -lg_indicate_data_points <true,false> - indicate the data points (at each time step) on the plot; default is true 2723 2724 Notes: 2725 Use TSMonitorLGCtxDestroy() to destroy. 2726 2727 Level: intermediate 2728 2729 .keywords: TS, monitor, line graph, residual, seealso 2730 2731 .seealso: TSMonitorLGTimeStep(), TSMonitorSet(), TSMonitorLGSolution(), TSMonitorLGError() 2732 2733 @*/ 2734 PetscErrorCode TSMonitorLGCtxCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscInt howoften,TSMonitorLGCtx *ctx) 2735 { 2736 PetscDraw win; 2737 PetscErrorCode ierr; 2738 PetscBool flg = PETSC_TRUE; 2739 2740 PetscFunctionBegin; 2741 ierr = PetscNew(struct _n_TSMonitorLGCtx,ctx);CHKERRQ(ierr); 2742 ierr = PetscDrawCreate(comm,host,label,x,y,m,n,&win);CHKERRQ(ierr); 2743 ierr = PetscDrawSetFromOptions(win);CHKERRQ(ierr); 2744 ierr = PetscDrawLGCreate(win,1,&(*ctx)->lg);CHKERRQ(ierr); 2745 ierr = PetscOptionsGetBool(NULL,"-lg_indicate_data_points",&flg,NULL);CHKERRQ(ierr); 2746 if (flg) { 2747 ierr = PetscDrawLGIndicateDataPoints((*ctx)->lg);CHKERRQ(ierr); 2748 } 2749 ierr = PetscLogObjectParent((*ctx)->lg,win);CHKERRQ(ierr); 2750 (*ctx)->howoften = howoften; 2751 PetscFunctionReturn(0); 2752 } 2753 2754 #undef __FUNCT__ 2755 #define __FUNCT__ "TSMonitorLGTimeStep" 2756 PetscErrorCode TSMonitorLGTimeStep(TS ts,PetscInt step,PetscReal ptime,Vec v,void *monctx) 2757 { 2758 TSMonitorLGCtx ctx = (TSMonitorLGCtx) monctx; 2759 PetscReal x = ptime,y; 2760 PetscErrorCode ierr; 2761 2762 PetscFunctionBegin; 2763 if (!step) { 2764 PetscDrawAxis axis; 2765 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 2766 ierr = PetscDrawAxisSetLabels(axis,"Timestep as function of time","Time","Time step");CHKERRQ(ierr); 2767 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 2768 } 2769 ierr = TSGetTimeStep(ts,&y);CHKERRQ(ierr); 2770 ierr = PetscDrawLGAddPoint(ctx->lg,&x,&y);CHKERRQ(ierr); 2771 if (((ctx->howoften > 0) && (!(step % ctx->howoften))) || ((ctx->howoften == -1) && ts->reason)) { 2772 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 2773 } 2774 PetscFunctionReturn(0); 2775 } 2776 2777 #undef __FUNCT__ 2778 #define __FUNCT__ "TSMonitorLGCtxDestroy" 2779 /*@C 2780 TSMonitorLGCtxDestroy - Destroys a line graph context that was created 2781 with TSMonitorLGCtxCreate(). 2782 2783 Collective on TSMonitorLGCtx 2784 2785 Input Parameter: 2786 . ctx - the monitor context 2787 2788 Level: intermediate 2789 2790 .keywords: TS, monitor, line graph, destroy 2791 2792 .seealso: TSMonitorLGCtxCreate(), TSMonitorSet(), TSMonitorLGTimeStep(); 2793 @*/ 2794 PetscErrorCode TSMonitorLGCtxDestroy(TSMonitorLGCtx *ctx) 2795 { 2796 PetscDraw draw; 2797 PetscErrorCode ierr; 2798 2799 PetscFunctionBegin; 2800 ierr = PetscDrawLGGetDraw((*ctx)->lg,&draw);CHKERRQ(ierr); 2801 ierr = PetscDrawDestroy(&draw);CHKERRQ(ierr); 2802 ierr = PetscDrawLGDestroy(&(*ctx)->lg);CHKERRQ(ierr); 2803 ierr = PetscFree(*ctx);CHKERRQ(ierr); 2804 PetscFunctionReturn(0); 2805 } 2806 2807 #undef __FUNCT__ 2808 #define __FUNCT__ "TSGetTime" 2809 /*@ 2810 TSGetTime - Gets the time of the most recently completed step. 2811 2812 Not Collective 2813 2814 Input Parameter: 2815 . ts - the TS context obtained from TSCreate() 2816 2817 Output Parameter: 2818 . t - the current time 2819 2820 Level: beginner 2821 2822 Note: 2823 When called during time step evaluation (e.g. during residual evaluation or via hooks set using TSSetPreStep(), 2824 TSSetPreStage(), or TSSetPostStep()), the time is the time at the start of the step being evaluated. 2825 2826 .seealso: TSSetInitialTimeStep(), TSGetTimeStep() 2827 2828 .keywords: TS, get, time 2829 @*/ 2830 PetscErrorCode TSGetTime(TS ts,PetscReal *t) 2831 { 2832 PetscFunctionBegin; 2833 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2834 PetscValidRealPointer(t,2); 2835 *t = ts->ptime; 2836 PetscFunctionReturn(0); 2837 } 2838 2839 #undef __FUNCT__ 2840 #define __FUNCT__ "TSSetTime" 2841 /*@ 2842 TSSetTime - Allows one to reset the time. 2843 2844 Logically Collective on TS 2845 2846 Input Parameters: 2847 + ts - the TS context obtained from TSCreate() 2848 - time - the time 2849 2850 Level: intermediate 2851 2852 .seealso: TSGetTime(), TSSetDuration() 2853 2854 .keywords: TS, set, time 2855 @*/ 2856 PetscErrorCode TSSetTime(TS ts, PetscReal t) 2857 { 2858 PetscFunctionBegin; 2859 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2860 PetscValidLogicalCollectiveReal(ts,t,2); 2861 ts->ptime = t; 2862 PetscFunctionReturn(0); 2863 } 2864 2865 #undef __FUNCT__ 2866 #define __FUNCT__ "TSSetOptionsPrefix" 2867 /*@C 2868 TSSetOptionsPrefix - Sets the prefix used for searching for all 2869 TS options in the database. 2870 2871 Logically Collective on TS 2872 2873 Input Parameter: 2874 + ts - The TS context 2875 - prefix - The prefix to prepend to all option names 2876 2877 Notes: 2878 A hyphen (-) must NOT be given at the beginning of the prefix name. 2879 The first character of all runtime options is AUTOMATICALLY the 2880 hyphen. 2881 2882 Level: advanced 2883 2884 .keywords: TS, set, options, prefix, database 2885 2886 .seealso: TSSetFromOptions() 2887 2888 @*/ 2889 PetscErrorCode TSSetOptionsPrefix(TS ts,const char prefix[]) 2890 { 2891 PetscErrorCode ierr; 2892 SNES snes; 2893 2894 PetscFunctionBegin; 2895 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2896 ierr = PetscObjectSetOptionsPrefix((PetscObject)ts,prefix);CHKERRQ(ierr); 2897 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 2898 ierr = SNESSetOptionsPrefix(snes,prefix);CHKERRQ(ierr); 2899 PetscFunctionReturn(0); 2900 } 2901 2902 2903 #undef __FUNCT__ 2904 #define __FUNCT__ "TSAppendOptionsPrefix" 2905 /*@C 2906 TSAppendOptionsPrefix - Appends to the prefix used for searching for all 2907 TS options in the database. 2908 2909 Logically Collective on TS 2910 2911 Input Parameter: 2912 + ts - The TS context 2913 - prefix - The prefix to prepend to all option names 2914 2915 Notes: 2916 A hyphen (-) must NOT be given at the beginning of the prefix name. 2917 The first character of all runtime options is AUTOMATICALLY the 2918 hyphen. 2919 2920 Level: advanced 2921 2922 .keywords: TS, append, options, prefix, database 2923 2924 .seealso: TSGetOptionsPrefix() 2925 2926 @*/ 2927 PetscErrorCode TSAppendOptionsPrefix(TS ts,const char prefix[]) 2928 { 2929 PetscErrorCode ierr; 2930 SNES snes; 2931 2932 PetscFunctionBegin; 2933 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2934 ierr = PetscObjectAppendOptionsPrefix((PetscObject)ts,prefix);CHKERRQ(ierr); 2935 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 2936 ierr = SNESAppendOptionsPrefix(snes,prefix);CHKERRQ(ierr); 2937 PetscFunctionReturn(0); 2938 } 2939 2940 #undef __FUNCT__ 2941 #define __FUNCT__ "TSGetOptionsPrefix" 2942 /*@C 2943 TSGetOptionsPrefix - Sets the prefix used for searching for all 2944 TS options in the database. 2945 2946 Not Collective 2947 2948 Input Parameter: 2949 . ts - The TS context 2950 2951 Output Parameter: 2952 . prefix - A pointer to the prefix string used 2953 2954 Notes: On the fortran side, the user should pass in a string 'prifix' of 2955 sufficient length to hold the prefix. 2956 2957 Level: intermediate 2958 2959 .keywords: TS, get, options, prefix, database 2960 2961 .seealso: TSAppendOptionsPrefix() 2962 @*/ 2963 PetscErrorCode TSGetOptionsPrefix(TS ts,const char *prefix[]) 2964 { 2965 PetscErrorCode ierr; 2966 2967 PetscFunctionBegin; 2968 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2969 PetscValidPointer(prefix,2); 2970 ierr = PetscObjectGetOptionsPrefix((PetscObject)ts,prefix);CHKERRQ(ierr); 2971 PetscFunctionReturn(0); 2972 } 2973 2974 #undef __FUNCT__ 2975 #define __FUNCT__ "TSGetRHSJacobian" 2976 /*@C 2977 TSGetRHSJacobian - Returns the Jacobian J at the present timestep. 2978 2979 Not Collective, but parallel objects are returned if TS is parallel 2980 2981 Input Parameter: 2982 . ts - The TS context obtained from TSCreate() 2983 2984 Output Parameters: 2985 + Amat - The (approximate) Jacobian J of G, where U_t = G(U,t) (or NULL) 2986 . Pmat - The matrix from which the preconditioner is constructed, usually the same as Amat (or NULL) 2987 . func - Function to compute the Jacobian of the RHS (or NULL) 2988 - ctx - User-defined context for Jacobian evaluation routine (or NULL) 2989 2990 Notes: You can pass in NULL for any return argument you do not need. 2991 2992 Level: intermediate 2993 2994 .seealso: TSGetTimeStep(), TSGetMatrices(), TSGetTime(), TSGetTimeStepNumber() 2995 2996 .keywords: TS, timestep, get, matrix, Jacobian 2997 @*/ 2998 PetscErrorCode TSGetRHSJacobian(TS ts,Mat *Amat,Mat *Pmat,TSRHSJacobian *func,void **ctx) 2999 { 3000 PetscErrorCode ierr; 3001 SNES snes; 3002 DM dm; 3003 3004 PetscFunctionBegin; 3005 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 3006 ierr = SNESGetJacobian(snes,Amat,Pmat,NULL,NULL);CHKERRQ(ierr); 3007 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 3008 ierr = DMTSGetRHSJacobian(dm,func,ctx);CHKERRQ(ierr); 3009 PetscFunctionReturn(0); 3010 } 3011 3012 #undef __FUNCT__ 3013 #define __FUNCT__ "TSGetIJacobian" 3014 /*@C 3015 TSGetIJacobian - Returns the implicit Jacobian at the present timestep. 3016 3017 Not Collective, but parallel objects are returned if TS is parallel 3018 3019 Input Parameter: 3020 . ts - The TS context obtained from TSCreate() 3021 3022 Output Parameters: 3023 + Amat - The (approximate) Jacobian of F(t,U,U_t) 3024 . Pmat - The matrix from which the preconditioner is constructed, often the same as Amat 3025 . f - The function to compute the matrices 3026 - ctx - User-defined context for Jacobian evaluation routine 3027 3028 Notes: You can pass in NULL for any return argument you do not need. 3029 3030 Level: advanced 3031 3032 .seealso: TSGetTimeStep(), TSGetRHSJacobian(), TSGetMatrices(), TSGetTime(), TSGetTimeStepNumber() 3033 3034 .keywords: TS, timestep, get, matrix, Jacobian 3035 @*/ 3036 PetscErrorCode TSGetIJacobian(TS ts,Mat *Amat,Mat *Pmat,TSIJacobian *f,void **ctx) 3037 { 3038 PetscErrorCode ierr; 3039 SNES snes; 3040 DM dm; 3041 3042 PetscFunctionBegin; 3043 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 3044 ierr = SNESSetUpMatrices(snes);CHKERRQ(ierr); 3045 ierr = SNESGetJacobian(snes,Amat,Pmat,NULL,NULL);CHKERRQ(ierr); 3046 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 3047 ierr = DMTSGetIJacobian(dm,f,ctx);CHKERRQ(ierr); 3048 PetscFunctionReturn(0); 3049 } 3050 3051 3052 #undef __FUNCT__ 3053 #define __FUNCT__ "TSMonitorDrawSolution" 3054 /*@C 3055 TSMonitorDrawSolution - Monitors progress of the TS solvers by calling 3056 VecView() for the solution at each timestep 3057 3058 Collective on TS 3059 3060 Input Parameters: 3061 + ts - the TS context 3062 . step - current time-step 3063 . ptime - current time 3064 - dummy - either a viewer or NULL 3065 3066 Options Database: 3067 . -ts_monitor_draw_solution_initial - show initial solution as well as current solution 3068 3069 Notes: the initial solution and current solution are not displayed with a common axis scaling so generally the option -ts_monitor_draw_solution_initial 3070 will look bad 3071 3072 Level: intermediate 3073 3074 .keywords: TS, vector, monitor, view 3075 3076 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 3077 @*/ 3078 PetscErrorCode TSMonitorDrawSolution(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dummy) 3079 { 3080 PetscErrorCode ierr; 3081 TSMonitorDrawCtx ictx = (TSMonitorDrawCtx)dummy; 3082 PetscDraw draw; 3083 3084 PetscFunctionBegin; 3085 if (!step && ictx->showinitial) { 3086 if (!ictx->initialsolution) { 3087 ierr = VecDuplicate(u,&ictx->initialsolution);CHKERRQ(ierr); 3088 } 3089 ierr = VecCopy(u,ictx->initialsolution);CHKERRQ(ierr); 3090 } 3091 if (!(((ictx->howoften > 0) && (!(step % ictx->howoften))) || ((ictx->howoften == -1) && ts->reason))) PetscFunctionReturn(0); 3092 3093 if (ictx->showinitial) { 3094 PetscReal pause; 3095 ierr = PetscViewerDrawGetPause(ictx->viewer,&pause);CHKERRQ(ierr); 3096 ierr = PetscViewerDrawSetPause(ictx->viewer,0.0);CHKERRQ(ierr); 3097 ierr = VecView(ictx->initialsolution,ictx->viewer);CHKERRQ(ierr); 3098 ierr = PetscViewerDrawSetPause(ictx->viewer,pause);CHKERRQ(ierr); 3099 ierr = PetscViewerDrawSetHold(ictx->viewer,PETSC_TRUE);CHKERRQ(ierr); 3100 } 3101 ierr = VecView(u,ictx->viewer);CHKERRQ(ierr); 3102 if (ictx->showtimestepandtime) { 3103 PetscReal xl,yl,xr,yr,tw,w,h; 3104 char time[32]; 3105 size_t len; 3106 3107 ierr = PetscViewerDrawGetDraw(ictx->viewer,0,&draw);CHKERRQ(ierr); 3108 ierr = PetscSNPrintf(time,32,"Timestep %d Time %f",(int)step,(double)ptime);CHKERRQ(ierr); 3109 ierr = PetscDrawGetCoordinates(draw,&xl,&yl,&xr,&yr);CHKERRQ(ierr); 3110 ierr = PetscStrlen(time,&len);CHKERRQ(ierr); 3111 ierr = PetscDrawStringGetSize(draw,&tw,NULL);CHKERRQ(ierr); 3112 w = xl + .5*(xr - xl) - .5*len*tw; 3113 h = yl + .95*(yr - yl); 3114 ierr = PetscDrawString(draw,w,h,PETSC_DRAW_BLACK,time);CHKERRQ(ierr); 3115 ierr = PetscDrawFlush(draw);CHKERRQ(ierr); 3116 } 3117 3118 if (ictx->showinitial) { 3119 ierr = PetscViewerDrawSetHold(ictx->viewer,PETSC_FALSE);CHKERRQ(ierr); 3120 } 3121 PetscFunctionReturn(0); 3122 } 3123 3124 #undef __FUNCT__ 3125 #define __FUNCT__ "TSMonitorDrawSolutionPhase" 3126 /*@C 3127 TSMonitorDrawSolutionPhase - Monitors progress of the TS solvers by plotting the solution as a phase diagram 3128 3129 Collective on TS 3130 3131 Input Parameters: 3132 + ts - the TS context 3133 . step - current time-step 3134 . ptime - current time 3135 - dummy - either a viewer or NULL 3136 3137 Level: intermediate 3138 3139 .keywords: TS, vector, monitor, view 3140 3141 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 3142 @*/ 3143 PetscErrorCode TSMonitorDrawSolutionPhase(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dummy) 3144 { 3145 PetscErrorCode ierr; 3146 TSMonitorDrawCtx ictx = (TSMonitorDrawCtx)dummy; 3147 PetscDraw draw; 3148 MPI_Comm comm; 3149 PetscInt n; 3150 PetscMPIInt size; 3151 PetscReal xl,yl,xr,yr,tw,w,h; 3152 char time[32]; 3153 size_t len; 3154 const PetscScalar *U; 3155 3156 PetscFunctionBegin; 3157 ierr = PetscObjectGetComm((PetscObject)ts,&comm);CHKERRQ(ierr); 3158 ierr = MPI_Comm_size(comm,&size);CHKERRQ(ierr); 3159 if (size != 1) SETERRQ(comm,PETSC_ERR_SUP,"Only allowed for sequential runs"); 3160 ierr = VecGetSize(u,&n);CHKERRQ(ierr); 3161 if (n != 2) SETERRQ(comm,PETSC_ERR_SUP,"Only for ODEs with two unknowns"); 3162 3163 ierr = PetscViewerDrawGetDraw(ictx->viewer,0,&draw);CHKERRQ(ierr); 3164 3165 ierr = VecGetArrayRead(u,&U);CHKERRQ(ierr); 3166 ierr = PetscDrawAxisGetLimits(ictx->axis,&xl,&xr,&yl,&yr);CHKERRQ(ierr); 3167 if ((PetscRealPart(U[0]) < xl) || (PetscRealPart(U[1]) < yl) || (PetscRealPart(U[0]) > xr) || (PetscRealPart(U[1]) > yr)) { 3168 ierr = VecRestoreArrayRead(u,&U);CHKERRQ(ierr); 3169 PetscFunctionReturn(0); 3170 } 3171 if (!step) ictx->color++; 3172 ierr = PetscDrawPoint(draw,PetscRealPart(U[0]),PetscRealPart(U[1]),ictx->color);CHKERRQ(ierr); 3173 ierr = VecRestoreArrayRead(u,&U);CHKERRQ(ierr); 3174 3175 if (ictx->showtimestepandtime) { 3176 ierr = PetscDrawGetCoordinates(draw,&xl,&yl,&xr,&yr);CHKERRQ(ierr); 3177 ierr = PetscSNPrintf(time,32,"Timestep %d Time %f",(int)step,(double)ptime);CHKERRQ(ierr); 3178 ierr = PetscStrlen(time,&len);CHKERRQ(ierr); 3179 ierr = PetscDrawStringGetSize(draw,&tw,NULL);CHKERRQ(ierr); 3180 w = xl + .5*(xr - xl) - .5*len*tw; 3181 h = yl + .95*(yr - yl); 3182 ierr = PetscDrawString(draw,w,h,PETSC_DRAW_BLACK,time);CHKERRQ(ierr); 3183 } 3184 ierr = PetscDrawFlush(draw);CHKERRQ(ierr); 3185 PetscFunctionReturn(0); 3186 } 3187 3188 3189 #undef __FUNCT__ 3190 #define __FUNCT__ "TSMonitorDrawCtxDestroy" 3191 /*@C 3192 TSMonitorDrawCtxDestroy - Destroys the monitor context for TSMonitorDrawSolution() 3193 3194 Collective on TS 3195 3196 Input Parameters: 3197 . ctx - the monitor context 3198 3199 Level: intermediate 3200 3201 .keywords: TS, vector, monitor, view 3202 3203 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorDrawSolution(), TSMonitorDrawError() 3204 @*/ 3205 PetscErrorCode TSMonitorDrawCtxDestroy(TSMonitorDrawCtx *ictx) 3206 { 3207 PetscErrorCode ierr; 3208 3209 PetscFunctionBegin; 3210 ierr = PetscDrawAxisDestroy(&(*ictx)->axis);CHKERRQ(ierr); 3211 ierr = PetscViewerDestroy(&(*ictx)->viewer);CHKERRQ(ierr); 3212 ierr = VecDestroy(&(*ictx)->initialsolution);CHKERRQ(ierr); 3213 ierr = PetscFree(*ictx);CHKERRQ(ierr); 3214 PetscFunctionReturn(0); 3215 } 3216 3217 #undef __FUNCT__ 3218 #define __FUNCT__ "TSMonitorDrawCtxCreate" 3219 /*@C 3220 TSMonitorDrawCtxCreate - Creates the monitor context for TSMonitorDrawCtx 3221 3222 Collective on TS 3223 3224 Input Parameter: 3225 . ts - time-step context 3226 3227 Output Patameter: 3228 . ctx - the monitor context 3229 3230 Options Database: 3231 . -ts_monitor_draw_solution_initial - show initial solution as well as current solution 3232 3233 Level: intermediate 3234 3235 .keywords: TS, vector, monitor, view 3236 3237 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorDrawCtx() 3238 @*/ 3239 PetscErrorCode TSMonitorDrawCtxCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscInt howoften,TSMonitorDrawCtx *ctx) 3240 { 3241 PetscErrorCode ierr; 3242 3243 PetscFunctionBegin; 3244 ierr = PetscNew(struct _n_TSMonitorDrawCtx,ctx);CHKERRQ(ierr); 3245 ierr = PetscViewerDrawOpen(comm,host,label,x,y,m,n,&(*ctx)->viewer);CHKERRQ(ierr); 3246 ierr = PetscViewerSetFromOptions((*ctx)->viewer);CHKERRQ(ierr); 3247 3248 (*ctx)->howoften = howoften; 3249 (*ctx)->showinitial = PETSC_FALSE; 3250 ierr = PetscOptionsGetBool(NULL,"-ts_monitor_draw_solution_initial",&(*ctx)->showinitial,NULL);CHKERRQ(ierr); 3251 3252 (*ctx)->showtimestepandtime = PETSC_FALSE; 3253 ierr = PetscOptionsGetBool(NULL,"-ts_monitor_draw_solution_show_time",&(*ctx)->showtimestepandtime,NULL);CHKERRQ(ierr); 3254 (*ctx)->color = PETSC_DRAW_WHITE; 3255 PetscFunctionReturn(0); 3256 } 3257 3258 #undef __FUNCT__ 3259 #define __FUNCT__ "TSMonitorDrawError" 3260 /*@C 3261 TSMonitorDrawError - Monitors progress of the TS solvers by calling 3262 VecView() for the error at each timestep 3263 3264 Collective on TS 3265 3266 Input Parameters: 3267 + ts - the TS context 3268 . step - current time-step 3269 . ptime - current time 3270 - dummy - either a viewer or NULL 3271 3272 Level: intermediate 3273 3274 .keywords: TS, vector, monitor, view 3275 3276 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 3277 @*/ 3278 PetscErrorCode TSMonitorDrawError(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dummy) 3279 { 3280 PetscErrorCode ierr; 3281 TSMonitorDrawCtx ctx = (TSMonitorDrawCtx)dummy; 3282 PetscViewer viewer = ctx->viewer; 3283 Vec work; 3284 3285 PetscFunctionBegin; 3286 if (!(((ctx->howoften > 0) && (!(step % ctx->howoften))) || ((ctx->howoften == -1) && ts->reason))) PetscFunctionReturn(0); 3287 ierr = VecDuplicate(u,&work);CHKERRQ(ierr); 3288 ierr = TSComputeSolutionFunction(ts,ptime,work);CHKERRQ(ierr); 3289 ierr = VecAXPY(work,-1.0,u);CHKERRQ(ierr); 3290 ierr = VecView(work,viewer);CHKERRQ(ierr); 3291 ierr = VecDestroy(&work);CHKERRQ(ierr); 3292 PetscFunctionReturn(0); 3293 } 3294 3295 #include <petsc-private/dmimpl.h> 3296 #undef __FUNCT__ 3297 #define __FUNCT__ "TSSetDM" 3298 /*@ 3299 TSSetDM - Sets the DM that may be used by some preconditioners 3300 3301 Logically Collective on TS and DM 3302 3303 Input Parameters: 3304 + ts - the preconditioner context 3305 - dm - the dm 3306 3307 Level: intermediate 3308 3309 3310 .seealso: TSGetDM(), SNESSetDM(), SNESGetDM() 3311 @*/ 3312 PetscErrorCode TSSetDM(TS ts,DM dm) 3313 { 3314 PetscErrorCode ierr; 3315 SNES snes; 3316 DMTS tsdm; 3317 3318 PetscFunctionBegin; 3319 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3320 ierr = PetscObjectReference((PetscObject)dm);CHKERRQ(ierr); 3321 if (ts->dm) { /* Move the DMTS context over to the new DM unless the new DM already has one */ 3322 if (ts->dm->dmts && !dm->dmts) { 3323 ierr = DMCopyDMTS(ts->dm,dm);CHKERRQ(ierr); 3324 ierr = DMGetDMTS(ts->dm,&tsdm);CHKERRQ(ierr); 3325 if (tsdm->originaldm == ts->dm) { /* Grant write privileges to the replacement DM */ 3326 tsdm->originaldm = dm; 3327 } 3328 } 3329 ierr = DMDestroy(&ts->dm);CHKERRQ(ierr); 3330 } 3331 ts->dm = dm; 3332 3333 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 3334 ierr = SNESSetDM(snes,dm);CHKERRQ(ierr); 3335 PetscFunctionReturn(0); 3336 } 3337 3338 #undef __FUNCT__ 3339 #define __FUNCT__ "TSGetDM" 3340 /*@ 3341 TSGetDM - Gets the DM that may be used by some preconditioners 3342 3343 Not Collective 3344 3345 Input Parameter: 3346 . ts - the preconditioner context 3347 3348 Output Parameter: 3349 . dm - the dm 3350 3351 Level: intermediate 3352 3353 3354 .seealso: TSSetDM(), SNESSetDM(), SNESGetDM() 3355 @*/ 3356 PetscErrorCode TSGetDM(TS ts,DM *dm) 3357 { 3358 PetscErrorCode ierr; 3359 3360 PetscFunctionBegin; 3361 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3362 if (!ts->dm) { 3363 ierr = DMShellCreate(PetscObjectComm((PetscObject)ts),&ts->dm);CHKERRQ(ierr); 3364 if (ts->snes) {ierr = SNESSetDM(ts->snes,ts->dm);CHKERRQ(ierr);} 3365 } 3366 *dm = ts->dm; 3367 PetscFunctionReturn(0); 3368 } 3369 3370 #undef __FUNCT__ 3371 #define __FUNCT__ "SNESTSFormFunction" 3372 /*@ 3373 SNESTSFormFunction - Function to evaluate nonlinear residual 3374 3375 Logically Collective on SNES 3376 3377 Input Parameter: 3378 + snes - nonlinear solver 3379 . U - the current state at which to evaluate the residual 3380 - ctx - user context, must be a TS 3381 3382 Output Parameter: 3383 . F - the nonlinear residual 3384 3385 Notes: 3386 This function is not normally called by users and is automatically registered with the SNES used by TS. 3387 It is most frequently passed to MatFDColoringSetFunction(). 3388 3389 Level: advanced 3390 3391 .seealso: SNESSetFunction(), MatFDColoringSetFunction() 3392 @*/ 3393 PetscErrorCode SNESTSFormFunction(SNES snes,Vec U,Vec F,void *ctx) 3394 { 3395 TS ts = (TS)ctx; 3396 PetscErrorCode ierr; 3397 3398 PetscFunctionBegin; 3399 PetscValidHeaderSpecific(snes,SNES_CLASSID,1); 3400 PetscValidHeaderSpecific(U,VEC_CLASSID,2); 3401 PetscValidHeaderSpecific(F,VEC_CLASSID,3); 3402 PetscValidHeaderSpecific(ts,TS_CLASSID,4); 3403 ierr = (ts->ops->snesfunction)(snes,U,F,ts);CHKERRQ(ierr); 3404 PetscFunctionReturn(0); 3405 } 3406 3407 #undef __FUNCT__ 3408 #define __FUNCT__ "SNESTSFormJacobian" 3409 /*@ 3410 SNESTSFormJacobian - Function to evaluate the Jacobian 3411 3412 Collective on SNES 3413 3414 Input Parameter: 3415 + snes - nonlinear solver 3416 . U - the current state at which to evaluate the residual 3417 - ctx - user context, must be a TS 3418 3419 Output Parameter: 3420 + A - the Jacobian 3421 . B - the preconditioning matrix (may be the same as A) 3422 - flag - indicates any structure change in the matrix 3423 3424 Notes: 3425 This function is not normally called by users and is automatically registered with the SNES used by TS. 3426 3427 Level: developer 3428 3429 .seealso: SNESSetJacobian() 3430 @*/ 3431 PetscErrorCode SNESTSFormJacobian(SNES snes,Vec U,Mat *A,Mat *B,MatStructure *flag,void *ctx) 3432 { 3433 TS ts = (TS)ctx; 3434 PetscErrorCode ierr; 3435 3436 PetscFunctionBegin; 3437 PetscValidHeaderSpecific(snes,SNES_CLASSID,1); 3438 PetscValidHeaderSpecific(U,VEC_CLASSID,2); 3439 PetscValidPointer(A,3); 3440 PetscValidHeaderSpecific(*A,MAT_CLASSID,3); 3441 PetscValidPointer(B,4); 3442 PetscValidHeaderSpecific(*B,MAT_CLASSID,4); 3443 PetscValidPointer(flag,5); 3444 PetscValidHeaderSpecific(ts,TS_CLASSID,6); 3445 ierr = (ts->ops->snesjacobian)(snes,U,A,B,flag,ts);CHKERRQ(ierr); 3446 PetscFunctionReturn(0); 3447 } 3448 3449 #undef __FUNCT__ 3450 #define __FUNCT__ "TSComputeRHSFunctionLinear" 3451 /*@C 3452 TSComputeRHSFunctionLinear - Evaluate the right hand side via the user-provided Jacobian, for linear problems only 3453 3454 Collective on TS 3455 3456 Input Arguments: 3457 + ts - time stepping context 3458 . t - time at which to evaluate 3459 . U - state at which to evaluate 3460 - ctx - context 3461 3462 Output Arguments: 3463 . F - right hand side 3464 3465 Level: intermediate 3466 3467 Notes: 3468 This function is intended to be passed to TSSetRHSFunction() to evaluate the right hand side for linear problems. 3469 The matrix (and optionally the evaluation context) should be passed to TSSetRHSJacobian(). 3470 3471 .seealso: TSSetRHSFunction(), TSSetRHSJacobian(), TSComputeRHSJacobianConstant() 3472 @*/ 3473 PetscErrorCode TSComputeRHSFunctionLinear(TS ts,PetscReal t,Vec U,Vec F,void *ctx) 3474 { 3475 PetscErrorCode ierr; 3476 Mat Arhs,Brhs; 3477 MatStructure flg2; 3478 3479 PetscFunctionBegin; 3480 ierr = TSGetRHSMats_Private(ts,&Arhs,&Brhs);CHKERRQ(ierr); 3481 ierr = TSComputeRHSJacobian(ts,t,U,&Arhs,&Brhs,&flg2);CHKERRQ(ierr); 3482 ierr = MatMult(Arhs,U,F);CHKERRQ(ierr); 3483 PetscFunctionReturn(0); 3484 } 3485 3486 #undef __FUNCT__ 3487 #define __FUNCT__ "TSComputeRHSJacobianConstant" 3488 /*@C 3489 TSComputeRHSJacobianConstant - Reuses a Jacobian that is time-independent. 3490 3491 Collective on TS 3492 3493 Input Arguments: 3494 + ts - time stepping context 3495 . t - time at which to evaluate 3496 . U - state at which to evaluate 3497 - ctx - context 3498 3499 Output Arguments: 3500 + A - pointer to operator 3501 . B - pointer to preconditioning matrix 3502 - flg - matrix structure flag 3503 3504 Level: intermediate 3505 3506 Notes: 3507 This function is intended to be passed to TSSetRHSJacobian() to evaluate the Jacobian for linear time-independent problems. 3508 3509 .seealso: TSSetRHSFunction(), TSSetRHSJacobian(), TSComputeRHSFunctionLinear() 3510 @*/ 3511 PetscErrorCode TSComputeRHSJacobianConstant(TS ts,PetscReal t,Vec U,Mat *A,Mat *B,MatStructure *flg,void *ctx) 3512 { 3513 PetscFunctionBegin; 3514 *flg = SAME_PRECONDITIONER; 3515 PetscFunctionReturn(0); 3516 } 3517 3518 #undef __FUNCT__ 3519 #define __FUNCT__ "TSComputeIFunctionLinear" 3520 /*@C 3521 TSComputeIFunctionLinear - Evaluate the left hand side via the user-provided Jacobian, for linear problems only 3522 3523 Collective on TS 3524 3525 Input Arguments: 3526 + ts - time stepping context 3527 . t - time at which to evaluate 3528 . U - state at which to evaluate 3529 . Udot - time derivative of state vector 3530 - ctx - context 3531 3532 Output Arguments: 3533 . F - left hand side 3534 3535 Level: intermediate 3536 3537 Notes: 3538 The assumption here is that the left hand side is of the form A*Udot (and not A*Udot + B*U). For other cases, the 3539 user is required to write their own TSComputeIFunction. 3540 This function is intended to be passed to TSSetIFunction() to evaluate the left hand side for linear problems. 3541 The matrix (and optionally the evaluation context) should be passed to TSSetIJacobian(). 3542 3543 .seealso: TSSetIFunction(), TSSetIJacobian(), TSComputeIJacobianConstant() 3544 @*/ 3545 PetscErrorCode TSComputeIFunctionLinear(TS ts,PetscReal t,Vec U,Vec Udot,Vec F,void *ctx) 3546 { 3547 PetscErrorCode ierr; 3548 Mat A,B; 3549 MatStructure flg2; 3550 3551 PetscFunctionBegin; 3552 ierr = TSGetIJacobian(ts,&A,&B,NULL,NULL);CHKERRQ(ierr); 3553 ierr = TSComputeIJacobian(ts,t,U,Udot,1.0,&A,&B,&flg2,PETSC_TRUE);CHKERRQ(ierr); 3554 ierr = MatMult(A,Udot,F);CHKERRQ(ierr); 3555 PetscFunctionReturn(0); 3556 } 3557 3558 #undef __FUNCT__ 3559 #define __FUNCT__ "TSComputeIJacobianConstant" 3560 /*@C 3561 TSComputeIJacobianConstant - Reuses a time-independent for a semi-implicit DAE or ODE 3562 3563 Collective on TS 3564 3565 Input Arguments: 3566 + ts - time stepping context 3567 . t - time at which to evaluate 3568 . U - state at which to evaluate 3569 . Udot - time derivative of state vector 3570 . shift - shift to apply 3571 - ctx - context 3572 3573 Output Arguments: 3574 + A - pointer to operator 3575 . B - pointer to preconditioning matrix 3576 - flg - matrix structure flag 3577 3578 Level: advanced 3579 3580 Notes: 3581 This function is intended to be passed to TSSetIJacobian() to evaluate the Jacobian for linear time-independent problems. 3582 3583 It is only appropriate for problems of the form 3584 3585 $ M Udot = F(U,t) 3586 3587 where M is constant and F is non-stiff. The user must pass M to TSSetIJacobian(). The current implementation only 3588 works with IMEX time integration methods such as TSROSW and TSARKIMEX, since there is no support for de-constructing 3589 an implicit operator of the form 3590 3591 $ shift*M + J 3592 3593 where J is the Jacobian of -F(U). Support may be added in a future version of PETSc, but for now, the user must store 3594 a copy of M or reassemble it when requested. 3595 3596 .seealso: TSSetIFunction(), TSSetIJacobian(), TSComputeIFunctionLinear() 3597 @*/ 3598 PetscErrorCode TSComputeIJacobianConstant(TS ts,PetscReal t,Vec U,Vec Udot,PetscReal shift,Mat *A,Mat *B,MatStructure *flg,void *ctx) 3599 { 3600 PetscErrorCode ierr; 3601 3602 PetscFunctionBegin; 3603 ierr = MatScale(*A, shift / ts->ijacobian.shift);CHKERRQ(ierr); 3604 ts->ijacobian.shift = shift; 3605 *flg = SAME_PRECONDITIONER; 3606 PetscFunctionReturn(0); 3607 } 3608 3609 #undef __FUNCT__ 3610 #define __FUNCT__ "TSGetEquationType" 3611 /*@ 3612 TSGetEquationType - Gets the type of the equation that TS is solving. 3613 3614 Not Collective 3615 3616 Input Parameter: 3617 . ts - the TS context 3618 3619 Output Parameter: 3620 . equation_type - see TSEquationType 3621 3622 Level: beginner 3623 3624 .keywords: TS, equation type 3625 3626 .seealso: TSSetEquationType(), TSEquationType 3627 @*/ 3628 PetscErrorCode TSGetEquationType(TS ts,TSEquationType *equation_type) 3629 { 3630 PetscFunctionBegin; 3631 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3632 PetscValidPointer(equation_type,2); 3633 *equation_type = ts->equation_type; 3634 PetscFunctionReturn(0); 3635 } 3636 3637 #undef __FUNCT__ 3638 #define __FUNCT__ "TSSetEquationType" 3639 /*@ 3640 TSSetEquationType - Sets the type of the equation that TS is solving. 3641 3642 Not Collective 3643 3644 Input Parameter: 3645 + ts - the TS context 3646 . equation_type - see TSEquationType 3647 3648 Level: advanced 3649 3650 .keywords: TS, equation type 3651 3652 .seealso: TSGetEquationType(), TSEquationType 3653 @*/ 3654 PetscErrorCode TSSetEquationType(TS ts,TSEquationType equation_type) 3655 { 3656 PetscFunctionBegin; 3657 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3658 ts->equation_type = equation_type; 3659 PetscFunctionReturn(0); 3660 } 3661 3662 #undef __FUNCT__ 3663 #define __FUNCT__ "TSGetConvergedReason" 3664 /*@ 3665 TSGetConvergedReason - Gets the reason the TS iteration was stopped. 3666 3667 Not Collective 3668 3669 Input Parameter: 3670 . ts - the TS context 3671 3672 Output Parameter: 3673 . reason - negative value indicates diverged, positive value converged, see TSConvergedReason or the 3674 manual pages for the individual convergence tests for complete lists 3675 3676 Level: beginner 3677 3678 Notes: 3679 Can only be called after the call to TSSolve() is complete. 3680 3681 .keywords: TS, nonlinear, set, convergence, test 3682 3683 .seealso: TSSetConvergenceTest(), TSConvergedReason 3684 @*/ 3685 PetscErrorCode TSGetConvergedReason(TS ts,TSConvergedReason *reason) 3686 { 3687 PetscFunctionBegin; 3688 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3689 PetscValidPointer(reason,2); 3690 *reason = ts->reason; 3691 PetscFunctionReturn(0); 3692 } 3693 3694 #undef __FUNCT__ 3695 #define __FUNCT__ "TSSetConvergedReason" 3696 /*@ 3697 TSSetConvergedReason - Sets the reason for handling the convergence of TSSolve. 3698 3699 Not Collective 3700 3701 Input Parameter: 3702 + ts - the TS context 3703 . reason - negative value indicates diverged, positive value converged, see TSConvergedReason or the 3704 manual pages for the individual convergence tests for complete lists 3705 3706 Level: advanced 3707 3708 Notes: 3709 Can only be called during TSSolve() is active. 3710 3711 .keywords: TS, nonlinear, set, convergence, test 3712 3713 .seealso: TSConvergedReason 3714 @*/ 3715 PetscErrorCode TSSetConvergedReason(TS ts,TSConvergedReason reason) 3716 { 3717 PetscFunctionBegin; 3718 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3719 ts->reason = reason; 3720 PetscFunctionReturn(0); 3721 } 3722 3723 #undef __FUNCT__ 3724 #define __FUNCT__ "TSGetSolveTime" 3725 /*@ 3726 TSGetSolveTime - Gets the time after a call to TSSolve() 3727 3728 Not Collective 3729 3730 Input Parameter: 3731 . ts - the TS context 3732 3733 Output Parameter: 3734 . ftime - the final time. This time should correspond to the final time set with TSSetDuration() 3735 3736 Level: beginner 3737 3738 Notes: 3739 Can only be called after the call to TSSolve() is complete. 3740 3741 .keywords: TS, nonlinear, set, convergence, test 3742 3743 .seealso: TSSetConvergenceTest(), TSConvergedReason 3744 @*/ 3745 PetscErrorCode TSGetSolveTime(TS ts,PetscReal *ftime) 3746 { 3747 PetscFunctionBegin; 3748 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3749 PetscValidPointer(ftime,2); 3750 *ftime = ts->solvetime; 3751 PetscFunctionReturn(0); 3752 } 3753 3754 #undef __FUNCT__ 3755 #define __FUNCT__ "TSGetSNESIterations" 3756 /*@ 3757 TSGetSNESIterations - Gets the total number of nonlinear iterations 3758 used by the time integrator. 3759 3760 Not Collective 3761 3762 Input Parameter: 3763 . ts - TS context 3764 3765 Output Parameter: 3766 . nits - number of nonlinear iterations 3767 3768 Notes: 3769 This counter is reset to zero for each successive call to TSSolve(). 3770 3771 Level: intermediate 3772 3773 .keywords: TS, get, number, nonlinear, iterations 3774 3775 .seealso: TSGetKSPIterations() 3776 @*/ 3777 PetscErrorCode TSGetSNESIterations(TS ts,PetscInt *nits) 3778 { 3779 PetscFunctionBegin; 3780 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3781 PetscValidIntPointer(nits,2); 3782 *nits = ts->snes_its; 3783 PetscFunctionReturn(0); 3784 } 3785 3786 #undef __FUNCT__ 3787 #define __FUNCT__ "TSGetKSPIterations" 3788 /*@ 3789 TSGetKSPIterations - Gets the total number of linear iterations 3790 used by the time integrator. 3791 3792 Not Collective 3793 3794 Input Parameter: 3795 . ts - TS context 3796 3797 Output Parameter: 3798 . lits - number of linear iterations 3799 3800 Notes: 3801 This counter is reset to zero for each successive call to TSSolve(). 3802 3803 Level: intermediate 3804 3805 .keywords: TS, get, number, linear, iterations 3806 3807 .seealso: TSGetSNESIterations(), SNESGetKSPIterations() 3808 @*/ 3809 PetscErrorCode TSGetKSPIterations(TS ts,PetscInt *lits) 3810 { 3811 PetscFunctionBegin; 3812 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3813 PetscValidIntPointer(lits,2); 3814 *lits = ts->ksp_its; 3815 PetscFunctionReturn(0); 3816 } 3817 3818 #undef __FUNCT__ 3819 #define __FUNCT__ "TSGetStepRejections" 3820 /*@ 3821 TSGetStepRejections - Gets the total number of rejected steps. 3822 3823 Not Collective 3824 3825 Input Parameter: 3826 . ts - TS context 3827 3828 Output Parameter: 3829 . rejects - number of steps rejected 3830 3831 Notes: 3832 This counter is reset to zero for each successive call to TSSolve(). 3833 3834 Level: intermediate 3835 3836 .keywords: TS, get, number 3837 3838 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxStepRejections(), TSGetSNESFailures(), TSSetMaxSNESFailures(), TSSetErrorIfStepFails() 3839 @*/ 3840 PetscErrorCode TSGetStepRejections(TS ts,PetscInt *rejects) 3841 { 3842 PetscFunctionBegin; 3843 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3844 PetscValidIntPointer(rejects,2); 3845 *rejects = ts->reject; 3846 PetscFunctionReturn(0); 3847 } 3848 3849 #undef __FUNCT__ 3850 #define __FUNCT__ "TSGetSNESFailures" 3851 /*@ 3852 TSGetSNESFailures - Gets the total number of failed SNES solves 3853 3854 Not Collective 3855 3856 Input Parameter: 3857 . ts - TS context 3858 3859 Output Parameter: 3860 . fails - number of failed nonlinear solves 3861 3862 Notes: 3863 This counter is reset to zero for each successive call to TSSolve(). 3864 3865 Level: intermediate 3866 3867 .keywords: TS, get, number 3868 3869 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxStepRejections(), TSGetStepRejections(), TSSetMaxSNESFailures() 3870 @*/ 3871 PetscErrorCode TSGetSNESFailures(TS ts,PetscInt *fails) 3872 { 3873 PetscFunctionBegin; 3874 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3875 PetscValidIntPointer(fails,2); 3876 *fails = ts->num_snes_failures; 3877 PetscFunctionReturn(0); 3878 } 3879 3880 #undef __FUNCT__ 3881 #define __FUNCT__ "TSSetMaxStepRejections" 3882 /*@ 3883 TSSetMaxStepRejections - Sets the maximum number of step rejections before a step fails 3884 3885 Not Collective 3886 3887 Input Parameter: 3888 + ts - TS context 3889 - rejects - maximum number of rejected steps, pass -1 for unlimited 3890 3891 Notes: 3892 The counter is reset to zero for each step 3893 3894 Options Database Key: 3895 . -ts_max_reject - Maximum number of step rejections before a step fails 3896 3897 Level: intermediate 3898 3899 .keywords: TS, set, maximum, number 3900 3901 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxSNESFailures(), TSGetStepRejections(), TSGetSNESFailures(), TSSetErrorIfStepFails(), TSGetConvergedReason() 3902 @*/ 3903 PetscErrorCode TSSetMaxStepRejections(TS ts,PetscInt rejects) 3904 { 3905 PetscFunctionBegin; 3906 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3907 ts->max_reject = rejects; 3908 PetscFunctionReturn(0); 3909 } 3910 3911 #undef __FUNCT__ 3912 #define __FUNCT__ "TSSetMaxSNESFailures" 3913 /*@ 3914 TSSetMaxSNESFailures - Sets the maximum number of failed SNES solves 3915 3916 Not Collective 3917 3918 Input Parameter: 3919 + ts - TS context 3920 - fails - maximum number of failed nonlinear solves, pass -1 for unlimited 3921 3922 Notes: 3923 The counter is reset to zero for each successive call to TSSolve(). 3924 3925 Options Database Key: 3926 . -ts_max_snes_failures - Maximum number of nonlinear solve failures 3927 3928 Level: intermediate 3929 3930 .keywords: TS, set, maximum, number 3931 3932 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxStepRejections(), TSGetStepRejections(), TSGetSNESFailures(), SNESGetConvergedReason(), TSGetConvergedReason() 3933 @*/ 3934 PetscErrorCode TSSetMaxSNESFailures(TS ts,PetscInt fails) 3935 { 3936 PetscFunctionBegin; 3937 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3938 ts->max_snes_failures = fails; 3939 PetscFunctionReturn(0); 3940 } 3941 3942 #undef __FUNCT__ 3943 #define __FUNCT__ "TSSetErrorIfStepFails()" 3944 /*@ 3945 TSSetErrorIfStepFails - Error if no step succeeds 3946 3947 Not Collective 3948 3949 Input Parameter: 3950 + ts - TS context 3951 - err - PETSC_TRUE to error if no step succeeds, PETSC_FALSE to return without failure 3952 3953 Options Database Key: 3954 . -ts_error_if_step_fails - Error if no step succeeds 3955 3956 Level: intermediate 3957 3958 .keywords: TS, set, error 3959 3960 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxStepRejections(), TSGetStepRejections(), TSGetSNESFailures(), TSSetErrorIfStepFails(), TSGetConvergedReason() 3961 @*/ 3962 PetscErrorCode TSSetErrorIfStepFails(TS ts,PetscBool err) 3963 { 3964 PetscFunctionBegin; 3965 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3966 ts->errorifstepfailed = err; 3967 PetscFunctionReturn(0); 3968 } 3969 3970 #undef __FUNCT__ 3971 #define __FUNCT__ "TSMonitorSolutionBinary" 3972 /*@C 3973 TSMonitorSolutionBinary - Monitors progress of the TS solvers by VecView() for the solution at each timestep. Normally the viewer is a binary file 3974 3975 Collective on TS 3976 3977 Input Parameters: 3978 + ts - the TS context 3979 . step - current time-step 3980 . ptime - current time 3981 . u - current state 3982 - viewer - binary viewer 3983 3984 Level: intermediate 3985 3986 .keywords: TS, vector, monitor, view 3987 3988 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 3989 @*/ 3990 PetscErrorCode TSMonitorSolutionBinary(TS ts,PetscInt step,PetscReal ptime,Vec u,void *viewer) 3991 { 3992 PetscErrorCode ierr; 3993 PetscViewer v = (PetscViewer)viewer; 3994 3995 PetscFunctionBegin; 3996 ierr = VecView(u,v);CHKERRQ(ierr); 3997 PetscFunctionReturn(0); 3998 } 3999 4000 #undef __FUNCT__ 4001 #define __FUNCT__ "TSMonitorSolutionVTK" 4002 /*@C 4003 TSMonitorSolutionVTK - Monitors progress of the TS solvers by VecView() for the solution at each timestep. 4004 4005 Collective on TS 4006 4007 Input Parameters: 4008 + ts - the TS context 4009 . step - current time-step 4010 . ptime - current time 4011 . u - current state 4012 - filenametemplate - string containing a format specifier for the integer time step (e.g. %03D) 4013 4014 Level: intermediate 4015 4016 Notes: 4017 The VTK format does not allow writing multiple time steps in the same file, therefore a different file will be written for each time step. 4018 These are named according to the file name template. 4019 4020 This function is normally passed as an argument to TSMonitorSet() along with TSMonitorSolutionVTKDestroy(). 4021 4022 .keywords: TS, vector, monitor, view 4023 4024 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 4025 @*/ 4026 PetscErrorCode TSMonitorSolutionVTK(TS ts,PetscInt step,PetscReal ptime,Vec u,void *filenametemplate) 4027 { 4028 PetscErrorCode ierr; 4029 char filename[PETSC_MAX_PATH_LEN]; 4030 PetscViewer viewer; 4031 4032 PetscFunctionBegin; 4033 ierr = PetscSNPrintf(filename,sizeof(filename),(const char*)filenametemplate,step);CHKERRQ(ierr); 4034 ierr = PetscViewerVTKOpen(PetscObjectComm((PetscObject)ts),filename,FILE_MODE_WRITE,&viewer);CHKERRQ(ierr); 4035 ierr = VecView(u,viewer);CHKERRQ(ierr); 4036 ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr); 4037 PetscFunctionReturn(0); 4038 } 4039 4040 #undef __FUNCT__ 4041 #define __FUNCT__ "TSMonitorSolutionVTKDestroy" 4042 /*@C 4043 TSMonitorSolutionVTKDestroy - Destroy context for monitoring 4044 4045 Collective on TS 4046 4047 Input Parameters: 4048 . filenametemplate - string containing a format specifier for the integer time step (e.g. %03D) 4049 4050 Level: intermediate 4051 4052 Note: 4053 This function is normally passed to TSMonitorSet() along with TSMonitorSolutionVTK(). 4054 4055 .keywords: TS, vector, monitor, view 4056 4057 .seealso: TSMonitorSet(), TSMonitorSolutionVTK() 4058 @*/ 4059 PetscErrorCode TSMonitorSolutionVTKDestroy(void *filenametemplate) 4060 { 4061 PetscErrorCode ierr; 4062 4063 PetscFunctionBegin; 4064 ierr = PetscFree(*(char**)filenametemplate);CHKERRQ(ierr); 4065 PetscFunctionReturn(0); 4066 } 4067 4068 #undef __FUNCT__ 4069 #define __FUNCT__ "TSGetAdapt" 4070 /*@ 4071 TSGetAdapt - Get the adaptive controller context for the current method 4072 4073 Collective on TS if controller has not been created yet 4074 4075 Input Arguments: 4076 . ts - time stepping context 4077 4078 Output Arguments: 4079 . adapt - adaptive controller 4080 4081 Level: intermediate 4082 4083 .seealso: TSAdapt, TSAdaptSetType(), TSAdaptChoose() 4084 @*/ 4085 PetscErrorCode TSGetAdapt(TS ts,TSAdapt *adapt) 4086 { 4087 PetscErrorCode ierr; 4088 4089 PetscFunctionBegin; 4090 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4091 PetscValidPointer(adapt,2); 4092 if (!ts->adapt) { 4093 ierr = TSAdaptCreate(PetscObjectComm((PetscObject)ts),&ts->adapt);CHKERRQ(ierr); 4094 ierr = PetscLogObjectParent(ts,ts->adapt);CHKERRQ(ierr); 4095 ierr = PetscObjectIncrementTabLevel((PetscObject)ts->adapt,(PetscObject)ts,1);CHKERRQ(ierr); 4096 } 4097 *adapt = ts->adapt; 4098 PetscFunctionReturn(0); 4099 } 4100 4101 #undef __FUNCT__ 4102 #define __FUNCT__ "TSSetTolerances" 4103 /*@ 4104 TSSetTolerances - Set tolerances for local truncation error when using adaptive controller 4105 4106 Logically Collective 4107 4108 Input Arguments: 4109 + ts - time integration context 4110 . atol - scalar absolute tolerances, PETSC_DECIDE to leave current value 4111 . vatol - vector of absolute tolerances or NULL, used in preference to atol if present 4112 . rtol - scalar relative tolerances, PETSC_DECIDE to leave current value 4113 - vrtol - vector of relative tolerances or NULL, used in preference to atol if present 4114 4115 Level: beginner 4116 4117 .seealso: TS, TSAdapt, TSVecNormWRMS(), TSGetTolerances() 4118 @*/ 4119 PetscErrorCode TSSetTolerances(TS ts,PetscReal atol,Vec vatol,PetscReal rtol,Vec vrtol) 4120 { 4121 PetscErrorCode ierr; 4122 4123 PetscFunctionBegin; 4124 if (atol != PETSC_DECIDE && atol != PETSC_DEFAULT) ts->atol = atol; 4125 if (vatol) { 4126 ierr = PetscObjectReference((PetscObject)vatol);CHKERRQ(ierr); 4127 ierr = VecDestroy(&ts->vatol);CHKERRQ(ierr); 4128 4129 ts->vatol = vatol; 4130 } 4131 if (rtol != PETSC_DECIDE && rtol != PETSC_DEFAULT) ts->rtol = rtol; 4132 if (vrtol) { 4133 ierr = PetscObjectReference((PetscObject)vrtol);CHKERRQ(ierr); 4134 ierr = VecDestroy(&ts->vrtol);CHKERRQ(ierr); 4135 4136 ts->vrtol = vrtol; 4137 } 4138 PetscFunctionReturn(0); 4139 } 4140 4141 #undef __FUNCT__ 4142 #define __FUNCT__ "TSGetTolerances" 4143 /*@ 4144 TSGetTolerances - Get tolerances for local truncation error when using adaptive controller 4145 4146 Logically Collective 4147 4148 Input Arguments: 4149 . ts - time integration context 4150 4151 Output Arguments: 4152 + atol - scalar absolute tolerances, NULL to ignore 4153 . vatol - vector of absolute tolerances, NULL to ignore 4154 . rtol - scalar relative tolerances, NULL to ignore 4155 - vrtol - vector of relative tolerances, NULL to ignore 4156 4157 Level: beginner 4158 4159 .seealso: TS, TSAdapt, TSVecNormWRMS(), TSSetTolerances() 4160 @*/ 4161 PetscErrorCode TSGetTolerances(TS ts,PetscReal *atol,Vec *vatol,PetscReal *rtol,Vec *vrtol) 4162 { 4163 PetscFunctionBegin; 4164 if (atol) *atol = ts->atol; 4165 if (vatol) *vatol = ts->vatol; 4166 if (rtol) *rtol = ts->rtol; 4167 if (vrtol) *vrtol = ts->vrtol; 4168 PetscFunctionReturn(0); 4169 } 4170 4171 #undef __FUNCT__ 4172 #define __FUNCT__ "TSErrorNormWRMS" 4173 /*@ 4174 TSErrorNormWRMS - compute a weighted norm of the difference between a vector and the current state 4175 4176 Collective on TS 4177 4178 Input Arguments: 4179 + ts - time stepping context 4180 - Y - state vector to be compared to ts->vec_sol 4181 4182 Output Arguments: 4183 . norm - weighted norm, a value of 1.0 is considered small 4184 4185 Level: developer 4186 4187 .seealso: TSSetTolerances() 4188 @*/ 4189 PetscErrorCode TSErrorNormWRMS(TS ts,Vec Y,PetscReal *norm) 4190 { 4191 PetscErrorCode ierr; 4192 PetscInt i,n,N; 4193 const PetscScalar *u,*y; 4194 Vec U; 4195 PetscReal sum,gsum; 4196 4197 PetscFunctionBegin; 4198 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4199 PetscValidHeaderSpecific(Y,VEC_CLASSID,2); 4200 PetscValidPointer(norm,3); 4201 U = ts->vec_sol; 4202 PetscCheckSameTypeAndComm(U,1,Y,2); 4203 if (U == Y) SETERRQ(PetscObjectComm((PetscObject)U),PETSC_ERR_ARG_IDN,"Y cannot be the TS solution vector"); 4204 4205 ierr = VecGetSize(U,&N);CHKERRQ(ierr); 4206 ierr = VecGetLocalSize(U,&n);CHKERRQ(ierr); 4207 ierr = VecGetArrayRead(U,&u);CHKERRQ(ierr); 4208 ierr = VecGetArrayRead(Y,&y);CHKERRQ(ierr); 4209 sum = 0.; 4210 if (ts->vatol && ts->vrtol) { 4211 const PetscScalar *atol,*rtol; 4212 ierr = VecGetArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 4213 ierr = VecGetArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 4214 for (i=0; i<n; i++) { 4215 PetscReal tol = PetscRealPart(atol[i]) + PetscRealPart(rtol[i]) * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 4216 sum += PetscSqr(PetscAbsScalar(y[i] - u[i]) / tol); 4217 } 4218 ierr = VecRestoreArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 4219 ierr = VecRestoreArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 4220 } else if (ts->vatol) { /* vector atol, scalar rtol */ 4221 const PetscScalar *atol; 4222 ierr = VecGetArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 4223 for (i=0; i<n; i++) { 4224 PetscReal tol = PetscRealPart(atol[i]) + ts->rtol * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 4225 sum += PetscSqr(PetscAbsScalar(y[i] - u[i]) / tol); 4226 } 4227 ierr = VecRestoreArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 4228 } else if (ts->vrtol) { /* scalar atol, vector rtol */ 4229 const PetscScalar *rtol; 4230 ierr = VecGetArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 4231 for (i=0; i<n; i++) { 4232 PetscReal tol = ts->atol + PetscRealPart(rtol[i]) * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 4233 sum += PetscSqr(PetscAbsScalar(y[i] - u[i]) / tol); 4234 } 4235 ierr = VecRestoreArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 4236 } else { /* scalar atol, scalar rtol */ 4237 for (i=0; i<n; i++) { 4238 PetscReal tol = ts->atol + ts->rtol * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 4239 sum += PetscSqr(PetscAbsScalar(y[i] - u[i]) / tol); 4240 } 4241 } 4242 ierr = VecRestoreArrayRead(U,&u);CHKERRQ(ierr); 4243 ierr = VecRestoreArrayRead(Y,&y);CHKERRQ(ierr); 4244 4245 ierr = MPI_Allreduce(&sum,&gsum,1,MPIU_REAL,MPIU_SUM,PetscObjectComm((PetscObject)ts));CHKERRQ(ierr); 4246 *norm = PetscSqrtReal(gsum / N); 4247 if (PetscIsInfOrNanScalar(*norm)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in norm"); 4248 PetscFunctionReturn(0); 4249 } 4250 4251 #undef __FUNCT__ 4252 #define __FUNCT__ "TSSetCFLTimeLocal" 4253 /*@ 4254 TSSetCFLTimeLocal - Set the local CFL constraint relative to forward Euler 4255 4256 Logically Collective on TS 4257 4258 Input Arguments: 4259 + ts - time stepping context 4260 - cfltime - maximum stable time step if using forward Euler (value can be different on each process) 4261 4262 Note: 4263 After calling this function, the global CFL time can be obtained by calling TSGetCFLTime() 4264 4265 Level: intermediate 4266 4267 .seealso: TSGetCFLTime(), TSADAPTCFL 4268 @*/ 4269 PetscErrorCode TSSetCFLTimeLocal(TS ts,PetscReal cfltime) 4270 { 4271 PetscFunctionBegin; 4272 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4273 ts->cfltime_local = cfltime; 4274 ts->cfltime = -1.; 4275 PetscFunctionReturn(0); 4276 } 4277 4278 #undef __FUNCT__ 4279 #define __FUNCT__ "TSGetCFLTime" 4280 /*@ 4281 TSGetCFLTime - Get the maximum stable time step according to CFL criteria applied to forward Euler 4282 4283 Collective on TS 4284 4285 Input Arguments: 4286 . ts - time stepping context 4287 4288 Output Arguments: 4289 . cfltime - maximum stable time step for forward Euler 4290 4291 Level: advanced 4292 4293 .seealso: TSSetCFLTimeLocal() 4294 @*/ 4295 PetscErrorCode TSGetCFLTime(TS ts,PetscReal *cfltime) 4296 { 4297 PetscErrorCode ierr; 4298 4299 PetscFunctionBegin; 4300 if (ts->cfltime < 0) { 4301 ierr = MPI_Allreduce(&ts->cfltime_local,&ts->cfltime,1,MPIU_REAL,MPIU_MIN,PetscObjectComm((PetscObject)ts));CHKERRQ(ierr); 4302 } 4303 *cfltime = ts->cfltime; 4304 PetscFunctionReturn(0); 4305 } 4306 4307 #undef __FUNCT__ 4308 #define __FUNCT__ "TSVISetVariableBounds" 4309 /*@ 4310 TSVISetVariableBounds - Sets the lower and upper bounds for the solution vector. xl <= x <= xu 4311 4312 Input Parameters: 4313 . ts - the TS context. 4314 . xl - lower bound. 4315 . xu - upper bound. 4316 4317 Notes: 4318 If this routine is not called then the lower and upper bounds are set to 4319 SNES_VI_NINF and SNES_VI_INF respectively during SNESSetUp(). 4320 4321 Level: advanced 4322 4323 @*/ 4324 PetscErrorCode TSVISetVariableBounds(TS ts, Vec xl, Vec xu) 4325 { 4326 PetscErrorCode ierr; 4327 SNES snes; 4328 4329 PetscFunctionBegin; 4330 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 4331 ierr = SNESVISetVariableBounds(snes,xl,xu);CHKERRQ(ierr); 4332 PetscFunctionReturn(0); 4333 } 4334 4335 #if defined(PETSC_HAVE_MATLAB_ENGINE) 4336 #include <mex.h> 4337 4338 typedef struct {char *funcname; mxArray *ctx;} TSMatlabContext; 4339 4340 #undef __FUNCT__ 4341 #define __FUNCT__ "TSComputeFunction_Matlab" 4342 /* 4343 TSComputeFunction_Matlab - Calls the function that has been set with 4344 TSSetFunctionMatlab(). 4345 4346 Collective on TS 4347 4348 Input Parameters: 4349 + snes - the TS context 4350 - u - input vector 4351 4352 Output Parameter: 4353 . y - function vector, as set by TSSetFunction() 4354 4355 Notes: 4356 TSComputeFunction() is typically used within nonlinear solvers 4357 implementations, so most users would not generally call this routine 4358 themselves. 4359 4360 Level: developer 4361 4362 .keywords: TS, nonlinear, compute, function 4363 4364 .seealso: TSSetFunction(), TSGetFunction() 4365 */ 4366 PetscErrorCode TSComputeFunction_Matlab(TS snes,PetscReal time,Vec u,Vec udot,Vec y, void *ctx) 4367 { 4368 PetscErrorCode ierr; 4369 TSMatlabContext *sctx = (TSMatlabContext*)ctx; 4370 int nlhs = 1,nrhs = 7; 4371 mxArray *plhs[1],*prhs[7]; 4372 long long int lx = 0,lxdot = 0,ly = 0,ls = 0; 4373 4374 PetscFunctionBegin; 4375 PetscValidHeaderSpecific(snes,TS_CLASSID,1); 4376 PetscValidHeaderSpecific(u,VEC_CLASSID,3); 4377 PetscValidHeaderSpecific(udot,VEC_CLASSID,4); 4378 PetscValidHeaderSpecific(y,VEC_CLASSID,5); 4379 PetscCheckSameComm(snes,1,u,3); 4380 PetscCheckSameComm(snes,1,y,5); 4381 4382 ierr = PetscMemcpy(&ls,&snes,sizeof(snes));CHKERRQ(ierr); 4383 ierr = PetscMemcpy(&lx,&u,sizeof(u));CHKERRQ(ierr); 4384 ierr = PetscMemcpy(&lxdot,&udot,sizeof(udot));CHKERRQ(ierr); 4385 ierr = PetscMemcpy(&ly,&y,sizeof(u));CHKERRQ(ierr); 4386 4387 prhs[0] = mxCreateDoubleScalar((double)ls); 4388 prhs[1] = mxCreateDoubleScalar(time); 4389 prhs[2] = mxCreateDoubleScalar((double)lx); 4390 prhs[3] = mxCreateDoubleScalar((double)lxdot); 4391 prhs[4] = mxCreateDoubleScalar((double)ly); 4392 prhs[5] = mxCreateString(sctx->funcname); 4393 prhs[6] = sctx->ctx; 4394 ierr = mexCallMATLAB(nlhs,plhs,nrhs,prhs,"PetscTSComputeFunctionInternal");CHKERRQ(ierr); 4395 ierr = mxGetScalar(plhs[0]);CHKERRQ(ierr); 4396 mxDestroyArray(prhs[0]); 4397 mxDestroyArray(prhs[1]); 4398 mxDestroyArray(prhs[2]); 4399 mxDestroyArray(prhs[3]); 4400 mxDestroyArray(prhs[4]); 4401 mxDestroyArray(prhs[5]); 4402 mxDestroyArray(plhs[0]); 4403 PetscFunctionReturn(0); 4404 } 4405 4406 4407 #undef __FUNCT__ 4408 #define __FUNCT__ "TSSetFunctionMatlab" 4409 /* 4410 TSSetFunctionMatlab - Sets the function evaluation routine and function 4411 vector for use by the TS routines in solving ODEs 4412 equations from MATLAB. Here the function is a string containing the name of a MATLAB function 4413 4414 Logically Collective on TS 4415 4416 Input Parameters: 4417 + ts - the TS context 4418 - func - function evaluation routine 4419 4420 Calling sequence of func: 4421 $ func (TS ts,PetscReal time,Vec u,Vec udot,Vec f,void *ctx); 4422 4423 Level: beginner 4424 4425 .keywords: TS, nonlinear, set, function 4426 4427 .seealso: TSGetFunction(), TSComputeFunction(), TSSetJacobian(), TSSetFunction() 4428 */ 4429 PetscErrorCode TSSetFunctionMatlab(TS ts,const char *func,mxArray *ctx) 4430 { 4431 PetscErrorCode ierr; 4432 TSMatlabContext *sctx; 4433 4434 PetscFunctionBegin; 4435 /* currently sctx is memory bleed */ 4436 ierr = PetscMalloc(sizeof(TSMatlabContext),&sctx);CHKERRQ(ierr); 4437 ierr = PetscStrallocpy(func,&sctx->funcname);CHKERRQ(ierr); 4438 /* 4439 This should work, but it doesn't 4440 sctx->ctx = ctx; 4441 mexMakeArrayPersistent(sctx->ctx); 4442 */ 4443 sctx->ctx = mxDuplicateArray(ctx); 4444 4445 ierr = TSSetIFunction(ts,NULL,TSComputeFunction_Matlab,sctx);CHKERRQ(ierr); 4446 PetscFunctionReturn(0); 4447 } 4448 4449 #undef __FUNCT__ 4450 #define __FUNCT__ "TSComputeJacobian_Matlab" 4451 /* 4452 TSComputeJacobian_Matlab - Calls the function that has been set with 4453 TSSetJacobianMatlab(). 4454 4455 Collective on TS 4456 4457 Input Parameters: 4458 + ts - the TS context 4459 . u - input vector 4460 . A, B - the matrices 4461 - ctx - user context 4462 4463 Output Parameter: 4464 . flag - structure of the matrix 4465 4466 Level: developer 4467 4468 .keywords: TS, nonlinear, compute, function 4469 4470 .seealso: TSSetFunction(), TSGetFunction() 4471 @*/ 4472 PetscErrorCode TSComputeJacobian_Matlab(TS ts,PetscReal time,Vec u,Vec udot,PetscReal shift,Mat *A,Mat *B,MatStructure *flag, void *ctx) 4473 { 4474 PetscErrorCode ierr; 4475 TSMatlabContext *sctx = (TSMatlabContext*)ctx; 4476 int nlhs = 2,nrhs = 9; 4477 mxArray *plhs[2],*prhs[9]; 4478 long long int lx = 0,lxdot = 0,lA = 0,ls = 0, lB = 0; 4479 4480 PetscFunctionBegin; 4481 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4482 PetscValidHeaderSpecific(u,VEC_CLASSID,3); 4483 4484 /* call Matlab function in ctx with arguments u and y */ 4485 4486 ierr = PetscMemcpy(&ls,&ts,sizeof(ts));CHKERRQ(ierr); 4487 ierr = PetscMemcpy(&lx,&u,sizeof(u));CHKERRQ(ierr); 4488 ierr = PetscMemcpy(&lxdot,&udot,sizeof(u));CHKERRQ(ierr); 4489 ierr = PetscMemcpy(&lA,A,sizeof(u));CHKERRQ(ierr); 4490 ierr = PetscMemcpy(&lB,B,sizeof(u));CHKERRQ(ierr); 4491 4492 prhs[0] = mxCreateDoubleScalar((double)ls); 4493 prhs[1] = mxCreateDoubleScalar((double)time); 4494 prhs[2] = mxCreateDoubleScalar((double)lx); 4495 prhs[3] = mxCreateDoubleScalar((double)lxdot); 4496 prhs[4] = mxCreateDoubleScalar((double)shift); 4497 prhs[5] = mxCreateDoubleScalar((double)lA); 4498 prhs[6] = mxCreateDoubleScalar((double)lB); 4499 prhs[7] = mxCreateString(sctx->funcname); 4500 prhs[8] = sctx->ctx; 4501 ierr = mexCallMATLAB(nlhs,plhs,nrhs,prhs,"PetscTSComputeJacobianInternal");CHKERRQ(ierr); 4502 ierr = mxGetScalar(plhs[0]);CHKERRQ(ierr); 4503 *flag = (MatStructure) mxGetScalar(plhs[1]);CHKERRQ(ierr); 4504 mxDestroyArray(prhs[0]); 4505 mxDestroyArray(prhs[1]); 4506 mxDestroyArray(prhs[2]); 4507 mxDestroyArray(prhs[3]); 4508 mxDestroyArray(prhs[4]); 4509 mxDestroyArray(prhs[5]); 4510 mxDestroyArray(prhs[6]); 4511 mxDestroyArray(prhs[7]); 4512 mxDestroyArray(plhs[0]); 4513 mxDestroyArray(plhs[1]); 4514 PetscFunctionReturn(0); 4515 } 4516 4517 4518 #undef __FUNCT__ 4519 #define __FUNCT__ "TSSetJacobianMatlab" 4520 /* 4521 TSSetJacobianMatlab - Sets the Jacobian function evaluation routine and two empty Jacobian matrices 4522 vector for use by the TS routines in solving ODEs from MATLAB. Here the function is a string containing the name of a MATLAB function 4523 4524 Logically Collective on TS 4525 4526 Input Parameters: 4527 + ts - the TS context 4528 . A,B - Jacobian matrices 4529 . func - function evaluation routine 4530 - ctx - user context 4531 4532 Calling sequence of func: 4533 $ flag = func (TS ts,PetscReal time,Vec u,Vec udot,Mat A,Mat B,void *ctx); 4534 4535 4536 Level: developer 4537 4538 .keywords: TS, nonlinear, set, function 4539 4540 .seealso: TSGetFunction(), TSComputeFunction(), TSSetJacobian(), TSSetFunction() 4541 */ 4542 PetscErrorCode TSSetJacobianMatlab(TS ts,Mat A,Mat B,const char *func,mxArray *ctx) 4543 { 4544 PetscErrorCode ierr; 4545 TSMatlabContext *sctx; 4546 4547 PetscFunctionBegin; 4548 /* currently sctx is memory bleed */ 4549 ierr = PetscMalloc(sizeof(TSMatlabContext),&sctx);CHKERRQ(ierr); 4550 ierr = PetscStrallocpy(func,&sctx->funcname);CHKERRQ(ierr); 4551 /* 4552 This should work, but it doesn't 4553 sctx->ctx = ctx; 4554 mexMakeArrayPersistent(sctx->ctx); 4555 */ 4556 sctx->ctx = mxDuplicateArray(ctx); 4557 4558 ierr = TSSetIJacobian(ts,A,B,TSComputeJacobian_Matlab,sctx);CHKERRQ(ierr); 4559 PetscFunctionReturn(0); 4560 } 4561 4562 #undef __FUNCT__ 4563 #define __FUNCT__ "TSMonitor_Matlab" 4564 /* 4565 TSMonitor_Matlab - Calls the function that has been set with TSMonitorSetMatlab(). 4566 4567 Collective on TS 4568 4569 .seealso: TSSetFunction(), TSGetFunction() 4570 @*/ 4571 PetscErrorCode TSMonitor_Matlab(TS ts,PetscInt it, PetscReal time,Vec u, void *ctx) 4572 { 4573 PetscErrorCode ierr; 4574 TSMatlabContext *sctx = (TSMatlabContext*)ctx; 4575 int nlhs = 1,nrhs = 6; 4576 mxArray *plhs[1],*prhs[6]; 4577 long long int lx = 0,ls = 0; 4578 4579 PetscFunctionBegin; 4580 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4581 PetscValidHeaderSpecific(u,VEC_CLASSID,4); 4582 4583 ierr = PetscMemcpy(&ls,&ts,sizeof(ts));CHKERRQ(ierr); 4584 ierr = PetscMemcpy(&lx,&u,sizeof(u));CHKERRQ(ierr); 4585 4586 prhs[0] = mxCreateDoubleScalar((double)ls); 4587 prhs[1] = mxCreateDoubleScalar((double)it); 4588 prhs[2] = mxCreateDoubleScalar((double)time); 4589 prhs[3] = mxCreateDoubleScalar((double)lx); 4590 prhs[4] = mxCreateString(sctx->funcname); 4591 prhs[5] = sctx->ctx; 4592 ierr = mexCallMATLAB(nlhs,plhs,nrhs,prhs,"PetscTSMonitorInternal");CHKERRQ(ierr); 4593 ierr = mxGetScalar(plhs[0]);CHKERRQ(ierr); 4594 mxDestroyArray(prhs[0]); 4595 mxDestroyArray(prhs[1]); 4596 mxDestroyArray(prhs[2]); 4597 mxDestroyArray(prhs[3]); 4598 mxDestroyArray(prhs[4]); 4599 mxDestroyArray(plhs[0]); 4600 PetscFunctionReturn(0); 4601 } 4602 4603 4604 #undef __FUNCT__ 4605 #define __FUNCT__ "TSMonitorSetMatlab" 4606 /* 4607 TSMonitorSetMatlab - Sets the monitor function from Matlab 4608 4609 Level: developer 4610 4611 .keywords: TS, nonlinear, set, function 4612 4613 .seealso: TSGetFunction(), TSComputeFunction(), TSSetJacobian(), TSSetFunction() 4614 */ 4615 PetscErrorCode TSMonitorSetMatlab(TS ts,const char *func,mxArray *ctx) 4616 { 4617 PetscErrorCode ierr; 4618 TSMatlabContext *sctx; 4619 4620 PetscFunctionBegin; 4621 /* currently sctx is memory bleed */ 4622 ierr = PetscMalloc(sizeof(TSMatlabContext),&sctx);CHKERRQ(ierr); 4623 ierr = PetscStrallocpy(func,&sctx->funcname);CHKERRQ(ierr); 4624 /* 4625 This should work, but it doesn't 4626 sctx->ctx = ctx; 4627 mexMakeArrayPersistent(sctx->ctx); 4628 */ 4629 sctx->ctx = mxDuplicateArray(ctx); 4630 4631 ierr = TSMonitorSet(ts,TSMonitor_Matlab,sctx,NULL);CHKERRQ(ierr); 4632 PetscFunctionReturn(0); 4633 } 4634 #endif 4635 4636 4637 4638 #undef __FUNCT__ 4639 #define __FUNCT__ "TSMonitorLGSolution" 4640 /*@C 4641 TSMonitorLGSolution - Monitors progress of the TS solvers by plotting each component of the solution vector 4642 in a time based line graph 4643 4644 Collective on TS 4645 4646 Input Parameters: 4647 + ts - the TS context 4648 . step - current time-step 4649 . ptime - current time 4650 - lg - a line graph object 4651 4652 Level: intermediate 4653 4654 Notes: each process in a parallel run displays its component solutions in a separate window 4655 4656 .keywords: TS, vector, monitor, view 4657 4658 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 4659 @*/ 4660 PetscErrorCode TSMonitorLGSolution(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dummy) 4661 { 4662 PetscErrorCode ierr; 4663 TSMonitorLGCtx ctx = (TSMonitorLGCtx)dummy; 4664 const PetscScalar *yy; 4665 PetscInt dim; 4666 4667 PetscFunctionBegin; 4668 if (!step) { 4669 PetscDrawAxis axis; 4670 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 4671 ierr = PetscDrawAxisSetLabels(axis,"Solution as function of time","Time","Solution");CHKERRQ(ierr); 4672 ierr = VecGetLocalSize(u,&dim);CHKERRQ(ierr); 4673 ierr = PetscDrawLGSetDimension(ctx->lg,dim);CHKERRQ(ierr); 4674 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 4675 } 4676 ierr = VecGetArrayRead(u,&yy);CHKERRQ(ierr); 4677 #if defined(PETSC_USE_COMPLEX) 4678 { 4679 PetscReal *yreal; 4680 PetscInt i,n; 4681 ierr = VecGetLocalSize(u,&n);CHKERRQ(ierr); 4682 ierr = PetscMalloc(n*sizeof(PetscReal),&yreal);CHKERRQ(ierr); 4683 for (i=0; i<n; i++) yreal[i] = PetscRealPart(yy[i]); 4684 ierr = PetscDrawLGAddCommonPoint(ctx->lg,ptime,yreal);CHKERRQ(ierr); 4685 ierr = PetscFree(yreal);CHKERRQ(ierr); 4686 } 4687 #else 4688 ierr = PetscDrawLGAddCommonPoint(ctx->lg,ptime,yy);CHKERRQ(ierr); 4689 #endif 4690 ierr = VecRestoreArrayRead(u,&yy);CHKERRQ(ierr); 4691 if (((ctx->howoften > 0) && (!(step % ctx->howoften))) || ((ctx->howoften == -1) && ts->reason)) { 4692 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 4693 } 4694 PetscFunctionReturn(0); 4695 } 4696 4697 #undef __FUNCT__ 4698 #define __FUNCT__ "TSMonitorLGError" 4699 /*@C 4700 TSMonitorLGError - Monitors progress of the TS solvers by plotting each component of the solution vector 4701 in a time based line graph 4702 4703 Collective on TS 4704 4705 Input Parameters: 4706 + ts - the TS context 4707 . step - current time-step 4708 . ptime - current time 4709 - lg - a line graph object 4710 4711 Level: intermediate 4712 4713 Notes: 4714 Only for sequential solves. 4715 4716 The user must provide the solution using TSSetSolutionFunction() to use this monitor. 4717 4718 Options Database Keys: 4719 . -ts_monitor_lg_error - create a graphical monitor of error history 4720 4721 .keywords: TS, vector, monitor, view 4722 4723 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSSetSolutionFunction() 4724 @*/ 4725 PetscErrorCode TSMonitorLGError(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dummy) 4726 { 4727 PetscErrorCode ierr; 4728 TSMonitorLGCtx ctx = (TSMonitorLGCtx)dummy; 4729 const PetscScalar *yy; 4730 Vec y; 4731 PetscInt dim; 4732 4733 PetscFunctionBegin; 4734 if (!step) { 4735 PetscDrawAxis axis; 4736 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 4737 ierr = PetscDrawAxisSetLabels(axis,"Error in solution as function of time","Time","Solution");CHKERRQ(ierr); 4738 ierr = VecGetLocalSize(u,&dim);CHKERRQ(ierr); 4739 ierr = PetscDrawLGSetDimension(ctx->lg,dim);CHKERRQ(ierr); 4740 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 4741 } 4742 ierr = VecDuplicate(u,&y);CHKERRQ(ierr); 4743 ierr = TSComputeSolutionFunction(ts,ptime,y);CHKERRQ(ierr); 4744 ierr = VecAXPY(y,-1.0,u);CHKERRQ(ierr); 4745 ierr = VecGetArrayRead(y,&yy);CHKERRQ(ierr); 4746 #if defined(PETSC_USE_COMPLEX) 4747 { 4748 PetscReal *yreal; 4749 PetscInt i,n; 4750 ierr = VecGetLocalSize(y,&n);CHKERRQ(ierr); 4751 ierr = PetscMalloc(n*sizeof(PetscReal),&yreal);CHKERRQ(ierr); 4752 for (i=0; i<n; i++) yreal[i] = PetscRealPart(yy[i]); 4753 ierr = PetscDrawLGAddCommonPoint(ctx->lg,ptime,yreal);CHKERRQ(ierr); 4754 ierr = PetscFree(yreal);CHKERRQ(ierr); 4755 } 4756 #else 4757 ierr = PetscDrawLGAddCommonPoint(ctx->lg,ptime,yy);CHKERRQ(ierr); 4758 #endif 4759 ierr = VecRestoreArrayRead(y,&yy);CHKERRQ(ierr); 4760 ierr = VecDestroy(&y);CHKERRQ(ierr); 4761 if (((ctx->howoften > 0) && (!(step % ctx->howoften))) || ((ctx->howoften == -1) && ts->reason)) { 4762 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 4763 } 4764 PetscFunctionReturn(0); 4765 } 4766 4767 #undef __FUNCT__ 4768 #define __FUNCT__ "TSMonitorLGSNESIterations" 4769 PetscErrorCode TSMonitorLGSNESIterations(TS ts,PetscInt n,PetscReal ptime,Vec v,void *monctx) 4770 { 4771 TSMonitorLGCtx ctx = (TSMonitorLGCtx) monctx; 4772 PetscReal x = ptime,y; 4773 PetscErrorCode ierr; 4774 PetscInt its; 4775 4776 PetscFunctionBegin; 4777 if (!n) { 4778 PetscDrawAxis axis; 4779 4780 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 4781 ierr = PetscDrawAxisSetLabels(axis,"Nonlinear iterations as function of time","Time","SNES Iterations");CHKERRQ(ierr); 4782 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 4783 4784 ctx->snes_its = 0; 4785 } 4786 ierr = TSGetSNESIterations(ts,&its);CHKERRQ(ierr); 4787 y = its - ctx->snes_its; 4788 ierr = PetscDrawLGAddPoint(ctx->lg,&x,&y);CHKERRQ(ierr); 4789 if (((ctx->howoften > 0) && (!(n % ctx->howoften)) && (n > -1)) || ((ctx->howoften == -1) && (n == -1))) { 4790 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 4791 } 4792 ctx->snes_its = its; 4793 PetscFunctionReturn(0); 4794 } 4795 4796 #undef __FUNCT__ 4797 #define __FUNCT__ "TSMonitorLGKSPIterations" 4798 PetscErrorCode TSMonitorLGKSPIterations(TS ts,PetscInt n,PetscReal ptime,Vec v,void *monctx) 4799 { 4800 TSMonitorLGCtx ctx = (TSMonitorLGCtx) monctx; 4801 PetscReal x = ptime,y; 4802 PetscErrorCode ierr; 4803 PetscInt its; 4804 4805 PetscFunctionBegin; 4806 if (!n) { 4807 PetscDrawAxis axis; 4808 4809 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 4810 ierr = PetscDrawAxisSetLabels(axis,"Linear iterations as function of time","Time","KSP Iterations");CHKERRQ(ierr); 4811 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 4812 4813 ctx->ksp_its = 0; 4814 } 4815 ierr = TSGetKSPIterations(ts,&its);CHKERRQ(ierr); 4816 y = its - ctx->ksp_its; 4817 ierr = PetscDrawLGAddPoint(ctx->lg,&x,&y);CHKERRQ(ierr); 4818 if (((ctx->howoften > 0) && (!(n % ctx->howoften)) && (n > -1)) || ((ctx->howoften == -1) && (n == -1))) { 4819 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 4820 } 4821 ctx->ksp_its = its; 4822 PetscFunctionReturn(0); 4823 } 4824 4825 #undef __FUNCT__ 4826 #define __FUNCT__ "TSComputeLinearStability" 4827 /*@ 4828 TSComputeLinearStability - computes the linear stability function at a point 4829 4830 Collective on TS and Vec 4831 4832 Input Parameters: 4833 + ts - the TS context 4834 - xr,xi - real and imaginary part of input arguments 4835 4836 Output Parameters: 4837 . yr,yi - real and imaginary part of function value 4838 4839 Level: developer 4840 4841 .keywords: TS, compute 4842 4843 .seealso: TSSetRHSFunction(), TSComputeIFunction() 4844 @*/ 4845 PetscErrorCode TSComputeLinearStability(TS ts,PetscReal xr,PetscReal xi,PetscReal *yr,PetscReal *yi) 4846 { 4847 PetscErrorCode ierr; 4848 4849 PetscFunctionBegin; 4850 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4851 if (!ts->ops->linearstability) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"Linearized stability function not provided for this method"); 4852 ierr = (*ts->ops->linearstability)(ts,xr,xi,yr,yi);CHKERRQ(ierr); 4853 PetscFunctionReturn(0); 4854 } 4855 4856 #undef __FUNCT__ 4857 #define __FUNCT__ "TSRollBack" 4858 /*@ 4859 TSRollBack - Rolls back one time step 4860 4861 Collective on TS 4862 4863 Input Parameter: 4864 . ts - the TS context obtained from TSCreate() 4865 4866 Level: advanced 4867 4868 .keywords: TS, timestep, rollback 4869 4870 .seealso: TSCreate(), TSSetUp(), TSDestroy(), TSSolve(), TSSetPreStep(), TSSetPreStage(), TSInterpolate() 4871 @*/ 4872 PetscErrorCode TSRollBack(TS ts) 4873 { 4874 PetscErrorCode ierr; 4875 4876 PetscFunctionBegin; 4877 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 4878 4879 if (!ts->ops->rollback) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"TSRollBack not implemented for type '%s'",((PetscObject)ts)->type_name); 4880 ierr = (*ts->ops->rollback)(ts);CHKERRQ(ierr); 4881 ts->time_step = ts->ptime - ts->ptime_prev; 4882 ts->ptime = ts->ptime_prev; 4883 PetscFunctionReturn(0); 4884 } 4885