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