1 #include <petsc/private/tsimpl.h> /*I "petscts.h" I*/ 2 #include <petscdmshell.h> 3 #include <petscdmda.h> 4 #include <petscviewer.h> 5 #include <petscdraw.h> 6 7 /* Logging support */ 8 PetscClassId TS_CLASSID, DMTS_CLASSID; 9 PetscLogEvent TS_Step, TS_PseudoComputeTimeStep, TS_FunctionEval, TS_JacobianEval; 10 11 const char *const TSExactFinalTimeOptions[] = {"UNSPECIFIED","STEPOVER","INTERPOLATE","MATCHSTEP","TSExactFinalTimeOption","TS_EXACTFINALTIME_",0}; 12 13 /*@C 14 TSMonitorSetFromOptions - Sets a monitor function and viewer appropriate for the type indicated by the user 15 16 Collective on TS 17 18 Input Parameters: 19 + ts - TS object you wish to monitor 20 . name - the monitor type one is seeking 21 . help - message indicating what monitoring is done 22 . manual - manual page for the monitor 23 . monitor - the monitor function 24 - monitorsetup - a function that is called once ONLY if the user selected this monitor that may set additional features of the TS or PetscViewer objects 25 26 Level: developer 27 28 .seealso: PetscOptionsGetViewer(), PetscOptionsGetReal(), PetscOptionsHasName(), PetscOptionsGetString(), 29 PetscOptionsGetIntArray(), PetscOptionsGetRealArray(), PetscOptionsBool() 30 PetscOptionsInt(), PetscOptionsString(), PetscOptionsReal(), PetscOptionsBool(), 31 PetscOptionsName(), PetscOptionsBegin(), PetscOptionsEnd(), PetscOptionsHead(), 32 PetscOptionsStringArray(),PetscOptionsRealArray(), PetscOptionsScalar(), 33 PetscOptionsBoolGroupBegin(), PetscOptionsBoolGroup(), PetscOptionsBoolGroupEnd(), 34 PetscOptionsFList(), PetscOptionsEList() 35 @*/ 36 PetscErrorCode TSMonitorSetFromOptions(TS ts,const char name[],const char help[], const char manual[],PetscErrorCode (*monitor)(TS,PetscInt,PetscReal,Vec,PetscViewerAndFormat*),PetscErrorCode (*monitorsetup)(TS,PetscViewerAndFormat*)) 37 { 38 PetscErrorCode ierr; 39 PetscViewer viewer; 40 PetscViewerFormat format; 41 PetscBool flg; 42 43 PetscFunctionBegin; 44 ierr = PetscOptionsGetViewer(PetscObjectComm((PetscObject)ts),((PetscObject) ts)->options,((PetscObject)ts)->prefix,name,&viewer,&format,&flg);CHKERRQ(ierr); 45 if (flg) { 46 PetscViewerAndFormat *vf; 47 ierr = PetscViewerAndFormatCreate(viewer,format,&vf);CHKERRQ(ierr); 48 ierr = PetscObjectDereference((PetscObject)viewer);CHKERRQ(ierr); 49 if (monitorsetup) { 50 ierr = (*monitorsetup)(ts,vf);CHKERRQ(ierr); 51 } 52 ierr = TSMonitorSet(ts,(PetscErrorCode (*)(TS,PetscInt,PetscReal,Vec,void*))monitor,vf,(PetscErrorCode (*)(void**))PetscViewerAndFormatDestroy);CHKERRQ(ierr); 53 } 54 PetscFunctionReturn(0); 55 } 56 57 static PetscErrorCode TSAdaptSetDefaultType(TSAdapt adapt,TSAdaptType default_type) 58 { 59 PetscErrorCode ierr; 60 61 PetscFunctionBegin; 62 PetscValidHeaderSpecific(adapt,TSADAPT_CLASSID,1); 63 PetscValidCharPointer(default_type,2); 64 if (!((PetscObject)adapt)->type_name) { 65 ierr = TSAdaptSetType(adapt,default_type);CHKERRQ(ierr); 66 } 67 PetscFunctionReturn(0); 68 } 69 70 /*@ 71 TSSetFromOptions - Sets various TS parameters from user options. 72 73 Collective on TS 74 75 Input Parameter: 76 . ts - the TS context obtained from TSCreate() 77 78 Options Database Keys: 79 + -ts_type <type> - TSEULER, TSBEULER, TSSUNDIALS, TSPSEUDO, TSCN, TSRK, TSTHETA, TSALPHA, TSGLLE, TSSSP, TSGLEE, TSBSYMP 80 . -ts_save_trajectory - checkpoint the solution at each time-step 81 . -ts_max_time <time> - maximum time to compute to 82 . -ts_max_steps <steps> - maximum number of time-steps to take 83 . -ts_init_time <time> - initial time to start computation 84 . -ts_final_time <time> - final time to compute to (deprecated: use -ts_max_time) 85 . -ts_dt <dt> - initial time step 86 . -ts_exact_final_time <stepover,interpolate,matchstep> whether to stop at the exact given final time and how to compute the solution at that ti,e 87 . -ts_max_snes_failures <maxfailures> - Maximum number of nonlinear solve failures allowed 88 . -ts_max_reject <maxrejects> - Maximum number of step rejections before step fails 89 . -ts_error_if_step_fails <true,false> - Error if no step succeeds 90 . -ts_rtol <rtol> - relative tolerance for local truncation error 91 . -ts_atol <atol> Absolute tolerance for local truncation error 92 . -ts_rhs_jacobian_test_mult -mat_shell_test_mult_view - test the Jacobian at each iteration against finite difference with RHS function 93 . -ts_rhs_jacobian_test_mult_transpose -mat_shell_test_mult_transpose_view - test the Jacobian at each iteration against finite difference with RHS function 94 . -ts_adjoint_solve <yes,no> After solving the ODE/DAE solve the adjoint problem (requires -ts_save_trajectory) 95 . -ts_fd_color - Use finite differences with coloring to compute IJacobian 96 . -ts_monitor - print information at each timestep 97 . -ts_monitor_lg_solution - Monitor solution graphically 98 . -ts_monitor_lg_error - Monitor error graphically 99 . -ts_monitor_error - Monitors norm of error 100 . -ts_monitor_lg_timestep - Monitor timestep size graphically 101 . -ts_monitor_lg_timestep_log - Monitor log timestep size graphically 102 . -ts_monitor_lg_snes_iterations - Monitor number nonlinear iterations for each timestep graphically 103 . -ts_monitor_lg_ksp_iterations - Monitor number nonlinear iterations for each timestep graphically 104 . -ts_monitor_sp_eig - Monitor eigenvalues of linearized operator graphically 105 . -ts_monitor_draw_solution - Monitor solution graphically 106 . -ts_monitor_draw_solution_phase <xleft,yleft,xright,yright> - Monitor solution graphically with phase diagram, requires problem with exactly 2 degrees of freedom 107 . -ts_monitor_draw_error - Monitor error graphically, requires use to have provided TSSetSolutionFunction() 108 . -ts_monitor_solution [ascii binary draw][:filename][:viewerformat] - monitors the solution at each timestep 109 . -ts_monitor_solution_vtk <filename.vts,filename.vtu> - Save each time step to a binary file, use filename-%%03D.vts (filename-%%03D.vtu) 110 . -ts_monitor_envelope - determine maximum and minimum value of each component of the solution over the solution time 111 112 Developer Note: We should unify all the -ts_monitor options in the way that -xxx_view has been unified 113 114 Level: beginner 115 116 .keywords: TS, timestep, set, options, database 117 118 .seealso: TSGetType() 119 @*/ 120 PetscErrorCode TSSetFromOptions(TS ts) 121 { 122 PetscBool opt,flg,tflg; 123 PetscErrorCode ierr; 124 char monfilename[PETSC_MAX_PATH_LEN]; 125 PetscReal time_step; 126 TSExactFinalTimeOption eftopt; 127 char dir[16]; 128 TSIFunction ifun; 129 const char *defaultType; 130 char typeName[256]; 131 132 PetscFunctionBegin; 133 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 134 135 ierr = TSRegisterAll();CHKERRQ(ierr); 136 ierr = TSGetIFunction(ts,NULL,&ifun,NULL);CHKERRQ(ierr); 137 138 ierr = PetscObjectOptionsBegin((PetscObject)ts);CHKERRQ(ierr); 139 if (((PetscObject)ts)->type_name) defaultType = ((PetscObject)ts)->type_name; 140 else defaultType = ifun ? TSBEULER : TSEULER; 141 ierr = PetscOptionsFList("-ts_type","TS method","TSSetType",TSList,defaultType,typeName,256,&opt);CHKERRQ(ierr); 142 if (opt) { 143 ierr = TSSetType(ts,typeName);CHKERRQ(ierr); 144 } else { 145 ierr = TSSetType(ts,defaultType);CHKERRQ(ierr); 146 } 147 148 /* Handle generic TS options */ 149 ierr = PetscOptionsDeprecated("-ts_final_time","-ts_max_time","3.10",NULL);CHKERRQ(ierr); 150 ierr = PetscOptionsReal("-ts_max_time","Maximum time to run to","TSSetMaxTime",ts->max_time,&ts->max_time,NULL);CHKERRQ(ierr); 151 ierr = PetscOptionsInt("-ts_max_steps","Maximum number of time steps","TSSetMaxSteps",ts->max_steps,&ts->max_steps,NULL);CHKERRQ(ierr); 152 ierr = PetscOptionsReal("-ts_init_time","Initial time","TSSetTime",ts->ptime,&ts->ptime,NULL);CHKERRQ(ierr); 153 ierr = PetscOptionsReal("-ts_dt","Initial time step","TSSetTimeStep",ts->time_step,&time_step,&flg);CHKERRQ(ierr); 154 if (flg) {ierr = TSSetTimeStep(ts,time_step);CHKERRQ(ierr);} 155 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); 156 if (flg) {ierr = TSSetExactFinalTime(ts,eftopt);CHKERRQ(ierr);} 157 ierr = PetscOptionsInt("-ts_max_snes_failures","Maximum number of nonlinear solve failures","TSSetMaxSNESFailures",ts->max_snes_failures,&ts->max_snes_failures,NULL);CHKERRQ(ierr); 158 ierr = PetscOptionsInt("-ts_max_reject","Maximum number of step rejections before step fails","TSSetMaxStepRejections",ts->max_reject,&ts->max_reject,NULL);CHKERRQ(ierr); 159 ierr = PetscOptionsBool("-ts_error_if_step_fails","Error if no step succeeds","TSSetErrorIfStepFails",ts->errorifstepfailed,&ts->errorifstepfailed,NULL);CHKERRQ(ierr); 160 ierr = PetscOptionsReal("-ts_rtol","Relative tolerance for local truncation error","TSSetTolerances",ts->rtol,&ts->rtol,NULL);CHKERRQ(ierr); 161 ierr = PetscOptionsReal("-ts_atol","Absolute tolerance for local truncation error","TSSetTolerances",ts->atol,&ts->atol,NULL);CHKERRQ(ierr); 162 163 ierr = PetscOptionsBool("-ts_rhs_jacobian_test_mult","Test the RHS Jacobian for consistency with RHS at each solve ","None",ts->testjacobian,&ts->testjacobian,NULL);CHKERRQ(ierr); 164 ierr = PetscOptionsBool("-ts_rhs_jacobian_test_mult_transpose","Test the RHS Jacobian transpose for consistency with RHS at each solve ","None",ts->testjacobiantranspose,&ts->testjacobiantranspose,NULL);CHKERRQ(ierr); 165 ierr = PetscOptionsBool("-ts_use_splitrhsfunction","Use the split RHS function for multirate solvers ","TSSetUseSplitRHSFunction",ts->use_splitrhsfunction,&ts->use_splitrhsfunction,NULL);CHKERRQ(ierr); 166 #if defined(PETSC_HAVE_SAWS) 167 { 168 PetscBool set; 169 flg = PETSC_FALSE; 170 ierr = PetscOptionsBool("-ts_saws_block","Block for SAWs memory snooper at end of TSSolve","PetscObjectSAWsBlock",((PetscObject)ts)->amspublishblock,&flg,&set);CHKERRQ(ierr); 171 if (set) { 172 ierr = PetscObjectSAWsSetBlock((PetscObject)ts,flg);CHKERRQ(ierr); 173 } 174 } 175 #endif 176 177 /* Monitor options */ 178 ierr = TSMonitorSetFromOptions(ts,"-ts_monitor","Monitor time and timestep size","TSMonitorDefault",TSMonitorDefault,NULL);CHKERRQ(ierr); 179 ierr = TSMonitorSetFromOptions(ts,"-ts_monitor_extreme","Monitor extreme values of the solution","TSMonitorExtreme",TSMonitorExtreme,NULL);CHKERRQ(ierr); 180 ierr = TSMonitorSetFromOptions(ts,"-ts_monitor_solution","View the solution at each timestep","TSMonitorSolution",TSMonitorSolution,NULL);CHKERRQ(ierr); 181 182 ierr = PetscOptionsString("-ts_monitor_python","Use Python function","TSMonitorSet",0,monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr); 183 if (flg) {ierr = PetscPythonMonitorSet((PetscObject)ts,monfilename);CHKERRQ(ierr);} 184 185 ierr = PetscOptionsName("-ts_monitor_lg_solution","Monitor solution graphically","TSMonitorLGSolution",&opt);CHKERRQ(ierr); 186 if (opt) { 187 TSMonitorLGCtx ctx; 188 PetscInt howoften = 1; 189 190 ierr = PetscOptionsInt("-ts_monitor_lg_solution","Monitor solution graphically","TSMonitorLGSolution",howoften,&howoften,NULL);CHKERRQ(ierr); 191 ierr = TSMonitorLGCtxCreate(PETSC_COMM_SELF,0,0,PETSC_DECIDE,PETSC_DECIDE,400,300,howoften,&ctx);CHKERRQ(ierr); 192 ierr = TSMonitorSet(ts,TSMonitorLGSolution,ctx,(PetscErrorCode (*)(void**))TSMonitorLGCtxDestroy);CHKERRQ(ierr); 193 } 194 195 ierr = PetscOptionsName("-ts_monitor_lg_error","Monitor error graphically","TSMonitorLGError",&opt);CHKERRQ(ierr); 196 if (opt) { 197 TSMonitorLGCtx ctx; 198 PetscInt howoften = 1; 199 200 ierr = PetscOptionsInt("-ts_monitor_lg_error","Monitor error graphically","TSMonitorLGError",howoften,&howoften,NULL);CHKERRQ(ierr); 201 ierr = TSMonitorLGCtxCreate(PETSC_COMM_SELF,0,0,PETSC_DECIDE,PETSC_DECIDE,400,300,howoften,&ctx);CHKERRQ(ierr); 202 ierr = TSMonitorSet(ts,TSMonitorLGError,ctx,(PetscErrorCode (*)(void**))TSMonitorLGCtxDestroy);CHKERRQ(ierr); 203 } 204 ierr = TSMonitorSetFromOptions(ts,"-ts_monitor_error","View the error at each timestep","TSMonitorError",TSMonitorError,NULL);CHKERRQ(ierr); 205 206 ierr = PetscOptionsName("-ts_monitor_lg_timestep","Monitor timestep size graphically","TSMonitorLGTimeStep",&opt);CHKERRQ(ierr); 207 if (opt) { 208 TSMonitorLGCtx ctx; 209 PetscInt howoften = 1; 210 211 ierr = PetscOptionsInt("-ts_monitor_lg_timestep","Monitor timestep size graphically","TSMonitorLGTimeStep",howoften,&howoften,NULL);CHKERRQ(ierr); 212 ierr = TSMonitorLGCtxCreate(PetscObjectComm((PetscObject)ts),NULL,NULL,PETSC_DECIDE,PETSC_DECIDE,400,300,howoften,&ctx);CHKERRQ(ierr); 213 ierr = TSMonitorSet(ts,TSMonitorLGTimeStep,ctx,(PetscErrorCode (*)(void**))TSMonitorLGCtxDestroy);CHKERRQ(ierr); 214 } 215 ierr = PetscOptionsName("-ts_monitor_lg_timestep_log","Monitor log timestep size graphically","TSMonitorLGTimeStep",&opt);CHKERRQ(ierr); 216 if (opt) { 217 TSMonitorLGCtx ctx; 218 PetscInt howoften = 1; 219 220 ierr = PetscOptionsInt("-ts_monitor_lg_timestep_log","Monitor log timestep size graphically","TSMonitorLGTimeStep",howoften,&howoften,NULL);CHKERRQ(ierr); 221 ierr = TSMonitorLGCtxCreate(PetscObjectComm((PetscObject)ts),NULL,NULL,PETSC_DECIDE,PETSC_DECIDE,400,300,howoften,&ctx);CHKERRQ(ierr); 222 ierr = TSMonitorSet(ts,TSMonitorLGTimeStep,ctx,(PetscErrorCode (*)(void**))TSMonitorLGCtxDestroy);CHKERRQ(ierr); 223 ctx->semilogy = PETSC_TRUE; 224 } 225 226 ierr = PetscOptionsName("-ts_monitor_lg_snes_iterations","Monitor number nonlinear iterations for each timestep graphically","TSMonitorLGSNESIterations",&opt);CHKERRQ(ierr); 227 if (opt) { 228 TSMonitorLGCtx ctx; 229 PetscInt howoften = 1; 230 231 ierr = PetscOptionsInt("-ts_monitor_lg_snes_iterations","Monitor number nonlinear iterations for each timestep graphically","TSMonitorLGSNESIterations",howoften,&howoften,NULL);CHKERRQ(ierr); 232 ierr = TSMonitorLGCtxCreate(PetscObjectComm((PetscObject)ts),NULL,NULL,PETSC_DECIDE,PETSC_DECIDE,400,300,howoften,&ctx);CHKERRQ(ierr); 233 ierr = TSMonitorSet(ts,TSMonitorLGSNESIterations,ctx,(PetscErrorCode (*)(void**))TSMonitorLGCtxDestroy);CHKERRQ(ierr); 234 } 235 ierr = PetscOptionsName("-ts_monitor_lg_ksp_iterations","Monitor number nonlinear iterations for each timestep graphically","TSMonitorLGKSPIterations",&opt);CHKERRQ(ierr); 236 if (opt) { 237 TSMonitorLGCtx ctx; 238 PetscInt howoften = 1; 239 240 ierr = PetscOptionsInt("-ts_monitor_lg_ksp_iterations","Monitor number nonlinear iterations for each timestep graphically","TSMonitorLGKSPIterations",howoften,&howoften,NULL);CHKERRQ(ierr); 241 ierr = TSMonitorLGCtxCreate(PetscObjectComm((PetscObject)ts),NULL,NULL,PETSC_DECIDE,PETSC_DECIDE,400,300,howoften,&ctx);CHKERRQ(ierr); 242 ierr = TSMonitorSet(ts,TSMonitorLGKSPIterations,ctx,(PetscErrorCode (*)(void**))TSMonitorLGCtxDestroy);CHKERRQ(ierr); 243 } 244 ierr = PetscOptionsName("-ts_monitor_sp_eig","Monitor eigenvalues of linearized operator graphically","TSMonitorSPEig",&opt);CHKERRQ(ierr); 245 if (opt) { 246 TSMonitorSPEigCtx ctx; 247 PetscInt howoften = 1; 248 249 ierr = PetscOptionsInt("-ts_monitor_sp_eig","Monitor eigenvalues of linearized operator graphically","TSMonitorSPEig",howoften,&howoften,NULL);CHKERRQ(ierr); 250 ierr = TSMonitorSPEigCtxCreate(PETSC_COMM_SELF,0,0,PETSC_DECIDE,PETSC_DECIDE,300,300,howoften,&ctx);CHKERRQ(ierr); 251 ierr = TSMonitorSet(ts,TSMonitorSPEig,ctx,(PetscErrorCode (*)(void**))TSMonitorSPEigCtxDestroy);CHKERRQ(ierr); 252 } 253 ierr = PetscOptionsName("-ts_monitor_sp_swarm","Display particle phase from the DMSwarm","TSMonitorSPSwarm",&opt);CHKERRQ(ierr); 254 if (opt) { 255 TSMonitorSPCtx ctx; 256 PetscInt howoften = 1; 257 ierr = PetscOptionsInt("-ts_monitor_sp_swarm","Display particles phase from the DMSwarm","TSMonitorSPSwarm",howoften,&howoften,NULL);CHKERRQ(ierr); 258 ierr = TSMonitorSPCtxCreate(PETSC_COMM_SELF, NULL, NULL, PETSC_DECIDE, PETSC_DECIDE, 300, 300, howoften, &ctx);CHKERRQ(ierr); 259 ierr = TSMonitorSet(ts, TSMonitorSPSwarmSolution, ctx, (PetscErrorCode (*)(void**))TSMonitorSPCtxDestroy);CHKERRQ(ierr); 260 } 261 opt = PETSC_FALSE; 262 ierr = PetscOptionsName("-ts_monitor_draw_solution","Monitor solution graphically","TSMonitorDrawSolution",&opt);CHKERRQ(ierr); 263 if (opt) { 264 TSMonitorDrawCtx ctx; 265 PetscInt howoften = 1; 266 267 ierr = PetscOptionsInt("-ts_monitor_draw_solution","Monitor solution graphically","TSMonitorDrawSolution",howoften,&howoften,NULL);CHKERRQ(ierr); 268 ierr = TSMonitorDrawCtxCreate(PetscObjectComm((PetscObject)ts),0,"Computed Solution",PETSC_DECIDE,PETSC_DECIDE,300,300,howoften,&ctx);CHKERRQ(ierr); 269 ierr = TSMonitorSet(ts,TSMonitorDrawSolution,ctx,(PetscErrorCode (*)(void**))TSMonitorDrawCtxDestroy);CHKERRQ(ierr); 270 } 271 opt = PETSC_FALSE; 272 ierr = PetscOptionsName("-ts_monitor_draw_solution_phase","Monitor solution graphically","TSMonitorDrawSolutionPhase",&opt);CHKERRQ(ierr); 273 if (opt) { 274 TSMonitorDrawCtx ctx; 275 PetscReal bounds[4]; 276 PetscInt n = 4; 277 PetscDraw draw; 278 PetscDrawAxis axis; 279 280 ierr = PetscOptionsRealArray("-ts_monitor_draw_solution_phase","Monitor solution graphically","TSMonitorDrawSolutionPhase",bounds,&n,NULL);CHKERRQ(ierr); 281 if (n != 4) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_WRONG,"Must provide bounding box of phase field"); 282 ierr = TSMonitorDrawCtxCreate(PetscObjectComm((PetscObject)ts),0,0,PETSC_DECIDE,PETSC_DECIDE,300,300,1,&ctx);CHKERRQ(ierr); 283 ierr = PetscViewerDrawGetDraw(ctx->viewer,0,&draw);CHKERRQ(ierr); 284 ierr = PetscViewerDrawGetDrawAxis(ctx->viewer,0,&axis);CHKERRQ(ierr); 285 ierr = PetscDrawAxisSetLimits(axis,bounds[0],bounds[2],bounds[1],bounds[3]);CHKERRQ(ierr); 286 ierr = PetscDrawAxisSetLabels(axis,"Phase Diagram","Variable 1","Variable 2");CHKERRQ(ierr); 287 ierr = TSMonitorSet(ts,TSMonitorDrawSolutionPhase,ctx,(PetscErrorCode (*)(void**))TSMonitorDrawCtxDestroy);CHKERRQ(ierr); 288 } 289 opt = PETSC_FALSE; 290 ierr = PetscOptionsName("-ts_monitor_draw_error","Monitor error graphically","TSMonitorDrawError",&opt);CHKERRQ(ierr); 291 if (opt) { 292 TSMonitorDrawCtx ctx; 293 PetscInt howoften = 1; 294 295 ierr = PetscOptionsInt("-ts_monitor_draw_error","Monitor error graphically","TSMonitorDrawError",howoften,&howoften,NULL);CHKERRQ(ierr); 296 ierr = TSMonitorDrawCtxCreate(PetscObjectComm((PetscObject)ts),0,"Error",PETSC_DECIDE,PETSC_DECIDE,300,300,howoften,&ctx);CHKERRQ(ierr); 297 ierr = TSMonitorSet(ts,TSMonitorDrawError,ctx,(PetscErrorCode (*)(void**))TSMonitorDrawCtxDestroy);CHKERRQ(ierr); 298 } 299 opt = PETSC_FALSE; 300 ierr = PetscOptionsName("-ts_monitor_draw_solution_function","Monitor solution provided by TSMonitorSetSolutionFunction() graphically","TSMonitorDrawSolutionFunction",&opt);CHKERRQ(ierr); 301 if (opt) { 302 TSMonitorDrawCtx ctx; 303 PetscInt howoften = 1; 304 305 ierr = PetscOptionsInt("-ts_monitor_draw_solution_function","Monitor solution provided by TSMonitorSetSolutionFunction() graphically","TSMonitorDrawSolutionFunction",howoften,&howoften,NULL);CHKERRQ(ierr); 306 ierr = TSMonitorDrawCtxCreate(PetscObjectComm((PetscObject)ts),0,"Solution provided by user function",PETSC_DECIDE,PETSC_DECIDE,300,300,howoften,&ctx);CHKERRQ(ierr); 307 ierr = TSMonitorSet(ts,TSMonitorDrawSolutionFunction,ctx,(PetscErrorCode (*)(void**))TSMonitorDrawCtxDestroy);CHKERRQ(ierr); 308 } 309 310 opt = PETSC_FALSE; 311 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); 312 if (flg) { 313 const char *ptr,*ptr2; 314 char *filetemplate; 315 if (!monfilename[0]) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_USER,"-ts_monitor_solution_vtk requires a file template, e.g. filename-%%03D.vts"); 316 /* Do some cursory validation of the input. */ 317 ierr = PetscStrstr(monfilename,"%",(char**)&ptr);CHKERRQ(ierr); 318 if (!ptr) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_USER,"-ts_monitor_solution_vtk requires a file template, e.g. filename-%%03D.vts"); 319 for (ptr++; ptr && *ptr; ptr++) { 320 ierr = PetscStrchr("DdiouxX",*ptr,(char**)&ptr2);CHKERRQ(ierr); 321 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"); 322 if (ptr2) break; 323 } 324 ierr = PetscStrallocpy(monfilename,&filetemplate);CHKERRQ(ierr); 325 ierr = TSMonitorSet(ts,TSMonitorSolutionVTK,filetemplate,(PetscErrorCode (*)(void**))TSMonitorSolutionVTKDestroy);CHKERRQ(ierr); 326 } 327 328 ierr = PetscOptionsString("-ts_monitor_dmda_ray","Display a ray of the solution","None","y=0",dir,16,&flg);CHKERRQ(ierr); 329 if (flg) { 330 TSMonitorDMDARayCtx *rayctx; 331 int ray = 0; 332 DMDADirection ddir; 333 DM da; 334 PetscMPIInt rank; 335 336 if (dir[1] != '=') SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_WRONG,"Unknown ray %s",dir); 337 if (dir[0] == 'x') ddir = DMDA_X; 338 else if (dir[0] == 'y') ddir = DMDA_Y; 339 else SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_WRONG,"Unknown ray %s",dir); 340 sscanf(dir+2,"%d",&ray); 341 342 ierr = PetscInfo2(((PetscObject)ts),"Displaying DMDA ray %c = %D\n",dir[0],ray);CHKERRQ(ierr); 343 ierr = PetscNew(&rayctx);CHKERRQ(ierr); 344 ierr = TSGetDM(ts,&da);CHKERRQ(ierr); 345 ierr = DMDAGetRay(da,ddir,ray,&rayctx->ray,&rayctx->scatter);CHKERRQ(ierr); 346 ierr = MPI_Comm_rank(PetscObjectComm((PetscObject)ts),&rank);CHKERRQ(ierr); 347 if (!rank) { 348 ierr = PetscViewerDrawOpen(PETSC_COMM_SELF,0,0,0,0,600,300,&rayctx->viewer);CHKERRQ(ierr); 349 } 350 rayctx->lgctx = NULL; 351 ierr = TSMonitorSet(ts,TSMonitorDMDARay,rayctx,TSMonitorDMDARayDestroy);CHKERRQ(ierr); 352 } 353 ierr = PetscOptionsString("-ts_monitor_lg_dmda_ray","Display a ray of the solution","None","x=0",dir,16,&flg);CHKERRQ(ierr); 354 if (flg) { 355 TSMonitorDMDARayCtx *rayctx; 356 int ray = 0; 357 DMDADirection ddir; 358 DM da; 359 PetscInt howoften = 1; 360 361 if (dir[1] != '=') SETERRQ1(PetscObjectComm((PetscObject) ts), PETSC_ERR_ARG_WRONG, "Malformed ray %s", dir); 362 if (dir[0] == 'x') ddir = DMDA_X; 363 else if (dir[0] == 'y') ddir = DMDA_Y; 364 else SETERRQ1(PetscObjectComm((PetscObject) ts), PETSC_ERR_ARG_WRONG, "Unknown ray direction %s", dir); 365 sscanf(dir+2, "%d", &ray); 366 367 ierr = PetscInfo2(((PetscObject) ts),"Displaying LG DMDA ray %c = %D\n", dir[0], ray);CHKERRQ(ierr); 368 ierr = PetscNew(&rayctx);CHKERRQ(ierr); 369 ierr = TSGetDM(ts, &da);CHKERRQ(ierr); 370 ierr = DMDAGetRay(da, ddir, ray, &rayctx->ray, &rayctx->scatter);CHKERRQ(ierr); 371 ierr = TSMonitorLGCtxCreate(PETSC_COMM_SELF,0,0,PETSC_DECIDE,PETSC_DECIDE,600,400,howoften,&rayctx->lgctx);CHKERRQ(ierr); 372 ierr = TSMonitorSet(ts, TSMonitorLGDMDARay, rayctx, TSMonitorDMDARayDestroy);CHKERRQ(ierr); 373 } 374 375 ierr = PetscOptionsName("-ts_monitor_envelope","Monitor maximum and minimum value of each component of the solution","TSMonitorEnvelope",&opt);CHKERRQ(ierr); 376 if (opt) { 377 TSMonitorEnvelopeCtx ctx; 378 379 ierr = TSMonitorEnvelopeCtxCreate(ts,&ctx);CHKERRQ(ierr); 380 ierr = TSMonitorSet(ts,TSMonitorEnvelope,ctx,(PetscErrorCode (*)(void**))TSMonitorEnvelopeCtxDestroy);CHKERRQ(ierr); 381 } 382 383 flg = PETSC_FALSE; 384 ierr = PetscOptionsBool("-ts_fd_color", "Use finite differences with coloring to compute IJacobian", "TSComputeJacobianDefaultColor", flg, &flg, NULL);CHKERRQ(ierr); 385 if (flg) { 386 DM dm; 387 DMTS tdm; 388 389 ierr = TSGetDM(ts, &dm);CHKERRQ(ierr); 390 ierr = DMGetDMTS(dm, &tdm);CHKERRQ(ierr); 391 tdm->ijacobianctx = NULL; 392 ierr = TSSetIJacobian(ts, NULL, NULL, TSComputeIJacobianDefaultColor, 0);CHKERRQ(ierr); 393 ierr = PetscInfo(ts, "Setting default finite difference coloring Jacobian matrix\n");CHKERRQ(ierr); 394 } 395 396 /* Handle specific TS options */ 397 if (ts->ops->setfromoptions) { 398 ierr = (*ts->ops->setfromoptions)(PetscOptionsObject,ts);CHKERRQ(ierr); 399 } 400 401 /* Handle TSAdapt options */ 402 ierr = TSGetAdapt(ts,&ts->adapt);CHKERRQ(ierr); 403 ierr = TSAdaptSetDefaultType(ts->adapt,ts->default_adapt_type);CHKERRQ(ierr); 404 ierr = TSAdaptSetFromOptions(PetscOptionsObject,ts->adapt);CHKERRQ(ierr); 405 406 /* TS trajectory must be set after TS, since it may use some TS options above */ 407 tflg = ts->trajectory ? PETSC_TRUE : PETSC_FALSE; 408 ierr = PetscOptionsBool("-ts_save_trajectory","Save the solution at each timestep","TSSetSaveTrajectory",tflg,&tflg,NULL);CHKERRQ(ierr); 409 if (tflg) { 410 ierr = TSSetSaveTrajectory(ts);CHKERRQ(ierr); 411 } 412 413 ierr = TSAdjointSetFromOptions(PetscOptionsObject,ts);CHKERRQ(ierr); 414 415 /* process any options handlers added with PetscObjectAddOptionsHandler() */ 416 ierr = PetscObjectProcessOptionsHandlers(PetscOptionsObject,(PetscObject)ts);CHKERRQ(ierr); 417 ierr = PetscOptionsEnd();CHKERRQ(ierr); 418 419 if (ts->trajectory) { 420 ierr = TSTrajectorySetFromOptions(ts->trajectory,ts);CHKERRQ(ierr); 421 } 422 423 /* why do we have to do this here and not during TSSetUp? */ 424 ierr = TSGetSNES(ts,&ts->snes);CHKERRQ(ierr); 425 if (ts->problem_type == TS_LINEAR) { 426 ierr = PetscObjectTypeCompareAny((PetscObject)ts->snes,&flg,SNESKSPONLY,SNESKSPTRANSPOSEONLY,"");CHKERRQ(ierr); 427 if (!flg) { ierr = SNESSetType(ts->snes,SNESKSPONLY);CHKERRQ(ierr); } 428 } 429 ierr = SNESSetFromOptions(ts->snes);CHKERRQ(ierr); 430 PetscFunctionReturn(0); 431 } 432 433 /*@ 434 TSGetTrajectory - Gets the trajectory from a TS if it exists 435 436 Collective on TS 437 438 Input Parameters: 439 . ts - the TS context obtained from TSCreate() 440 441 Output Parameters; 442 . tr - the TSTrajectory object, if it exists 443 444 Note: This routine should be called after all TS options have been set 445 446 Level: advanced 447 448 .seealso: TSGetTrajectory(), TSAdjointSolve(), TSTrajectory, TSTrajectoryCreate() 449 450 .keywords: TS, set, checkpoint, 451 @*/ 452 PetscErrorCode TSGetTrajectory(TS ts,TSTrajectory *tr) 453 { 454 PetscFunctionBegin; 455 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 456 *tr = ts->trajectory; 457 PetscFunctionReturn(0); 458 } 459 460 /*@ 461 TSSetSaveTrajectory - Causes the TS to save its solutions as it iterates forward in time in a TSTrajectory object 462 463 Collective on TS 464 465 Input Parameters: 466 . ts - the TS context obtained from TSCreate() 467 468 Options Database: 469 + -ts_save_trajectory - saves the trajectory to a file 470 - -ts_trajectory_type type 471 472 Note: This routine should be called after all TS options have been set 473 474 The TSTRAJECTORYVISUALIZATION files can be loaded into Python with $PETSC_DIR/lib/petsc/bin/PetscBinaryIOTrajectory.py and 475 MATLAB with $PETSC_DIR/share/petsc/matlab/PetscReadBinaryTrajectory.m 476 477 Level: intermediate 478 479 .seealso: TSGetTrajectory(), TSAdjointSolve() 480 481 .keywords: TS, set, checkpoint, 482 @*/ 483 PetscErrorCode TSSetSaveTrajectory(TS ts) 484 { 485 PetscErrorCode ierr; 486 487 PetscFunctionBegin; 488 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 489 if (!ts->trajectory) { 490 ierr = TSTrajectoryCreate(PetscObjectComm((PetscObject)ts),&ts->trajectory);CHKERRQ(ierr); 491 } 492 PetscFunctionReturn(0); 493 } 494 495 /*@ 496 TSResetTrajectory - Destroys and recreates the internal TSTrajectory object 497 498 Collective on TS 499 500 Input Parameters: 501 . ts - the TS context obtained from TSCreate() 502 503 Level: intermediate 504 505 .seealso: TSGetTrajectory(), TSAdjointSolve() 506 507 .keywords: TS, set, checkpoint, 508 @*/ 509 PetscErrorCode TSResetTrajectory(TS ts) 510 { 511 PetscErrorCode ierr; 512 513 PetscFunctionBegin; 514 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 515 if (ts->trajectory) { 516 ierr = TSTrajectoryDestroy(&ts->trajectory);CHKERRQ(ierr); 517 ierr = TSTrajectoryCreate(PetscObjectComm((PetscObject)ts),&ts->trajectory);CHKERRQ(ierr); 518 } 519 PetscFunctionReturn(0); 520 } 521 522 /*@ 523 TSComputeRHSJacobian - Computes the Jacobian matrix that has been 524 set with TSSetRHSJacobian(). 525 526 Collective on TS and Vec 527 528 Input Parameters: 529 + ts - the TS context 530 . t - current timestep 531 - U - input vector 532 533 Output Parameters: 534 + A - Jacobian matrix 535 . B - optional preconditioning matrix 536 - flag - flag indicating matrix structure 537 538 Notes: 539 Most users should not need to explicitly call this routine, as it 540 is used internally within the nonlinear solvers. 541 542 See KSPSetOperators() for important information about setting the 543 flag parameter. 544 545 Level: developer 546 547 .keywords: SNES, compute, Jacobian, matrix 548 549 .seealso: TSSetRHSJacobian(), KSPSetOperators() 550 @*/ 551 PetscErrorCode TSComputeRHSJacobian(TS ts,PetscReal t,Vec U,Mat A,Mat B) 552 { 553 PetscErrorCode ierr; 554 PetscObjectState Ustate; 555 PetscObjectId Uid; 556 DM dm; 557 DMTS tsdm; 558 TSRHSJacobian rhsjacobianfunc; 559 void *ctx; 560 TSIJacobian ijacobianfunc; 561 TSRHSFunction rhsfunction; 562 563 PetscFunctionBegin; 564 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 565 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 566 PetscCheckSameComm(ts,1,U,3); 567 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 568 ierr = DMGetDMTS(dm,&tsdm);CHKERRQ(ierr); 569 ierr = DMTSGetRHSJacobian(dm,&rhsjacobianfunc,&ctx);CHKERRQ(ierr); 570 ierr = DMTSGetIJacobian(dm,&ijacobianfunc,NULL);CHKERRQ(ierr); 571 ierr = DMTSGetRHSFunction(dm,&rhsfunction,&ctx);CHKERRQ(ierr); 572 ierr = PetscObjectStateGet((PetscObject)U,&Ustate);CHKERRQ(ierr); 573 ierr = PetscObjectGetId((PetscObject)U,&Uid);CHKERRQ(ierr); 574 575 if (ts->rhsjacobian.time == t && (ts->problem_type == TS_LINEAR || (ts->rhsjacobian.Xid == Uid && ts->rhsjacobian.Xstate == Ustate)) && (rhsfunction != TSComputeRHSFunctionLinear)) { 576 /* restore back RHS Jacobian matrices if they have been shifted/scaled */ 577 if (A == ts->Arhs) { 578 if (ts->rhsjacobian.shift != 0) { 579 ierr = MatShift(A,-ts->rhsjacobian.shift);CHKERRQ(ierr); 580 } 581 if (ts->rhsjacobian.scale != 1.) { 582 ierr = MatScale(A,1./ts->rhsjacobian.scale);CHKERRQ(ierr); 583 } 584 } 585 if (B && B == ts->Brhs && A != B) { 586 if (ts->rhsjacobian.shift != 0) { 587 ierr = MatShift(B,-ts->rhsjacobian.shift);CHKERRQ(ierr); 588 } 589 if (ts->rhsjacobian.scale != 1.) { 590 ierr = MatScale(B,1./ts->rhsjacobian.scale);CHKERRQ(ierr); 591 } 592 } 593 ts->rhsjacobian.shift = 0; 594 ts->rhsjacobian.scale = 1.; 595 PetscFunctionReturn(0); 596 } 597 598 if (!rhsjacobianfunc && !ijacobianfunc) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_USER,"Must call TSSetRHSJacobian() and / or TSSetIJacobian()"); 599 600 if (ts->rhsjacobian.reuse) { 601 if (A == ts->Arhs) { 602 /* MatScale has a short path for this case. 603 However, this code path is taken the first time TSComputeRHSJacobian is called 604 and the matrices have not assembled yet */ 605 if (ts->rhsjacobian.shift != 0) { 606 ierr = MatShift(A,-ts->rhsjacobian.shift);CHKERRQ(ierr); 607 } 608 if (ts->rhsjacobian.scale != 1.) { 609 ierr = MatScale(A,1./ts->rhsjacobian.scale);CHKERRQ(ierr); 610 } 611 } 612 if (B && B == ts->Brhs && A != B) { 613 if (ts->rhsjacobian.shift != 0) { 614 ierr = MatShift(B,-ts->rhsjacobian.shift);CHKERRQ(ierr); 615 } 616 if (ts->rhsjacobian.scale != 1.) { 617 ierr = MatScale(B,1./ts->rhsjacobian.scale);CHKERRQ(ierr); 618 } 619 } 620 } 621 622 if (rhsjacobianfunc) { 623 PetscBool missing; 624 ierr = PetscLogEventBegin(TS_JacobianEval,ts,U,A,B);CHKERRQ(ierr); 625 PetscStackPush("TS user Jacobian function"); 626 ierr = (*rhsjacobianfunc)(ts,t,U,A,B,ctx);CHKERRQ(ierr); 627 PetscStackPop; 628 ierr = PetscLogEventEnd(TS_JacobianEval,ts,U,A,B);CHKERRQ(ierr); 629 if (A) { 630 ierr = MatMissingDiagonal(A,&missing,NULL);CHKERRQ(ierr); 631 if (missing) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"Amat passed to TSSetRHSJacobian() must have all diagonal entries set, if they are zero you must still set them with a zero value"); 632 } 633 if (B && B != A) { 634 ierr = MatMissingDiagonal(B,&missing,NULL);CHKERRQ(ierr); 635 if (missing) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"Bmat passed to TSSetRHSJacobian() must have all diagonal entries set, if they are zero you must still set them with a zero value"); 636 } 637 } else { 638 ierr = MatZeroEntries(A);CHKERRQ(ierr); 639 if (B && A != B) {ierr = MatZeroEntries(B);CHKERRQ(ierr);} 640 } 641 ts->rhsjacobian.time = t; 642 ts->rhsjacobian.shift = 0; 643 ts->rhsjacobian.scale = 1.; 644 ierr = PetscObjectGetId((PetscObject)U,&ts->rhsjacobian.Xid);CHKERRQ(ierr); 645 ierr = PetscObjectStateGet((PetscObject)U,&ts->rhsjacobian.Xstate);CHKERRQ(ierr); 646 PetscFunctionReturn(0); 647 } 648 649 /*@ 650 TSComputeRHSFunction - Evaluates the right-hand-side function. 651 652 Collective on TS and Vec 653 654 Input Parameters: 655 + ts - the TS context 656 . t - current time 657 - U - state vector 658 659 Output Parameter: 660 . y - right hand side 661 662 Note: 663 Most users should not need to explicitly call this routine, as it 664 is used internally within the nonlinear solvers. 665 666 Level: developer 667 668 .keywords: TS, compute 669 670 .seealso: TSSetRHSFunction(), TSComputeIFunction() 671 @*/ 672 PetscErrorCode TSComputeRHSFunction(TS ts,PetscReal t,Vec U,Vec y) 673 { 674 PetscErrorCode ierr; 675 TSRHSFunction rhsfunction; 676 TSIFunction ifunction; 677 void *ctx; 678 DM dm; 679 680 PetscFunctionBegin; 681 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 682 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 683 PetscValidHeaderSpecific(y,VEC_CLASSID,4); 684 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 685 ierr = DMTSGetRHSFunction(dm,&rhsfunction,&ctx);CHKERRQ(ierr); 686 ierr = DMTSGetIFunction(dm,&ifunction,NULL);CHKERRQ(ierr); 687 688 if (!rhsfunction && !ifunction) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_USER,"Must call TSSetRHSFunction() and / or TSSetIFunction()"); 689 690 ierr = PetscLogEventBegin(TS_FunctionEval,ts,U,y,0);CHKERRQ(ierr); 691 if (rhsfunction) { 692 PetscStackPush("TS user right-hand-side function"); 693 ierr = (*rhsfunction)(ts,t,U,y,ctx);CHKERRQ(ierr); 694 PetscStackPop; 695 } else { 696 ierr = VecZeroEntries(y);CHKERRQ(ierr); 697 } 698 699 ierr = PetscLogEventEnd(TS_FunctionEval,ts,U,y,0);CHKERRQ(ierr); 700 PetscFunctionReturn(0); 701 } 702 703 /*@ 704 TSComputeSolutionFunction - Evaluates the solution function. 705 706 Collective on TS and Vec 707 708 Input Parameters: 709 + ts - the TS context 710 - t - current time 711 712 Output Parameter: 713 . U - the solution 714 715 Note: 716 Most users should not need to explicitly call this routine, as it 717 is used internally within the nonlinear solvers. 718 719 Level: developer 720 721 .keywords: TS, compute 722 723 .seealso: TSSetSolutionFunction(), TSSetRHSFunction(), TSComputeIFunction() 724 @*/ 725 PetscErrorCode TSComputeSolutionFunction(TS ts,PetscReal t,Vec U) 726 { 727 PetscErrorCode ierr; 728 TSSolutionFunction solutionfunction; 729 void *ctx; 730 DM dm; 731 732 PetscFunctionBegin; 733 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 734 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 735 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 736 ierr = DMTSGetSolutionFunction(dm,&solutionfunction,&ctx);CHKERRQ(ierr); 737 738 if (solutionfunction) { 739 PetscStackPush("TS user solution function"); 740 ierr = (*solutionfunction)(ts,t,U,ctx);CHKERRQ(ierr); 741 PetscStackPop; 742 } 743 PetscFunctionReturn(0); 744 } 745 /*@ 746 TSComputeForcingFunction - Evaluates the forcing function. 747 748 Collective on TS and Vec 749 750 Input Parameters: 751 + ts - the TS context 752 - t - current time 753 754 Output Parameter: 755 . U - the function value 756 757 Note: 758 Most users should not need to explicitly call this routine, as it 759 is used internally within the nonlinear solvers. 760 761 Level: developer 762 763 .keywords: TS, compute 764 765 .seealso: TSSetSolutionFunction(), TSSetRHSFunction(), TSComputeIFunction() 766 @*/ 767 PetscErrorCode TSComputeForcingFunction(TS ts,PetscReal t,Vec U) 768 { 769 PetscErrorCode ierr, (*forcing)(TS,PetscReal,Vec,void*); 770 void *ctx; 771 DM dm; 772 773 PetscFunctionBegin; 774 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 775 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 776 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 777 ierr = DMTSGetForcingFunction(dm,&forcing,&ctx);CHKERRQ(ierr); 778 779 if (forcing) { 780 PetscStackPush("TS user forcing function"); 781 ierr = (*forcing)(ts,t,U,ctx);CHKERRQ(ierr); 782 PetscStackPop; 783 } 784 PetscFunctionReturn(0); 785 } 786 787 static PetscErrorCode TSGetRHSVec_Private(TS ts,Vec *Frhs) 788 { 789 Vec F; 790 PetscErrorCode ierr; 791 792 PetscFunctionBegin; 793 *Frhs = NULL; 794 ierr = TSGetIFunction(ts,&F,NULL,NULL);CHKERRQ(ierr); 795 if (!ts->Frhs) { 796 ierr = VecDuplicate(F,&ts->Frhs);CHKERRQ(ierr); 797 } 798 *Frhs = ts->Frhs; 799 PetscFunctionReturn(0); 800 } 801 802 PetscErrorCode TSGetRHSMats_Private(TS ts,Mat *Arhs,Mat *Brhs) 803 { 804 Mat A,B; 805 PetscErrorCode ierr; 806 TSIJacobian ijacobian; 807 808 PetscFunctionBegin; 809 if (Arhs) *Arhs = NULL; 810 if (Brhs) *Brhs = NULL; 811 ierr = TSGetIJacobian(ts,&A,&B,&ijacobian,NULL);CHKERRQ(ierr); 812 if (Arhs) { 813 if (!ts->Arhs) { 814 if (ijacobian) { 815 ierr = MatDuplicate(A,MAT_DO_NOT_COPY_VALUES,&ts->Arhs);CHKERRQ(ierr); 816 } else { 817 ts->Arhs = A; 818 ierr = PetscObjectReference((PetscObject)A);CHKERRQ(ierr); 819 } 820 } else { 821 PetscBool flg; 822 ierr = SNESGetUseMatrixFree(ts->snes,NULL,&flg);CHKERRQ(ierr); 823 /* Handle case where user provided only RHSJacobian and used -snes_mf_operator */ 824 if (flg && !ijacobian && ts->Arhs == ts->Brhs){ 825 ierr = PetscObjectDereference((PetscObject)ts->Arhs);CHKERRQ(ierr); 826 ts->Arhs = A; 827 ierr = PetscObjectReference((PetscObject)A);CHKERRQ(ierr); 828 } 829 } 830 *Arhs = ts->Arhs; 831 } 832 if (Brhs) { 833 if (!ts->Brhs) { 834 if (A != B) { 835 if (ijacobian) { 836 ierr = MatDuplicate(B,MAT_DO_NOT_COPY_VALUES,&ts->Brhs);CHKERRQ(ierr); 837 } else { 838 ts->Brhs = B; 839 ierr = PetscObjectReference((PetscObject)B);CHKERRQ(ierr); 840 } 841 } else { 842 ierr = PetscObjectReference((PetscObject)ts->Arhs);CHKERRQ(ierr); 843 ts->Brhs = ts->Arhs; 844 } 845 } 846 *Brhs = ts->Brhs; 847 } 848 PetscFunctionReturn(0); 849 } 850 851 /*@ 852 TSComputeIFunction - Evaluates the DAE residual written in implicit form F(t,U,Udot)=0 853 854 Collective on TS and Vec 855 856 Input Parameters: 857 + ts - the TS context 858 . t - current time 859 . U - state vector 860 . Udot - time derivative of state vector 861 - imex - flag indicates if the method is IMEX so that the RHSFunction should be kept separate 862 863 Output Parameter: 864 . Y - right hand side 865 866 Note: 867 Most users should not need to explicitly call this routine, as it 868 is used internally within the nonlinear solvers. 869 870 If the user did did not write their equations in implicit form, this 871 function recasts them in implicit form. 872 873 Level: developer 874 875 .keywords: TS, compute 876 877 .seealso: TSSetIFunction(), TSComputeRHSFunction() 878 @*/ 879 PetscErrorCode TSComputeIFunction(TS ts,PetscReal t,Vec U,Vec Udot,Vec Y,PetscBool imex) 880 { 881 PetscErrorCode ierr; 882 TSIFunction ifunction; 883 TSRHSFunction rhsfunction; 884 void *ctx; 885 DM dm; 886 887 PetscFunctionBegin; 888 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 889 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 890 PetscValidHeaderSpecific(Udot,VEC_CLASSID,4); 891 PetscValidHeaderSpecific(Y,VEC_CLASSID,5); 892 893 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 894 ierr = DMTSGetIFunction(dm,&ifunction,&ctx);CHKERRQ(ierr); 895 ierr = DMTSGetRHSFunction(dm,&rhsfunction,NULL);CHKERRQ(ierr); 896 897 if (!rhsfunction && !ifunction) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_USER,"Must call TSSetRHSFunction() and / or TSSetIFunction()"); 898 899 ierr = PetscLogEventBegin(TS_FunctionEval,ts,U,Udot,Y);CHKERRQ(ierr); 900 if (ifunction) { 901 PetscStackPush("TS user implicit function"); 902 ierr = (*ifunction)(ts,t,U,Udot,Y,ctx);CHKERRQ(ierr); 903 PetscStackPop; 904 } 905 if (imex) { 906 if (!ifunction) { 907 ierr = VecCopy(Udot,Y);CHKERRQ(ierr); 908 } 909 } else if (rhsfunction) { 910 if (ifunction) { 911 Vec Frhs; 912 ierr = TSGetRHSVec_Private(ts,&Frhs);CHKERRQ(ierr); 913 ierr = TSComputeRHSFunction(ts,t,U,Frhs);CHKERRQ(ierr); 914 ierr = VecAXPY(Y,-1,Frhs);CHKERRQ(ierr); 915 } else { 916 ierr = TSComputeRHSFunction(ts,t,U,Y);CHKERRQ(ierr); 917 ierr = VecAYPX(Y,-1,Udot);CHKERRQ(ierr); 918 } 919 } 920 ierr = PetscLogEventEnd(TS_FunctionEval,ts,U,Udot,Y);CHKERRQ(ierr); 921 PetscFunctionReturn(0); 922 } 923 924 /*@ 925 TSComputeIJacobian - Evaluates the Jacobian of the DAE 926 927 Collective on TS and Vec 928 929 Input 930 Input Parameters: 931 + ts - the TS context 932 . t - current timestep 933 . U - state vector 934 . Udot - time derivative of state vector 935 . shift - shift to apply, see note below 936 - imex - flag indicates if the method is IMEX so that the RHSJacobian should be kept separate 937 938 Output Parameters: 939 + A - Jacobian matrix 940 - B - matrix from which the preconditioner is constructed; often the same as A 941 942 Notes: 943 If F(t,U,Udot)=0 is the DAE, the required Jacobian is 944 945 dF/dU + shift*dF/dUdot 946 947 Most users should not need to explicitly call this routine, as it 948 is used internally within the nonlinear solvers. 949 950 Level: developer 951 952 .keywords: TS, compute, Jacobian, matrix 953 954 .seealso: TSSetIJacobian() 955 @*/ 956 PetscErrorCode TSComputeIJacobian(TS ts,PetscReal t,Vec U,Vec Udot,PetscReal shift,Mat A,Mat B,PetscBool imex) 957 { 958 PetscErrorCode ierr; 959 TSIJacobian ijacobian; 960 TSRHSJacobian rhsjacobian; 961 DM dm; 962 void *ctx; 963 964 PetscFunctionBegin; 965 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 966 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 967 PetscValidHeaderSpecific(Udot,VEC_CLASSID,4); 968 PetscValidPointer(A,6); 969 PetscValidHeaderSpecific(A,MAT_CLASSID,6); 970 PetscValidPointer(B,7); 971 PetscValidHeaderSpecific(B,MAT_CLASSID,7); 972 973 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 974 ierr = DMTSGetIJacobian(dm,&ijacobian,&ctx);CHKERRQ(ierr); 975 ierr = DMTSGetRHSJacobian(dm,&rhsjacobian,NULL);CHKERRQ(ierr); 976 977 if (!rhsjacobian && !ijacobian) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_USER,"Must call TSSetRHSJacobian() and / or TSSetIJacobian()"); 978 979 ierr = PetscLogEventBegin(TS_JacobianEval,ts,U,A,B);CHKERRQ(ierr); 980 if (ijacobian) { 981 PetscBool missing; 982 PetscStackPush("TS user implicit Jacobian"); 983 ierr = (*ijacobian)(ts,t,U,Udot,shift,A,B,ctx);CHKERRQ(ierr); 984 PetscStackPop; 985 ierr = MatMissingDiagonal(A,&missing,NULL);CHKERRQ(ierr); 986 if (missing) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"Amat passed to TSSetIJacobian() must have all diagonal entries set, if they are zero you must still set them with a zero value"); 987 if (B != A) { 988 ierr = MatMissingDiagonal(B,&missing,NULL);CHKERRQ(ierr); 989 if (missing) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"Bmat passed to TSSetIJacobian() must have all diagonal entries set, if they are zero you must still set them with a zero value"); 990 } 991 } 992 if (imex) { 993 if (!ijacobian) { /* system was written as Udot = G(t,U) */ 994 PetscBool assembled; 995 if (rhsjacobian) { 996 Mat Arhs = NULL; 997 ierr = TSGetRHSMats_Private(ts,&Arhs,NULL);CHKERRQ(ierr); 998 if (A == Arhs) { 999 if (rhsjacobian == TSComputeRHSJacobianConstant) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"Unsupported operation! cannot use TSComputeRHSJacobianConstant"); 1000 ts->rhsjacobian.time = PETSC_MIN_REAL; 1001 } 1002 } 1003 ierr = MatZeroEntries(A);CHKERRQ(ierr); 1004 ierr = MatAssembled(A,&assembled);CHKERRQ(ierr); 1005 if (!assembled) { 1006 ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); 1007 ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); 1008 } 1009 ierr = MatShift(A,shift);CHKERRQ(ierr); 1010 if (A != B) { 1011 ierr = MatZeroEntries(B);CHKERRQ(ierr); 1012 ierr = MatAssembled(B,&assembled);CHKERRQ(ierr); 1013 if (!assembled) { 1014 ierr = MatAssemblyBegin(B,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); 1015 ierr = MatAssemblyEnd(B,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); 1016 } 1017 ierr = MatShift(B,shift);CHKERRQ(ierr); 1018 } 1019 } 1020 } else { 1021 Mat Arhs = NULL,Brhs = NULL; 1022 if (rhsjacobian) { 1023 ierr = TSGetRHSMats_Private(ts,&Arhs,&Brhs);CHKERRQ(ierr); 1024 ierr = TSComputeRHSJacobian(ts,t,U,Arhs,Brhs);CHKERRQ(ierr); 1025 } 1026 if (Arhs == A) { /* No IJacobian, so we only have the RHS matrix */ 1027 PetscBool flg; 1028 ts->rhsjacobian.scale = -1; 1029 ts->rhsjacobian.shift = shift; 1030 ierr = SNESGetUseMatrixFree(ts->snes,NULL,&flg);CHKERRQ(ierr); 1031 /* since -snes_mf_operator uses the full SNES function it does not need to be shifted or scaled here */ 1032 if (!flg) { 1033 ierr = MatScale(A,-1);CHKERRQ(ierr); 1034 ierr = MatShift(A,shift);CHKERRQ(ierr); 1035 } 1036 if (A != B) { 1037 ierr = MatScale(B,-1);CHKERRQ(ierr); 1038 ierr = MatShift(B,shift);CHKERRQ(ierr); 1039 } 1040 } else if (Arhs) { /* Both IJacobian and RHSJacobian */ 1041 MatStructure axpy = DIFFERENT_NONZERO_PATTERN; 1042 if (!ijacobian) { /* No IJacobian provided, but we have a separate RHS matrix */ 1043 ierr = MatZeroEntries(A);CHKERRQ(ierr); 1044 ierr = MatShift(A,shift);CHKERRQ(ierr); 1045 if (A != B) { 1046 ierr = MatZeroEntries(B);CHKERRQ(ierr); 1047 ierr = MatShift(B,shift);CHKERRQ(ierr); 1048 } 1049 } 1050 ierr = MatAXPY(A,-1,Arhs,axpy);CHKERRQ(ierr); 1051 if (A != B) { 1052 ierr = MatAXPY(B,-1,Brhs,axpy);CHKERRQ(ierr); 1053 } 1054 } 1055 } 1056 ierr = PetscLogEventEnd(TS_JacobianEval,ts,U,A,B);CHKERRQ(ierr); 1057 PetscFunctionReturn(0); 1058 } 1059 1060 /*@C 1061 TSSetRHSFunction - Sets the routine for evaluating the function, 1062 where U_t = G(t,u). 1063 1064 Logically Collective on TS 1065 1066 Input Parameters: 1067 + ts - the TS context obtained from TSCreate() 1068 . r - vector to put the computed right hand side (or NULL to have it created) 1069 . f - routine for evaluating the right-hand-side function 1070 - ctx - [optional] user-defined context for private data for the 1071 function evaluation routine (may be NULL) 1072 1073 Calling sequence of func: 1074 $ func (TS ts,PetscReal t,Vec u,Vec F,void *ctx); 1075 1076 + t - current timestep 1077 . u - input vector 1078 . F - function vector 1079 - ctx - [optional] user-defined function context 1080 1081 Level: beginner 1082 1083 Notes: 1084 You must call this function or TSSetIFunction() to define your ODE. You cannot use this function when solving a DAE. 1085 1086 .keywords: TS, timestep, set, right-hand-side, function 1087 1088 .seealso: TSSetRHSJacobian(), TSSetIJacobian(), TSSetIFunction() 1089 @*/ 1090 PetscErrorCode TSSetRHSFunction(TS ts,Vec r,PetscErrorCode (*f)(TS,PetscReal,Vec,Vec,void*),void *ctx) 1091 { 1092 PetscErrorCode ierr; 1093 SNES snes; 1094 Vec ralloc = NULL; 1095 DM dm; 1096 1097 PetscFunctionBegin; 1098 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1099 if (r) PetscValidHeaderSpecific(r,VEC_CLASSID,2); 1100 1101 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1102 ierr = DMTSSetRHSFunction(dm,f,ctx);CHKERRQ(ierr); 1103 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 1104 if (!r && !ts->dm && ts->vec_sol) { 1105 ierr = VecDuplicate(ts->vec_sol,&ralloc);CHKERRQ(ierr); 1106 r = ralloc; 1107 } 1108 ierr = SNESSetFunction(snes,r,SNESTSFormFunction,ts);CHKERRQ(ierr); 1109 ierr = VecDestroy(&ralloc);CHKERRQ(ierr); 1110 PetscFunctionReturn(0); 1111 } 1112 1113 /*@C 1114 TSSetSolutionFunction - Provide a function that computes the solution of the ODE or DAE 1115 1116 Logically Collective on TS 1117 1118 Input Parameters: 1119 + ts - the TS context obtained from TSCreate() 1120 . f - routine for evaluating the solution 1121 - ctx - [optional] user-defined context for private data for the 1122 function evaluation routine (may be NULL) 1123 1124 Calling sequence of func: 1125 $ func (TS ts,PetscReal t,Vec u,void *ctx); 1126 1127 + t - current timestep 1128 . u - output vector 1129 - ctx - [optional] user-defined function context 1130 1131 Options Database: 1132 + -ts_monitor_lg_error - create a graphical monitor of error history, requires user to have provided TSSetSolutionFunction() 1133 - -ts_monitor_draw_error - Monitor error graphically, requires user to have provided TSSetSolutionFunction() 1134 1135 Notes: 1136 This routine is used for testing accuracy of time integration schemes when you already know the solution. 1137 If analytic solutions are not known for your system, consider using the Method of Manufactured Solutions to 1138 create closed-form solutions with non-physical forcing terms. 1139 1140 For low-dimensional problems solved in serial, such as small discrete systems, TSMonitorLGError() can be used to monitor the error history. 1141 1142 Level: beginner 1143 1144 .keywords: TS, timestep, set, right-hand-side, function 1145 1146 .seealso: TSSetRHSJacobian(), TSSetIJacobian(), TSComputeSolutionFunction(), TSSetForcingFunction(), TSSetSolution(), TSGetSolution(), TSMonitorLGError(), TSMonitorDrawError() 1147 @*/ 1148 PetscErrorCode TSSetSolutionFunction(TS ts,PetscErrorCode (*f)(TS,PetscReal,Vec,void*),void *ctx) 1149 { 1150 PetscErrorCode ierr; 1151 DM dm; 1152 1153 PetscFunctionBegin; 1154 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1155 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1156 ierr = DMTSSetSolutionFunction(dm,f,ctx);CHKERRQ(ierr); 1157 PetscFunctionReturn(0); 1158 } 1159 1160 /*@C 1161 TSSetForcingFunction - Provide a function that computes a forcing term for a ODE or PDE 1162 1163 Logically Collective on TS 1164 1165 Input Parameters: 1166 + ts - the TS context obtained from TSCreate() 1167 . func - routine for evaluating the forcing function 1168 - ctx - [optional] user-defined context for private data for the 1169 function evaluation routine (may be NULL) 1170 1171 Calling sequence of func: 1172 $ func (TS ts,PetscReal t,Vec f,void *ctx); 1173 1174 + t - current timestep 1175 . f - output vector 1176 - ctx - [optional] user-defined function context 1177 1178 Notes: 1179 This routine is useful for testing accuracy of time integration schemes when using the Method of Manufactured Solutions to 1180 create closed-form solutions with a non-physical forcing term. It allows you to use the Method of Manufactored Solution without directly editing the 1181 definition of the problem you are solving and hence possibly introducing bugs. 1182 1183 This replaces the ODE F(u,u_t,t) = 0 the TS is solving with F(u,u_t,t) - func(t) = 0 1184 1185 This forcing function does not depend on the solution to the equations, it can only depend on spatial location, time, and possibly parameters, the 1186 parameters can be passed in the ctx variable. 1187 1188 For low-dimensional problems solved in serial, such as small discrete systems, TSMonitorLGError() can be used to monitor the error history. 1189 1190 Level: beginner 1191 1192 .keywords: TS, timestep, set, right-hand-side, function 1193 1194 .seealso: TSSetRHSJacobian(), TSSetIJacobian(), TSComputeSolutionFunction(), TSSetSolutionFunction() 1195 @*/ 1196 PetscErrorCode TSSetForcingFunction(TS ts,TSForcingFunction func,void *ctx) 1197 { 1198 PetscErrorCode ierr; 1199 DM dm; 1200 1201 PetscFunctionBegin; 1202 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1203 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1204 ierr = DMTSSetForcingFunction(dm,func,ctx);CHKERRQ(ierr); 1205 PetscFunctionReturn(0); 1206 } 1207 1208 /*@C 1209 TSSetRHSJacobian - Sets the function to compute the Jacobian of G, 1210 where U_t = G(U,t), as well as the location to store the matrix. 1211 1212 Logically Collective on TS 1213 1214 Input Parameters: 1215 + ts - the TS context obtained from TSCreate() 1216 . Amat - (approximate) Jacobian matrix 1217 . Pmat - matrix from which preconditioner is to be constructed (usually the same as Amat) 1218 . f - the Jacobian evaluation routine 1219 - ctx - [optional] user-defined context for private data for the 1220 Jacobian evaluation routine (may be NULL) 1221 1222 Calling sequence of f: 1223 $ func (TS ts,PetscReal t,Vec u,Mat A,Mat B,void *ctx); 1224 1225 + t - current timestep 1226 . u - input vector 1227 . Amat - (approximate) Jacobian matrix 1228 . Pmat - matrix from which preconditioner is to be constructed (usually the same as Amat) 1229 - ctx - [optional] user-defined context for matrix evaluation routine 1230 1231 Notes: 1232 You must set all the diagonal entries of the matrices, if they are zero you must still set them with a zero value 1233 1234 The TS solver may modify the nonzero structure and the entries of the matrices Amat and Pmat between the calls to f() 1235 You should not assume the values are the same in the next call to f() as you set them in the previous call. 1236 1237 Level: beginner 1238 1239 .keywords: TS, timestep, set, right-hand-side, Jacobian 1240 1241 .seealso: SNESComputeJacobianDefaultColor(), TSSetRHSFunction(), TSRHSJacobianSetReuse(), TSSetIJacobian() 1242 1243 @*/ 1244 PetscErrorCode TSSetRHSJacobian(TS ts,Mat Amat,Mat Pmat,TSRHSJacobian f,void *ctx) 1245 { 1246 PetscErrorCode ierr; 1247 SNES snes; 1248 DM dm; 1249 TSIJacobian ijacobian; 1250 1251 PetscFunctionBegin; 1252 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1253 if (Amat) PetscValidHeaderSpecific(Amat,MAT_CLASSID,2); 1254 if (Pmat) PetscValidHeaderSpecific(Pmat,MAT_CLASSID,3); 1255 if (Amat) PetscCheckSameComm(ts,1,Amat,2); 1256 if (Pmat) PetscCheckSameComm(ts,1,Pmat,3); 1257 1258 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1259 ierr = DMTSSetRHSJacobian(dm,f,ctx);CHKERRQ(ierr); 1260 if (f == TSComputeRHSJacobianConstant) { 1261 /* Handle this case automatically for the user; otherwise user should call themselves. */ 1262 ierr = TSRHSJacobianSetReuse(ts,PETSC_TRUE);CHKERRQ(ierr); 1263 } 1264 ierr = DMTSGetIJacobian(dm,&ijacobian,NULL);CHKERRQ(ierr); 1265 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 1266 if (!ijacobian) { 1267 ierr = SNESSetJacobian(snes,Amat,Pmat,SNESTSFormJacobian,ts);CHKERRQ(ierr); 1268 } 1269 if (Amat) { 1270 ierr = PetscObjectReference((PetscObject)Amat);CHKERRQ(ierr); 1271 ierr = MatDestroy(&ts->Arhs);CHKERRQ(ierr); 1272 ts->Arhs = Amat; 1273 } 1274 if (Pmat) { 1275 ierr = PetscObjectReference((PetscObject)Pmat);CHKERRQ(ierr); 1276 ierr = MatDestroy(&ts->Brhs);CHKERRQ(ierr); 1277 ts->Brhs = Pmat; 1278 } 1279 PetscFunctionReturn(0); 1280 } 1281 1282 /*@C 1283 TSSetIFunction - Set the function to compute F(t,U,U_t) where F() = 0 is the DAE to be solved. 1284 1285 Logically Collective on TS 1286 1287 Input Parameters: 1288 + ts - the TS context obtained from TSCreate() 1289 . r - vector to hold the residual (or NULL to have it created internally) 1290 . f - the function evaluation routine 1291 - ctx - user-defined context for private data for the function evaluation routine (may be NULL) 1292 1293 Calling sequence of f: 1294 $ f(TS ts,PetscReal t,Vec u,Vec u_t,Vec F,ctx); 1295 1296 + t - time at step/stage being solved 1297 . u - state vector 1298 . u_t - time derivative of state vector 1299 . F - function vector 1300 - ctx - [optional] user-defined context for matrix evaluation routine 1301 1302 Important: 1303 The user MUST call either this routine or TSSetRHSFunction() to define the ODE. When solving DAEs you must use this function. 1304 1305 Level: beginner 1306 1307 .keywords: TS, timestep, set, DAE, Jacobian 1308 1309 .seealso: TSSetRHSJacobian(), TSSetRHSFunction(), TSSetIJacobian() 1310 @*/ 1311 PetscErrorCode TSSetIFunction(TS ts,Vec r,TSIFunction f,void *ctx) 1312 { 1313 PetscErrorCode ierr; 1314 SNES snes; 1315 Vec ralloc = NULL; 1316 DM dm; 1317 1318 PetscFunctionBegin; 1319 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1320 if (r) PetscValidHeaderSpecific(r,VEC_CLASSID,2); 1321 1322 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1323 ierr = DMTSSetIFunction(dm,f,ctx);CHKERRQ(ierr); 1324 1325 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 1326 if (!r && !ts->dm && ts->vec_sol) { 1327 ierr = VecDuplicate(ts->vec_sol,&ralloc);CHKERRQ(ierr); 1328 r = ralloc; 1329 } 1330 ierr = SNESSetFunction(snes,r,SNESTSFormFunction,ts);CHKERRQ(ierr); 1331 ierr = VecDestroy(&ralloc);CHKERRQ(ierr); 1332 PetscFunctionReturn(0); 1333 } 1334 1335 /*@C 1336 TSGetIFunction - Returns the vector where the implicit residual is stored and the function/contex to compute it. 1337 1338 Not Collective 1339 1340 Input Parameter: 1341 . ts - the TS context 1342 1343 Output Parameter: 1344 + r - vector to hold residual (or NULL) 1345 . func - the function to compute residual (or NULL) 1346 - ctx - the function context (or NULL) 1347 1348 Level: advanced 1349 1350 .keywords: TS, nonlinear, get, function 1351 1352 .seealso: TSSetIFunction(), SNESGetFunction() 1353 @*/ 1354 PetscErrorCode TSGetIFunction(TS ts,Vec *r,TSIFunction *func,void **ctx) 1355 { 1356 PetscErrorCode ierr; 1357 SNES snes; 1358 DM dm; 1359 1360 PetscFunctionBegin; 1361 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1362 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 1363 ierr = SNESGetFunction(snes,r,NULL,NULL);CHKERRQ(ierr); 1364 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1365 ierr = DMTSGetIFunction(dm,func,ctx);CHKERRQ(ierr); 1366 PetscFunctionReturn(0); 1367 } 1368 1369 /*@C 1370 TSGetRHSFunction - Returns the vector where the right hand side is stored and the function/context to compute it. 1371 1372 Not Collective 1373 1374 Input Parameter: 1375 . ts - the TS context 1376 1377 Output Parameter: 1378 + r - vector to hold computed right hand side (or NULL) 1379 . func - the function to compute right hand side (or NULL) 1380 - ctx - the function context (or NULL) 1381 1382 Level: advanced 1383 1384 .keywords: TS, nonlinear, get, function 1385 1386 .seealso: TSSetRHSFunction(), SNESGetFunction() 1387 @*/ 1388 PetscErrorCode TSGetRHSFunction(TS ts,Vec *r,TSRHSFunction *func,void **ctx) 1389 { 1390 PetscErrorCode ierr; 1391 SNES snes; 1392 DM dm; 1393 1394 PetscFunctionBegin; 1395 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1396 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 1397 ierr = SNESGetFunction(snes,r,NULL,NULL);CHKERRQ(ierr); 1398 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1399 ierr = DMTSGetRHSFunction(dm,func,ctx);CHKERRQ(ierr); 1400 PetscFunctionReturn(0); 1401 } 1402 1403 /*@C 1404 TSSetIJacobian - Set the function to compute the matrix dF/dU + a*dF/dU_t where F(t,U,U_t) is the function 1405 provided with TSSetIFunction(). 1406 1407 Logically Collective on TS 1408 1409 Input Parameters: 1410 + ts - the TS context obtained from TSCreate() 1411 . Amat - (approximate) Jacobian matrix 1412 . Pmat - matrix used to compute preconditioner (usually the same as Amat) 1413 . f - the Jacobian evaluation routine 1414 - ctx - user-defined context for private data for the Jacobian evaluation routine (may be NULL) 1415 1416 Calling sequence of f: 1417 $ f(TS ts,PetscReal t,Vec U,Vec U_t,PetscReal a,Mat Amat,Mat Pmat,void *ctx); 1418 1419 + t - time at step/stage being solved 1420 . U - state vector 1421 . U_t - time derivative of state vector 1422 . a - shift 1423 . Amat - (approximate) Jacobian of F(t,U,W+a*U), equivalent to dF/dU + a*dF/dU_t 1424 . Pmat - matrix used for constructing preconditioner, usually the same as Amat 1425 - ctx - [optional] user-defined context for matrix evaluation routine 1426 1427 Notes: 1428 The matrices Amat and Pmat are exactly the matrices that are used by SNES for the nonlinear solve. 1429 1430 If you know the operator Amat has a null space you can use MatSetNullSpace() and MatSetTransposeNullSpace() to supply the null 1431 space to Amat and the KSP solvers will automatically use that null space as needed during the solution process. 1432 1433 The matrix dF/dU + a*dF/dU_t you provide turns out to be 1434 the Jacobian of F(t,U,W+a*U) where F(t,U,U_t) = 0 is the DAE to be solved. 1435 The time integrator internally approximates U_t by W+a*U where the positive "shift" 1436 a and vector W depend on the integration method, step size, and past states. For example with 1437 the backward Euler method a = 1/dt and W = -a*U(previous timestep) so 1438 W + a*U = a*(U - U(previous timestep)) = (U - U(previous timestep))/dt 1439 1440 You must set all the diagonal entries of the matrices, if they are zero you must still set them with a zero value 1441 1442 The TS solver may modify the nonzero structure and the entries of the matrices Amat and Pmat between the calls to f() 1443 You should not assume the values are the same in the next call to f() as you set them in the previous call. 1444 1445 Level: beginner 1446 1447 .keywords: TS, timestep, DAE, Jacobian 1448 1449 .seealso: TSSetIFunction(), TSSetRHSJacobian(), SNESComputeJacobianDefaultColor(), SNESComputeJacobianDefault(), TSSetRHSFunction() 1450 1451 @*/ 1452 PetscErrorCode TSSetIJacobian(TS ts,Mat Amat,Mat Pmat,TSIJacobian f,void *ctx) 1453 { 1454 PetscErrorCode ierr; 1455 SNES snes; 1456 DM dm; 1457 1458 PetscFunctionBegin; 1459 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1460 if (Amat) PetscValidHeaderSpecific(Amat,MAT_CLASSID,2); 1461 if (Pmat) PetscValidHeaderSpecific(Pmat,MAT_CLASSID,3); 1462 if (Amat) PetscCheckSameComm(ts,1,Amat,2); 1463 if (Pmat) PetscCheckSameComm(ts,1,Pmat,3); 1464 1465 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1466 ierr = DMTSSetIJacobian(dm,f,ctx);CHKERRQ(ierr); 1467 1468 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 1469 ierr = SNESSetJacobian(snes,Amat,Pmat,SNESTSFormJacobian,ts);CHKERRQ(ierr); 1470 PetscFunctionReturn(0); 1471 } 1472 1473 /*@ 1474 TSRHSJacobianSetReuse - restore RHS Jacobian before re-evaluating. Without this flag, TS will change the sign and 1475 shift the RHS Jacobian for a finite-time-step implicit solve, in which case the user function will need to recompute 1476 the entire Jacobian. The reuse flag must be set if the evaluation function will assume that the matrix entries have 1477 not been changed by the TS. 1478 1479 Logically Collective 1480 1481 Input Arguments: 1482 + ts - TS context obtained from TSCreate() 1483 - reuse - PETSC_TRUE if the RHS Jacobian 1484 1485 Level: intermediate 1486 1487 .seealso: TSSetRHSJacobian(), TSComputeRHSJacobianConstant() 1488 @*/ 1489 PetscErrorCode TSRHSJacobianSetReuse(TS ts,PetscBool reuse) 1490 { 1491 PetscFunctionBegin; 1492 ts->rhsjacobian.reuse = reuse; 1493 PetscFunctionReturn(0); 1494 } 1495 1496 /*@C 1497 TSSetI2Function - Set the function to compute F(t,U,U_t,U_tt) where F = 0 is the DAE to be solved. 1498 1499 Logically Collective on TS 1500 1501 Input Parameters: 1502 + ts - the TS context obtained from TSCreate() 1503 . F - vector to hold the residual (or NULL to have it created internally) 1504 . fun - the function evaluation routine 1505 - ctx - user-defined context for private data for the function evaluation routine (may be NULL) 1506 1507 Calling sequence of fun: 1508 $ fun(TS ts,PetscReal t,Vec U,Vec U_t,Vec U_tt,Vec F,ctx); 1509 1510 + t - time at step/stage being solved 1511 . U - state vector 1512 . U_t - time derivative of state vector 1513 . U_tt - second time derivative of state vector 1514 . F - function vector 1515 - ctx - [optional] user-defined context for matrix evaluation routine (may be NULL) 1516 1517 Level: beginner 1518 1519 .keywords: TS, timestep, set, ODE, DAE, Function 1520 1521 .seealso: TSSetI2Jacobian() 1522 @*/ 1523 PetscErrorCode TSSetI2Function(TS ts,Vec F,TSI2Function fun,void *ctx) 1524 { 1525 DM dm; 1526 PetscErrorCode ierr; 1527 1528 PetscFunctionBegin; 1529 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1530 if (F) PetscValidHeaderSpecific(F,VEC_CLASSID,2); 1531 ierr = TSSetIFunction(ts,F,NULL,NULL);CHKERRQ(ierr); 1532 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1533 ierr = DMTSSetI2Function(dm,fun,ctx);CHKERRQ(ierr); 1534 PetscFunctionReturn(0); 1535 } 1536 1537 /*@C 1538 TSGetI2Function - Returns the vector where the implicit residual is stored and the function/contex to compute it. 1539 1540 Not Collective 1541 1542 Input Parameter: 1543 . ts - the TS context 1544 1545 Output Parameter: 1546 + r - vector to hold residual (or NULL) 1547 . fun - the function to compute residual (or NULL) 1548 - ctx - the function context (or NULL) 1549 1550 Level: advanced 1551 1552 .keywords: TS, nonlinear, get, function 1553 1554 .seealso: TSSetI2Function(), SNESGetFunction() 1555 @*/ 1556 PetscErrorCode TSGetI2Function(TS ts,Vec *r,TSI2Function *fun,void **ctx) 1557 { 1558 PetscErrorCode ierr; 1559 SNES snes; 1560 DM dm; 1561 1562 PetscFunctionBegin; 1563 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1564 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 1565 ierr = SNESGetFunction(snes,r,NULL,NULL);CHKERRQ(ierr); 1566 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1567 ierr = DMTSGetI2Function(dm,fun,ctx);CHKERRQ(ierr); 1568 PetscFunctionReturn(0); 1569 } 1570 1571 /*@C 1572 TSSetI2Jacobian - Set the function to compute the matrix dF/dU + v*dF/dU_t + a*dF/dU_tt 1573 where F(t,U,U_t,U_tt) is the function you provided with TSSetI2Function(). 1574 1575 Logically Collective on TS 1576 1577 Input Parameters: 1578 + ts - the TS context obtained from TSCreate() 1579 . J - Jacobian matrix 1580 . P - preconditioning matrix for J (may be same as J) 1581 . jac - the Jacobian evaluation routine 1582 - ctx - user-defined context for private data for the Jacobian evaluation routine (may be NULL) 1583 1584 Calling sequence of jac: 1585 $ jac(TS ts,PetscReal t,Vec U,Vec U_t,Vec U_tt,PetscReal v,PetscReal a,Mat J,Mat P,void *ctx); 1586 1587 + t - time at step/stage being solved 1588 . U - state vector 1589 . U_t - time derivative of state vector 1590 . U_tt - second time derivative of state vector 1591 . v - shift for U_t 1592 . a - shift for U_tt 1593 . J - Jacobian of G(U) = F(t,U,W+v*U,W'+a*U), equivalent to dF/dU + v*dF/dU_t + a*dF/dU_tt 1594 . P - preconditioning matrix for J, may be same as J 1595 - ctx - [optional] user-defined context for matrix evaluation routine 1596 1597 Notes: 1598 The matrices J and P are exactly the matrices that are used by SNES for the nonlinear solve. 1599 1600 The matrix dF/dU + v*dF/dU_t + a*dF/dU_tt you provide turns out to be 1601 the Jacobian of G(U) = F(t,U,W+v*U,W'+a*U) where F(t,U,U_t,U_tt) = 0 is the DAE to be solved. 1602 The time integrator internally approximates U_t by W+v*U and U_tt by W'+a*U where the positive "shift" 1603 parameters 'v' and 'a' and vectors W, W' depend on the integration method, step size, and past states. 1604 1605 Level: beginner 1606 1607 .keywords: TS, timestep, set, ODE, DAE, Jacobian 1608 1609 .seealso: TSSetI2Function() 1610 @*/ 1611 PetscErrorCode TSSetI2Jacobian(TS ts,Mat J,Mat P,TSI2Jacobian jac,void *ctx) 1612 { 1613 DM dm; 1614 PetscErrorCode ierr; 1615 1616 PetscFunctionBegin; 1617 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1618 if (J) PetscValidHeaderSpecific(J,MAT_CLASSID,2); 1619 if (P) PetscValidHeaderSpecific(P,MAT_CLASSID,3); 1620 ierr = TSSetIJacobian(ts,J,P,NULL,NULL);CHKERRQ(ierr); 1621 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1622 ierr = DMTSSetI2Jacobian(dm,jac,ctx);CHKERRQ(ierr); 1623 PetscFunctionReturn(0); 1624 } 1625 1626 /*@C 1627 TSGetI2Jacobian - Returns the implicit Jacobian at the present timestep. 1628 1629 Not Collective, but parallel objects are returned if TS is parallel 1630 1631 Input Parameter: 1632 . ts - The TS context obtained from TSCreate() 1633 1634 Output Parameters: 1635 + J - The (approximate) Jacobian of F(t,U,U_t,U_tt) 1636 . P - The matrix from which the preconditioner is constructed, often the same as J 1637 . jac - The function to compute the Jacobian matrices 1638 - ctx - User-defined context for Jacobian evaluation routine 1639 1640 Notes: 1641 You can pass in NULL for any return argument you do not need. 1642 1643 Level: advanced 1644 1645 .seealso: TSGetTimeStep(), TSGetMatrices(), TSGetTime(), TSGetStepNumber() 1646 1647 .keywords: TS, timestep, get, matrix, Jacobian 1648 @*/ 1649 PetscErrorCode TSGetI2Jacobian(TS ts,Mat *J,Mat *P,TSI2Jacobian *jac,void **ctx) 1650 { 1651 PetscErrorCode ierr; 1652 SNES snes; 1653 DM dm; 1654 1655 PetscFunctionBegin; 1656 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 1657 ierr = SNESSetUpMatrices(snes);CHKERRQ(ierr); 1658 ierr = SNESGetJacobian(snes,J,P,NULL,NULL);CHKERRQ(ierr); 1659 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1660 ierr = DMTSGetI2Jacobian(dm,jac,ctx);CHKERRQ(ierr); 1661 PetscFunctionReturn(0); 1662 } 1663 1664 /*@ 1665 TSComputeI2Function - Evaluates the DAE residual written in implicit form F(t,U,U_t,U_tt) = 0 1666 1667 Collective on TS and Vec 1668 1669 Input Parameters: 1670 + ts - the TS context 1671 . t - current time 1672 . U - state vector 1673 . V - time derivative of state vector (U_t) 1674 - A - second time derivative of state vector (U_tt) 1675 1676 Output Parameter: 1677 . F - the residual vector 1678 1679 Note: 1680 Most users should not need to explicitly call this routine, as it 1681 is used internally within the nonlinear solvers. 1682 1683 Level: developer 1684 1685 .keywords: TS, compute, function, vector 1686 1687 .seealso: TSSetI2Function() 1688 @*/ 1689 PetscErrorCode TSComputeI2Function(TS ts,PetscReal t,Vec U,Vec V,Vec A,Vec F) 1690 { 1691 DM dm; 1692 TSI2Function I2Function; 1693 void *ctx; 1694 TSRHSFunction rhsfunction; 1695 PetscErrorCode ierr; 1696 1697 PetscFunctionBegin; 1698 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1699 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 1700 PetscValidHeaderSpecific(V,VEC_CLASSID,4); 1701 PetscValidHeaderSpecific(A,VEC_CLASSID,5); 1702 PetscValidHeaderSpecific(F,VEC_CLASSID,6); 1703 1704 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1705 ierr = DMTSGetI2Function(dm,&I2Function,&ctx);CHKERRQ(ierr); 1706 ierr = DMTSGetRHSFunction(dm,&rhsfunction,NULL);CHKERRQ(ierr); 1707 1708 if (!I2Function) { 1709 ierr = TSComputeIFunction(ts,t,U,A,F,PETSC_FALSE);CHKERRQ(ierr); 1710 PetscFunctionReturn(0); 1711 } 1712 1713 ierr = PetscLogEventBegin(TS_FunctionEval,ts,U,V,F);CHKERRQ(ierr); 1714 1715 PetscStackPush("TS user implicit function"); 1716 ierr = I2Function(ts,t,U,V,A,F,ctx);CHKERRQ(ierr); 1717 PetscStackPop; 1718 1719 if (rhsfunction) { 1720 Vec Frhs; 1721 ierr = TSGetRHSVec_Private(ts,&Frhs);CHKERRQ(ierr); 1722 ierr = TSComputeRHSFunction(ts,t,U,Frhs);CHKERRQ(ierr); 1723 ierr = VecAXPY(F,-1,Frhs);CHKERRQ(ierr); 1724 } 1725 1726 ierr = PetscLogEventEnd(TS_FunctionEval,ts,U,V,F);CHKERRQ(ierr); 1727 PetscFunctionReturn(0); 1728 } 1729 1730 /*@ 1731 TSComputeI2Jacobian - Evaluates the Jacobian of the DAE 1732 1733 Collective on TS and Vec 1734 1735 Input Parameters: 1736 + ts - the TS context 1737 . t - current timestep 1738 . U - state vector 1739 . V - time derivative of state vector 1740 . A - second time derivative of state vector 1741 . shiftV - shift to apply, see note below 1742 - shiftA - shift to apply, see note below 1743 1744 Output Parameters: 1745 + J - Jacobian matrix 1746 - P - optional preconditioning matrix 1747 1748 Notes: 1749 If F(t,U,V,A)=0 is the DAE, the required Jacobian is 1750 1751 dF/dU + shiftV*dF/dV + shiftA*dF/dA 1752 1753 Most users should not need to explicitly call this routine, as it 1754 is used internally within the nonlinear solvers. 1755 1756 Level: developer 1757 1758 .keywords: TS, compute, Jacobian, matrix 1759 1760 .seealso: TSSetI2Jacobian() 1761 @*/ 1762 PetscErrorCode TSComputeI2Jacobian(TS ts,PetscReal t,Vec U,Vec V,Vec A,PetscReal shiftV,PetscReal shiftA,Mat J,Mat P) 1763 { 1764 DM dm; 1765 TSI2Jacobian I2Jacobian; 1766 void *ctx; 1767 TSRHSJacobian rhsjacobian; 1768 PetscErrorCode ierr; 1769 1770 PetscFunctionBegin; 1771 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1772 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 1773 PetscValidHeaderSpecific(V,VEC_CLASSID,4); 1774 PetscValidHeaderSpecific(A,VEC_CLASSID,5); 1775 PetscValidHeaderSpecific(J,MAT_CLASSID,8); 1776 PetscValidHeaderSpecific(P,MAT_CLASSID,9); 1777 1778 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 1779 ierr = DMTSGetI2Jacobian(dm,&I2Jacobian,&ctx);CHKERRQ(ierr); 1780 ierr = DMTSGetRHSJacobian(dm,&rhsjacobian,NULL);CHKERRQ(ierr); 1781 1782 if (!I2Jacobian) { 1783 ierr = TSComputeIJacobian(ts,t,U,A,shiftA,J,P,PETSC_FALSE);CHKERRQ(ierr); 1784 PetscFunctionReturn(0); 1785 } 1786 1787 ierr = PetscLogEventBegin(TS_JacobianEval,ts,U,J,P);CHKERRQ(ierr); 1788 1789 PetscStackPush("TS user implicit Jacobian"); 1790 ierr = I2Jacobian(ts,t,U,V,A,shiftV,shiftA,J,P,ctx);CHKERRQ(ierr); 1791 PetscStackPop; 1792 1793 if (rhsjacobian) { 1794 Mat Jrhs,Prhs; MatStructure axpy = DIFFERENT_NONZERO_PATTERN; 1795 ierr = TSGetRHSMats_Private(ts,&Jrhs,&Prhs);CHKERRQ(ierr); 1796 ierr = TSComputeRHSJacobian(ts,t,U,Jrhs,Prhs);CHKERRQ(ierr); 1797 ierr = MatAXPY(J,-1,Jrhs,axpy);CHKERRQ(ierr); 1798 if (P != J) {ierr = MatAXPY(P,-1,Prhs,axpy);CHKERRQ(ierr);} 1799 } 1800 1801 ierr = PetscLogEventEnd(TS_JacobianEval,ts,U,J,P);CHKERRQ(ierr); 1802 PetscFunctionReturn(0); 1803 } 1804 1805 /*@ 1806 TS2SetSolution - Sets the initial solution and time derivative vectors 1807 for use by the TS routines handling second order equations. 1808 1809 Logically Collective on TS and Vec 1810 1811 Input Parameters: 1812 + ts - the TS context obtained from TSCreate() 1813 . u - the solution vector 1814 - v - the time derivative vector 1815 1816 Level: beginner 1817 1818 .keywords: TS, timestep, set, solution, initial conditions 1819 @*/ 1820 PetscErrorCode TS2SetSolution(TS ts,Vec u,Vec v) 1821 { 1822 PetscErrorCode ierr; 1823 1824 PetscFunctionBegin; 1825 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1826 PetscValidHeaderSpecific(u,VEC_CLASSID,2); 1827 PetscValidHeaderSpecific(v,VEC_CLASSID,3); 1828 ierr = TSSetSolution(ts,u);CHKERRQ(ierr); 1829 ierr = PetscObjectReference((PetscObject)v);CHKERRQ(ierr); 1830 ierr = VecDestroy(&ts->vec_dot);CHKERRQ(ierr); 1831 ts->vec_dot = v; 1832 PetscFunctionReturn(0); 1833 } 1834 1835 /*@ 1836 TS2GetSolution - Returns the solution and time derivative at the present timestep 1837 for second order equations. It is valid to call this routine inside the function 1838 that you are evaluating in order to move to the new timestep. This vector not 1839 changed until the solution at the next timestep has been calculated. 1840 1841 Not Collective, but Vec returned is parallel if TS is parallel 1842 1843 Input Parameter: 1844 . ts - the TS context obtained from TSCreate() 1845 1846 Output Parameter: 1847 + u - the vector containing the solution 1848 - v - the vector containing the time derivative 1849 1850 Level: intermediate 1851 1852 .seealso: TS2SetSolution(), TSGetTimeStep(), TSGetTime() 1853 1854 .keywords: TS, timestep, get, solution 1855 @*/ 1856 PetscErrorCode TS2GetSolution(TS ts,Vec *u,Vec *v) 1857 { 1858 PetscFunctionBegin; 1859 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1860 if (u) PetscValidPointer(u,2); 1861 if (v) PetscValidPointer(v,3); 1862 if (u) *u = ts->vec_sol; 1863 if (v) *v = ts->vec_dot; 1864 PetscFunctionReturn(0); 1865 } 1866 1867 /*@C 1868 TSLoad - Loads a KSP that has been stored in binary with KSPView(). 1869 1870 Collective on PetscViewer 1871 1872 Input Parameters: 1873 + newdm - the newly loaded TS, this needs to have been created with TSCreate() or 1874 some related function before a call to TSLoad(). 1875 - viewer - binary file viewer, obtained from PetscViewerBinaryOpen() 1876 1877 Level: intermediate 1878 1879 Notes: 1880 The type is determined by the data in the file, any type set into the TS before this call is ignored. 1881 1882 Notes for advanced users: 1883 Most users should not need to know the details of the binary storage 1884 format, since TSLoad() and TSView() completely hide these details. 1885 But for anyone who's interested, the standard binary matrix storage 1886 format is 1887 .vb 1888 has not yet been determined 1889 .ve 1890 1891 .seealso: PetscViewerBinaryOpen(), TSView(), MatLoad(), VecLoad() 1892 @*/ 1893 PetscErrorCode TSLoad(TS ts, PetscViewer viewer) 1894 { 1895 PetscErrorCode ierr; 1896 PetscBool isbinary; 1897 PetscInt classid; 1898 char type[256]; 1899 DMTS sdm; 1900 DM dm; 1901 1902 PetscFunctionBegin; 1903 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1904 PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,2); 1905 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERBINARY,&isbinary);CHKERRQ(ierr); 1906 if (!isbinary) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Invalid viewer; open viewer with PetscViewerBinaryOpen()"); 1907 1908 ierr = PetscViewerBinaryRead(viewer,&classid,1,NULL,PETSC_INT);CHKERRQ(ierr); 1909 if (classid != TS_FILE_CLASSID) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_WRONG,"Not TS next in file"); 1910 ierr = PetscViewerBinaryRead(viewer,type,256,NULL,PETSC_CHAR);CHKERRQ(ierr); 1911 ierr = TSSetType(ts, type);CHKERRQ(ierr); 1912 if (ts->ops->load) { 1913 ierr = (*ts->ops->load)(ts,viewer);CHKERRQ(ierr); 1914 } 1915 ierr = DMCreate(PetscObjectComm((PetscObject)ts),&dm);CHKERRQ(ierr); 1916 ierr = DMLoad(dm,viewer);CHKERRQ(ierr); 1917 ierr = TSSetDM(ts,dm);CHKERRQ(ierr); 1918 ierr = DMCreateGlobalVector(ts->dm,&ts->vec_sol);CHKERRQ(ierr); 1919 ierr = VecLoad(ts->vec_sol,viewer);CHKERRQ(ierr); 1920 ierr = DMGetDMTS(ts->dm,&sdm);CHKERRQ(ierr); 1921 ierr = DMTSLoad(sdm,viewer);CHKERRQ(ierr); 1922 PetscFunctionReturn(0); 1923 } 1924 1925 #include <petscdraw.h> 1926 #if defined(PETSC_HAVE_SAWS) 1927 #include <petscviewersaws.h> 1928 #endif 1929 /*@C 1930 TSView - Prints the TS data structure. 1931 1932 Collective on TS 1933 1934 Input Parameters: 1935 + ts - the TS context obtained from TSCreate() 1936 - viewer - visualization context 1937 1938 Options Database Key: 1939 . -ts_view - calls TSView() at end of TSStep() 1940 1941 Notes: 1942 The available visualization contexts include 1943 + PETSC_VIEWER_STDOUT_SELF - standard output (default) 1944 - PETSC_VIEWER_STDOUT_WORLD - synchronized standard 1945 output where only the first processor opens 1946 the file. All other processors send their 1947 data to the first processor to print. 1948 1949 The user can open an alternative visualization context with 1950 PetscViewerASCIIOpen() - output to a specified file. 1951 1952 Level: beginner 1953 1954 .keywords: TS, timestep, view 1955 1956 .seealso: PetscViewerASCIIOpen() 1957 @*/ 1958 PetscErrorCode TSView(TS ts,PetscViewer viewer) 1959 { 1960 PetscErrorCode ierr; 1961 TSType type; 1962 PetscBool iascii,isstring,isundials,isbinary,isdraw; 1963 DMTS sdm; 1964 #if defined(PETSC_HAVE_SAWS) 1965 PetscBool issaws; 1966 #endif 1967 1968 PetscFunctionBegin; 1969 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 1970 if (!viewer) { 1971 ierr = PetscViewerASCIIGetStdout(PetscObjectComm((PetscObject)ts),&viewer);CHKERRQ(ierr); 1972 } 1973 PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,2); 1974 PetscCheckSameComm(ts,1,viewer,2); 1975 1976 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr); 1977 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSTRING,&isstring);CHKERRQ(ierr); 1978 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERBINARY,&isbinary);CHKERRQ(ierr); 1979 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERDRAW,&isdraw);CHKERRQ(ierr); 1980 #if defined(PETSC_HAVE_SAWS) 1981 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSAWS,&issaws);CHKERRQ(ierr); 1982 #endif 1983 if (iascii) { 1984 ierr = PetscObjectPrintClassNamePrefixType((PetscObject)ts,viewer);CHKERRQ(ierr); 1985 if (ts->ops->view) { 1986 ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); 1987 ierr = (*ts->ops->view)(ts,viewer);CHKERRQ(ierr); 1988 ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); 1989 } 1990 if (ts->max_steps < PETSC_MAX_INT) { 1991 ierr = PetscViewerASCIIPrintf(viewer," maximum steps=%D\n",ts->max_steps);CHKERRQ(ierr); 1992 } 1993 if (ts->max_time < PETSC_MAX_REAL) { 1994 ierr = PetscViewerASCIIPrintf(viewer," maximum time=%g\n",(double)ts->max_time);CHKERRQ(ierr); 1995 } 1996 if (ts->usessnes) { 1997 PetscBool lin; 1998 if (ts->problem_type == TS_NONLINEAR) { 1999 ierr = PetscViewerASCIIPrintf(viewer," total number of nonlinear solver iterations=%D\n",ts->snes_its);CHKERRQ(ierr); 2000 } 2001 ierr = PetscViewerASCIIPrintf(viewer," total number of linear solver iterations=%D\n",ts->ksp_its);CHKERRQ(ierr); 2002 ierr = PetscObjectTypeCompareAny((PetscObject)ts->snes,&lin,SNESKSPONLY,SNESKSPTRANSPOSEONLY,"");CHKERRQ(ierr); 2003 ierr = PetscViewerASCIIPrintf(viewer," total number of %slinear solve failures=%D\n",lin ? "" : "non",ts->num_snes_failures);CHKERRQ(ierr); 2004 } 2005 ierr = PetscViewerASCIIPrintf(viewer," total number of rejected steps=%D\n",ts->reject);CHKERRQ(ierr); 2006 if (ts->vrtol) { 2007 ierr = PetscViewerASCIIPrintf(viewer," using vector of relative error tolerances, ");CHKERRQ(ierr); 2008 } else { 2009 ierr = PetscViewerASCIIPrintf(viewer," using relative error tolerance of %g, ",(double)ts->rtol);CHKERRQ(ierr); 2010 } 2011 if (ts->vatol) { 2012 ierr = PetscViewerASCIIPrintf(viewer," using vector of absolute error tolerances\n");CHKERRQ(ierr); 2013 } else { 2014 ierr = PetscViewerASCIIPrintf(viewer," using absolute error tolerance of %g\n",(double)ts->atol);CHKERRQ(ierr); 2015 } 2016 ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); 2017 ierr = TSAdaptView(ts->adapt,viewer);CHKERRQ(ierr); 2018 ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); 2019 if (ts->snes && ts->usessnes) { 2020 ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); 2021 ierr = SNESView(ts->snes,viewer);CHKERRQ(ierr); 2022 ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); 2023 } 2024 ierr = DMGetDMTS(ts->dm,&sdm);CHKERRQ(ierr); 2025 ierr = DMTSView(sdm,viewer);CHKERRQ(ierr); 2026 } else if (isstring) { 2027 ierr = TSGetType(ts,&type);CHKERRQ(ierr); 2028 ierr = PetscViewerStringSPrintf(viewer," %-7.7s",type);CHKERRQ(ierr); 2029 } else if (isbinary) { 2030 PetscInt classid = TS_FILE_CLASSID; 2031 MPI_Comm comm; 2032 PetscMPIInt rank; 2033 char type[256]; 2034 2035 ierr = PetscObjectGetComm((PetscObject)ts,&comm);CHKERRQ(ierr); 2036 ierr = MPI_Comm_rank(comm,&rank);CHKERRQ(ierr); 2037 if (!rank) { 2038 ierr = PetscViewerBinaryWrite(viewer,&classid,1,PETSC_INT,PETSC_FALSE);CHKERRQ(ierr); 2039 ierr = PetscStrncpy(type,((PetscObject)ts)->type_name,256);CHKERRQ(ierr); 2040 ierr = PetscViewerBinaryWrite(viewer,type,256,PETSC_CHAR,PETSC_FALSE);CHKERRQ(ierr); 2041 } 2042 if (ts->ops->view) { 2043 ierr = (*ts->ops->view)(ts,viewer);CHKERRQ(ierr); 2044 } 2045 if (ts->adapt) {ierr = TSAdaptView(ts->adapt,viewer);CHKERRQ(ierr);} 2046 ierr = DMView(ts->dm,viewer);CHKERRQ(ierr); 2047 ierr = VecView(ts->vec_sol,viewer);CHKERRQ(ierr); 2048 ierr = DMGetDMTS(ts->dm,&sdm);CHKERRQ(ierr); 2049 ierr = DMTSView(sdm,viewer);CHKERRQ(ierr); 2050 } else if (isdraw) { 2051 PetscDraw draw; 2052 char str[36]; 2053 PetscReal x,y,bottom,h; 2054 2055 ierr = PetscViewerDrawGetDraw(viewer,0,&draw);CHKERRQ(ierr); 2056 ierr = PetscDrawGetCurrentPoint(draw,&x,&y);CHKERRQ(ierr); 2057 ierr = PetscStrcpy(str,"TS: ");CHKERRQ(ierr); 2058 ierr = PetscStrcat(str,((PetscObject)ts)->type_name);CHKERRQ(ierr); 2059 ierr = PetscDrawStringBoxed(draw,x,y,PETSC_DRAW_BLACK,PETSC_DRAW_BLACK,str,NULL,&h);CHKERRQ(ierr); 2060 bottom = y - h; 2061 ierr = PetscDrawPushCurrentPoint(draw,x,bottom);CHKERRQ(ierr); 2062 if (ts->ops->view) { 2063 ierr = (*ts->ops->view)(ts,viewer);CHKERRQ(ierr); 2064 } 2065 if (ts->adapt) {ierr = TSAdaptView(ts->adapt,viewer);CHKERRQ(ierr);} 2066 if (ts->snes) {ierr = SNESView(ts->snes,viewer);CHKERRQ(ierr);} 2067 ierr = PetscDrawPopCurrentPoint(draw);CHKERRQ(ierr); 2068 #if defined(PETSC_HAVE_SAWS) 2069 } else if (issaws) { 2070 PetscMPIInt rank; 2071 const char *name; 2072 2073 ierr = PetscObjectGetName((PetscObject)ts,&name);CHKERRQ(ierr); 2074 ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr); 2075 if (!((PetscObject)ts)->amsmem && !rank) { 2076 char dir[1024]; 2077 2078 ierr = PetscObjectViewSAWs((PetscObject)ts,viewer);CHKERRQ(ierr); 2079 ierr = PetscSNPrintf(dir,1024,"/PETSc/Objects/%s/time_step",name);CHKERRQ(ierr); 2080 PetscStackCallSAWs(SAWs_Register,(dir,&ts->steps,1,SAWs_READ,SAWs_INT)); 2081 ierr = PetscSNPrintf(dir,1024,"/PETSc/Objects/%s/time",name);CHKERRQ(ierr); 2082 PetscStackCallSAWs(SAWs_Register,(dir,&ts->ptime,1,SAWs_READ,SAWs_DOUBLE)); 2083 } 2084 if (ts->ops->view) { 2085 ierr = (*ts->ops->view)(ts,viewer);CHKERRQ(ierr); 2086 } 2087 #endif 2088 } 2089 2090 ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); 2091 ierr = PetscObjectTypeCompare((PetscObject)ts,TSSUNDIALS,&isundials);CHKERRQ(ierr); 2092 ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); 2093 PetscFunctionReturn(0); 2094 } 2095 2096 /*@ 2097 TSSetApplicationContext - Sets an optional user-defined context for 2098 the timesteppers. 2099 2100 Logically Collective on TS 2101 2102 Input Parameters: 2103 + ts - the TS context obtained from TSCreate() 2104 - usrP - optional user context 2105 2106 Fortran Notes: 2107 To use this from Fortran you must write a Fortran interface definition for this 2108 function that tells Fortran the Fortran derived data type that you are passing in as the ctx argument. 2109 2110 Level: intermediate 2111 2112 .keywords: TS, timestep, set, application, context 2113 2114 .seealso: TSGetApplicationContext() 2115 @*/ 2116 PetscErrorCode TSSetApplicationContext(TS ts,void *usrP) 2117 { 2118 PetscFunctionBegin; 2119 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2120 ts->user = usrP; 2121 PetscFunctionReturn(0); 2122 } 2123 2124 /*@ 2125 TSGetApplicationContext - Gets the user-defined context for the 2126 timestepper. 2127 2128 Not Collective 2129 2130 Input Parameter: 2131 . ts - the TS context obtained from TSCreate() 2132 2133 Output Parameter: 2134 . usrP - user context 2135 2136 Fortran Notes: 2137 To use this from Fortran you must write a Fortran interface definition for this 2138 function that tells Fortran the Fortran derived data type that you are passing in as the ctx argument. 2139 2140 Level: intermediate 2141 2142 .keywords: TS, timestep, get, application, context 2143 2144 .seealso: TSSetApplicationContext() 2145 @*/ 2146 PetscErrorCode TSGetApplicationContext(TS ts,void *usrP) 2147 { 2148 PetscFunctionBegin; 2149 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2150 *(void**)usrP = ts->user; 2151 PetscFunctionReturn(0); 2152 } 2153 2154 /*@ 2155 TSGetStepNumber - Gets the number of steps completed. 2156 2157 Not Collective 2158 2159 Input Parameter: 2160 . ts - the TS context obtained from TSCreate() 2161 2162 Output Parameter: 2163 . steps - number of steps completed so far 2164 2165 Level: intermediate 2166 2167 .keywords: TS, timestep, get, iteration, number 2168 .seealso: TSGetTime(), TSGetTimeStep(), TSSetPreStep(), TSSetPreStage(), TSSetPostStage(), TSSetPostStep() 2169 @*/ 2170 PetscErrorCode TSGetStepNumber(TS ts,PetscInt *steps) 2171 { 2172 PetscFunctionBegin; 2173 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2174 PetscValidIntPointer(steps,2); 2175 *steps = ts->steps; 2176 PetscFunctionReturn(0); 2177 } 2178 2179 /*@ 2180 TSSetStepNumber - Sets the number of steps completed. 2181 2182 Logically Collective on TS 2183 2184 Input Parameters: 2185 + ts - the TS context 2186 - steps - number of steps completed so far 2187 2188 Notes: 2189 For most uses of the TS solvers the user need not explicitly call 2190 TSSetStepNumber(), as the step counter is appropriately updated in 2191 TSSolve()/TSStep()/TSRollBack(). Power users may call this routine to 2192 reinitialize timestepping by setting the step counter to zero (and time 2193 to the initial time) to solve a similar problem with different initial 2194 conditions or parameters. Other possible use case is to continue 2195 timestepping from a previously interrupted run in such a way that TS 2196 monitors will be called with a initial nonzero step counter. 2197 2198 Level: advanced 2199 2200 .keywords: TS, timestep, set, iteration, number 2201 .seealso: TSGetStepNumber(), TSSetTime(), TSSetTimeStep(), TSSetSolution() 2202 @*/ 2203 PetscErrorCode TSSetStepNumber(TS ts,PetscInt steps) 2204 { 2205 PetscFunctionBegin; 2206 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2207 PetscValidLogicalCollectiveInt(ts,steps,2); 2208 if (steps < 0) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_OUTOFRANGE,"Step number must be non-negative"); 2209 ts->steps = steps; 2210 PetscFunctionReturn(0); 2211 } 2212 2213 /*@ 2214 TSSetTimeStep - Allows one to reset the timestep at any time, 2215 useful for simple pseudo-timestepping codes. 2216 2217 Logically Collective on TS 2218 2219 Input Parameters: 2220 + ts - the TS context obtained from TSCreate() 2221 - time_step - the size of the timestep 2222 2223 Level: intermediate 2224 2225 .seealso: TSGetTimeStep(), TSSetTime() 2226 2227 .keywords: TS, set, timestep 2228 @*/ 2229 PetscErrorCode TSSetTimeStep(TS ts,PetscReal time_step) 2230 { 2231 PetscFunctionBegin; 2232 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2233 PetscValidLogicalCollectiveReal(ts,time_step,2); 2234 ts->time_step = time_step; 2235 PetscFunctionReturn(0); 2236 } 2237 2238 /*@ 2239 TSSetExactFinalTime - Determines whether to adapt the final time step to 2240 match the exact final time, interpolate solution to the exact final time, 2241 or just return at the final time TS computed. 2242 2243 Logically Collective on TS 2244 2245 Input Parameter: 2246 + ts - the time-step context 2247 - eftopt - exact final time option 2248 2249 $ TS_EXACTFINALTIME_STEPOVER - Don't do anything if final time is exceeded 2250 $ TS_EXACTFINALTIME_INTERPOLATE - Interpolate back to final time 2251 $ TS_EXACTFINALTIME_MATCHSTEP - Adapt final time step to match the final time 2252 2253 Options Database: 2254 . -ts_exact_final_time <stepover,interpolate,matchstep> - select the final step at runtime 2255 2256 Warning: If you use the option TS_EXACTFINALTIME_STEPOVER the solution may be at a very different time 2257 then the final time you selected. 2258 2259 Level: beginner 2260 2261 .seealso: TSExactFinalTimeOption, TSGetExactFinalTime() 2262 @*/ 2263 PetscErrorCode TSSetExactFinalTime(TS ts,TSExactFinalTimeOption eftopt) 2264 { 2265 PetscFunctionBegin; 2266 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2267 PetscValidLogicalCollectiveEnum(ts,eftopt,2); 2268 ts->exact_final_time = eftopt; 2269 PetscFunctionReturn(0); 2270 } 2271 2272 /*@ 2273 TSGetExactFinalTime - Gets the exact final time option. 2274 2275 Not Collective 2276 2277 Input Parameter: 2278 . ts - the TS context 2279 2280 Output Parameter: 2281 . eftopt - exact final time option 2282 2283 Level: beginner 2284 2285 .seealso: TSExactFinalTimeOption, TSSetExactFinalTime() 2286 @*/ 2287 PetscErrorCode TSGetExactFinalTime(TS ts,TSExactFinalTimeOption *eftopt) 2288 { 2289 PetscFunctionBegin; 2290 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2291 PetscValidPointer(eftopt,2); 2292 *eftopt = ts->exact_final_time; 2293 PetscFunctionReturn(0); 2294 } 2295 2296 /*@ 2297 TSGetTimeStep - Gets the current timestep size. 2298 2299 Not Collective 2300 2301 Input Parameter: 2302 . ts - the TS context obtained from TSCreate() 2303 2304 Output Parameter: 2305 . dt - the current timestep size 2306 2307 Level: intermediate 2308 2309 .seealso: TSSetTimeStep(), TSGetTime() 2310 2311 .keywords: TS, get, timestep 2312 @*/ 2313 PetscErrorCode TSGetTimeStep(TS ts,PetscReal *dt) 2314 { 2315 PetscFunctionBegin; 2316 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2317 PetscValidRealPointer(dt,2); 2318 *dt = ts->time_step; 2319 PetscFunctionReturn(0); 2320 } 2321 2322 /*@ 2323 TSGetSolution - Returns the solution at the present timestep. It 2324 is valid to call this routine inside the function that you are evaluating 2325 in order to move to the new timestep. This vector not changed until 2326 the solution at the next timestep has been calculated. 2327 2328 Not Collective, but Vec returned is parallel if TS is parallel 2329 2330 Input Parameter: 2331 . ts - the TS context obtained from TSCreate() 2332 2333 Output Parameter: 2334 . v - the vector containing the solution 2335 2336 Note: If you used TSSetExactFinalTime(ts,TS_EXACTFINALTIME_MATCHSTEP); this does not return the solution at the requested 2337 final time. It returns the solution at the next timestep. 2338 2339 Level: intermediate 2340 2341 .seealso: TSGetTimeStep(), TSGetTime(), TSGetSolveTime(), TSGetSolutionComponents(), TSSetSolutionFunction() 2342 2343 .keywords: TS, timestep, get, solution 2344 @*/ 2345 PetscErrorCode TSGetSolution(TS ts,Vec *v) 2346 { 2347 PetscFunctionBegin; 2348 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2349 PetscValidPointer(v,2); 2350 *v = ts->vec_sol; 2351 PetscFunctionReturn(0); 2352 } 2353 2354 /*@ 2355 TSGetSolutionComponents - Returns any solution components at the present 2356 timestep, if available for the time integration method being used. 2357 Solution components are quantities that share the same size and 2358 structure as the solution vector. 2359 2360 Not Collective, but Vec returned is parallel if TS is parallel 2361 2362 Parameters : 2363 . ts - the TS context obtained from TSCreate() (input parameter). 2364 . n - If v is PETSC_NULL, then the number of solution components is 2365 returned through n, else the n-th solution component is 2366 returned in v. 2367 . v - the vector containing the n-th solution component 2368 (may be PETSC_NULL to use this function to find out 2369 the number of solutions components). 2370 2371 Level: advanced 2372 2373 .seealso: TSGetSolution() 2374 2375 .keywords: TS, timestep, get, solution 2376 @*/ 2377 PetscErrorCode TSGetSolutionComponents(TS ts,PetscInt *n,Vec *v) 2378 { 2379 PetscErrorCode ierr; 2380 2381 PetscFunctionBegin; 2382 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2383 if (!ts->ops->getsolutioncomponents) *n = 0; 2384 else { 2385 ierr = (*ts->ops->getsolutioncomponents)(ts,n,v);CHKERRQ(ierr); 2386 } 2387 PetscFunctionReturn(0); 2388 } 2389 2390 /*@ 2391 TSGetAuxSolution - Returns an auxiliary solution at the present 2392 timestep, if available for the time integration method being used. 2393 2394 Not Collective, but Vec returned is parallel if TS is parallel 2395 2396 Parameters : 2397 . ts - the TS context obtained from TSCreate() (input parameter). 2398 . v - the vector containing the auxiliary solution 2399 2400 Level: intermediate 2401 2402 .seealso: TSGetSolution() 2403 2404 .keywords: TS, timestep, get, solution 2405 @*/ 2406 PetscErrorCode TSGetAuxSolution(TS ts,Vec *v) 2407 { 2408 PetscErrorCode ierr; 2409 2410 PetscFunctionBegin; 2411 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2412 if (ts->ops->getauxsolution) { 2413 ierr = (*ts->ops->getauxsolution)(ts,v);CHKERRQ(ierr); 2414 } else { 2415 ierr = VecZeroEntries(*v); CHKERRQ(ierr); 2416 } 2417 PetscFunctionReturn(0); 2418 } 2419 2420 /*@ 2421 TSGetTimeError - Returns the estimated error vector, if the chosen 2422 TSType has an error estimation functionality. 2423 2424 Not Collective, but Vec returned is parallel if TS is parallel 2425 2426 Note: MUST call after TSSetUp() 2427 2428 Parameters : 2429 . ts - the TS context obtained from TSCreate() (input parameter). 2430 . n - current estimate (n=0) or previous one (n=-1) 2431 . v - the vector containing the error (same size as the solution). 2432 2433 Level: intermediate 2434 2435 .seealso: TSGetSolution(), TSSetTimeError() 2436 2437 .keywords: TS, timestep, get, error 2438 @*/ 2439 PetscErrorCode TSGetTimeError(TS ts,PetscInt n,Vec *v) 2440 { 2441 PetscErrorCode ierr; 2442 2443 PetscFunctionBegin; 2444 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2445 if (ts->ops->gettimeerror) { 2446 ierr = (*ts->ops->gettimeerror)(ts,n,v);CHKERRQ(ierr); 2447 } else { 2448 ierr = VecZeroEntries(*v);CHKERRQ(ierr); 2449 } 2450 PetscFunctionReturn(0); 2451 } 2452 2453 /*@ 2454 TSSetTimeError - Sets the estimated error vector, if the chosen 2455 TSType has an error estimation functionality. This can be used 2456 to restart such a time integrator with a given error vector. 2457 2458 Not Collective, but Vec returned is parallel if TS is parallel 2459 2460 Parameters : 2461 . ts - the TS context obtained from TSCreate() (input parameter). 2462 . v - the vector containing the error (same size as the solution). 2463 2464 Level: intermediate 2465 2466 .seealso: TSSetSolution(), TSGetTimeError) 2467 2468 .keywords: TS, timestep, get, error 2469 @*/ 2470 PetscErrorCode TSSetTimeError(TS ts,Vec v) 2471 { 2472 PetscErrorCode ierr; 2473 2474 PetscFunctionBegin; 2475 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2476 if (!ts->setupcalled) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"Must call TSSetUp() first"); 2477 if (ts->ops->settimeerror) { 2478 ierr = (*ts->ops->settimeerror)(ts,v);CHKERRQ(ierr); 2479 } 2480 PetscFunctionReturn(0); 2481 } 2482 2483 /* ----- Routines to initialize and destroy a timestepper ---- */ 2484 /*@ 2485 TSSetProblemType - Sets the type of problem to be solved. 2486 2487 Not collective 2488 2489 Input Parameters: 2490 + ts - The TS 2491 - type - One of TS_LINEAR, TS_NONLINEAR where these types refer to problems of the forms 2492 .vb 2493 U_t - A U = 0 (linear) 2494 U_t - A(t) U = 0 (linear) 2495 F(t,U,U_t) = 0 (nonlinear) 2496 .ve 2497 2498 Level: beginner 2499 2500 .keywords: TS, problem type 2501 .seealso: TSSetUp(), TSProblemType, TS 2502 @*/ 2503 PetscErrorCode TSSetProblemType(TS ts, TSProblemType type) 2504 { 2505 PetscErrorCode ierr; 2506 2507 PetscFunctionBegin; 2508 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 2509 ts->problem_type = type; 2510 if (type == TS_LINEAR) { 2511 SNES snes; 2512 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 2513 ierr = SNESSetType(snes,SNESKSPONLY);CHKERRQ(ierr); 2514 } 2515 PetscFunctionReturn(0); 2516 } 2517 2518 /*@C 2519 TSGetProblemType - Gets the type of problem to be solved. 2520 2521 Not collective 2522 2523 Input Parameter: 2524 . ts - The TS 2525 2526 Output Parameter: 2527 . type - One of TS_LINEAR, TS_NONLINEAR where these types refer to problems of the forms 2528 .vb 2529 M U_t = A U 2530 M(t) U_t = A(t) U 2531 F(t,U,U_t) 2532 .ve 2533 2534 Level: beginner 2535 2536 .keywords: TS, problem type 2537 .seealso: TSSetUp(), TSProblemType, TS 2538 @*/ 2539 PetscErrorCode TSGetProblemType(TS ts, TSProblemType *type) 2540 { 2541 PetscFunctionBegin; 2542 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 2543 PetscValidIntPointer(type,2); 2544 *type = ts->problem_type; 2545 PetscFunctionReturn(0); 2546 } 2547 2548 /*@ 2549 TSSetUp - Sets up the internal data structures for the later use 2550 of a timestepper. 2551 2552 Collective on TS 2553 2554 Input Parameter: 2555 . ts - the TS context obtained from TSCreate() 2556 2557 Notes: 2558 For basic use of the TS solvers the user need not explicitly call 2559 TSSetUp(), since these actions will automatically occur during 2560 the call to TSStep() or TSSolve(). However, if one wishes to control this 2561 phase separately, TSSetUp() should be called after TSCreate() 2562 and optional routines of the form TSSetXXX(), but before TSStep() and TSSolve(). 2563 2564 Level: advanced 2565 2566 .keywords: TS, timestep, setup 2567 2568 .seealso: TSCreate(), TSStep(), TSDestroy(), TSSolve() 2569 @*/ 2570 PetscErrorCode TSSetUp(TS ts) 2571 { 2572 PetscErrorCode ierr; 2573 DM dm; 2574 PetscErrorCode (*func)(SNES,Vec,Vec,void*); 2575 PetscErrorCode (*jac)(SNES,Vec,Mat,Mat,void*); 2576 TSIFunction ifun; 2577 TSIJacobian ijac; 2578 TSI2Jacobian i2jac; 2579 TSRHSJacobian rhsjac; 2580 PetscBool isnone; 2581 2582 PetscFunctionBegin; 2583 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2584 if (ts->setupcalled) PetscFunctionReturn(0); 2585 2586 if (!((PetscObject)ts)->type_name) { 2587 ierr = TSGetIFunction(ts,NULL,&ifun,NULL);CHKERRQ(ierr); 2588 ierr = TSSetType(ts,ifun ? TSBEULER : TSEULER);CHKERRQ(ierr); 2589 } 2590 2591 if (!ts->vec_sol) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"Must call TSSetSolution() first"); 2592 2593 ierr = TSGetRHSJacobian(ts,NULL,NULL,&rhsjac,NULL);CHKERRQ(ierr); 2594 if (ts->rhsjacobian.reuse && rhsjac == TSComputeRHSJacobianConstant) { 2595 Mat Amat,Pmat; 2596 SNES snes; 2597 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 2598 ierr = SNESGetJacobian(snes,&Amat,&Pmat,NULL,NULL);CHKERRQ(ierr); 2599 /* Matching matrices implies that an IJacobian is NOT set, because if it had been set, the IJacobian's matrix would 2600 * have displaced the RHS matrix */ 2601 if (Amat && Amat == ts->Arhs) { 2602 /* we need to copy the values of the matrix because for the constant Jacobian case the user will never set the numerical values in this new location */ 2603 ierr = MatDuplicate(ts->Arhs,MAT_COPY_VALUES,&Amat);CHKERRQ(ierr); 2604 ierr = SNESSetJacobian(snes,Amat,NULL,NULL,NULL);CHKERRQ(ierr); 2605 ierr = MatDestroy(&Amat);CHKERRQ(ierr); 2606 } 2607 if (Pmat && Pmat == ts->Brhs) { 2608 ierr = MatDuplicate(ts->Brhs,MAT_COPY_VALUES,&Pmat);CHKERRQ(ierr); 2609 ierr = SNESSetJacobian(snes,NULL,Pmat,NULL,NULL);CHKERRQ(ierr); 2610 ierr = MatDestroy(&Pmat);CHKERRQ(ierr); 2611 } 2612 } 2613 2614 ierr = TSGetAdapt(ts,&ts->adapt);CHKERRQ(ierr); 2615 ierr = TSAdaptSetDefaultType(ts->adapt,ts->default_adapt_type);CHKERRQ(ierr); 2616 2617 if (ts->ops->setup) { 2618 ierr = (*ts->ops->setup)(ts);CHKERRQ(ierr); 2619 } 2620 2621 /* Attempt to check/preset a default value for the exact final time option */ 2622 ierr = PetscObjectTypeCompare((PetscObject)ts->adapt,TSADAPTNONE,&isnone);CHKERRQ(ierr); 2623 if (!isnone && ts->exact_final_time == TS_EXACTFINALTIME_UNSPECIFIED) 2624 ts->exact_final_time = TS_EXACTFINALTIME_MATCHSTEP; 2625 2626 /* In the case where we've set a DMTSFunction or what have you, we need the default SNESFunction 2627 to be set right but can't do it elsewhere due to the overreliance on ctx=ts. 2628 */ 2629 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 2630 ierr = DMSNESGetFunction(dm,&func,NULL);CHKERRQ(ierr); 2631 if (!func) { 2632 ierr = DMSNESSetFunction(dm,SNESTSFormFunction,ts);CHKERRQ(ierr); 2633 } 2634 /* If the SNES doesn't have a jacobian set and the TS has an ijacobian or rhsjacobian set, set the SNES to use it. 2635 Otherwise, the SNES will use coloring internally to form the Jacobian. 2636 */ 2637 ierr = DMSNESGetJacobian(dm,&jac,NULL);CHKERRQ(ierr); 2638 ierr = DMTSGetIJacobian(dm,&ijac,NULL);CHKERRQ(ierr); 2639 ierr = DMTSGetI2Jacobian(dm,&i2jac,NULL);CHKERRQ(ierr); 2640 ierr = DMTSGetRHSJacobian(dm,&rhsjac,NULL);CHKERRQ(ierr); 2641 if (!jac && (ijac || i2jac || rhsjac)) { 2642 ierr = DMSNESSetJacobian(dm,SNESTSFormJacobian,ts);CHKERRQ(ierr); 2643 } 2644 2645 /* if time integration scheme has a starting method, call it */ 2646 if (ts->ops->startingmethod) { 2647 ierr = (*ts->ops->startingmethod)(ts);CHKERRQ(ierr); 2648 } 2649 2650 ts->setupcalled = PETSC_TRUE; 2651 PetscFunctionReturn(0); 2652 } 2653 2654 /*@ 2655 TSReset - Resets a TS context and removes any allocated Vecs and Mats. 2656 2657 Collective on TS 2658 2659 Input Parameter: 2660 . ts - the TS context obtained from TSCreate() 2661 2662 Level: beginner 2663 2664 .keywords: TS, timestep, reset 2665 2666 .seealso: TSCreate(), TSSetup(), TSDestroy() 2667 @*/ 2668 PetscErrorCode TSReset(TS ts) 2669 { 2670 TS_RHSSplitLink ilink = ts->tsrhssplit,next; 2671 PetscErrorCode ierr; 2672 2673 PetscFunctionBegin; 2674 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2675 2676 if (ts->ops->reset) { 2677 ierr = (*ts->ops->reset)(ts);CHKERRQ(ierr); 2678 } 2679 if (ts->snes) {ierr = SNESReset(ts->snes);CHKERRQ(ierr);} 2680 if (ts->adapt) {ierr = TSAdaptReset(ts->adapt);CHKERRQ(ierr);} 2681 2682 ierr = MatDestroy(&ts->Arhs);CHKERRQ(ierr); 2683 ierr = MatDestroy(&ts->Brhs);CHKERRQ(ierr); 2684 ierr = VecDestroy(&ts->Frhs);CHKERRQ(ierr); 2685 ierr = VecDestroy(&ts->vec_sol);CHKERRQ(ierr); 2686 ierr = VecDestroy(&ts->vec_dot);CHKERRQ(ierr); 2687 ierr = VecDestroy(&ts->vatol);CHKERRQ(ierr); 2688 ierr = VecDestroy(&ts->vrtol);CHKERRQ(ierr); 2689 ierr = VecDestroyVecs(ts->nwork,&ts->work);CHKERRQ(ierr); 2690 2691 ierr = VecDestroyVecs(ts->numcost,&ts->vecs_drdy);CHKERRQ(ierr); 2692 ierr = VecDestroyVecs(ts->numcost,&ts->vecs_drdp);CHKERRQ(ierr); 2693 2694 ierr = MatDestroy(&ts->Jacp);CHKERRQ(ierr); 2695 ierr = VecDestroy(&ts->vec_costintegral);CHKERRQ(ierr); 2696 ierr = VecDestroy(&ts->vec_costintegrand);CHKERRQ(ierr); 2697 ierr = MatDestroy(&ts->mat_sensip);CHKERRQ(ierr); 2698 2699 while (ilink) { 2700 next = ilink->next; 2701 ierr = TSDestroy(&ilink->ts);CHKERRQ(ierr); 2702 ierr = PetscFree(ilink->splitname);CHKERRQ(ierr); 2703 ierr = ISDestroy(&ilink->is);CHKERRQ(ierr); 2704 ierr = PetscFree(ilink);CHKERRQ(ierr); 2705 ilink = next; 2706 } 2707 ts->num_rhs_splits = 0; 2708 ts->setupcalled = PETSC_FALSE; 2709 PetscFunctionReturn(0); 2710 } 2711 2712 /*@ 2713 TSDestroy - Destroys the timestepper context that was created 2714 with TSCreate(). 2715 2716 Collective on TS 2717 2718 Input Parameter: 2719 . ts - the TS context obtained from TSCreate() 2720 2721 Level: beginner 2722 2723 .keywords: TS, timestepper, destroy 2724 2725 .seealso: TSCreate(), TSSetUp(), TSSolve() 2726 @*/ 2727 PetscErrorCode TSDestroy(TS *ts) 2728 { 2729 PetscErrorCode ierr; 2730 2731 PetscFunctionBegin; 2732 if (!*ts) PetscFunctionReturn(0); 2733 PetscValidHeaderSpecific((*ts),TS_CLASSID,1); 2734 if (--((PetscObject)(*ts))->refct > 0) {*ts = 0; PetscFunctionReturn(0);} 2735 2736 ierr = TSReset((*ts));CHKERRQ(ierr); 2737 2738 /* if memory was published with SAWs then destroy it */ 2739 ierr = PetscObjectSAWsViewOff((PetscObject)*ts);CHKERRQ(ierr); 2740 if ((*ts)->ops->destroy) {ierr = (*(*ts)->ops->destroy)((*ts));CHKERRQ(ierr);} 2741 2742 ierr = TSTrajectoryDestroy(&(*ts)->trajectory);CHKERRQ(ierr); 2743 2744 ierr = TSAdaptDestroy(&(*ts)->adapt);CHKERRQ(ierr); 2745 ierr = TSEventDestroy(&(*ts)->event);CHKERRQ(ierr); 2746 2747 ierr = SNESDestroy(&(*ts)->snes);CHKERRQ(ierr); 2748 ierr = DMDestroy(&(*ts)->dm);CHKERRQ(ierr); 2749 ierr = TSMonitorCancel((*ts));CHKERRQ(ierr); 2750 ierr = TSAdjointMonitorCancel((*ts));CHKERRQ(ierr); 2751 2752 ierr = PetscHeaderDestroy(ts);CHKERRQ(ierr); 2753 PetscFunctionReturn(0); 2754 } 2755 2756 /*@ 2757 TSGetSNES - Returns the SNES (nonlinear solver) associated with 2758 a TS (timestepper) context. Valid only for nonlinear problems. 2759 2760 Not Collective, but SNES is parallel if TS is parallel 2761 2762 Input Parameter: 2763 . ts - the TS context obtained from TSCreate() 2764 2765 Output Parameter: 2766 . snes - the nonlinear solver context 2767 2768 Notes: 2769 The user can then directly manipulate the SNES context to set various 2770 options, etc. Likewise, the user can then extract and manipulate the 2771 KSP, KSP, and PC contexts as well. 2772 2773 TSGetSNES() does not work for integrators that do not use SNES; in 2774 this case TSGetSNES() returns NULL in snes. 2775 2776 Level: beginner 2777 2778 .keywords: timestep, get, SNES 2779 @*/ 2780 PetscErrorCode TSGetSNES(TS ts,SNES *snes) 2781 { 2782 PetscErrorCode ierr; 2783 2784 PetscFunctionBegin; 2785 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2786 PetscValidPointer(snes,2); 2787 if (!ts->snes) { 2788 ierr = SNESCreate(PetscObjectComm((PetscObject)ts),&ts->snes);CHKERRQ(ierr); 2789 ierr = PetscObjectSetOptions((PetscObject)ts->snes,((PetscObject)ts)->options);CHKERRQ(ierr); 2790 ierr = SNESSetFunction(ts->snes,NULL,SNESTSFormFunction,ts);CHKERRQ(ierr); 2791 ierr = PetscLogObjectParent((PetscObject)ts,(PetscObject)ts->snes);CHKERRQ(ierr); 2792 ierr = PetscObjectIncrementTabLevel((PetscObject)ts->snes,(PetscObject)ts,1);CHKERRQ(ierr); 2793 if (ts->dm) {ierr = SNESSetDM(ts->snes,ts->dm);CHKERRQ(ierr);} 2794 if (ts->problem_type == TS_LINEAR) { 2795 ierr = SNESSetType(ts->snes,SNESKSPONLY);CHKERRQ(ierr); 2796 } 2797 } 2798 *snes = ts->snes; 2799 PetscFunctionReturn(0); 2800 } 2801 2802 /*@ 2803 TSSetSNES - Set the SNES (nonlinear solver) to be used by the timestepping context 2804 2805 Collective 2806 2807 Input Parameter: 2808 + ts - the TS context obtained from TSCreate() 2809 - snes - the nonlinear solver context 2810 2811 Notes: 2812 Most users should have the TS created by calling TSGetSNES() 2813 2814 Level: developer 2815 2816 .keywords: timestep, set, SNES 2817 @*/ 2818 PetscErrorCode TSSetSNES(TS ts,SNES snes) 2819 { 2820 PetscErrorCode ierr; 2821 PetscErrorCode (*func)(SNES,Vec,Mat,Mat,void*); 2822 2823 PetscFunctionBegin; 2824 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2825 PetscValidHeaderSpecific(snes,SNES_CLASSID,2); 2826 ierr = PetscObjectReference((PetscObject)snes);CHKERRQ(ierr); 2827 ierr = SNESDestroy(&ts->snes);CHKERRQ(ierr); 2828 2829 ts->snes = snes; 2830 2831 ierr = SNESSetFunction(ts->snes,NULL,SNESTSFormFunction,ts);CHKERRQ(ierr); 2832 ierr = SNESGetJacobian(ts->snes,NULL,NULL,&func,NULL);CHKERRQ(ierr); 2833 if (func == SNESTSFormJacobian) { 2834 ierr = SNESSetJacobian(ts->snes,NULL,NULL,SNESTSFormJacobian,ts);CHKERRQ(ierr); 2835 } 2836 PetscFunctionReturn(0); 2837 } 2838 2839 /*@ 2840 TSGetKSP - Returns the KSP (linear solver) associated with 2841 a TS (timestepper) context. 2842 2843 Not Collective, but KSP is parallel if TS is parallel 2844 2845 Input Parameter: 2846 . ts - the TS context obtained from TSCreate() 2847 2848 Output Parameter: 2849 . ksp - the nonlinear solver context 2850 2851 Notes: 2852 The user can then directly manipulate the KSP context to set various 2853 options, etc. Likewise, the user can then extract and manipulate the 2854 KSP and PC contexts as well. 2855 2856 TSGetKSP() does not work for integrators that do not use KSP; 2857 in this case TSGetKSP() returns NULL in ksp. 2858 2859 Level: beginner 2860 2861 .keywords: timestep, get, KSP 2862 @*/ 2863 PetscErrorCode TSGetKSP(TS ts,KSP *ksp) 2864 { 2865 PetscErrorCode ierr; 2866 SNES snes; 2867 2868 PetscFunctionBegin; 2869 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2870 PetscValidPointer(ksp,2); 2871 if (!((PetscObject)ts)->type_name) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NULL,"KSP is not created yet. Call TSSetType() first"); 2872 if (ts->problem_type != TS_LINEAR) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Linear only; use TSGetSNES()"); 2873 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 2874 ierr = SNESGetKSP(snes,ksp);CHKERRQ(ierr); 2875 PetscFunctionReturn(0); 2876 } 2877 2878 /* ----------- Routines to set solver parameters ---------- */ 2879 2880 /*@ 2881 TSSetMaxSteps - Sets the maximum number of steps to use. 2882 2883 Logically Collective on TS 2884 2885 Input Parameters: 2886 + ts - the TS context obtained from TSCreate() 2887 - maxsteps - maximum number of steps to use 2888 2889 Options Database Keys: 2890 . -ts_max_steps <maxsteps> - Sets maxsteps 2891 2892 Notes: 2893 The default maximum number of steps is 5000 2894 2895 Level: intermediate 2896 2897 .keywords: TS, timestep, set, maximum, steps 2898 2899 .seealso: TSGetMaxSteps(), TSSetMaxTime(), TSSetExactFinalTime() 2900 @*/ 2901 PetscErrorCode TSSetMaxSteps(TS ts,PetscInt maxsteps) 2902 { 2903 PetscFunctionBegin; 2904 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2905 PetscValidLogicalCollectiveInt(ts,maxsteps,2); 2906 if (maxsteps < 0 ) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_OUTOFRANGE,"Maximum number of steps must be non-negative"); 2907 ts->max_steps = maxsteps; 2908 PetscFunctionReturn(0); 2909 } 2910 2911 /*@ 2912 TSGetMaxSteps - Gets the maximum number of steps to use. 2913 2914 Not Collective 2915 2916 Input Parameters: 2917 . ts - the TS context obtained from TSCreate() 2918 2919 Output Parameter: 2920 . maxsteps - maximum number of steps to use 2921 2922 Level: advanced 2923 2924 .keywords: TS, timestep, get, maximum, steps 2925 2926 .seealso: TSSetMaxSteps(), TSGetMaxTime(), TSSetMaxTime() 2927 @*/ 2928 PetscErrorCode TSGetMaxSteps(TS ts,PetscInt *maxsteps) 2929 { 2930 PetscFunctionBegin; 2931 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2932 PetscValidIntPointer(maxsteps,2); 2933 *maxsteps = ts->max_steps; 2934 PetscFunctionReturn(0); 2935 } 2936 2937 /*@ 2938 TSSetMaxTime - Sets the maximum (or final) time for timestepping. 2939 2940 Logically Collective on TS 2941 2942 Input Parameters: 2943 + ts - the TS context obtained from TSCreate() 2944 - maxtime - final time to step to 2945 2946 Options Database Keys: 2947 . -ts_max_time <maxtime> - Sets maxtime 2948 2949 Notes: 2950 The default maximum time is 5.0 2951 2952 Level: intermediate 2953 2954 .keywords: TS, timestep, set, maximum, time 2955 2956 .seealso: TSGetMaxTime(), TSSetMaxSteps(), TSSetExactFinalTime() 2957 @*/ 2958 PetscErrorCode TSSetMaxTime(TS ts,PetscReal maxtime) 2959 { 2960 PetscFunctionBegin; 2961 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2962 PetscValidLogicalCollectiveReal(ts,maxtime,2); 2963 ts->max_time = maxtime; 2964 PetscFunctionReturn(0); 2965 } 2966 2967 /*@ 2968 TSGetMaxTime - Gets the maximum (or final) time for timestepping. 2969 2970 Not Collective 2971 2972 Input Parameters: 2973 . ts - the TS context obtained from TSCreate() 2974 2975 Output Parameter: 2976 . maxtime - final time to step to 2977 2978 Level: advanced 2979 2980 .keywords: TS, timestep, get, maximum, time 2981 2982 .seealso: TSSetMaxTime(), TSGetMaxSteps(), TSSetMaxSteps() 2983 @*/ 2984 PetscErrorCode TSGetMaxTime(TS ts,PetscReal *maxtime) 2985 { 2986 PetscFunctionBegin; 2987 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2988 PetscValidRealPointer(maxtime,2); 2989 *maxtime = ts->max_time; 2990 PetscFunctionReturn(0); 2991 } 2992 2993 /*@ 2994 TSSetInitialTimeStep - Deprecated, use TSSetTime() and TSSetTimeStep(). 2995 2996 Level: deprecated 2997 2998 @*/ 2999 PetscErrorCode TSSetInitialTimeStep(TS ts,PetscReal initial_time,PetscReal time_step) 3000 { 3001 PetscErrorCode ierr; 3002 PetscFunctionBegin; 3003 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3004 ierr = TSSetTime(ts,initial_time);CHKERRQ(ierr); 3005 ierr = TSSetTimeStep(ts,time_step);CHKERRQ(ierr); 3006 PetscFunctionReturn(0); 3007 } 3008 3009 /*@ 3010 TSGetDuration - Deprecated, use TSGetMaxSteps() and TSGetMaxTime(). 3011 3012 Level: deprecated 3013 3014 @*/ 3015 PetscErrorCode TSGetDuration(TS ts, PetscInt *maxsteps, PetscReal *maxtime) 3016 { 3017 PetscFunctionBegin; 3018 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 3019 if (maxsteps) { 3020 PetscValidIntPointer(maxsteps,2); 3021 *maxsteps = ts->max_steps; 3022 } 3023 if (maxtime) { 3024 PetscValidScalarPointer(maxtime,3); 3025 *maxtime = ts->max_time; 3026 } 3027 PetscFunctionReturn(0); 3028 } 3029 3030 /*@ 3031 TSSetDuration - Deprecated, use TSSetMaxSteps() and TSSetMaxTime(). 3032 3033 Level: deprecated 3034 3035 @*/ 3036 PetscErrorCode TSSetDuration(TS ts,PetscInt maxsteps,PetscReal maxtime) 3037 { 3038 PetscFunctionBegin; 3039 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3040 PetscValidLogicalCollectiveInt(ts,maxsteps,2); 3041 PetscValidLogicalCollectiveReal(ts,maxtime,2); 3042 if (maxsteps >= 0) ts->max_steps = maxsteps; 3043 if (maxtime != PETSC_DEFAULT) ts->max_time = maxtime; 3044 PetscFunctionReturn(0); 3045 } 3046 3047 /*@ 3048 TSGetTimeStepNumber - Deprecated, use TSGetStepNumber(). 3049 3050 Level: deprecated 3051 3052 @*/ 3053 PetscErrorCode TSGetTimeStepNumber(TS ts,PetscInt *steps) { return TSGetStepNumber(ts,steps); } 3054 3055 /*@ 3056 TSGetTotalSteps - Deprecated, use TSGetStepNumber(). 3057 3058 Level: deprecated 3059 3060 @*/ 3061 PetscErrorCode TSGetTotalSteps(TS ts,PetscInt *steps) { return TSGetStepNumber(ts,steps); } 3062 3063 /*@ 3064 TSSetSolution - Sets the initial solution vector 3065 for use by the TS routines. 3066 3067 Logically Collective on TS and Vec 3068 3069 Input Parameters: 3070 + ts - the TS context obtained from TSCreate() 3071 - u - the solution vector 3072 3073 Level: beginner 3074 3075 .keywords: TS, timestep, set, solution, initial values 3076 3077 .seealso: TSSetSolutionFunction(), TSGetSolution(), TSCreate() 3078 @*/ 3079 PetscErrorCode TSSetSolution(TS ts,Vec u) 3080 { 3081 PetscErrorCode ierr; 3082 DM dm; 3083 3084 PetscFunctionBegin; 3085 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3086 PetscValidHeaderSpecific(u,VEC_CLASSID,2); 3087 ierr = PetscObjectReference((PetscObject)u);CHKERRQ(ierr); 3088 ierr = VecDestroy(&ts->vec_sol);CHKERRQ(ierr); 3089 ts->vec_sol = u; 3090 3091 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 3092 ierr = DMShellSetGlobalVector(dm,u);CHKERRQ(ierr); 3093 PetscFunctionReturn(0); 3094 } 3095 3096 /*@C 3097 TSSetPreStep - Sets the general-purpose function 3098 called once at the beginning of each time step. 3099 3100 Logically Collective on TS 3101 3102 Input Parameters: 3103 + ts - The TS context obtained from TSCreate() 3104 - func - The function 3105 3106 Calling sequence of func: 3107 . func (TS ts); 3108 3109 Level: intermediate 3110 3111 .keywords: TS, timestep 3112 .seealso: TSSetPreStage(), TSSetPostStage(), TSSetPostStep(), TSStep(), TSRestartStep() 3113 @*/ 3114 PetscErrorCode TSSetPreStep(TS ts, PetscErrorCode (*func)(TS)) 3115 { 3116 PetscFunctionBegin; 3117 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 3118 ts->prestep = func; 3119 PetscFunctionReturn(0); 3120 } 3121 3122 /*@ 3123 TSPreStep - Runs the user-defined pre-step function. 3124 3125 Collective on TS 3126 3127 Input Parameters: 3128 . ts - The TS context obtained from TSCreate() 3129 3130 Notes: 3131 TSPreStep() is typically used within time stepping implementations, 3132 so most users would not generally call this routine themselves. 3133 3134 Level: developer 3135 3136 .keywords: TS, timestep 3137 .seealso: TSSetPreStep(), TSPreStage(), TSPostStage(), TSPostStep() 3138 @*/ 3139 PetscErrorCode TSPreStep(TS ts) 3140 { 3141 PetscErrorCode ierr; 3142 3143 PetscFunctionBegin; 3144 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3145 if (ts->prestep) { 3146 Vec U; 3147 PetscObjectState sprev,spost; 3148 3149 ierr = TSGetSolution(ts,&U);CHKERRQ(ierr); 3150 ierr = PetscObjectStateGet((PetscObject)U,&sprev);CHKERRQ(ierr); 3151 PetscStackCallStandard((*ts->prestep),(ts)); 3152 ierr = PetscObjectStateGet((PetscObject)U,&spost);CHKERRQ(ierr); 3153 if (sprev != spost) {ierr = TSRestartStep(ts);CHKERRQ(ierr);} 3154 } 3155 PetscFunctionReturn(0); 3156 } 3157 3158 /*@C 3159 TSSetPreStage - Sets the general-purpose function 3160 called once at the beginning of each stage. 3161 3162 Logically Collective on TS 3163 3164 Input Parameters: 3165 + ts - The TS context obtained from TSCreate() 3166 - func - The function 3167 3168 Calling sequence of func: 3169 . PetscErrorCode func(TS ts, PetscReal stagetime); 3170 3171 Level: intermediate 3172 3173 Note: 3174 There may be several stages per time step. If the solve for a given stage fails, the step may be rejected and retried. 3175 The time step number being computed can be queried using TSGetStepNumber() and the total size of the step being 3176 attempted can be obtained using TSGetTimeStep(). The time at the start of the step is available via TSGetTime(). 3177 3178 .keywords: TS, timestep 3179 .seealso: TSSetPostStage(), TSSetPreStep(), TSSetPostStep(), TSGetApplicationContext() 3180 @*/ 3181 PetscErrorCode TSSetPreStage(TS ts, PetscErrorCode (*func)(TS,PetscReal)) 3182 { 3183 PetscFunctionBegin; 3184 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 3185 ts->prestage = func; 3186 PetscFunctionReturn(0); 3187 } 3188 3189 /*@C 3190 TSSetPostStage - Sets the general-purpose function 3191 called once at the end of each stage. 3192 3193 Logically Collective on TS 3194 3195 Input Parameters: 3196 + ts - The TS context obtained from TSCreate() 3197 - func - The function 3198 3199 Calling sequence of func: 3200 . PetscErrorCode func(TS ts, PetscReal stagetime, PetscInt stageindex, Vec* Y); 3201 3202 Level: intermediate 3203 3204 Note: 3205 There may be several stages per time step. If the solve for a given stage fails, the step may be rejected and retried. 3206 The time step number being computed can be queried using TSGetStepNumber() and the total size of the step being 3207 attempted can be obtained using TSGetTimeStep(). The time at the start of the step is available via TSGetTime(). 3208 3209 .keywords: TS, timestep 3210 .seealso: TSSetPreStage(), TSSetPreStep(), TSSetPostStep(), TSGetApplicationContext() 3211 @*/ 3212 PetscErrorCode TSSetPostStage(TS ts, PetscErrorCode (*func)(TS,PetscReal,PetscInt,Vec*)) 3213 { 3214 PetscFunctionBegin; 3215 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 3216 ts->poststage = func; 3217 PetscFunctionReturn(0); 3218 } 3219 3220 /*@C 3221 TSSetPostEvaluate - Sets the general-purpose function 3222 called once at the end of each step evaluation. 3223 3224 Logically Collective on TS 3225 3226 Input Parameters: 3227 + ts - The TS context obtained from TSCreate() 3228 - func - The function 3229 3230 Calling sequence of func: 3231 . PetscErrorCode func(TS ts); 3232 3233 Level: intermediate 3234 3235 Note: 3236 Semantically, TSSetPostEvaluate() differs from TSSetPostStep() since the function it sets is called before event-handling 3237 thus guaranteeing the same solution (computed by the time-stepper) will be passed to it. On the other hand, TSPostStep() 3238 may be passed a different solution, possibly changed by the event handler. TSPostEvaluate() is called after the next step 3239 solution is evaluated allowing to modify it, if need be. The solution can be obtained with TSGetSolution(), the time step 3240 with TSGetTimeStep(), and the time at the start of the step is available via TSGetTime() 3241 3242 .keywords: TS, timestep 3243 .seealso: TSSetPreStage(), TSSetPreStep(), TSSetPostStep(), TSGetApplicationContext() 3244 @*/ 3245 PetscErrorCode TSSetPostEvaluate(TS ts, PetscErrorCode (*func)(TS)) 3246 { 3247 PetscFunctionBegin; 3248 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 3249 ts->postevaluate = func; 3250 PetscFunctionReturn(0); 3251 } 3252 3253 /*@ 3254 TSPreStage - Runs the user-defined pre-stage function set using TSSetPreStage() 3255 3256 Collective on TS 3257 3258 Input Parameters: 3259 . ts - The TS context obtained from TSCreate() 3260 stagetime - The absolute time of the current stage 3261 3262 Notes: 3263 TSPreStage() is typically used within time stepping implementations, 3264 most users would not generally call this routine themselves. 3265 3266 Level: developer 3267 3268 .keywords: TS, timestep 3269 .seealso: TSPostStage(), TSSetPreStep(), TSPreStep(), TSPostStep() 3270 @*/ 3271 PetscErrorCode TSPreStage(TS ts, PetscReal stagetime) 3272 { 3273 PetscFunctionBegin; 3274 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3275 if (ts->prestage) { 3276 PetscStackCallStandard((*ts->prestage),(ts,stagetime)); 3277 } 3278 PetscFunctionReturn(0); 3279 } 3280 3281 /*@ 3282 TSPostStage - Runs the user-defined post-stage function set using TSSetPostStage() 3283 3284 Collective on TS 3285 3286 Input Parameters: 3287 . ts - The TS context obtained from TSCreate() 3288 stagetime - The absolute time of the current stage 3289 stageindex - Stage number 3290 Y - Array of vectors (of size = total number 3291 of stages) with the stage solutions 3292 3293 Notes: 3294 TSPostStage() is typically used within time stepping implementations, 3295 most users would not generally call this routine themselves. 3296 3297 Level: developer 3298 3299 .keywords: TS, timestep 3300 .seealso: TSPreStage(), TSSetPreStep(), TSPreStep(), TSPostStep() 3301 @*/ 3302 PetscErrorCode TSPostStage(TS ts, PetscReal stagetime, PetscInt stageindex, Vec *Y) 3303 { 3304 PetscFunctionBegin; 3305 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3306 if (ts->poststage) { 3307 PetscStackCallStandard((*ts->poststage),(ts,stagetime,stageindex,Y)); 3308 } 3309 PetscFunctionReturn(0); 3310 } 3311 3312 /*@ 3313 TSPostEvaluate - Runs the user-defined post-evaluate function set using TSSetPostEvaluate() 3314 3315 Collective on TS 3316 3317 Input Parameters: 3318 . ts - The TS context obtained from TSCreate() 3319 3320 Notes: 3321 TSPostEvaluate() is typically used within time stepping implementations, 3322 most users would not generally call this routine themselves. 3323 3324 Level: developer 3325 3326 .keywords: TS, timestep 3327 .seealso: TSSetPostEvaluate(), TSSetPreStep(), TSPreStep(), TSPostStep() 3328 @*/ 3329 PetscErrorCode TSPostEvaluate(TS ts) 3330 { 3331 PetscErrorCode ierr; 3332 3333 PetscFunctionBegin; 3334 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3335 if (ts->postevaluate) { 3336 Vec U; 3337 PetscObjectState sprev,spost; 3338 3339 ierr = TSGetSolution(ts,&U);CHKERRQ(ierr); 3340 ierr = PetscObjectStateGet((PetscObject)U,&sprev);CHKERRQ(ierr); 3341 PetscStackCallStandard((*ts->postevaluate),(ts)); 3342 ierr = PetscObjectStateGet((PetscObject)U,&spost);CHKERRQ(ierr); 3343 if (sprev != spost) {ierr = TSRestartStep(ts);CHKERRQ(ierr);} 3344 } 3345 PetscFunctionReturn(0); 3346 } 3347 3348 /*@C 3349 TSSetPostStep - Sets the general-purpose function 3350 called once at the end of each time step. 3351 3352 Logically Collective on TS 3353 3354 Input Parameters: 3355 + ts - The TS context obtained from TSCreate() 3356 - func - The function 3357 3358 Calling sequence of func: 3359 $ func (TS ts); 3360 3361 Notes: 3362 The function set by TSSetPostStep() is called after each successful step. The solution vector X 3363 obtained by TSGetSolution() may be different than that computed at the step end if the event handler 3364 locates an event and TSPostEvent() modifies it. Use TSSetPostEvaluate() if an unmodified solution is needed instead. 3365 3366 Level: intermediate 3367 3368 .keywords: TS, timestep 3369 .seealso: TSSetPreStep(), TSSetPreStage(), TSSetPostEvaluate(), TSGetTimeStep(), TSGetStepNumber(), TSGetTime(), TSRestartStep() 3370 @*/ 3371 PetscErrorCode TSSetPostStep(TS ts, PetscErrorCode (*func)(TS)) 3372 { 3373 PetscFunctionBegin; 3374 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 3375 ts->poststep = func; 3376 PetscFunctionReturn(0); 3377 } 3378 3379 /*@ 3380 TSPostStep - Runs the user-defined post-step function. 3381 3382 Collective on TS 3383 3384 Input Parameters: 3385 . ts - The TS context obtained from TSCreate() 3386 3387 Notes: 3388 TSPostStep() is typically used within time stepping implementations, 3389 so most users would not generally call this routine themselves. 3390 3391 Level: developer 3392 3393 .keywords: TS, timestep 3394 @*/ 3395 PetscErrorCode TSPostStep(TS ts) 3396 { 3397 PetscErrorCode ierr; 3398 3399 PetscFunctionBegin; 3400 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3401 if (ts->poststep) { 3402 Vec U; 3403 PetscObjectState sprev,spost; 3404 3405 ierr = TSGetSolution(ts,&U);CHKERRQ(ierr); 3406 ierr = PetscObjectStateGet((PetscObject)U,&sprev);CHKERRQ(ierr); 3407 PetscStackCallStandard((*ts->poststep),(ts)); 3408 ierr = PetscObjectStateGet((PetscObject)U,&spost);CHKERRQ(ierr); 3409 if (sprev != spost) {ierr = TSRestartStep(ts);CHKERRQ(ierr);} 3410 } 3411 PetscFunctionReturn(0); 3412 } 3413 3414 /* ------------ Routines to set performance monitoring options ----------- */ 3415 3416 /*@C 3417 TSMonitorSet - Sets an ADDITIONAL function that is to be used at every 3418 timestep to display the iteration's progress. 3419 3420 Logically Collective on TS 3421 3422 Input Parameters: 3423 + ts - the TS context obtained from TSCreate() 3424 . monitor - monitoring routine 3425 . mctx - [optional] user-defined context for private data for the 3426 monitor routine (use NULL if no context is desired) 3427 - monitordestroy - [optional] routine that frees monitor context 3428 (may be NULL) 3429 3430 Calling sequence of monitor: 3431 $ PetscErrorCode monitor(TS ts,PetscInt steps,PetscReal time,Vec u,void *mctx) 3432 3433 + ts - the TS context 3434 . steps - iteration number (after the final time step the monitor routine may be called with a step of -1, this indicates the solution has been interpolated to this time) 3435 . time - current time 3436 . u - current iterate 3437 - mctx - [optional] monitoring context 3438 3439 Notes: 3440 This routine adds an additional monitor to the list of monitors that 3441 already has been loaded. 3442 3443 Fortran Notes: 3444 Only a single monitor function can be set for each TS object 3445 3446 Level: intermediate 3447 3448 .keywords: TS, timestep, set, monitor 3449 3450 .seealso: TSMonitorDefault(), TSMonitorCancel() 3451 @*/ 3452 PetscErrorCode TSMonitorSet(TS ts,PetscErrorCode (*monitor)(TS,PetscInt,PetscReal,Vec,void*),void *mctx,PetscErrorCode (*mdestroy)(void**)) 3453 { 3454 PetscErrorCode ierr; 3455 PetscInt i; 3456 PetscBool identical; 3457 3458 PetscFunctionBegin; 3459 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3460 for (i=0; i<ts->numbermonitors;i++) { 3461 ierr = PetscMonitorCompare((PetscErrorCode (*)(void))monitor,mctx,mdestroy,(PetscErrorCode (*)(void))ts->monitor[i],ts->monitorcontext[i],ts->monitordestroy[i],&identical);CHKERRQ(ierr); 3462 if (identical) PetscFunctionReturn(0); 3463 } 3464 if (ts->numbermonitors >= MAXTSMONITORS) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Too many monitors set"); 3465 ts->monitor[ts->numbermonitors] = monitor; 3466 ts->monitordestroy[ts->numbermonitors] = mdestroy; 3467 ts->monitorcontext[ts->numbermonitors++] = (void*)mctx; 3468 PetscFunctionReturn(0); 3469 } 3470 3471 /*@C 3472 TSMonitorCancel - Clears all the monitors that have been set on a time-step object. 3473 3474 Logically Collective on TS 3475 3476 Input Parameters: 3477 . ts - the TS context obtained from TSCreate() 3478 3479 Notes: 3480 There is no way to remove a single, specific monitor. 3481 3482 Level: intermediate 3483 3484 .keywords: TS, timestep, set, monitor 3485 3486 .seealso: TSMonitorDefault(), TSMonitorSet() 3487 @*/ 3488 PetscErrorCode TSMonitorCancel(TS ts) 3489 { 3490 PetscErrorCode ierr; 3491 PetscInt i; 3492 3493 PetscFunctionBegin; 3494 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3495 for (i=0; i<ts->numbermonitors; i++) { 3496 if (ts->monitordestroy[i]) { 3497 ierr = (*ts->monitordestroy[i])(&ts->monitorcontext[i]);CHKERRQ(ierr); 3498 } 3499 } 3500 ts->numbermonitors = 0; 3501 PetscFunctionReturn(0); 3502 } 3503 3504 /*@C 3505 TSMonitorDefault - The Default monitor, prints the timestep and time for each step 3506 3507 Level: intermediate 3508 3509 .keywords: TS, set, monitor 3510 3511 .seealso: TSMonitorSet() 3512 @*/ 3513 PetscErrorCode TSMonitorDefault(TS ts,PetscInt step,PetscReal ptime,Vec v,PetscViewerAndFormat *vf) 3514 { 3515 PetscErrorCode ierr; 3516 PetscViewer viewer = vf->viewer; 3517 PetscBool iascii,ibinary; 3518 3519 PetscFunctionBegin; 3520 PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,4); 3521 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr); 3522 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERBINARY,&ibinary);CHKERRQ(ierr); 3523 ierr = PetscViewerPushFormat(viewer,vf->format);CHKERRQ(ierr); 3524 if (iascii) { 3525 ierr = PetscViewerASCIIAddTab(viewer,((PetscObject)ts)->tablevel);CHKERRQ(ierr); 3526 if (step == -1){ /* this indicates it is an interpolated solution */ 3527 ierr = PetscViewerASCIIPrintf(viewer,"Interpolated solution at time %g between steps %D and %D\n",(double)ptime,ts->steps-1,ts->steps);CHKERRQ(ierr); 3528 } else { 3529 ierr = PetscViewerASCIIPrintf(viewer,"%D TS dt %g time %g%s",step,(double)ts->time_step,(double)ptime,ts->steprollback ? " (r)\n" : "\n");CHKERRQ(ierr); 3530 } 3531 ierr = PetscViewerASCIISubtractTab(viewer,((PetscObject)ts)->tablevel);CHKERRQ(ierr); 3532 } else if (ibinary) { 3533 PetscMPIInt rank; 3534 ierr = MPI_Comm_rank(PetscObjectComm((PetscObject)viewer),&rank);CHKERRQ(ierr); 3535 if (!rank) { 3536 PetscBool skipHeader; 3537 PetscInt classid = REAL_FILE_CLASSID; 3538 3539 ierr = PetscViewerBinaryGetSkipHeader(viewer,&skipHeader);CHKERRQ(ierr); 3540 if (!skipHeader) { 3541 ierr = PetscViewerBinaryWrite(viewer,&classid,1,PETSC_INT,PETSC_FALSE);CHKERRQ(ierr); 3542 } 3543 ierr = PetscRealView(1,&ptime,viewer);CHKERRQ(ierr); 3544 } else { 3545 ierr = PetscRealView(0,&ptime,viewer);CHKERRQ(ierr); 3546 } 3547 } 3548 ierr = PetscViewerPopFormat(viewer);CHKERRQ(ierr); 3549 PetscFunctionReturn(0); 3550 } 3551 3552 /*@C 3553 TSMonitorExtreme - Prints the extreme values of the solution at each timestep 3554 3555 Level: intermediate 3556 3557 .keywords: TS, set, monitor 3558 3559 .seealso: TSMonitorSet() 3560 @*/ 3561 PetscErrorCode TSMonitorExtreme(TS ts,PetscInt step,PetscReal ptime,Vec v,PetscViewerAndFormat *vf) 3562 { 3563 PetscErrorCode ierr; 3564 PetscViewer viewer = vf->viewer; 3565 PetscBool iascii; 3566 PetscReal max,min; 3567 3568 3569 PetscFunctionBegin; 3570 PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,4); 3571 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr); 3572 ierr = PetscViewerPushFormat(viewer,vf->format);CHKERRQ(ierr); 3573 if (iascii) { 3574 ierr = VecMax(v,NULL,&max);CHKERRQ(ierr); 3575 ierr = VecMin(v,NULL,&min);CHKERRQ(ierr); 3576 ierr = PetscViewerASCIIAddTab(viewer,((PetscObject)ts)->tablevel);CHKERRQ(ierr); 3577 ierr = PetscViewerASCIIPrintf(viewer,"%D TS dt %g time %g%s max %g min %g\n",step,(double)ts->time_step,(double)ptime,ts->steprollback ? " (r)" : "",(double)max,(double)min);CHKERRQ(ierr); 3578 ierr = PetscViewerASCIISubtractTab(viewer,((PetscObject)ts)->tablevel);CHKERRQ(ierr); 3579 } 3580 ierr = PetscViewerPopFormat(viewer);CHKERRQ(ierr); 3581 PetscFunctionReturn(0); 3582 } 3583 3584 /*@ 3585 TSInterpolate - Interpolate the solution computed during the previous step to an arbitrary location in the interval 3586 3587 Collective on TS 3588 3589 Input Argument: 3590 + ts - time stepping context 3591 - t - time to interpolate to 3592 3593 Output Argument: 3594 . U - state at given time 3595 3596 Level: intermediate 3597 3598 Developer Notes: 3599 TSInterpolate() and the storing of previous steps/stages should be generalized to support delay differential equations and continuous adjoints. 3600 3601 .keywords: TS, set 3602 3603 .seealso: TSSetExactFinalTime(), TSSolve() 3604 @*/ 3605 PetscErrorCode TSInterpolate(TS ts,PetscReal t,Vec U) 3606 { 3607 PetscErrorCode ierr; 3608 3609 PetscFunctionBegin; 3610 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3611 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 3612 if (t < ts->ptime_prev || t > ts->ptime) SETERRQ3(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_OUTOFRANGE,"Requested time %g not in last time steps [%g,%g]",t,(double)ts->ptime_prev,(double)ts->ptime); 3613 if (!ts->ops->interpolate) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"%s does not provide interpolation",((PetscObject)ts)->type_name); 3614 ierr = (*ts->ops->interpolate)(ts,t,U);CHKERRQ(ierr); 3615 PetscFunctionReturn(0); 3616 } 3617 3618 /*@ 3619 TSStep - Steps one time step 3620 3621 Collective on TS 3622 3623 Input Parameter: 3624 . ts - the TS context obtained from TSCreate() 3625 3626 Level: developer 3627 3628 Notes: 3629 The public interface for the ODE/DAE solvers is TSSolve(), you should almost for sure be using that routine and not this routine. 3630 3631 The hook set using TSSetPreStep() is called before each attempt to take the step. In general, the time step size may 3632 be changed due to adaptive error controller or solve failures. Note that steps may contain multiple stages. 3633 3634 This may over-step the final time provided in TSSetMaxTime() depending on the time-step used. TSSolve() interpolates to exactly the 3635 time provided in TSSetMaxTime(). One can use TSInterpolate() to determine an interpolated solution within the final timestep. 3636 3637 .keywords: TS, timestep, solve 3638 3639 .seealso: TSCreate(), TSSetUp(), TSDestroy(), TSSolve(), TSSetPreStep(), TSSetPreStage(), TSSetPostStage(), TSInterpolate() 3640 @*/ 3641 PetscErrorCode TSStep(TS ts) 3642 { 3643 PetscErrorCode ierr; 3644 static PetscBool cite = PETSC_FALSE; 3645 PetscReal ptime; 3646 3647 PetscFunctionBegin; 3648 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3649 ierr = PetscCitationsRegister("@techreport{tspaper,\n" 3650 " title = {{PETSc/TS}: A Modern Scalable {DAE/ODE} Solver Library},\n" 3651 " author = {Shrirang Abhyankar and Jed Brown and Emil Constantinescu and Debojyoti Ghosh and Barry F. Smith},\n" 3652 " type = {Preprint},\n" 3653 " number = {ANL/MCS-P5061-0114},\n" 3654 " institution = {Argonne National Laboratory},\n" 3655 " year = {2014}\n}\n",&cite);CHKERRQ(ierr); 3656 3657 ierr = TSSetUp(ts);CHKERRQ(ierr); 3658 ierr = TSTrajectorySetUp(ts->trajectory,ts);CHKERRQ(ierr); 3659 3660 if (ts->max_time >= PETSC_MAX_REAL && ts->max_steps == PETSC_MAX_INT) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_WRONGSTATE,"You must call TSSetMaxTime() or TSSetMaxSteps(), or use -ts_max_time <time> or -ts_max_steps <steps>"); 3661 if (ts->exact_final_time == TS_EXACTFINALTIME_UNSPECIFIED) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_WRONGSTATE,"You must call TSSetExactFinalTime() or use -ts_exact_final_time <stepover,interpolate,matchstep> before calling TSStep()"); 3662 if (ts->exact_final_time == TS_EXACTFINALTIME_MATCHSTEP && !ts->adapt) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"Since TS is not adaptive you cannot use TS_EXACTFINALTIME_MATCHSTEP, suggest TS_EXACTFINALTIME_INTERPOLATE"); 3663 3664 if (!ts->steps) ts->ptime_prev = ts->ptime; 3665 ptime = ts->ptime; ts->ptime_prev_rollback = ts->ptime_prev; 3666 ts->reason = TS_CONVERGED_ITERATING; 3667 if (!ts->ops->step) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"TSStep not implemented for type '%s'",((PetscObject)ts)->type_name); 3668 ierr = PetscLogEventBegin(TS_Step,ts,0,0,0);CHKERRQ(ierr); 3669 ierr = (*ts->ops->step)(ts);CHKERRQ(ierr); 3670 ierr = PetscLogEventEnd(TS_Step,ts,0,0,0);CHKERRQ(ierr); 3671 ts->ptime_prev = ptime; 3672 ts->steps++; 3673 ts->steprollback = PETSC_FALSE; 3674 ts->steprestart = PETSC_FALSE; 3675 3676 if (ts->reason < 0) { 3677 if (ts->errorifstepfailed) { 3678 if (ts->reason == TS_DIVERGED_NONLINEAR_SOLVE) 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]); 3679 else SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_NOT_CONVERGED,"TSStep has failed due to %s",TSConvergedReasons[ts->reason]); 3680 } 3681 } else if (!ts->reason) { 3682 if (ts->steps >= ts->max_steps) ts->reason = TS_CONVERGED_ITS; 3683 else if (ts->ptime >= ts->max_time) ts->reason = TS_CONVERGED_TIME; 3684 } 3685 PetscFunctionReturn(0); 3686 } 3687 3688 /*@ 3689 TSEvaluateWLTE - Evaluate the weighted local truncation error norm 3690 at the end of a time step with a given order of accuracy. 3691 3692 Collective on TS 3693 3694 Input Arguments: 3695 + ts - time stepping context 3696 . wnormtype - norm type, either NORM_2 or NORM_INFINITY 3697 - order - optional, desired order for the error evaluation or PETSC_DECIDE 3698 3699 Output Arguments: 3700 + order - optional, the actual order of the error evaluation 3701 - wlte - the weighted local truncation error norm 3702 3703 Level: advanced 3704 3705 Notes: 3706 If the timestepper cannot evaluate the error in a particular step 3707 (eg. in the first step or restart steps after event handling), 3708 this routine returns wlte=-1.0 . 3709 3710 .seealso: TSStep(), TSAdapt, TSErrorWeightedNorm() 3711 @*/ 3712 PetscErrorCode TSEvaluateWLTE(TS ts,NormType wnormtype,PetscInt *order,PetscReal *wlte) 3713 { 3714 PetscErrorCode ierr; 3715 3716 PetscFunctionBegin; 3717 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3718 PetscValidType(ts,1); 3719 PetscValidLogicalCollectiveEnum(ts,wnormtype,4); 3720 if (order) PetscValidIntPointer(order,3); 3721 if (order) PetscValidLogicalCollectiveInt(ts,*order,3); 3722 PetscValidRealPointer(wlte,4); 3723 if (wnormtype != NORM_2 && wnormtype != NORM_INFINITY) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"No support for norm type %s",NormTypes[wnormtype]); 3724 if (!ts->ops->evaluatewlte) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"TSEvaluateWLTE not implemented for type '%s'",((PetscObject)ts)->type_name); 3725 ierr = (*ts->ops->evaluatewlte)(ts,wnormtype,order,wlte);CHKERRQ(ierr); 3726 PetscFunctionReturn(0); 3727 } 3728 3729 /*@ 3730 TSEvaluateStep - Evaluate the solution at the end of a time step with a given order of accuracy. 3731 3732 Collective on TS 3733 3734 Input Arguments: 3735 + ts - time stepping context 3736 . order - desired order of accuracy 3737 - done - whether the step was evaluated at this order (pass NULL to generate an error if not available) 3738 3739 Output Arguments: 3740 . U - state at the end of the current step 3741 3742 Level: advanced 3743 3744 Notes: 3745 This function cannot be called until all stages have been evaluated. 3746 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. 3747 3748 .seealso: TSStep(), TSAdapt 3749 @*/ 3750 PetscErrorCode TSEvaluateStep(TS ts,PetscInt order,Vec U,PetscBool *done) 3751 { 3752 PetscErrorCode ierr; 3753 3754 PetscFunctionBegin; 3755 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3756 PetscValidType(ts,1); 3757 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 3758 if (!ts->ops->evaluatestep) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"TSEvaluateStep not implemented for type '%s'",((PetscObject)ts)->type_name); 3759 ierr = (*ts->ops->evaluatestep)(ts,order,U,done);CHKERRQ(ierr); 3760 PetscFunctionReturn(0); 3761 } 3762 3763 /*@ 3764 TSSolve - Steps the requested number of timesteps. 3765 3766 Collective on TS 3767 3768 Input Parameter: 3769 + ts - the TS context obtained from TSCreate() 3770 - u - the solution vector (can be null if TSSetSolution() was used and TSSetExactFinalTime(ts,TS_EXACTFINALTIME_MATCHSTEP) was not used, 3771 otherwise must contain the initial conditions and will contain the solution at the final requested time 3772 3773 Level: beginner 3774 3775 Notes: 3776 The final time returned by this function may be different from the time of the internally 3777 held state accessible by TSGetSolution() and TSGetTime() because the method may have 3778 stepped over the final time. 3779 3780 .keywords: TS, timestep, solve 3781 3782 .seealso: TSCreate(), TSSetSolution(), TSStep(), TSGetTime(), TSGetSolveTime() 3783 @*/ 3784 PetscErrorCode TSSolve(TS ts,Vec u) 3785 { 3786 Vec solution; 3787 PetscErrorCode ierr; 3788 3789 PetscFunctionBegin; 3790 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3791 if (u) PetscValidHeaderSpecific(u,VEC_CLASSID,2); 3792 3793 if (ts->exact_final_time == TS_EXACTFINALTIME_INTERPOLATE && u) { /* Need ts->vec_sol to be distinct so it is not overwritten when we interpolate at the end */ 3794 if (!ts->vec_sol || u == ts->vec_sol) { 3795 ierr = VecDuplicate(u,&solution);CHKERRQ(ierr); 3796 ierr = TSSetSolution(ts,solution);CHKERRQ(ierr); 3797 ierr = VecDestroy(&solution);CHKERRQ(ierr); /* grant ownership */ 3798 } 3799 ierr = VecCopy(u,ts->vec_sol);CHKERRQ(ierr); 3800 if (ts->forward_solve) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"Sensitivity analysis does not support the mode TS_EXACTFINALTIME_INTERPOLATE"); 3801 } else if (u) { 3802 ierr = TSSetSolution(ts,u);CHKERRQ(ierr); 3803 } 3804 ierr = TSSetUp(ts);CHKERRQ(ierr); 3805 ierr = TSTrajectorySetUp(ts->trajectory,ts);CHKERRQ(ierr); 3806 3807 if (ts->max_time >= PETSC_MAX_REAL && ts->max_steps == PETSC_MAX_INT) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_WRONGSTATE,"You must call TSSetMaxTime() or TSSetMaxSteps(), or use -ts_max_time <time> or -ts_max_steps <steps>"); 3808 if (ts->exact_final_time == TS_EXACTFINALTIME_UNSPECIFIED) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_WRONGSTATE,"You must call TSSetExactFinalTime() or use -ts_exact_final_time <stepover,interpolate,matchstep> before calling TSSolve()"); 3809 if (ts->exact_final_time == TS_EXACTFINALTIME_MATCHSTEP && !ts->adapt) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"Since TS is not adaptive you cannot use TS_EXACTFINALTIME_MATCHSTEP, suggest TS_EXACTFINALTIME_INTERPOLATE"); 3810 3811 if (ts->forward_solve) { 3812 ierr = TSForwardSetUp(ts);CHKERRQ(ierr); 3813 } 3814 3815 /* reset number of steps only when the step is not restarted. ARKIMEX 3816 restarts the step after an event. Resetting these counters in such case causes 3817 TSTrajectory to incorrectly save the output files 3818 */ 3819 /* reset time step and iteration counters */ 3820 if (!ts->steps) { 3821 ts->ksp_its = 0; 3822 ts->snes_its = 0; 3823 ts->num_snes_failures = 0; 3824 ts->reject = 0; 3825 ts->steprestart = PETSC_TRUE; 3826 ts->steprollback = PETSC_FALSE; 3827 } 3828 if (ts->exact_final_time == TS_EXACTFINALTIME_MATCHSTEP && ts->ptime + ts->time_step > ts->max_time) ts->time_step = ts->max_time - ts->ptime; 3829 ts->reason = TS_CONVERGED_ITERATING; 3830 3831 ierr = TSViewFromOptions(ts,NULL,"-ts_view_pre");CHKERRQ(ierr); 3832 3833 if (ts->ops->solve) { /* This private interface is transitional and should be removed when all implementations are updated. */ 3834 ierr = (*ts->ops->solve)(ts);CHKERRQ(ierr); 3835 if (u) {ierr = VecCopy(ts->vec_sol,u);CHKERRQ(ierr);} 3836 ts->solvetime = ts->ptime; 3837 solution = ts->vec_sol; 3838 } else { /* Step the requested number of timesteps. */ 3839 if (ts->steps >= ts->max_steps) ts->reason = TS_CONVERGED_ITS; 3840 else if (ts->ptime >= ts->max_time) ts->reason = TS_CONVERGED_TIME; 3841 3842 if (!ts->steps) { 3843 ierr = TSTrajectorySet(ts->trajectory,ts,ts->steps,ts->ptime,ts->vec_sol);CHKERRQ(ierr); 3844 ierr = TSEventInitialize(ts->event,ts,ts->ptime,ts->vec_sol);CHKERRQ(ierr); 3845 } 3846 3847 while (!ts->reason) { 3848 ierr = TSMonitor(ts,ts->steps,ts->ptime,ts->vec_sol);CHKERRQ(ierr); 3849 if (!ts->steprollback) { 3850 ierr = TSPreStep(ts);CHKERRQ(ierr); 3851 } 3852 ierr = TSStep(ts);CHKERRQ(ierr); 3853 if (ts->testjacobian) { 3854 ierr = TSRHSJacobianTest(ts,NULL);CHKERRQ(ierr); 3855 } 3856 if (ts->testjacobiantranspose) { 3857 ierr = TSRHSJacobianTestTranspose(ts,NULL);CHKERRQ(ierr); 3858 } 3859 if (ts->vec_costintegral && ts->costintegralfwd) { /* Must evaluate the cost integral before event is handled. The cost integral value can also be rolled back. */ 3860 ierr = TSForwardCostIntegral(ts);CHKERRQ(ierr); 3861 } 3862 if (ts->forward_solve) { /* compute forward sensitivities before event handling because postevent() may change RHS and jump conditions may have to be applied */ 3863 ierr = TSForwardStep(ts);CHKERRQ(ierr); 3864 } 3865 ierr = TSPostEvaluate(ts);CHKERRQ(ierr); 3866 ierr = TSEventHandler(ts);CHKERRQ(ierr); /* The right-hand side may be changed due to event. Be careful with Any computation using the RHS information after this point. */ 3867 if (ts->steprollback) { 3868 ierr = TSPostEvaluate(ts);CHKERRQ(ierr); 3869 } 3870 if (!ts->steprollback) { 3871 ierr = TSTrajectorySet(ts->trajectory,ts,ts->steps,ts->ptime,ts->vec_sol);CHKERRQ(ierr); 3872 ierr = TSPostStep(ts);CHKERRQ(ierr); 3873 } 3874 } 3875 ierr = TSMonitor(ts,ts->steps,ts->ptime,ts->vec_sol);CHKERRQ(ierr); 3876 3877 if (ts->exact_final_time == TS_EXACTFINALTIME_INTERPOLATE && ts->ptime > ts->max_time) { 3878 ierr = TSInterpolate(ts,ts->max_time,u);CHKERRQ(ierr); 3879 ts->solvetime = ts->max_time; 3880 solution = u; 3881 ierr = TSMonitor(ts,-1,ts->solvetime,solution);CHKERRQ(ierr); 3882 } else { 3883 if (u) {ierr = VecCopy(ts->vec_sol,u);CHKERRQ(ierr);} 3884 ts->solvetime = ts->ptime; 3885 solution = ts->vec_sol; 3886 } 3887 } 3888 3889 ierr = TSViewFromOptions(ts,NULL,"-ts_view");CHKERRQ(ierr); 3890 ierr = VecViewFromOptions(solution,NULL,"-ts_view_solution");CHKERRQ(ierr); 3891 ierr = PetscObjectSAWsBlock((PetscObject)ts);CHKERRQ(ierr); 3892 if (ts->adjoint_solve) { 3893 ierr = TSAdjointSolve(ts);CHKERRQ(ierr); 3894 } 3895 PetscFunctionReturn(0); 3896 } 3897 3898 /*@C 3899 TSMonitor - Runs all user-provided monitor routines set using TSMonitorSet() 3900 3901 Collective on TS 3902 3903 Input Parameters: 3904 + ts - time stepping context obtained from TSCreate() 3905 . step - step number that has just completed 3906 . ptime - model time of the state 3907 - u - state at the current model time 3908 3909 Notes: 3910 TSMonitor() is typically used automatically within the time stepping implementations. 3911 Users would almost never call this routine directly. 3912 3913 A step of -1 indicates that the monitor is being called on a solution obtained by interpolating from computed solutions 3914 3915 Level: developer 3916 3917 .keywords: TS, timestep 3918 @*/ 3919 PetscErrorCode TSMonitor(TS ts,PetscInt step,PetscReal ptime,Vec u) 3920 { 3921 DM dm; 3922 PetscInt i,n = ts->numbermonitors; 3923 PetscErrorCode ierr; 3924 3925 PetscFunctionBegin; 3926 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3927 PetscValidHeaderSpecific(u,VEC_CLASSID,4); 3928 3929 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 3930 ierr = DMSetOutputSequenceNumber(dm,step,ptime);CHKERRQ(ierr); 3931 3932 ierr = VecLockReadPush(u);CHKERRQ(ierr); 3933 for (i=0; i<n; i++) { 3934 ierr = (*ts->monitor[i])(ts,step,ptime,u,ts->monitorcontext[i]);CHKERRQ(ierr); 3935 } 3936 ierr = VecLockReadPop(u);CHKERRQ(ierr); 3937 PetscFunctionReturn(0); 3938 } 3939 3940 /* ------------------------------------------------------------------------*/ 3941 /*@C 3942 TSMonitorLGCtxCreate - Creates a TSMonitorLGCtx context for use with 3943 TS to monitor the solution process graphically in various ways 3944 3945 Collective on TS 3946 3947 Input Parameters: 3948 + host - the X display to open, or null for the local machine 3949 . label - the title to put in the title bar 3950 . x, y - the screen coordinates of the upper left coordinate of the window 3951 . m, n - the screen width and height in pixels 3952 - howoften - if positive then determines the frequency of the plotting, if -1 then only at the final time 3953 3954 Output Parameter: 3955 . ctx - the context 3956 3957 Options Database Key: 3958 + -ts_monitor_lg_timestep - automatically sets line graph monitor 3959 + -ts_monitor_lg_timestep_log - automatically sets line graph monitor 3960 . -ts_monitor_lg_solution - monitor the solution (or certain values of the solution by calling TSMonitorLGSetDisplayVariables() or TSMonitorLGCtxSetDisplayVariables()) 3961 . -ts_monitor_lg_error - monitor the error 3962 . -ts_monitor_lg_ksp_iterations - monitor the number of KSP iterations needed for each timestep 3963 . -ts_monitor_lg_snes_iterations - monitor the number of SNES iterations needed for each timestep 3964 - -lg_use_markers <true,false> - mark the data points (at each time step) on the plot; default is true 3965 3966 Notes: 3967 Use TSMonitorLGCtxDestroy() to destroy. 3968 3969 One can provide a function that transforms the solution before plotting it with TSMonitorLGCtxSetTransform() or TSMonitorLGSetTransform() 3970 3971 Many of the functions that control the monitoring have two forms: TSMonitorLGSet/GetXXXX() and TSMonitorLGCtxSet/GetXXXX() the first take a TS object as the 3972 first argument (if that TS object does not have a TSMonitorLGCtx associated with it the function call is ignored) and the second takes a TSMonitorLGCtx object 3973 as the first argument. 3974 3975 One can control the names displayed for each solution or error variable with TSMonitorLGCtxSetVariableNames() or TSMonitorLGSetVariableNames() 3976 3977 Level: intermediate 3978 3979 .keywords: TS, monitor, line graph, residual 3980 3981 .seealso: TSMonitorLGTimeStep(), TSMonitorSet(), TSMonitorLGSolution(), TSMonitorLGError(), TSMonitorDefault(), VecView(), 3982 TSMonitorLGCtxCreate(), TSMonitorLGCtxSetVariableNames(), TSMonitorLGCtxGetVariableNames(), 3983 TSMonitorLGSetVariableNames(), TSMonitorLGGetVariableNames(), TSMonitorLGSetDisplayVariables(), TSMonitorLGCtxSetDisplayVariables(), 3984 TSMonitorLGCtxSetTransform(), TSMonitorLGSetTransform(), TSMonitorLGError(), TSMonitorLGSNESIterations(), TSMonitorLGKSPIterations(), 3985 TSMonitorEnvelopeCtxCreate(), TSMonitorEnvelopeGetBounds(), TSMonitorEnvelopeCtxDestroy(), TSMonitorEnvelop() 3986 3987 @*/ 3988 PetscErrorCode TSMonitorLGCtxCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscInt howoften,TSMonitorLGCtx *ctx) 3989 { 3990 PetscDraw draw; 3991 PetscErrorCode ierr; 3992 3993 PetscFunctionBegin; 3994 ierr = PetscNew(ctx);CHKERRQ(ierr); 3995 ierr = PetscDrawCreate(comm,host,label,x,y,m,n,&draw);CHKERRQ(ierr); 3996 ierr = PetscDrawSetFromOptions(draw);CHKERRQ(ierr); 3997 ierr = PetscDrawLGCreate(draw,1,&(*ctx)->lg);CHKERRQ(ierr); 3998 ierr = PetscDrawLGSetFromOptions((*ctx)->lg);CHKERRQ(ierr); 3999 ierr = PetscDrawDestroy(&draw);CHKERRQ(ierr); 4000 (*ctx)->howoften = howoften; 4001 PetscFunctionReturn(0); 4002 } 4003 4004 PetscErrorCode TSMonitorLGTimeStep(TS ts,PetscInt step,PetscReal ptime,Vec v,void *monctx) 4005 { 4006 TSMonitorLGCtx ctx = (TSMonitorLGCtx) monctx; 4007 PetscReal x = ptime,y; 4008 PetscErrorCode ierr; 4009 4010 PetscFunctionBegin; 4011 if (step < 0) PetscFunctionReturn(0); /* -1 indicates an interpolated solution */ 4012 if (!step) { 4013 PetscDrawAxis axis; 4014 const char *ylabel = ctx->semilogy ? "Log Time Step" : "Time Step"; 4015 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 4016 ierr = PetscDrawAxisSetLabels(axis,"Timestep as function of time","Time",ylabel);CHKERRQ(ierr); 4017 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 4018 } 4019 ierr = TSGetTimeStep(ts,&y);CHKERRQ(ierr); 4020 if (ctx->semilogy) y = PetscLog10Real(y); 4021 ierr = PetscDrawLGAddPoint(ctx->lg,&x,&y);CHKERRQ(ierr); 4022 if (((ctx->howoften > 0) && (!(step % ctx->howoften))) || ((ctx->howoften == -1) && ts->reason)) { 4023 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 4024 ierr = PetscDrawLGSave(ctx->lg);CHKERRQ(ierr); 4025 } 4026 PetscFunctionReturn(0); 4027 } 4028 4029 /*@C 4030 TSMonitorLGCtxDestroy - Destroys a line graph context that was created 4031 with TSMonitorLGCtxCreate(). 4032 4033 Collective on TSMonitorLGCtx 4034 4035 Input Parameter: 4036 . ctx - the monitor context 4037 4038 Level: intermediate 4039 4040 .keywords: TS, monitor, line graph, destroy 4041 4042 .seealso: TSMonitorLGCtxCreate(), TSMonitorSet(), TSMonitorLGTimeStep(); 4043 @*/ 4044 PetscErrorCode TSMonitorLGCtxDestroy(TSMonitorLGCtx *ctx) 4045 { 4046 PetscErrorCode ierr; 4047 4048 PetscFunctionBegin; 4049 if ((*ctx)->transformdestroy) { 4050 ierr = ((*ctx)->transformdestroy)((*ctx)->transformctx);CHKERRQ(ierr); 4051 } 4052 ierr = PetscDrawLGDestroy(&(*ctx)->lg);CHKERRQ(ierr); 4053 ierr = PetscStrArrayDestroy(&(*ctx)->names);CHKERRQ(ierr); 4054 ierr = PetscStrArrayDestroy(&(*ctx)->displaynames);CHKERRQ(ierr); 4055 ierr = PetscFree((*ctx)->displayvariables);CHKERRQ(ierr); 4056 ierr = PetscFree((*ctx)->displayvalues);CHKERRQ(ierr); 4057 ierr = PetscFree(*ctx);CHKERRQ(ierr); 4058 PetscFunctionReturn(0); 4059 } 4060 4061 /* 4062 4063 Creates a TS Monitor SPCtx for use with DM Swarm particle visualizations 4064 4065 */ 4066 PetscErrorCode TSMonitorSPCtxCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscInt howoften,TSMonitorSPCtx *ctx) 4067 { 4068 PetscDraw draw; 4069 PetscErrorCode ierr; 4070 4071 PetscFunctionBegin; 4072 ierr = PetscNew(ctx);CHKERRQ(ierr); 4073 ierr = PetscDrawCreate(comm,host,label,x,y,m,n,&draw);CHKERRQ(ierr); 4074 ierr = PetscDrawSetFromOptions(draw);CHKERRQ(ierr); 4075 ierr = PetscDrawSPCreate(draw,1,&(*ctx)->sp);CHKERRQ(ierr); 4076 ierr = PetscDrawDestroy(&draw);CHKERRQ(ierr); 4077 (*ctx)->howoften = howoften; 4078 PetscFunctionReturn(0); 4079 4080 } 4081 4082 /* 4083 Destroys a TSMonitorSPCtx that was created with TSMonitorSPCtxCreate 4084 */ 4085 PetscErrorCode TSMonitorSPCtxDestroy(TSMonitorSPCtx *ctx) 4086 { 4087 PetscErrorCode ierr; 4088 4089 PetscFunctionBegin; 4090 4091 ierr = PetscDrawSPDestroy(&(*ctx)->sp);CHKERRQ(ierr); 4092 ierr = PetscFree(*ctx);CHKERRQ(ierr); 4093 4094 PetscFunctionReturn(0); 4095 4096 } 4097 4098 /*@ 4099 TSGetTime - Gets the time of the most recently completed step. 4100 4101 Not Collective 4102 4103 Input Parameter: 4104 . ts - the TS context obtained from TSCreate() 4105 4106 Output Parameter: 4107 . t - the current time. This time may not corresponds to the final time set with TSSetMaxTime(), use TSGetSolveTime(). 4108 4109 Level: beginner 4110 4111 Note: 4112 When called during time step evaluation (e.g. during residual evaluation or via hooks set using TSSetPreStep(), 4113 TSSetPreStage(), TSSetPostStage(), or TSSetPostStep()), the time is the time at the start of the step being evaluated. 4114 4115 .seealso: TSGetSolveTime(), TSSetTime(), TSGetTimeStep() 4116 4117 .keywords: TS, get, time 4118 @*/ 4119 PetscErrorCode TSGetTime(TS ts,PetscReal *t) 4120 { 4121 PetscFunctionBegin; 4122 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4123 PetscValidRealPointer(t,2); 4124 *t = ts->ptime; 4125 PetscFunctionReturn(0); 4126 } 4127 4128 /*@ 4129 TSGetPrevTime - Gets the starting time of the previously completed step. 4130 4131 Not Collective 4132 4133 Input Parameter: 4134 . ts - the TS context obtained from TSCreate() 4135 4136 Output Parameter: 4137 . t - the previous time 4138 4139 Level: beginner 4140 4141 .seealso: TSGetTime(), TSGetSolveTime(), TSGetTimeStep() 4142 4143 .keywords: TS, get, time 4144 @*/ 4145 PetscErrorCode TSGetPrevTime(TS ts,PetscReal *t) 4146 { 4147 PetscFunctionBegin; 4148 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4149 PetscValidRealPointer(t,2); 4150 *t = ts->ptime_prev; 4151 PetscFunctionReturn(0); 4152 } 4153 4154 /*@ 4155 TSSetTime - Allows one to reset the time. 4156 4157 Logically Collective on TS 4158 4159 Input Parameters: 4160 + ts - the TS context obtained from TSCreate() 4161 - time - the time 4162 4163 Level: intermediate 4164 4165 .seealso: TSGetTime(), TSSetMaxSteps() 4166 4167 .keywords: TS, set, time 4168 @*/ 4169 PetscErrorCode TSSetTime(TS ts, PetscReal t) 4170 { 4171 PetscFunctionBegin; 4172 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4173 PetscValidLogicalCollectiveReal(ts,t,2); 4174 ts->ptime = t; 4175 PetscFunctionReturn(0); 4176 } 4177 4178 /*@C 4179 TSSetOptionsPrefix - Sets the prefix used for searching for all 4180 TS options in the database. 4181 4182 Logically Collective on TS 4183 4184 Input Parameter: 4185 + ts - The TS context 4186 - prefix - The prefix to prepend to all option names 4187 4188 Notes: 4189 A hyphen (-) must NOT be given at the beginning of the prefix name. 4190 The first character of all runtime options is AUTOMATICALLY the 4191 hyphen. 4192 4193 Level: advanced 4194 4195 .keywords: TS, set, options, prefix, database 4196 4197 .seealso: TSSetFromOptions() 4198 4199 @*/ 4200 PetscErrorCode TSSetOptionsPrefix(TS ts,const char prefix[]) 4201 { 4202 PetscErrorCode ierr; 4203 SNES snes; 4204 4205 PetscFunctionBegin; 4206 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4207 ierr = PetscObjectSetOptionsPrefix((PetscObject)ts,prefix);CHKERRQ(ierr); 4208 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 4209 ierr = SNESSetOptionsPrefix(snes,prefix);CHKERRQ(ierr); 4210 PetscFunctionReturn(0); 4211 } 4212 4213 /*@C 4214 TSAppendOptionsPrefix - Appends to the prefix used for searching for all 4215 TS options in the database. 4216 4217 Logically Collective on TS 4218 4219 Input Parameter: 4220 + ts - The TS context 4221 - prefix - The prefix to prepend to all option names 4222 4223 Notes: 4224 A hyphen (-) must NOT be given at the beginning of the prefix name. 4225 The first character of all runtime options is AUTOMATICALLY the 4226 hyphen. 4227 4228 Level: advanced 4229 4230 .keywords: TS, append, options, prefix, database 4231 4232 .seealso: TSGetOptionsPrefix() 4233 4234 @*/ 4235 PetscErrorCode TSAppendOptionsPrefix(TS ts,const char prefix[]) 4236 { 4237 PetscErrorCode ierr; 4238 SNES snes; 4239 4240 PetscFunctionBegin; 4241 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4242 ierr = PetscObjectAppendOptionsPrefix((PetscObject)ts,prefix);CHKERRQ(ierr); 4243 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 4244 ierr = SNESAppendOptionsPrefix(snes,prefix);CHKERRQ(ierr); 4245 PetscFunctionReturn(0); 4246 } 4247 4248 /*@C 4249 TSGetOptionsPrefix - Sets the prefix used for searching for all 4250 TS options in the database. 4251 4252 Not Collective 4253 4254 Input Parameter: 4255 . ts - The TS context 4256 4257 Output Parameter: 4258 . prefix - A pointer to the prefix string used 4259 4260 Notes: 4261 On the fortran side, the user should pass in a string 'prifix' of 4262 sufficient length to hold the prefix. 4263 4264 Level: intermediate 4265 4266 .keywords: TS, get, options, prefix, database 4267 4268 .seealso: TSAppendOptionsPrefix() 4269 @*/ 4270 PetscErrorCode TSGetOptionsPrefix(TS ts,const char *prefix[]) 4271 { 4272 PetscErrorCode ierr; 4273 4274 PetscFunctionBegin; 4275 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4276 PetscValidPointer(prefix,2); 4277 ierr = PetscObjectGetOptionsPrefix((PetscObject)ts,prefix);CHKERRQ(ierr); 4278 PetscFunctionReturn(0); 4279 } 4280 4281 /*@C 4282 TSGetRHSJacobian - Returns the Jacobian J at the present timestep. 4283 4284 Not Collective, but parallel objects are returned if TS is parallel 4285 4286 Input Parameter: 4287 . ts - The TS context obtained from TSCreate() 4288 4289 Output Parameters: 4290 + Amat - The (approximate) Jacobian J of G, where U_t = G(U,t) (or NULL) 4291 . Pmat - The matrix from which the preconditioner is constructed, usually the same as Amat (or NULL) 4292 . func - Function to compute the Jacobian of the RHS (or NULL) 4293 - ctx - User-defined context for Jacobian evaluation routine (or NULL) 4294 4295 Notes: 4296 You can pass in NULL for any return argument you do not need. 4297 4298 Level: intermediate 4299 4300 .seealso: TSGetTimeStep(), TSGetMatrices(), TSGetTime(), TSGetStepNumber() 4301 4302 .keywords: TS, timestep, get, matrix, Jacobian 4303 @*/ 4304 PetscErrorCode TSGetRHSJacobian(TS ts,Mat *Amat,Mat *Pmat,TSRHSJacobian *func,void **ctx) 4305 { 4306 PetscErrorCode ierr; 4307 DM dm; 4308 4309 PetscFunctionBegin; 4310 if (Amat || Pmat) { 4311 SNES snes; 4312 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 4313 ierr = SNESSetUpMatrices(snes);CHKERRQ(ierr); 4314 ierr = SNESGetJacobian(snes,Amat,Pmat,NULL,NULL);CHKERRQ(ierr); 4315 } 4316 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 4317 ierr = DMTSGetRHSJacobian(dm,func,ctx);CHKERRQ(ierr); 4318 PetscFunctionReturn(0); 4319 } 4320 4321 /*@C 4322 TSGetIJacobian - Returns the implicit Jacobian at the present timestep. 4323 4324 Not Collective, but parallel objects are returned if TS is parallel 4325 4326 Input Parameter: 4327 . ts - The TS context obtained from TSCreate() 4328 4329 Output Parameters: 4330 + Amat - The (approximate) Jacobian of F(t,U,U_t) 4331 . Pmat - The matrix from which the preconditioner is constructed, often the same as Amat 4332 . f - The function to compute the matrices 4333 - ctx - User-defined context for Jacobian evaluation routine 4334 4335 Notes: 4336 You can pass in NULL for any return argument you do not need. 4337 4338 Level: advanced 4339 4340 .seealso: TSGetTimeStep(), TSGetRHSJacobian(), TSGetMatrices(), TSGetTime(), TSGetStepNumber() 4341 4342 .keywords: TS, timestep, get, matrix, Jacobian 4343 @*/ 4344 PetscErrorCode TSGetIJacobian(TS ts,Mat *Amat,Mat *Pmat,TSIJacobian *f,void **ctx) 4345 { 4346 PetscErrorCode ierr; 4347 DM dm; 4348 4349 PetscFunctionBegin; 4350 if (Amat || Pmat) { 4351 SNES snes; 4352 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 4353 ierr = SNESSetUpMatrices(snes);CHKERRQ(ierr); 4354 ierr = SNESGetJacobian(snes,Amat,Pmat,NULL,NULL);CHKERRQ(ierr); 4355 } 4356 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 4357 ierr = DMTSGetIJacobian(dm,f,ctx);CHKERRQ(ierr); 4358 PetscFunctionReturn(0); 4359 } 4360 4361 /*@C 4362 TSMonitorDrawSolution - Monitors progress of the TS solvers by calling 4363 VecView() for the solution at each timestep 4364 4365 Collective on TS 4366 4367 Input Parameters: 4368 + ts - the TS context 4369 . step - current time-step 4370 . ptime - current time 4371 - dummy - either a viewer or NULL 4372 4373 Options Database: 4374 . -ts_monitor_draw_solution_initial - show initial solution as well as current solution 4375 4376 Notes: 4377 the initial solution and current solution are not display with a common axis scaling so generally the option -ts_monitor_draw_solution_initial 4378 will look bad 4379 4380 Level: intermediate 4381 4382 .keywords: TS, vector, monitor, view 4383 4384 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 4385 @*/ 4386 PetscErrorCode TSMonitorDrawSolution(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dummy) 4387 { 4388 PetscErrorCode ierr; 4389 TSMonitorDrawCtx ictx = (TSMonitorDrawCtx)dummy; 4390 PetscDraw draw; 4391 4392 PetscFunctionBegin; 4393 if (!step && ictx->showinitial) { 4394 if (!ictx->initialsolution) { 4395 ierr = VecDuplicate(u,&ictx->initialsolution);CHKERRQ(ierr); 4396 } 4397 ierr = VecCopy(u,ictx->initialsolution);CHKERRQ(ierr); 4398 } 4399 if (!(((ictx->howoften > 0) && (!(step % ictx->howoften))) || ((ictx->howoften == -1) && ts->reason))) PetscFunctionReturn(0); 4400 4401 if (ictx->showinitial) { 4402 PetscReal pause; 4403 ierr = PetscViewerDrawGetPause(ictx->viewer,&pause);CHKERRQ(ierr); 4404 ierr = PetscViewerDrawSetPause(ictx->viewer,0.0);CHKERRQ(ierr); 4405 ierr = VecView(ictx->initialsolution,ictx->viewer);CHKERRQ(ierr); 4406 ierr = PetscViewerDrawSetPause(ictx->viewer,pause);CHKERRQ(ierr); 4407 ierr = PetscViewerDrawSetHold(ictx->viewer,PETSC_TRUE);CHKERRQ(ierr); 4408 } 4409 ierr = VecView(u,ictx->viewer);CHKERRQ(ierr); 4410 if (ictx->showtimestepandtime) { 4411 PetscReal xl,yl,xr,yr,h; 4412 char time[32]; 4413 4414 ierr = PetscViewerDrawGetDraw(ictx->viewer,0,&draw);CHKERRQ(ierr); 4415 ierr = PetscSNPrintf(time,32,"Timestep %d Time %g",(int)step,(double)ptime);CHKERRQ(ierr); 4416 ierr = PetscDrawGetCoordinates(draw,&xl,&yl,&xr,&yr);CHKERRQ(ierr); 4417 h = yl + .95*(yr - yl); 4418 ierr = PetscDrawStringCentered(draw,.5*(xl+xr),h,PETSC_DRAW_BLACK,time);CHKERRQ(ierr); 4419 ierr = PetscDrawFlush(draw);CHKERRQ(ierr); 4420 } 4421 4422 if (ictx->showinitial) { 4423 ierr = PetscViewerDrawSetHold(ictx->viewer,PETSC_FALSE);CHKERRQ(ierr); 4424 } 4425 PetscFunctionReturn(0); 4426 } 4427 4428 /*@C 4429 TSMonitorDrawSolutionPhase - Monitors progress of the TS solvers by plotting the solution as a phase diagram 4430 4431 Collective on TS 4432 4433 Input Parameters: 4434 + ts - the TS context 4435 . step - current time-step 4436 . ptime - current time 4437 - dummy - either a viewer or NULL 4438 4439 Level: intermediate 4440 4441 .keywords: TS, vector, monitor, view 4442 4443 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 4444 @*/ 4445 PetscErrorCode TSMonitorDrawSolutionPhase(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dummy) 4446 { 4447 PetscErrorCode ierr; 4448 TSMonitorDrawCtx ictx = (TSMonitorDrawCtx)dummy; 4449 PetscDraw draw; 4450 PetscDrawAxis axis; 4451 PetscInt n; 4452 PetscMPIInt size; 4453 PetscReal U0,U1,xl,yl,xr,yr,h; 4454 char time[32]; 4455 const PetscScalar *U; 4456 4457 PetscFunctionBegin; 4458 ierr = MPI_Comm_size(PetscObjectComm((PetscObject)ts),&size);CHKERRQ(ierr); 4459 if (size != 1) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"Only allowed for sequential runs"); 4460 ierr = VecGetSize(u,&n);CHKERRQ(ierr); 4461 if (n != 2) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"Only for ODEs with two unknowns"); 4462 4463 ierr = PetscViewerDrawGetDraw(ictx->viewer,0,&draw);CHKERRQ(ierr); 4464 ierr = PetscViewerDrawGetDrawAxis(ictx->viewer,0,&axis);CHKERRQ(ierr); 4465 ierr = PetscDrawAxisGetLimits(axis,&xl,&xr,&yl,&yr);CHKERRQ(ierr); 4466 if (!step) { 4467 ierr = PetscDrawClear(draw);CHKERRQ(ierr); 4468 ierr = PetscDrawAxisDraw(axis);CHKERRQ(ierr); 4469 } 4470 4471 ierr = VecGetArrayRead(u,&U);CHKERRQ(ierr); 4472 U0 = PetscRealPart(U[0]); 4473 U1 = PetscRealPart(U[1]); 4474 ierr = VecRestoreArrayRead(u,&U);CHKERRQ(ierr); 4475 if ((U0 < xl) || (U1 < yl) || (U0 > xr) || (U1 > yr)) PetscFunctionReturn(0); 4476 4477 ierr = PetscDrawCollectiveBegin(draw);CHKERRQ(ierr); 4478 ierr = PetscDrawPoint(draw,U0,U1,PETSC_DRAW_BLACK);CHKERRQ(ierr); 4479 if (ictx->showtimestepandtime) { 4480 ierr = PetscDrawGetCoordinates(draw,&xl,&yl,&xr,&yr);CHKERRQ(ierr); 4481 ierr = PetscSNPrintf(time,32,"Timestep %d Time %g",(int)step,(double)ptime);CHKERRQ(ierr); 4482 h = yl + .95*(yr - yl); 4483 ierr = PetscDrawStringCentered(draw,.5*(xl+xr),h,PETSC_DRAW_BLACK,time);CHKERRQ(ierr); 4484 } 4485 ierr = PetscDrawCollectiveEnd(draw);CHKERRQ(ierr); 4486 ierr = PetscDrawFlush(draw);CHKERRQ(ierr); 4487 ierr = PetscDrawPause(draw);CHKERRQ(ierr); 4488 ierr = PetscDrawSave(draw);CHKERRQ(ierr); 4489 PetscFunctionReturn(0); 4490 } 4491 4492 /*@C 4493 TSMonitorDrawCtxDestroy - Destroys the monitor context for TSMonitorDrawSolution() 4494 4495 Collective on TS 4496 4497 Input Parameters: 4498 . ctx - the monitor context 4499 4500 Level: intermediate 4501 4502 .keywords: TS, vector, monitor, view 4503 4504 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorDrawSolution(), TSMonitorDrawError() 4505 @*/ 4506 PetscErrorCode TSMonitorDrawCtxDestroy(TSMonitorDrawCtx *ictx) 4507 { 4508 PetscErrorCode ierr; 4509 4510 PetscFunctionBegin; 4511 ierr = PetscViewerDestroy(&(*ictx)->viewer);CHKERRQ(ierr); 4512 ierr = VecDestroy(&(*ictx)->initialsolution);CHKERRQ(ierr); 4513 ierr = PetscFree(*ictx);CHKERRQ(ierr); 4514 PetscFunctionReturn(0); 4515 } 4516 4517 /*@C 4518 TSMonitorDrawCtxCreate - Creates the monitor context for TSMonitorDrawCtx 4519 4520 Collective on TS 4521 4522 Input Parameter: 4523 . ts - time-step context 4524 4525 Output Patameter: 4526 . ctx - the monitor context 4527 4528 Options Database: 4529 . -ts_monitor_draw_solution_initial - show initial solution as well as current solution 4530 4531 Level: intermediate 4532 4533 .keywords: TS, vector, monitor, view 4534 4535 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorDrawCtx() 4536 @*/ 4537 PetscErrorCode TSMonitorDrawCtxCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscInt howoften,TSMonitorDrawCtx *ctx) 4538 { 4539 PetscErrorCode ierr; 4540 4541 PetscFunctionBegin; 4542 ierr = PetscNew(ctx);CHKERRQ(ierr); 4543 ierr = PetscViewerDrawOpen(comm,host,label,x,y,m,n,&(*ctx)->viewer);CHKERRQ(ierr); 4544 ierr = PetscViewerSetFromOptions((*ctx)->viewer);CHKERRQ(ierr); 4545 4546 (*ctx)->howoften = howoften; 4547 (*ctx)->showinitial = PETSC_FALSE; 4548 ierr = PetscOptionsGetBool(NULL,NULL,"-ts_monitor_draw_solution_initial",&(*ctx)->showinitial,NULL);CHKERRQ(ierr); 4549 4550 (*ctx)->showtimestepandtime = PETSC_FALSE; 4551 ierr = PetscOptionsGetBool(NULL,NULL,"-ts_monitor_draw_solution_show_time",&(*ctx)->showtimestepandtime,NULL);CHKERRQ(ierr); 4552 PetscFunctionReturn(0); 4553 } 4554 4555 /*@C 4556 TSMonitorDrawSolutionFunction - Monitors progress of the TS solvers by calling 4557 VecView() for the solution provided by TSSetSolutionFunction() at each timestep 4558 4559 Collective on TS 4560 4561 Input Parameters: 4562 + ts - the TS context 4563 . step - current time-step 4564 . ptime - current time 4565 - dummy - either a viewer or NULL 4566 4567 Options Database: 4568 . -ts_monitor_draw_solution_function - Monitor error graphically, requires user to have provided TSSetSolutionFunction() 4569 4570 Level: intermediate 4571 4572 .keywords: TS, vector, monitor, view 4573 4574 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSSetSolutionFunction() 4575 @*/ 4576 PetscErrorCode TSMonitorDrawSolutionFunction(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dummy) 4577 { 4578 PetscErrorCode ierr; 4579 TSMonitorDrawCtx ctx = (TSMonitorDrawCtx)dummy; 4580 PetscViewer viewer = ctx->viewer; 4581 Vec work; 4582 4583 PetscFunctionBegin; 4584 if (!(((ctx->howoften > 0) && (!(step % ctx->howoften))) || ((ctx->howoften == -1) && ts->reason))) PetscFunctionReturn(0); 4585 ierr = VecDuplicate(u,&work);CHKERRQ(ierr); 4586 ierr = TSComputeSolutionFunction(ts,ptime,work);CHKERRQ(ierr); 4587 ierr = VecView(work,viewer);CHKERRQ(ierr); 4588 ierr = VecDestroy(&work);CHKERRQ(ierr); 4589 PetscFunctionReturn(0); 4590 } 4591 4592 /*@C 4593 TSMonitorDrawError - Monitors progress of the TS solvers by calling 4594 VecView() for the error at each timestep 4595 4596 Collective on TS 4597 4598 Input Parameters: 4599 + ts - the TS context 4600 . step - current time-step 4601 . ptime - current time 4602 - dummy - either a viewer or NULL 4603 4604 Options Database: 4605 . -ts_monitor_draw_error - Monitor error graphically, requires user to have provided TSSetSolutionFunction() 4606 4607 Level: intermediate 4608 4609 .keywords: TS, vector, monitor, view 4610 4611 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSSetSolutionFunction() 4612 @*/ 4613 PetscErrorCode TSMonitorDrawError(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dummy) 4614 { 4615 PetscErrorCode ierr; 4616 TSMonitorDrawCtx ctx = (TSMonitorDrawCtx)dummy; 4617 PetscViewer viewer = ctx->viewer; 4618 Vec work; 4619 4620 PetscFunctionBegin; 4621 if (!(((ctx->howoften > 0) && (!(step % ctx->howoften))) || ((ctx->howoften == -1) && ts->reason))) PetscFunctionReturn(0); 4622 ierr = VecDuplicate(u,&work);CHKERRQ(ierr); 4623 ierr = TSComputeSolutionFunction(ts,ptime,work);CHKERRQ(ierr); 4624 ierr = VecAXPY(work,-1.0,u);CHKERRQ(ierr); 4625 ierr = VecView(work,viewer);CHKERRQ(ierr); 4626 ierr = VecDestroy(&work);CHKERRQ(ierr); 4627 PetscFunctionReturn(0); 4628 } 4629 4630 #include <petsc/private/dmimpl.h> 4631 /*@ 4632 TSSetDM - Sets the DM that may be used by some nonlinear solvers or preconditioners under the TS 4633 4634 Logically Collective on TS and DM 4635 4636 Input Parameters: 4637 + ts - the ODE integrator object 4638 - dm - the dm, cannot be NULL 4639 4640 Notes: 4641 A DM can only be used for solving one problem at a time because information about the problem is stored on the DM, 4642 even when not using interfaces like DMTSSetIFunction(). Use DMClone() to get a distinct DM when solving 4643 different problems using the same function space. 4644 4645 Level: intermediate 4646 4647 .seealso: TSGetDM(), SNESSetDM(), SNESGetDM() 4648 @*/ 4649 PetscErrorCode TSSetDM(TS ts,DM dm) 4650 { 4651 PetscErrorCode ierr; 4652 SNES snes; 4653 DMTS tsdm; 4654 4655 PetscFunctionBegin; 4656 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4657 PetscValidHeaderSpecific(dm,DM_CLASSID,2); 4658 ierr = PetscObjectReference((PetscObject)dm);CHKERRQ(ierr); 4659 if (ts->dm) { /* Move the DMTS context over to the new DM unless the new DM already has one */ 4660 if (ts->dm->dmts && !dm->dmts) { 4661 ierr = DMCopyDMTS(ts->dm,dm);CHKERRQ(ierr); 4662 ierr = DMGetDMTS(ts->dm,&tsdm);CHKERRQ(ierr); 4663 if (tsdm->originaldm == ts->dm) { /* Grant write privileges to the replacement DM */ 4664 tsdm->originaldm = dm; 4665 } 4666 } 4667 ierr = DMDestroy(&ts->dm);CHKERRQ(ierr); 4668 } 4669 ts->dm = dm; 4670 4671 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 4672 ierr = SNESSetDM(snes,dm);CHKERRQ(ierr); 4673 PetscFunctionReturn(0); 4674 } 4675 4676 /*@ 4677 TSGetDM - Gets the DM that may be used by some preconditioners 4678 4679 Not Collective 4680 4681 Input Parameter: 4682 . ts - the preconditioner context 4683 4684 Output Parameter: 4685 . dm - the dm 4686 4687 Level: intermediate 4688 4689 .seealso: TSSetDM(), SNESSetDM(), SNESGetDM() 4690 @*/ 4691 PetscErrorCode TSGetDM(TS ts,DM *dm) 4692 { 4693 PetscErrorCode ierr; 4694 4695 PetscFunctionBegin; 4696 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4697 if (!ts->dm) { 4698 ierr = DMShellCreate(PetscObjectComm((PetscObject)ts),&ts->dm);CHKERRQ(ierr); 4699 if (ts->snes) {ierr = SNESSetDM(ts->snes,ts->dm);CHKERRQ(ierr);} 4700 } 4701 *dm = ts->dm; 4702 PetscFunctionReturn(0); 4703 } 4704 4705 /*@ 4706 SNESTSFormFunction - Function to evaluate nonlinear residual 4707 4708 Logically Collective on SNES 4709 4710 Input Parameter: 4711 + snes - nonlinear solver 4712 . U - the current state at which to evaluate the residual 4713 - ctx - user context, must be a TS 4714 4715 Output Parameter: 4716 . F - the nonlinear residual 4717 4718 Notes: 4719 This function is not normally called by users and is automatically registered with the SNES used by TS. 4720 It is most frequently passed to MatFDColoringSetFunction(). 4721 4722 Level: advanced 4723 4724 .seealso: SNESSetFunction(), MatFDColoringSetFunction() 4725 @*/ 4726 PetscErrorCode SNESTSFormFunction(SNES snes,Vec U,Vec F,void *ctx) 4727 { 4728 TS ts = (TS)ctx; 4729 PetscErrorCode ierr; 4730 4731 PetscFunctionBegin; 4732 PetscValidHeaderSpecific(snes,SNES_CLASSID,1); 4733 PetscValidHeaderSpecific(U,VEC_CLASSID,2); 4734 PetscValidHeaderSpecific(F,VEC_CLASSID,3); 4735 PetscValidHeaderSpecific(ts,TS_CLASSID,4); 4736 ierr = (ts->ops->snesfunction)(snes,U,F,ts);CHKERRQ(ierr); 4737 PetscFunctionReturn(0); 4738 } 4739 4740 /*@ 4741 SNESTSFormJacobian - Function to evaluate the Jacobian 4742 4743 Collective on SNES 4744 4745 Input Parameter: 4746 + snes - nonlinear solver 4747 . U - the current state at which to evaluate the residual 4748 - ctx - user context, must be a TS 4749 4750 Output Parameter: 4751 + A - the Jacobian 4752 . B - the preconditioning matrix (may be the same as A) 4753 - flag - indicates any structure change in the matrix 4754 4755 Notes: 4756 This function is not normally called by users and is automatically registered with the SNES used by TS. 4757 4758 Level: developer 4759 4760 .seealso: SNESSetJacobian() 4761 @*/ 4762 PetscErrorCode SNESTSFormJacobian(SNES snes,Vec U,Mat A,Mat B,void *ctx) 4763 { 4764 TS ts = (TS)ctx; 4765 PetscErrorCode ierr; 4766 4767 PetscFunctionBegin; 4768 PetscValidHeaderSpecific(snes,SNES_CLASSID,1); 4769 PetscValidHeaderSpecific(U,VEC_CLASSID,2); 4770 PetscValidPointer(A,3); 4771 PetscValidHeaderSpecific(A,MAT_CLASSID,3); 4772 PetscValidPointer(B,4); 4773 PetscValidHeaderSpecific(B,MAT_CLASSID,4); 4774 PetscValidHeaderSpecific(ts,TS_CLASSID,6); 4775 ierr = (ts->ops->snesjacobian)(snes,U,A,B,ts);CHKERRQ(ierr); 4776 PetscFunctionReturn(0); 4777 } 4778 4779 /*@C 4780 TSComputeRHSFunctionLinear - Evaluate the right hand side via the user-provided Jacobian, for linear problems Udot = A U only 4781 4782 Collective on TS 4783 4784 Input Arguments: 4785 + ts - time stepping context 4786 . t - time at which to evaluate 4787 . U - state at which to evaluate 4788 - ctx - context 4789 4790 Output Arguments: 4791 . F - right hand side 4792 4793 Level: intermediate 4794 4795 Notes: 4796 This function is intended to be passed to TSSetRHSFunction() to evaluate the right hand side for linear problems. 4797 The matrix (and optionally the evaluation context) should be passed to TSSetRHSJacobian(). 4798 4799 .seealso: TSSetRHSFunction(), TSSetRHSJacobian(), TSComputeRHSJacobianConstant() 4800 @*/ 4801 PetscErrorCode TSComputeRHSFunctionLinear(TS ts,PetscReal t,Vec U,Vec F,void *ctx) 4802 { 4803 PetscErrorCode ierr; 4804 Mat Arhs,Brhs; 4805 4806 PetscFunctionBegin; 4807 ierr = TSGetRHSMats_Private(ts,&Arhs,&Brhs);CHKERRQ(ierr); 4808 ierr = TSComputeRHSJacobian(ts,t,U,Arhs,Brhs);CHKERRQ(ierr); 4809 ierr = MatMult(Arhs,U,F);CHKERRQ(ierr); 4810 PetscFunctionReturn(0); 4811 } 4812 4813 /*@C 4814 TSComputeRHSJacobianConstant - Reuses a Jacobian that is time-independent. 4815 4816 Collective on TS 4817 4818 Input Arguments: 4819 + ts - time stepping context 4820 . t - time at which to evaluate 4821 . U - state at which to evaluate 4822 - ctx - context 4823 4824 Output Arguments: 4825 + A - pointer to operator 4826 . B - pointer to preconditioning matrix 4827 - flg - matrix structure flag 4828 4829 Level: intermediate 4830 4831 Notes: 4832 This function is intended to be passed to TSSetRHSJacobian() to evaluate the Jacobian for linear time-independent problems. 4833 4834 .seealso: TSSetRHSFunction(), TSSetRHSJacobian(), TSComputeRHSFunctionLinear() 4835 @*/ 4836 PetscErrorCode TSComputeRHSJacobianConstant(TS ts,PetscReal t,Vec U,Mat A,Mat B,void *ctx) 4837 { 4838 PetscFunctionBegin; 4839 PetscFunctionReturn(0); 4840 } 4841 4842 /*@C 4843 TSComputeIFunctionLinear - Evaluate the left hand side via the user-provided Jacobian, for linear problems only 4844 4845 Collective on TS 4846 4847 Input Arguments: 4848 + ts - time stepping context 4849 . t - time at which to evaluate 4850 . U - state at which to evaluate 4851 . Udot - time derivative of state vector 4852 - ctx - context 4853 4854 Output Arguments: 4855 . F - left hand side 4856 4857 Level: intermediate 4858 4859 Notes: 4860 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 4861 user is required to write their own TSComputeIFunction. 4862 This function is intended to be passed to TSSetIFunction() to evaluate the left hand side for linear problems. 4863 The matrix (and optionally the evaluation context) should be passed to TSSetIJacobian(). 4864 4865 Note that using this function is NOT equivalent to using TSComputeRHSFunctionLinear() since that solves Udot = A U 4866 4867 .seealso: TSSetIFunction(), TSSetIJacobian(), TSComputeIJacobianConstant(), TSComputeRHSFunctionLinear() 4868 @*/ 4869 PetscErrorCode TSComputeIFunctionLinear(TS ts,PetscReal t,Vec U,Vec Udot,Vec F,void *ctx) 4870 { 4871 PetscErrorCode ierr; 4872 Mat A,B; 4873 4874 PetscFunctionBegin; 4875 ierr = TSGetIJacobian(ts,&A,&B,NULL,NULL);CHKERRQ(ierr); 4876 ierr = TSComputeIJacobian(ts,t,U,Udot,1.0,A,B,PETSC_TRUE);CHKERRQ(ierr); 4877 ierr = MatMult(A,Udot,F);CHKERRQ(ierr); 4878 PetscFunctionReturn(0); 4879 } 4880 4881 /*@C 4882 TSComputeIJacobianConstant - Reuses a time-independent for a semi-implicit DAE or ODE 4883 4884 Collective on TS 4885 4886 Input Arguments: 4887 + ts - time stepping context 4888 . t - time at which to evaluate 4889 . U - state at which to evaluate 4890 . Udot - time derivative of state vector 4891 . shift - shift to apply 4892 - ctx - context 4893 4894 Output Arguments: 4895 + A - pointer to operator 4896 . B - pointer to preconditioning matrix 4897 - flg - matrix structure flag 4898 4899 Level: advanced 4900 4901 Notes: 4902 This function is intended to be passed to TSSetIJacobian() to evaluate the Jacobian for linear time-independent problems. 4903 4904 It is only appropriate for problems of the form 4905 4906 $ M Udot = F(U,t) 4907 4908 where M is constant and F is non-stiff. The user must pass M to TSSetIJacobian(). The current implementation only 4909 works with IMEX time integration methods such as TSROSW and TSARKIMEX, since there is no support for de-constructing 4910 an implicit operator of the form 4911 4912 $ shift*M + J 4913 4914 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 4915 a copy of M or reassemble it when requested. 4916 4917 .seealso: TSSetIFunction(), TSSetIJacobian(), TSComputeIFunctionLinear() 4918 @*/ 4919 PetscErrorCode TSComputeIJacobianConstant(TS ts,PetscReal t,Vec U,Vec Udot,PetscReal shift,Mat A,Mat B,void *ctx) 4920 { 4921 PetscErrorCode ierr; 4922 4923 PetscFunctionBegin; 4924 ierr = MatScale(A, shift / ts->ijacobian.shift);CHKERRQ(ierr); 4925 ts->ijacobian.shift = shift; 4926 PetscFunctionReturn(0); 4927 } 4928 4929 /*@ 4930 TSGetEquationType - Gets the type of the equation that TS is solving. 4931 4932 Not Collective 4933 4934 Input Parameter: 4935 . ts - the TS context 4936 4937 Output Parameter: 4938 . equation_type - see TSEquationType 4939 4940 Level: beginner 4941 4942 .keywords: TS, equation type 4943 4944 .seealso: TSSetEquationType(), TSEquationType 4945 @*/ 4946 PetscErrorCode TSGetEquationType(TS ts,TSEquationType *equation_type) 4947 { 4948 PetscFunctionBegin; 4949 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4950 PetscValidPointer(equation_type,2); 4951 *equation_type = ts->equation_type; 4952 PetscFunctionReturn(0); 4953 } 4954 4955 /*@ 4956 TSSetEquationType - Sets the type of the equation that TS is solving. 4957 4958 Not Collective 4959 4960 Input Parameter: 4961 + ts - the TS context 4962 - equation_type - see TSEquationType 4963 4964 Level: advanced 4965 4966 .keywords: TS, equation type 4967 4968 .seealso: TSGetEquationType(), TSEquationType 4969 @*/ 4970 PetscErrorCode TSSetEquationType(TS ts,TSEquationType equation_type) 4971 { 4972 PetscFunctionBegin; 4973 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4974 ts->equation_type = equation_type; 4975 PetscFunctionReturn(0); 4976 } 4977 4978 /*@ 4979 TSGetConvergedReason - Gets the reason the TS iteration was stopped. 4980 4981 Not Collective 4982 4983 Input Parameter: 4984 . ts - the TS context 4985 4986 Output Parameter: 4987 . reason - negative value indicates diverged, positive value converged, see TSConvergedReason or the 4988 manual pages for the individual convergence tests for complete lists 4989 4990 Level: beginner 4991 4992 Notes: 4993 Can only be called after the call to TSSolve() is complete. 4994 4995 .keywords: TS, nonlinear, set, convergence, test 4996 4997 .seealso: TSSetConvergenceTest(), TSConvergedReason 4998 @*/ 4999 PetscErrorCode TSGetConvergedReason(TS ts,TSConvergedReason *reason) 5000 { 5001 PetscFunctionBegin; 5002 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5003 PetscValidPointer(reason,2); 5004 *reason = ts->reason; 5005 PetscFunctionReturn(0); 5006 } 5007 5008 /*@ 5009 TSSetConvergedReason - Sets the reason for handling the convergence of TSSolve. 5010 5011 Not Collective 5012 5013 Input Parameter: 5014 + ts - the TS context 5015 . reason - negative value indicates diverged, positive value converged, see TSConvergedReason or the 5016 manual pages for the individual convergence tests for complete lists 5017 5018 Level: advanced 5019 5020 Notes: 5021 Can only be called during TSSolve() is active. 5022 5023 .keywords: TS, nonlinear, set, convergence, test 5024 5025 .seealso: TSConvergedReason 5026 @*/ 5027 PetscErrorCode TSSetConvergedReason(TS ts,TSConvergedReason reason) 5028 { 5029 PetscFunctionBegin; 5030 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5031 ts->reason = reason; 5032 PetscFunctionReturn(0); 5033 } 5034 5035 /*@ 5036 TSGetSolveTime - Gets the time after a call to TSSolve() 5037 5038 Not Collective 5039 5040 Input Parameter: 5041 . ts - the TS context 5042 5043 Output Parameter: 5044 . ftime - the final time. This time corresponds to the final time set with TSSetMaxTime() 5045 5046 Level: beginner 5047 5048 Notes: 5049 Can only be called after the call to TSSolve() is complete. 5050 5051 .keywords: TS, nonlinear, set, convergence, test 5052 5053 .seealso: TSSetConvergenceTest(), TSConvergedReason 5054 @*/ 5055 PetscErrorCode TSGetSolveTime(TS ts,PetscReal *ftime) 5056 { 5057 PetscFunctionBegin; 5058 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5059 PetscValidPointer(ftime,2); 5060 *ftime = ts->solvetime; 5061 PetscFunctionReturn(0); 5062 } 5063 5064 /*@ 5065 TSGetSNESIterations - Gets the total number of nonlinear iterations 5066 used by the time integrator. 5067 5068 Not Collective 5069 5070 Input Parameter: 5071 . ts - TS context 5072 5073 Output Parameter: 5074 . nits - number of nonlinear iterations 5075 5076 Notes: 5077 This counter is reset to zero for each successive call to TSSolve(). 5078 5079 Level: intermediate 5080 5081 .keywords: TS, get, number, nonlinear, iterations 5082 5083 .seealso: TSGetKSPIterations() 5084 @*/ 5085 PetscErrorCode TSGetSNESIterations(TS ts,PetscInt *nits) 5086 { 5087 PetscFunctionBegin; 5088 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5089 PetscValidIntPointer(nits,2); 5090 *nits = ts->snes_its; 5091 PetscFunctionReturn(0); 5092 } 5093 5094 /*@ 5095 TSGetKSPIterations - Gets the total number of linear iterations 5096 used by the time integrator. 5097 5098 Not Collective 5099 5100 Input Parameter: 5101 . ts - TS context 5102 5103 Output Parameter: 5104 . lits - number of linear iterations 5105 5106 Notes: 5107 This counter is reset to zero for each successive call to TSSolve(). 5108 5109 Level: intermediate 5110 5111 .keywords: TS, get, number, linear, iterations 5112 5113 .seealso: TSGetSNESIterations(), SNESGetKSPIterations() 5114 @*/ 5115 PetscErrorCode TSGetKSPIterations(TS ts,PetscInt *lits) 5116 { 5117 PetscFunctionBegin; 5118 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5119 PetscValidIntPointer(lits,2); 5120 *lits = ts->ksp_its; 5121 PetscFunctionReturn(0); 5122 } 5123 5124 /*@ 5125 TSGetStepRejections - Gets the total number of rejected steps. 5126 5127 Not Collective 5128 5129 Input Parameter: 5130 . ts - TS context 5131 5132 Output Parameter: 5133 . rejects - number of steps rejected 5134 5135 Notes: 5136 This counter is reset to zero for each successive call to TSSolve(). 5137 5138 Level: intermediate 5139 5140 .keywords: TS, get, number 5141 5142 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxStepRejections(), TSGetSNESFailures(), TSSetMaxSNESFailures(), TSSetErrorIfStepFails() 5143 @*/ 5144 PetscErrorCode TSGetStepRejections(TS ts,PetscInt *rejects) 5145 { 5146 PetscFunctionBegin; 5147 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5148 PetscValidIntPointer(rejects,2); 5149 *rejects = ts->reject; 5150 PetscFunctionReturn(0); 5151 } 5152 5153 /*@ 5154 TSGetSNESFailures - Gets the total number of failed SNES solves 5155 5156 Not Collective 5157 5158 Input Parameter: 5159 . ts - TS context 5160 5161 Output Parameter: 5162 . fails - number of failed nonlinear solves 5163 5164 Notes: 5165 This counter is reset to zero for each successive call to TSSolve(). 5166 5167 Level: intermediate 5168 5169 .keywords: TS, get, number 5170 5171 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxStepRejections(), TSGetStepRejections(), TSSetMaxSNESFailures() 5172 @*/ 5173 PetscErrorCode TSGetSNESFailures(TS ts,PetscInt *fails) 5174 { 5175 PetscFunctionBegin; 5176 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5177 PetscValidIntPointer(fails,2); 5178 *fails = ts->num_snes_failures; 5179 PetscFunctionReturn(0); 5180 } 5181 5182 /*@ 5183 TSSetMaxStepRejections - Sets the maximum number of step rejections before a step fails 5184 5185 Not Collective 5186 5187 Input Parameter: 5188 + ts - TS context 5189 - rejects - maximum number of rejected steps, pass -1 for unlimited 5190 5191 Notes: 5192 The counter is reset to zero for each step 5193 5194 Options Database Key: 5195 . -ts_max_reject - Maximum number of step rejections before a step fails 5196 5197 Level: intermediate 5198 5199 .keywords: TS, set, maximum, number 5200 5201 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxSNESFailures(), TSGetStepRejections(), TSGetSNESFailures(), TSSetErrorIfStepFails(), TSGetConvergedReason() 5202 @*/ 5203 PetscErrorCode TSSetMaxStepRejections(TS ts,PetscInt rejects) 5204 { 5205 PetscFunctionBegin; 5206 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5207 ts->max_reject = rejects; 5208 PetscFunctionReturn(0); 5209 } 5210 5211 /*@ 5212 TSSetMaxSNESFailures - Sets the maximum number of failed SNES solves 5213 5214 Not Collective 5215 5216 Input Parameter: 5217 + ts - TS context 5218 - fails - maximum number of failed nonlinear solves, pass -1 for unlimited 5219 5220 Notes: 5221 The counter is reset to zero for each successive call to TSSolve(). 5222 5223 Options Database Key: 5224 . -ts_max_snes_failures - Maximum number of nonlinear solve failures 5225 5226 Level: intermediate 5227 5228 .keywords: TS, set, maximum, number 5229 5230 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxStepRejections(), TSGetStepRejections(), TSGetSNESFailures(), SNESGetConvergedReason(), TSGetConvergedReason() 5231 @*/ 5232 PetscErrorCode TSSetMaxSNESFailures(TS ts,PetscInt fails) 5233 { 5234 PetscFunctionBegin; 5235 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5236 ts->max_snes_failures = fails; 5237 PetscFunctionReturn(0); 5238 } 5239 5240 /*@ 5241 TSSetErrorIfStepFails - Error if no step succeeds 5242 5243 Not Collective 5244 5245 Input Parameter: 5246 + ts - TS context 5247 - err - PETSC_TRUE to error if no step succeeds, PETSC_FALSE to return without failure 5248 5249 Options Database Key: 5250 . -ts_error_if_step_fails - Error if no step succeeds 5251 5252 Level: intermediate 5253 5254 .keywords: TS, set, error 5255 5256 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxStepRejections(), TSGetStepRejections(), TSGetSNESFailures(), TSSetErrorIfStepFails(), TSGetConvergedReason() 5257 @*/ 5258 PetscErrorCode TSSetErrorIfStepFails(TS ts,PetscBool err) 5259 { 5260 PetscFunctionBegin; 5261 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5262 ts->errorifstepfailed = err; 5263 PetscFunctionReturn(0); 5264 } 5265 5266 /*@C 5267 TSMonitorSolution - Monitors progress of the TS solvers by VecView() for the solution at each timestep. Normally the viewer is a binary file or a PetscDraw object 5268 5269 Collective on TS 5270 5271 Input Parameters: 5272 + ts - the TS context 5273 . step - current time-step 5274 . ptime - current time 5275 . u - current state 5276 - vf - viewer and its format 5277 5278 Level: intermediate 5279 5280 .keywords: TS, vector, monitor, view 5281 5282 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 5283 @*/ 5284 PetscErrorCode TSMonitorSolution(TS ts,PetscInt step,PetscReal ptime,Vec u,PetscViewerAndFormat *vf) 5285 { 5286 PetscErrorCode ierr; 5287 5288 PetscFunctionBegin; 5289 ierr = PetscViewerPushFormat(vf->viewer,vf->format);CHKERRQ(ierr); 5290 ierr = VecView(u,vf->viewer);CHKERRQ(ierr); 5291 ierr = PetscViewerPopFormat(vf->viewer);CHKERRQ(ierr); 5292 PetscFunctionReturn(0); 5293 } 5294 5295 /*@C 5296 TSMonitorSolutionVTK - Monitors progress of the TS solvers by VecView() for the solution at each timestep. 5297 5298 Collective on TS 5299 5300 Input Parameters: 5301 + ts - the TS context 5302 . step - current time-step 5303 . ptime - current time 5304 . u - current state 5305 - filenametemplate - string containing a format specifier for the integer time step (e.g. %03D) 5306 5307 Level: intermediate 5308 5309 Notes: 5310 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. 5311 These are named according to the file name template. 5312 5313 This function is normally passed as an argument to TSMonitorSet() along with TSMonitorSolutionVTKDestroy(). 5314 5315 .keywords: TS, vector, monitor, view 5316 5317 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 5318 @*/ 5319 PetscErrorCode TSMonitorSolutionVTK(TS ts,PetscInt step,PetscReal ptime,Vec u,void *filenametemplate) 5320 { 5321 PetscErrorCode ierr; 5322 char filename[PETSC_MAX_PATH_LEN]; 5323 PetscViewer viewer; 5324 5325 PetscFunctionBegin; 5326 if (step < 0) PetscFunctionReturn(0); /* -1 indicates interpolated solution */ 5327 ierr = PetscSNPrintf(filename,sizeof(filename),(const char*)filenametemplate,step);CHKERRQ(ierr); 5328 ierr = PetscViewerVTKOpen(PetscObjectComm((PetscObject)ts),filename,FILE_MODE_WRITE,&viewer);CHKERRQ(ierr); 5329 ierr = VecView(u,viewer);CHKERRQ(ierr); 5330 ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr); 5331 PetscFunctionReturn(0); 5332 } 5333 5334 /*@C 5335 TSMonitorSolutionVTKDestroy - Destroy context for monitoring 5336 5337 Collective on TS 5338 5339 Input Parameters: 5340 . filenametemplate - string containing a format specifier for the integer time step (e.g. %03D) 5341 5342 Level: intermediate 5343 5344 Note: 5345 This function is normally passed to TSMonitorSet() along with TSMonitorSolutionVTK(). 5346 5347 .keywords: TS, vector, monitor, view 5348 5349 .seealso: TSMonitorSet(), TSMonitorSolutionVTK() 5350 @*/ 5351 PetscErrorCode TSMonitorSolutionVTKDestroy(void *filenametemplate) 5352 { 5353 PetscErrorCode ierr; 5354 5355 PetscFunctionBegin; 5356 ierr = PetscFree(*(char**)filenametemplate);CHKERRQ(ierr); 5357 PetscFunctionReturn(0); 5358 } 5359 5360 /*@ 5361 TSGetAdapt - Get the adaptive controller context for the current method 5362 5363 Collective on TS if controller has not been created yet 5364 5365 Input Arguments: 5366 . ts - time stepping context 5367 5368 Output Arguments: 5369 . adapt - adaptive controller 5370 5371 Level: intermediate 5372 5373 .seealso: TSAdapt, TSAdaptSetType(), TSAdaptChoose() 5374 @*/ 5375 PetscErrorCode TSGetAdapt(TS ts,TSAdapt *adapt) 5376 { 5377 PetscErrorCode ierr; 5378 5379 PetscFunctionBegin; 5380 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5381 PetscValidPointer(adapt,2); 5382 if (!ts->adapt) { 5383 ierr = TSAdaptCreate(PetscObjectComm((PetscObject)ts),&ts->adapt);CHKERRQ(ierr); 5384 ierr = PetscLogObjectParent((PetscObject)ts,(PetscObject)ts->adapt);CHKERRQ(ierr); 5385 ierr = PetscObjectIncrementTabLevel((PetscObject)ts->adapt,(PetscObject)ts,1);CHKERRQ(ierr); 5386 } 5387 *adapt = ts->adapt; 5388 PetscFunctionReturn(0); 5389 } 5390 5391 /*@ 5392 TSSetTolerances - Set tolerances for local truncation error when using adaptive controller 5393 5394 Logically Collective 5395 5396 Input Arguments: 5397 + ts - time integration context 5398 . atol - scalar absolute tolerances, PETSC_DECIDE to leave current value 5399 . vatol - vector of absolute tolerances or NULL, used in preference to atol if present 5400 . rtol - scalar relative tolerances, PETSC_DECIDE to leave current value 5401 - vrtol - vector of relative tolerances or NULL, used in preference to atol if present 5402 5403 Options Database keys: 5404 + -ts_rtol <rtol> - relative tolerance for local truncation error 5405 - -ts_atol <atol> Absolute tolerance for local truncation error 5406 5407 Notes: 5408 With PETSc's implicit schemes for DAE problems, the calculation of the local truncation error 5409 (LTE) includes both the differential and the algebraic variables. If one wants the LTE to be 5410 computed only for the differential or the algebraic part then this can be done using the vector of 5411 tolerances vatol. For example, by setting the tolerance vector with the desired tolerance for the 5412 differential part and infinity for the algebraic part, the LTE calculation will include only the 5413 differential variables. 5414 5415 Level: beginner 5416 5417 .seealso: TS, TSAdapt, TSVecNormWRMS(), TSGetTolerances() 5418 @*/ 5419 PetscErrorCode TSSetTolerances(TS ts,PetscReal atol,Vec vatol,PetscReal rtol,Vec vrtol) 5420 { 5421 PetscErrorCode ierr; 5422 5423 PetscFunctionBegin; 5424 if (atol != PETSC_DECIDE && atol != PETSC_DEFAULT) ts->atol = atol; 5425 if (vatol) { 5426 ierr = PetscObjectReference((PetscObject)vatol);CHKERRQ(ierr); 5427 ierr = VecDestroy(&ts->vatol);CHKERRQ(ierr); 5428 ts->vatol = vatol; 5429 } 5430 if (rtol != PETSC_DECIDE && rtol != PETSC_DEFAULT) ts->rtol = rtol; 5431 if (vrtol) { 5432 ierr = PetscObjectReference((PetscObject)vrtol);CHKERRQ(ierr); 5433 ierr = VecDestroy(&ts->vrtol);CHKERRQ(ierr); 5434 ts->vrtol = vrtol; 5435 } 5436 PetscFunctionReturn(0); 5437 } 5438 5439 /*@ 5440 TSGetTolerances - Get tolerances for local truncation error when using adaptive controller 5441 5442 Logically Collective 5443 5444 Input Arguments: 5445 . ts - time integration context 5446 5447 Output Arguments: 5448 + atol - scalar absolute tolerances, NULL to ignore 5449 . vatol - vector of absolute tolerances, NULL to ignore 5450 . rtol - scalar relative tolerances, NULL to ignore 5451 - vrtol - vector of relative tolerances, NULL to ignore 5452 5453 Level: beginner 5454 5455 .seealso: TS, TSAdapt, TSVecNormWRMS(), TSSetTolerances() 5456 @*/ 5457 PetscErrorCode TSGetTolerances(TS ts,PetscReal *atol,Vec *vatol,PetscReal *rtol,Vec *vrtol) 5458 { 5459 PetscFunctionBegin; 5460 if (atol) *atol = ts->atol; 5461 if (vatol) *vatol = ts->vatol; 5462 if (rtol) *rtol = ts->rtol; 5463 if (vrtol) *vrtol = ts->vrtol; 5464 PetscFunctionReturn(0); 5465 } 5466 5467 /*@ 5468 TSErrorWeightedNorm2 - compute a weighted 2-norm of the difference between two state vectors 5469 5470 Collective on TS 5471 5472 Input Arguments: 5473 + ts - time stepping context 5474 . U - state vector, usually ts->vec_sol 5475 - Y - state vector to be compared to U 5476 5477 Output Arguments: 5478 . norm - weighted norm, a value of 1.0 means that the error matches the tolerances 5479 . norma - weighted norm based on the absolute tolerance, a value of 1.0 means that the error matches the tolerances 5480 . normr - weighted norm based on the relative tolerance, a value of 1.0 means that the error matches the tolerances 5481 5482 Level: developer 5483 5484 .seealso: TSErrorWeightedNorm(), TSErrorWeightedNormInfinity() 5485 @*/ 5486 PetscErrorCode TSErrorWeightedNorm2(TS ts,Vec U,Vec Y,PetscReal *norm,PetscReal *norma,PetscReal *normr) 5487 { 5488 PetscErrorCode ierr; 5489 PetscInt i,n,N,rstart; 5490 PetscInt n_loc,na_loc,nr_loc; 5491 PetscReal n_glb,na_glb,nr_glb; 5492 const PetscScalar *u,*y; 5493 PetscReal sum,suma,sumr,gsum,gsuma,gsumr,diff; 5494 PetscReal tol,tola,tolr; 5495 PetscReal err_loc[6],err_glb[6]; 5496 5497 PetscFunctionBegin; 5498 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5499 PetscValidHeaderSpecific(U,VEC_CLASSID,2); 5500 PetscValidHeaderSpecific(Y,VEC_CLASSID,3); 5501 PetscValidType(U,2); 5502 PetscValidType(Y,3); 5503 PetscCheckSameComm(U,2,Y,3); 5504 PetscValidPointer(norm,4); 5505 PetscValidPointer(norma,5); 5506 PetscValidPointer(normr,6); 5507 if (U == Y) SETERRQ(PetscObjectComm((PetscObject)U),PETSC_ERR_ARG_IDN,"U and Y cannot be the same vector"); 5508 5509 ierr = VecGetSize(U,&N);CHKERRQ(ierr); 5510 ierr = VecGetLocalSize(U,&n);CHKERRQ(ierr); 5511 ierr = VecGetOwnershipRange(U,&rstart,NULL);CHKERRQ(ierr); 5512 ierr = VecGetArrayRead(U,&u);CHKERRQ(ierr); 5513 ierr = VecGetArrayRead(Y,&y);CHKERRQ(ierr); 5514 sum = 0.; n_loc = 0; 5515 suma = 0.; na_loc = 0; 5516 sumr = 0.; nr_loc = 0; 5517 if (ts->vatol && ts->vrtol) { 5518 const PetscScalar *atol,*rtol; 5519 ierr = VecGetArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5520 ierr = VecGetArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5521 for (i=0; i<n; i++) { 5522 diff = PetscAbsScalar(y[i] - u[i]); 5523 tola = PetscRealPart(atol[i]); 5524 if(tola>0.){ 5525 suma += PetscSqr(diff/tola); 5526 na_loc++; 5527 } 5528 tolr = PetscRealPart(rtol[i]) * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5529 if(tolr>0.){ 5530 sumr += PetscSqr(diff/tolr); 5531 nr_loc++; 5532 } 5533 tol=tola+tolr; 5534 if(tol>0.){ 5535 sum += PetscSqr(diff/tol); 5536 n_loc++; 5537 } 5538 } 5539 ierr = VecRestoreArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5540 ierr = VecRestoreArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5541 } else if (ts->vatol) { /* vector atol, scalar rtol */ 5542 const PetscScalar *atol; 5543 ierr = VecGetArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5544 for (i=0; i<n; i++) { 5545 diff = PetscAbsScalar(y[i] - u[i]); 5546 tola = PetscRealPart(atol[i]); 5547 if(tola>0.){ 5548 suma += PetscSqr(diff/tola); 5549 na_loc++; 5550 } 5551 tolr = ts->rtol * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5552 if(tolr>0.){ 5553 sumr += PetscSqr(diff/tolr); 5554 nr_loc++; 5555 } 5556 tol=tola+tolr; 5557 if(tol>0.){ 5558 sum += PetscSqr(diff/tol); 5559 n_loc++; 5560 } 5561 } 5562 ierr = VecRestoreArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5563 } else if (ts->vrtol) { /* scalar atol, vector rtol */ 5564 const PetscScalar *rtol; 5565 ierr = VecGetArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5566 for (i=0; i<n; i++) { 5567 diff = PetscAbsScalar(y[i] - u[i]); 5568 tola = ts->atol; 5569 if(tola>0.){ 5570 suma += PetscSqr(diff/tola); 5571 na_loc++; 5572 } 5573 tolr = PetscRealPart(rtol[i]) * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5574 if(tolr>0.){ 5575 sumr += PetscSqr(diff/tolr); 5576 nr_loc++; 5577 } 5578 tol=tola+tolr; 5579 if(tol>0.){ 5580 sum += PetscSqr(diff/tol); 5581 n_loc++; 5582 } 5583 } 5584 ierr = VecRestoreArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5585 } else { /* scalar atol, scalar rtol */ 5586 for (i=0; i<n; i++) { 5587 diff = PetscAbsScalar(y[i] - u[i]); 5588 tola = ts->atol; 5589 if(tola>0.){ 5590 suma += PetscSqr(diff/tola); 5591 na_loc++; 5592 } 5593 tolr = ts->rtol * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5594 if(tolr>0.){ 5595 sumr += PetscSqr(diff/tolr); 5596 nr_loc++; 5597 } 5598 tol=tola+tolr; 5599 if(tol>0.){ 5600 sum += PetscSqr(diff/tol); 5601 n_loc++; 5602 } 5603 } 5604 } 5605 ierr = VecRestoreArrayRead(U,&u);CHKERRQ(ierr); 5606 ierr = VecRestoreArrayRead(Y,&y);CHKERRQ(ierr); 5607 5608 err_loc[0] = sum; 5609 err_loc[1] = suma; 5610 err_loc[2] = sumr; 5611 err_loc[3] = (PetscReal)n_loc; 5612 err_loc[4] = (PetscReal)na_loc; 5613 err_loc[5] = (PetscReal)nr_loc; 5614 5615 ierr = MPIU_Allreduce(err_loc,err_glb,6,MPIU_REAL,MPIU_SUM,PetscObjectComm((PetscObject)ts));CHKERRQ(ierr); 5616 5617 gsum = err_glb[0]; 5618 gsuma = err_glb[1]; 5619 gsumr = err_glb[2]; 5620 n_glb = err_glb[3]; 5621 na_glb = err_glb[4]; 5622 nr_glb = err_glb[5]; 5623 5624 *norm = 0.; 5625 if(n_glb>0. ){*norm = PetscSqrtReal(gsum / n_glb );} 5626 *norma = 0.; 5627 if(na_glb>0.){*norma = PetscSqrtReal(gsuma / na_glb);} 5628 *normr = 0.; 5629 if(nr_glb>0.){*normr = PetscSqrtReal(gsumr / nr_glb);} 5630 5631 if (PetscIsInfOrNanScalar(*norm)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in norm"); 5632 if (PetscIsInfOrNanScalar(*norma)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in norma"); 5633 if (PetscIsInfOrNanScalar(*normr)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in normr"); 5634 PetscFunctionReturn(0); 5635 } 5636 5637 /*@ 5638 TSErrorWeightedNormInfinity - compute a weighted infinity-norm of the difference between two state vectors 5639 5640 Collective on TS 5641 5642 Input Arguments: 5643 + ts - time stepping context 5644 . U - state vector, usually ts->vec_sol 5645 - Y - state vector to be compared to U 5646 5647 Output Arguments: 5648 . norm - weighted norm, a value of 1.0 means that the error matches the tolerances 5649 . norma - weighted norm based on the absolute tolerance, a value of 1.0 means that the error matches the tolerances 5650 . normr - weighted norm based on the relative tolerance, a value of 1.0 means that the error matches the tolerances 5651 5652 Level: developer 5653 5654 .seealso: TSErrorWeightedNorm(), TSErrorWeightedNorm2() 5655 @*/ 5656 PetscErrorCode TSErrorWeightedNormInfinity(TS ts,Vec U,Vec Y,PetscReal *norm,PetscReal *norma,PetscReal *normr) 5657 { 5658 PetscErrorCode ierr; 5659 PetscInt i,n,N,rstart; 5660 const PetscScalar *u,*y; 5661 PetscReal max,gmax,maxa,gmaxa,maxr,gmaxr; 5662 PetscReal tol,tola,tolr,diff; 5663 PetscReal err_loc[3],err_glb[3]; 5664 5665 PetscFunctionBegin; 5666 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5667 PetscValidHeaderSpecific(U,VEC_CLASSID,2); 5668 PetscValidHeaderSpecific(Y,VEC_CLASSID,3); 5669 PetscValidType(U,2); 5670 PetscValidType(Y,3); 5671 PetscCheckSameComm(U,2,Y,3); 5672 PetscValidPointer(norm,4); 5673 PetscValidPointer(norma,5); 5674 PetscValidPointer(normr,6); 5675 if (U == Y) SETERRQ(PetscObjectComm((PetscObject)U),PETSC_ERR_ARG_IDN,"U and Y cannot be the same vector"); 5676 5677 ierr = VecGetSize(U,&N);CHKERRQ(ierr); 5678 ierr = VecGetLocalSize(U,&n);CHKERRQ(ierr); 5679 ierr = VecGetOwnershipRange(U,&rstart,NULL);CHKERRQ(ierr); 5680 ierr = VecGetArrayRead(U,&u);CHKERRQ(ierr); 5681 ierr = VecGetArrayRead(Y,&y);CHKERRQ(ierr); 5682 5683 max=0.; 5684 maxa=0.; 5685 maxr=0.; 5686 5687 if (ts->vatol && ts->vrtol) { /* vector atol, vector rtol */ 5688 const PetscScalar *atol,*rtol; 5689 ierr = VecGetArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5690 ierr = VecGetArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5691 5692 for (i=0; i<n; i++) { 5693 diff = PetscAbsScalar(y[i] - u[i]); 5694 tola = PetscRealPart(atol[i]); 5695 tolr = PetscRealPart(rtol[i]) * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5696 tol = tola+tolr; 5697 if(tola>0.){ 5698 maxa = PetscMax(maxa,diff / tola); 5699 } 5700 if(tolr>0.){ 5701 maxr = PetscMax(maxr,diff / tolr); 5702 } 5703 if(tol>0.){ 5704 max = PetscMax(max,diff / tol); 5705 } 5706 } 5707 ierr = VecRestoreArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5708 ierr = VecRestoreArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5709 } else if (ts->vatol) { /* vector atol, scalar rtol */ 5710 const PetscScalar *atol; 5711 ierr = VecGetArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5712 for (i=0; i<n; i++) { 5713 diff = PetscAbsScalar(y[i] - u[i]); 5714 tola = PetscRealPart(atol[i]); 5715 tolr = ts->rtol * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5716 tol = tola+tolr; 5717 if(tola>0.){ 5718 maxa = PetscMax(maxa,diff / tola); 5719 } 5720 if(tolr>0.){ 5721 maxr = PetscMax(maxr,diff / tolr); 5722 } 5723 if(tol>0.){ 5724 max = PetscMax(max,diff / tol); 5725 } 5726 } 5727 ierr = VecRestoreArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5728 } else if (ts->vrtol) { /* scalar atol, vector rtol */ 5729 const PetscScalar *rtol; 5730 ierr = VecGetArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5731 5732 for (i=0; i<n; i++) { 5733 diff = PetscAbsScalar(y[i] - u[i]); 5734 tola = ts->atol; 5735 tolr = PetscRealPart(rtol[i]) * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5736 tol = tola+tolr; 5737 if(tola>0.){ 5738 maxa = PetscMax(maxa,diff / tola); 5739 } 5740 if(tolr>0.){ 5741 maxr = PetscMax(maxr,diff / tolr); 5742 } 5743 if(tol>0.){ 5744 max = PetscMax(max,diff / tol); 5745 } 5746 } 5747 ierr = VecRestoreArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5748 } else { /* scalar atol, scalar rtol */ 5749 5750 for (i=0; i<n; i++) { 5751 diff = PetscAbsScalar(y[i] - u[i]); 5752 tola = ts->atol; 5753 tolr = ts->rtol * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5754 tol = tola+tolr; 5755 if(tola>0.){ 5756 maxa = PetscMax(maxa,diff / tola); 5757 } 5758 if(tolr>0.){ 5759 maxr = PetscMax(maxr,diff / tolr); 5760 } 5761 if(tol>0.){ 5762 max = PetscMax(max,diff / tol); 5763 } 5764 } 5765 } 5766 ierr = VecRestoreArrayRead(U,&u);CHKERRQ(ierr); 5767 ierr = VecRestoreArrayRead(Y,&y);CHKERRQ(ierr); 5768 err_loc[0] = max; 5769 err_loc[1] = maxa; 5770 err_loc[2] = maxr; 5771 ierr = MPIU_Allreduce(err_loc,err_glb,3,MPIU_REAL,MPIU_MAX,PetscObjectComm((PetscObject)ts));CHKERRQ(ierr); 5772 gmax = err_glb[0]; 5773 gmaxa = err_glb[1]; 5774 gmaxr = err_glb[2]; 5775 5776 *norm = gmax; 5777 *norma = gmaxa; 5778 *normr = gmaxr; 5779 if (PetscIsInfOrNanScalar(*norm)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in norm"); 5780 if (PetscIsInfOrNanScalar(*norma)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in norma"); 5781 if (PetscIsInfOrNanScalar(*normr)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in normr"); 5782 PetscFunctionReturn(0); 5783 } 5784 5785 /*@ 5786 TSErrorWeightedNorm - compute a weighted norm of the difference between two state vectors based on supplied absolute and relative tolerances 5787 5788 Collective on TS 5789 5790 Input Arguments: 5791 + ts - time stepping context 5792 . U - state vector, usually ts->vec_sol 5793 . Y - state vector to be compared to U 5794 - wnormtype - norm type, either NORM_2 or NORM_INFINITY 5795 5796 Output Arguments: 5797 . norm - weighted norm, a value of 1.0 achieves a balance between absolute and relative tolerances 5798 . norma - weighted norm, a value of 1.0 means that the error meets the absolute tolerance set by the user 5799 . normr - weighted norm, a value of 1.0 means that the error meets the relative tolerance set by the user 5800 5801 Options Database Keys: 5802 . -ts_adapt_wnormtype <wnormtype> - 2, INFINITY 5803 5804 Level: developer 5805 5806 .seealso: TSErrorWeightedNormInfinity(), TSErrorWeightedNorm2(), TSErrorWeightedENorm 5807 @*/ 5808 PetscErrorCode TSErrorWeightedNorm(TS ts,Vec U,Vec Y,NormType wnormtype,PetscReal *norm,PetscReal *norma,PetscReal *normr) 5809 { 5810 PetscErrorCode ierr; 5811 5812 PetscFunctionBegin; 5813 if (wnormtype == NORM_2) { 5814 ierr = TSErrorWeightedNorm2(ts,U,Y,norm,norma,normr);CHKERRQ(ierr); 5815 } else if(wnormtype == NORM_INFINITY) { 5816 ierr = TSErrorWeightedNormInfinity(ts,U,Y,norm,norma,normr);CHKERRQ(ierr); 5817 } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"No support for norm type %s",NormTypes[wnormtype]); 5818 PetscFunctionReturn(0); 5819 } 5820 5821 5822 /*@ 5823 TSErrorWeightedENorm2 - compute a weighted 2 error norm based on supplied absolute and relative tolerances 5824 5825 Collective on TS 5826 5827 Input Arguments: 5828 + ts - time stepping context 5829 . E - error vector 5830 . U - state vector, usually ts->vec_sol 5831 - Y - state vector, previous time step 5832 5833 Output Arguments: 5834 . norm - weighted norm, a value of 1.0 means that the error matches the tolerances 5835 . norma - weighted norm based on the absolute tolerance, a value of 1.0 means that the error matches the tolerances 5836 . normr - weighted norm based on the relative tolerance, a value of 1.0 means that the error matches the tolerances 5837 5838 Level: developer 5839 5840 .seealso: TSErrorWeightedENorm(), TSErrorWeightedENormInfinity() 5841 @*/ 5842 PetscErrorCode TSErrorWeightedENorm2(TS ts,Vec E,Vec U,Vec Y,PetscReal *norm,PetscReal *norma,PetscReal *normr) 5843 { 5844 PetscErrorCode ierr; 5845 PetscInt i,n,N,rstart; 5846 PetscInt n_loc,na_loc,nr_loc; 5847 PetscReal n_glb,na_glb,nr_glb; 5848 const PetscScalar *e,*u,*y; 5849 PetscReal err,sum,suma,sumr,gsum,gsuma,gsumr; 5850 PetscReal tol,tola,tolr; 5851 PetscReal err_loc[6],err_glb[6]; 5852 5853 PetscFunctionBegin; 5854 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5855 PetscValidHeaderSpecific(E,VEC_CLASSID,2); 5856 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 5857 PetscValidHeaderSpecific(Y,VEC_CLASSID,4); 5858 PetscValidType(E,2); 5859 PetscValidType(U,3); 5860 PetscValidType(Y,4); 5861 PetscCheckSameComm(E,2,U,3); 5862 PetscCheckSameComm(U,2,Y,3); 5863 PetscValidPointer(norm,5); 5864 PetscValidPointer(norma,6); 5865 PetscValidPointer(normr,7); 5866 5867 ierr = VecGetSize(E,&N);CHKERRQ(ierr); 5868 ierr = VecGetLocalSize(E,&n);CHKERRQ(ierr); 5869 ierr = VecGetOwnershipRange(E,&rstart,NULL);CHKERRQ(ierr); 5870 ierr = VecGetArrayRead(E,&e);CHKERRQ(ierr); 5871 ierr = VecGetArrayRead(U,&u);CHKERRQ(ierr); 5872 ierr = VecGetArrayRead(Y,&y);CHKERRQ(ierr); 5873 sum = 0.; n_loc = 0; 5874 suma = 0.; na_loc = 0; 5875 sumr = 0.; nr_loc = 0; 5876 if (ts->vatol && ts->vrtol) { 5877 const PetscScalar *atol,*rtol; 5878 ierr = VecGetArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5879 ierr = VecGetArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5880 for (i=0; i<n; i++) { 5881 err = PetscAbsScalar(e[i]); 5882 tola = PetscRealPart(atol[i]); 5883 if(tola>0.){ 5884 suma += PetscSqr(err/tola); 5885 na_loc++; 5886 } 5887 tolr = PetscRealPart(rtol[i]) * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5888 if(tolr>0.){ 5889 sumr += PetscSqr(err/tolr); 5890 nr_loc++; 5891 } 5892 tol=tola+tolr; 5893 if(tol>0.){ 5894 sum += PetscSqr(err/tol); 5895 n_loc++; 5896 } 5897 } 5898 ierr = VecRestoreArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5899 ierr = VecRestoreArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5900 } else if (ts->vatol) { /* vector atol, scalar rtol */ 5901 const PetscScalar *atol; 5902 ierr = VecGetArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5903 for (i=0; i<n; i++) { 5904 err = PetscAbsScalar(e[i]); 5905 tola = PetscRealPart(atol[i]); 5906 if(tola>0.){ 5907 suma += PetscSqr(err/tola); 5908 na_loc++; 5909 } 5910 tolr = ts->rtol * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5911 if(tolr>0.){ 5912 sumr += PetscSqr(err/tolr); 5913 nr_loc++; 5914 } 5915 tol=tola+tolr; 5916 if(tol>0.){ 5917 sum += PetscSqr(err/tol); 5918 n_loc++; 5919 } 5920 } 5921 ierr = VecRestoreArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5922 } else if (ts->vrtol) { /* scalar atol, vector rtol */ 5923 const PetscScalar *rtol; 5924 ierr = VecGetArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5925 for (i=0; i<n; i++) { 5926 err = PetscAbsScalar(e[i]); 5927 tola = ts->atol; 5928 if(tola>0.){ 5929 suma += PetscSqr(err/tola); 5930 na_loc++; 5931 } 5932 tolr = PetscRealPart(rtol[i]) * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5933 if(tolr>0.){ 5934 sumr += PetscSqr(err/tolr); 5935 nr_loc++; 5936 } 5937 tol=tola+tolr; 5938 if(tol>0.){ 5939 sum += PetscSqr(err/tol); 5940 n_loc++; 5941 } 5942 } 5943 ierr = VecRestoreArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5944 } else { /* scalar atol, scalar rtol */ 5945 for (i=0; i<n; i++) { 5946 err = PetscAbsScalar(e[i]); 5947 tola = ts->atol; 5948 if(tola>0.){ 5949 suma += PetscSqr(err/tola); 5950 na_loc++; 5951 } 5952 tolr = ts->rtol * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5953 if(tolr>0.){ 5954 sumr += PetscSqr(err/tolr); 5955 nr_loc++; 5956 } 5957 tol=tola+tolr; 5958 if(tol>0.){ 5959 sum += PetscSqr(err/tol); 5960 n_loc++; 5961 } 5962 } 5963 } 5964 ierr = VecRestoreArrayRead(E,&e);CHKERRQ(ierr); 5965 ierr = VecRestoreArrayRead(U,&u);CHKERRQ(ierr); 5966 ierr = VecRestoreArrayRead(Y,&y);CHKERRQ(ierr); 5967 5968 err_loc[0] = sum; 5969 err_loc[1] = suma; 5970 err_loc[2] = sumr; 5971 err_loc[3] = (PetscReal)n_loc; 5972 err_loc[4] = (PetscReal)na_loc; 5973 err_loc[5] = (PetscReal)nr_loc; 5974 5975 ierr = MPIU_Allreduce(err_loc,err_glb,6,MPIU_REAL,MPIU_SUM,PetscObjectComm((PetscObject)ts));CHKERRQ(ierr); 5976 5977 gsum = err_glb[0]; 5978 gsuma = err_glb[1]; 5979 gsumr = err_glb[2]; 5980 n_glb = err_glb[3]; 5981 na_glb = err_glb[4]; 5982 nr_glb = err_glb[5]; 5983 5984 *norm = 0.; 5985 if(n_glb>0. ){*norm = PetscSqrtReal(gsum / n_glb );} 5986 *norma = 0.; 5987 if(na_glb>0.){*norma = PetscSqrtReal(gsuma / na_glb);} 5988 *normr = 0.; 5989 if(nr_glb>0.){*normr = PetscSqrtReal(gsumr / nr_glb);} 5990 5991 if (PetscIsInfOrNanScalar(*norm)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in norm"); 5992 if (PetscIsInfOrNanScalar(*norma)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in norma"); 5993 if (PetscIsInfOrNanScalar(*normr)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in normr"); 5994 PetscFunctionReturn(0); 5995 } 5996 5997 /*@ 5998 TSErrorWeightedENormInfinity - compute a weighted infinity error norm based on supplied absolute and relative tolerances 5999 Collective on TS 6000 6001 Input Arguments: 6002 + ts - time stepping context 6003 . E - error vector 6004 . U - state vector, usually ts->vec_sol 6005 - Y - state vector, previous time step 6006 6007 Output Arguments: 6008 . norm - weighted norm, a value of 1.0 means that the error matches the tolerances 6009 . norma - weighted norm based on the absolute tolerance, a value of 1.0 means that the error matches the tolerances 6010 . normr - weighted norm based on the relative tolerance, a value of 1.0 means that the error matches the tolerances 6011 6012 Level: developer 6013 6014 .seealso: TSErrorWeightedENorm(), TSErrorWeightedENorm2() 6015 @*/ 6016 PetscErrorCode TSErrorWeightedENormInfinity(TS ts,Vec E,Vec U,Vec Y,PetscReal *norm,PetscReal *norma,PetscReal *normr) 6017 { 6018 PetscErrorCode ierr; 6019 PetscInt i,n,N,rstart; 6020 const PetscScalar *e,*u,*y; 6021 PetscReal err,max,gmax,maxa,gmaxa,maxr,gmaxr; 6022 PetscReal tol,tola,tolr; 6023 PetscReal err_loc[3],err_glb[3]; 6024 6025 PetscFunctionBegin; 6026 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 6027 PetscValidHeaderSpecific(E,VEC_CLASSID,2); 6028 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 6029 PetscValidHeaderSpecific(Y,VEC_CLASSID,4); 6030 PetscValidType(E,2); 6031 PetscValidType(U,3); 6032 PetscValidType(Y,4); 6033 PetscCheckSameComm(E,2,U,3); 6034 PetscCheckSameComm(U,2,Y,3); 6035 PetscValidPointer(norm,5); 6036 PetscValidPointer(norma,6); 6037 PetscValidPointer(normr,7); 6038 6039 ierr = VecGetSize(E,&N);CHKERRQ(ierr); 6040 ierr = VecGetLocalSize(E,&n);CHKERRQ(ierr); 6041 ierr = VecGetOwnershipRange(E,&rstart,NULL);CHKERRQ(ierr); 6042 ierr = VecGetArrayRead(E,&e);CHKERRQ(ierr); 6043 ierr = VecGetArrayRead(U,&u);CHKERRQ(ierr); 6044 ierr = VecGetArrayRead(Y,&y);CHKERRQ(ierr); 6045 6046 max=0.; 6047 maxa=0.; 6048 maxr=0.; 6049 6050 if (ts->vatol && ts->vrtol) { /* vector atol, vector rtol */ 6051 const PetscScalar *atol,*rtol; 6052 ierr = VecGetArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 6053 ierr = VecGetArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 6054 6055 for (i=0; i<n; i++) { 6056 err = PetscAbsScalar(e[i]); 6057 tola = PetscRealPart(atol[i]); 6058 tolr = PetscRealPart(rtol[i]) * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 6059 tol = tola+tolr; 6060 if(tola>0.){ 6061 maxa = PetscMax(maxa,err / tola); 6062 } 6063 if(tolr>0.){ 6064 maxr = PetscMax(maxr,err / tolr); 6065 } 6066 if(tol>0.){ 6067 max = PetscMax(max,err / tol); 6068 } 6069 } 6070 ierr = VecRestoreArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 6071 ierr = VecRestoreArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 6072 } else if (ts->vatol) { /* vector atol, scalar rtol */ 6073 const PetscScalar *atol; 6074 ierr = VecGetArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 6075 for (i=0; i<n; i++) { 6076 err = PetscAbsScalar(e[i]); 6077 tola = PetscRealPart(atol[i]); 6078 tolr = ts->rtol * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 6079 tol = tola+tolr; 6080 if(tola>0.){ 6081 maxa = PetscMax(maxa,err / tola); 6082 } 6083 if(tolr>0.){ 6084 maxr = PetscMax(maxr,err / tolr); 6085 } 6086 if(tol>0.){ 6087 max = PetscMax(max,err / tol); 6088 } 6089 } 6090 ierr = VecRestoreArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 6091 } else if (ts->vrtol) { /* scalar atol, vector rtol */ 6092 const PetscScalar *rtol; 6093 ierr = VecGetArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 6094 6095 for (i=0; i<n; i++) { 6096 err = PetscAbsScalar(e[i]); 6097 tola = ts->atol; 6098 tolr = PetscRealPart(rtol[i]) * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 6099 tol = tola+tolr; 6100 if(tola>0.){ 6101 maxa = PetscMax(maxa,err / tola); 6102 } 6103 if(tolr>0.){ 6104 maxr = PetscMax(maxr,err / tolr); 6105 } 6106 if(tol>0.){ 6107 max = PetscMax(max,err / tol); 6108 } 6109 } 6110 ierr = VecRestoreArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 6111 } else { /* scalar atol, scalar rtol */ 6112 6113 for (i=0; i<n; i++) { 6114 err = PetscAbsScalar(e[i]); 6115 tola = ts->atol; 6116 tolr = ts->rtol * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 6117 tol = tola+tolr; 6118 if(tola>0.){ 6119 maxa = PetscMax(maxa,err / tola); 6120 } 6121 if(tolr>0.){ 6122 maxr = PetscMax(maxr,err / tolr); 6123 } 6124 if(tol>0.){ 6125 max = PetscMax(max,err / tol); 6126 } 6127 } 6128 } 6129 ierr = VecRestoreArrayRead(E,&e);CHKERRQ(ierr); 6130 ierr = VecRestoreArrayRead(U,&u);CHKERRQ(ierr); 6131 ierr = VecRestoreArrayRead(Y,&y);CHKERRQ(ierr); 6132 err_loc[0] = max; 6133 err_loc[1] = maxa; 6134 err_loc[2] = maxr; 6135 ierr = MPIU_Allreduce(err_loc,err_glb,3,MPIU_REAL,MPIU_MAX,PetscObjectComm((PetscObject)ts));CHKERRQ(ierr); 6136 gmax = err_glb[0]; 6137 gmaxa = err_glb[1]; 6138 gmaxr = err_glb[2]; 6139 6140 *norm = gmax; 6141 *norma = gmaxa; 6142 *normr = gmaxr; 6143 if (PetscIsInfOrNanScalar(*norm)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in norm"); 6144 if (PetscIsInfOrNanScalar(*norma)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in norma"); 6145 if (PetscIsInfOrNanScalar(*normr)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in normr"); 6146 PetscFunctionReturn(0); 6147 } 6148 6149 /*@ 6150 TSErrorWeightedENorm - compute a weighted error norm based on supplied absolute and relative tolerances 6151 6152 Collective on TS 6153 6154 Input Arguments: 6155 + ts - time stepping context 6156 . E - error vector 6157 . U - state vector, usually ts->vec_sol 6158 . Y - state vector, previous time step 6159 - wnormtype - norm type, either NORM_2 or NORM_INFINITY 6160 6161 Output Arguments: 6162 . norm - weighted norm, a value of 1.0 achieves a balance between absolute and relative tolerances 6163 . norma - weighted norm, a value of 1.0 means that the error meets the absolute tolerance set by the user 6164 . normr - weighted norm, a value of 1.0 means that the error meets the relative tolerance set by the user 6165 6166 Options Database Keys: 6167 . -ts_adapt_wnormtype <wnormtype> - 2, INFINITY 6168 6169 Level: developer 6170 6171 .seealso: TSErrorWeightedENormInfinity(), TSErrorWeightedENorm2(), TSErrorWeightedNormInfinity(), TSErrorWeightedNorm2() 6172 @*/ 6173 PetscErrorCode TSErrorWeightedENorm(TS ts,Vec E,Vec U,Vec Y,NormType wnormtype,PetscReal *norm,PetscReal *norma,PetscReal *normr) 6174 { 6175 PetscErrorCode ierr; 6176 6177 PetscFunctionBegin; 6178 if (wnormtype == NORM_2) { 6179 ierr = TSErrorWeightedENorm2(ts,E,U,Y,norm,norma,normr);CHKERRQ(ierr); 6180 } else if(wnormtype == NORM_INFINITY) { 6181 ierr = TSErrorWeightedENormInfinity(ts,E,U,Y,norm,norma,normr);CHKERRQ(ierr); 6182 } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"No support for norm type %s",NormTypes[wnormtype]); 6183 PetscFunctionReturn(0); 6184 } 6185 6186 6187 /*@ 6188 TSSetCFLTimeLocal - Set the local CFL constraint relative to forward Euler 6189 6190 Logically Collective on TS 6191 6192 Input Arguments: 6193 + ts - time stepping context 6194 - cfltime - maximum stable time step if using forward Euler (value can be different on each process) 6195 6196 Note: 6197 After calling this function, the global CFL time can be obtained by calling TSGetCFLTime() 6198 6199 Level: intermediate 6200 6201 .seealso: TSGetCFLTime(), TSADAPTCFL 6202 @*/ 6203 PetscErrorCode TSSetCFLTimeLocal(TS ts,PetscReal cfltime) 6204 { 6205 PetscFunctionBegin; 6206 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 6207 ts->cfltime_local = cfltime; 6208 ts->cfltime = -1.; 6209 PetscFunctionReturn(0); 6210 } 6211 6212 /*@ 6213 TSGetCFLTime - Get the maximum stable time step according to CFL criteria applied to forward Euler 6214 6215 Collective on TS 6216 6217 Input Arguments: 6218 . ts - time stepping context 6219 6220 Output Arguments: 6221 . cfltime - maximum stable time step for forward Euler 6222 6223 Level: advanced 6224 6225 .seealso: TSSetCFLTimeLocal() 6226 @*/ 6227 PetscErrorCode TSGetCFLTime(TS ts,PetscReal *cfltime) 6228 { 6229 PetscErrorCode ierr; 6230 6231 PetscFunctionBegin; 6232 if (ts->cfltime < 0) { 6233 ierr = MPIU_Allreduce(&ts->cfltime_local,&ts->cfltime,1,MPIU_REAL,MPIU_MIN,PetscObjectComm((PetscObject)ts));CHKERRQ(ierr); 6234 } 6235 *cfltime = ts->cfltime; 6236 PetscFunctionReturn(0); 6237 } 6238 6239 /*@ 6240 TSVISetVariableBounds - Sets the lower and upper bounds for the solution vector. xl <= x <= xu 6241 6242 Input Parameters: 6243 . ts - the TS context. 6244 . xl - lower bound. 6245 . xu - upper bound. 6246 6247 Notes: 6248 If this routine is not called then the lower and upper bounds are set to 6249 PETSC_NINFINITY and PETSC_INFINITY respectively during SNESSetUp(). 6250 6251 Level: advanced 6252 6253 @*/ 6254 PetscErrorCode TSVISetVariableBounds(TS ts, Vec xl, Vec xu) 6255 { 6256 PetscErrorCode ierr; 6257 SNES snes; 6258 6259 PetscFunctionBegin; 6260 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 6261 ierr = SNESVISetVariableBounds(snes,xl,xu);CHKERRQ(ierr); 6262 PetscFunctionReturn(0); 6263 } 6264 6265 #if defined(PETSC_HAVE_MATLAB_ENGINE) 6266 #include <mex.h> 6267 6268 typedef struct {char *funcname; mxArray *ctx;} TSMatlabContext; 6269 6270 /* 6271 TSComputeFunction_Matlab - Calls the function that has been set with 6272 TSSetFunctionMatlab(). 6273 6274 Collective on TS 6275 6276 Input Parameters: 6277 + snes - the TS context 6278 - u - input vector 6279 6280 Output Parameter: 6281 . y - function vector, as set by TSSetFunction() 6282 6283 Notes: 6284 TSComputeFunction() is typically used within nonlinear solvers 6285 implementations, so most users would not generally call this routine 6286 themselves. 6287 6288 Level: developer 6289 6290 .keywords: TS, nonlinear, compute, function 6291 6292 .seealso: TSSetFunction(), TSGetFunction() 6293 */ 6294 PetscErrorCode TSComputeFunction_Matlab(TS snes,PetscReal time,Vec u,Vec udot,Vec y, void *ctx) 6295 { 6296 PetscErrorCode ierr; 6297 TSMatlabContext *sctx = (TSMatlabContext*)ctx; 6298 int nlhs = 1,nrhs = 7; 6299 mxArray *plhs[1],*prhs[7]; 6300 long long int lx = 0,lxdot = 0,ly = 0,ls = 0; 6301 6302 PetscFunctionBegin; 6303 PetscValidHeaderSpecific(snes,TS_CLASSID,1); 6304 PetscValidHeaderSpecific(u,VEC_CLASSID,3); 6305 PetscValidHeaderSpecific(udot,VEC_CLASSID,4); 6306 PetscValidHeaderSpecific(y,VEC_CLASSID,5); 6307 PetscCheckSameComm(snes,1,u,3); 6308 PetscCheckSameComm(snes,1,y,5); 6309 6310 ierr = PetscMemcpy(&ls,&snes,sizeof(snes));CHKERRQ(ierr); 6311 ierr = PetscMemcpy(&lx,&u,sizeof(u));CHKERRQ(ierr); 6312 ierr = PetscMemcpy(&lxdot,&udot,sizeof(udot));CHKERRQ(ierr); 6313 ierr = PetscMemcpy(&ly,&y,sizeof(u));CHKERRQ(ierr); 6314 6315 prhs[0] = mxCreateDoubleScalar((double)ls); 6316 prhs[1] = mxCreateDoubleScalar(time); 6317 prhs[2] = mxCreateDoubleScalar((double)lx); 6318 prhs[3] = mxCreateDoubleScalar((double)lxdot); 6319 prhs[4] = mxCreateDoubleScalar((double)ly); 6320 prhs[5] = mxCreateString(sctx->funcname); 6321 prhs[6] = sctx->ctx; 6322 ierr = mexCallMATLAB(nlhs,plhs,nrhs,prhs,"PetscTSComputeFunctionInternal");CHKERRQ(ierr); 6323 ierr = mxGetScalar(plhs[0]);CHKERRQ(ierr); 6324 mxDestroyArray(prhs[0]); 6325 mxDestroyArray(prhs[1]); 6326 mxDestroyArray(prhs[2]); 6327 mxDestroyArray(prhs[3]); 6328 mxDestroyArray(prhs[4]); 6329 mxDestroyArray(prhs[5]); 6330 mxDestroyArray(plhs[0]); 6331 PetscFunctionReturn(0); 6332 } 6333 6334 /* 6335 TSSetFunctionMatlab - Sets the function evaluation routine and function 6336 vector for use by the TS routines in solving ODEs 6337 equations from MATLAB. Here the function is a string containing the name of a MATLAB function 6338 6339 Logically Collective on TS 6340 6341 Input Parameters: 6342 + ts - the TS context 6343 - func - function evaluation routine 6344 6345 Calling sequence of func: 6346 $ func (TS ts,PetscReal time,Vec u,Vec udot,Vec f,void *ctx); 6347 6348 Level: beginner 6349 6350 .keywords: TS, nonlinear, set, function 6351 6352 .seealso: TSGetFunction(), TSComputeFunction(), TSSetJacobian(), TSSetFunction() 6353 */ 6354 PetscErrorCode TSSetFunctionMatlab(TS ts,const char *func,mxArray *ctx) 6355 { 6356 PetscErrorCode ierr; 6357 TSMatlabContext *sctx; 6358 6359 PetscFunctionBegin; 6360 /* currently sctx is memory bleed */ 6361 ierr = PetscNew(&sctx);CHKERRQ(ierr); 6362 ierr = PetscStrallocpy(func,&sctx->funcname);CHKERRQ(ierr); 6363 /* 6364 This should work, but it doesn't 6365 sctx->ctx = ctx; 6366 mexMakeArrayPersistent(sctx->ctx); 6367 */ 6368 sctx->ctx = mxDuplicateArray(ctx); 6369 6370 ierr = TSSetIFunction(ts,NULL,TSComputeFunction_Matlab,sctx);CHKERRQ(ierr); 6371 PetscFunctionReturn(0); 6372 } 6373 6374 /* 6375 TSComputeJacobian_Matlab - Calls the function that has been set with 6376 TSSetJacobianMatlab(). 6377 6378 Collective on TS 6379 6380 Input Parameters: 6381 + ts - the TS context 6382 . u - input vector 6383 . A, B - the matrices 6384 - ctx - user context 6385 6386 Level: developer 6387 6388 .keywords: TS, nonlinear, compute, function 6389 6390 .seealso: TSSetFunction(), TSGetFunction() 6391 @*/ 6392 PetscErrorCode TSComputeJacobian_Matlab(TS ts,PetscReal time,Vec u,Vec udot,PetscReal shift,Mat A,Mat B,void *ctx) 6393 { 6394 PetscErrorCode ierr; 6395 TSMatlabContext *sctx = (TSMatlabContext*)ctx; 6396 int nlhs = 2,nrhs = 9; 6397 mxArray *plhs[2],*prhs[9]; 6398 long long int lx = 0,lxdot = 0,lA = 0,ls = 0, lB = 0; 6399 6400 PetscFunctionBegin; 6401 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 6402 PetscValidHeaderSpecific(u,VEC_CLASSID,3); 6403 6404 /* call Matlab function in ctx with arguments u and y */ 6405 6406 ierr = PetscMemcpy(&ls,&ts,sizeof(ts));CHKERRQ(ierr); 6407 ierr = PetscMemcpy(&lx,&u,sizeof(u));CHKERRQ(ierr); 6408 ierr = PetscMemcpy(&lxdot,&udot,sizeof(u));CHKERRQ(ierr); 6409 ierr = PetscMemcpy(&lA,A,sizeof(u));CHKERRQ(ierr); 6410 ierr = PetscMemcpy(&lB,B,sizeof(u));CHKERRQ(ierr); 6411 6412 prhs[0] = mxCreateDoubleScalar((double)ls); 6413 prhs[1] = mxCreateDoubleScalar((double)time); 6414 prhs[2] = mxCreateDoubleScalar((double)lx); 6415 prhs[3] = mxCreateDoubleScalar((double)lxdot); 6416 prhs[4] = mxCreateDoubleScalar((double)shift); 6417 prhs[5] = mxCreateDoubleScalar((double)lA); 6418 prhs[6] = mxCreateDoubleScalar((double)lB); 6419 prhs[7] = mxCreateString(sctx->funcname); 6420 prhs[8] = sctx->ctx; 6421 ierr = mexCallMATLAB(nlhs,plhs,nrhs,prhs,"PetscTSComputeJacobianInternal");CHKERRQ(ierr); 6422 ierr = mxGetScalar(plhs[0]);CHKERRQ(ierr); 6423 mxDestroyArray(prhs[0]); 6424 mxDestroyArray(prhs[1]); 6425 mxDestroyArray(prhs[2]); 6426 mxDestroyArray(prhs[3]); 6427 mxDestroyArray(prhs[4]); 6428 mxDestroyArray(prhs[5]); 6429 mxDestroyArray(prhs[6]); 6430 mxDestroyArray(prhs[7]); 6431 mxDestroyArray(plhs[0]); 6432 mxDestroyArray(plhs[1]); 6433 PetscFunctionReturn(0); 6434 } 6435 6436 /* 6437 TSSetJacobianMatlab - Sets the Jacobian function evaluation routine and two empty Jacobian matrices 6438 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 6439 6440 Logically Collective on TS 6441 6442 Input Parameters: 6443 + ts - the TS context 6444 . A,B - Jacobian matrices 6445 . func - function evaluation routine 6446 - ctx - user context 6447 6448 Calling sequence of func: 6449 $ flag = func (TS ts,PetscReal time,Vec u,Vec udot,Mat A,Mat B,void *ctx); 6450 6451 Level: developer 6452 6453 .keywords: TS, nonlinear, set, function 6454 6455 .seealso: TSGetFunction(), TSComputeFunction(), TSSetJacobian(), TSSetFunction() 6456 */ 6457 PetscErrorCode TSSetJacobianMatlab(TS ts,Mat A,Mat B,const char *func,mxArray *ctx) 6458 { 6459 PetscErrorCode ierr; 6460 TSMatlabContext *sctx; 6461 6462 PetscFunctionBegin; 6463 /* currently sctx is memory bleed */ 6464 ierr = PetscNew(&sctx);CHKERRQ(ierr); 6465 ierr = PetscStrallocpy(func,&sctx->funcname);CHKERRQ(ierr); 6466 /* 6467 This should work, but it doesn't 6468 sctx->ctx = ctx; 6469 mexMakeArrayPersistent(sctx->ctx); 6470 */ 6471 sctx->ctx = mxDuplicateArray(ctx); 6472 6473 ierr = TSSetIJacobian(ts,A,B,TSComputeJacobian_Matlab,sctx);CHKERRQ(ierr); 6474 PetscFunctionReturn(0); 6475 } 6476 6477 /* 6478 TSMonitor_Matlab - Calls the function that has been set with TSMonitorSetMatlab(). 6479 6480 Collective on TS 6481 6482 .seealso: TSSetFunction(), TSGetFunction() 6483 @*/ 6484 PetscErrorCode TSMonitor_Matlab(TS ts,PetscInt it, PetscReal time,Vec u, void *ctx) 6485 { 6486 PetscErrorCode ierr; 6487 TSMatlabContext *sctx = (TSMatlabContext*)ctx; 6488 int nlhs = 1,nrhs = 6; 6489 mxArray *plhs[1],*prhs[6]; 6490 long long int lx = 0,ls = 0; 6491 6492 PetscFunctionBegin; 6493 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 6494 PetscValidHeaderSpecific(u,VEC_CLASSID,4); 6495 6496 ierr = PetscMemcpy(&ls,&ts,sizeof(ts));CHKERRQ(ierr); 6497 ierr = PetscMemcpy(&lx,&u,sizeof(u));CHKERRQ(ierr); 6498 6499 prhs[0] = mxCreateDoubleScalar((double)ls); 6500 prhs[1] = mxCreateDoubleScalar((double)it); 6501 prhs[2] = mxCreateDoubleScalar((double)time); 6502 prhs[3] = mxCreateDoubleScalar((double)lx); 6503 prhs[4] = mxCreateString(sctx->funcname); 6504 prhs[5] = sctx->ctx; 6505 ierr = mexCallMATLAB(nlhs,plhs,nrhs,prhs,"PetscTSMonitorInternal");CHKERRQ(ierr); 6506 ierr = mxGetScalar(plhs[0]);CHKERRQ(ierr); 6507 mxDestroyArray(prhs[0]); 6508 mxDestroyArray(prhs[1]); 6509 mxDestroyArray(prhs[2]); 6510 mxDestroyArray(prhs[3]); 6511 mxDestroyArray(prhs[4]); 6512 mxDestroyArray(plhs[0]); 6513 PetscFunctionReturn(0); 6514 } 6515 6516 /* 6517 TSMonitorSetMatlab - Sets the monitor function from Matlab 6518 6519 Level: developer 6520 6521 .keywords: TS, nonlinear, set, function 6522 6523 .seealso: TSGetFunction(), TSComputeFunction(), TSSetJacobian(), TSSetFunction() 6524 */ 6525 PetscErrorCode TSMonitorSetMatlab(TS ts,const char *func,mxArray *ctx) 6526 { 6527 PetscErrorCode ierr; 6528 TSMatlabContext *sctx; 6529 6530 PetscFunctionBegin; 6531 /* currently sctx is memory bleed */ 6532 ierr = PetscNew(&sctx);CHKERRQ(ierr); 6533 ierr = PetscStrallocpy(func,&sctx->funcname);CHKERRQ(ierr); 6534 /* 6535 This should work, but it doesn't 6536 sctx->ctx = ctx; 6537 mexMakeArrayPersistent(sctx->ctx); 6538 */ 6539 sctx->ctx = mxDuplicateArray(ctx); 6540 6541 ierr = TSMonitorSet(ts,TSMonitor_Matlab,sctx,NULL);CHKERRQ(ierr); 6542 PetscFunctionReturn(0); 6543 } 6544 #endif 6545 6546 /*@C 6547 TSMonitorLGSolution - Monitors progress of the TS solvers by plotting each component of the solution vector 6548 in a time based line graph 6549 6550 Collective on TS 6551 6552 Input Parameters: 6553 + ts - the TS context 6554 . step - current time-step 6555 . ptime - current time 6556 . u - current solution 6557 - dctx - the TSMonitorLGCtx object that contains all the options for the monitoring, this is created with TSMonitorLGCtxCreate() 6558 6559 Options Database: 6560 . -ts_monitor_lg_solution_variables 6561 6562 Level: intermediate 6563 6564 Notes: 6565 Each process in a parallel run displays its component solutions in a separate window 6566 6567 .keywords: TS, vector, monitor, view 6568 6569 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGCtxCreate(), TSMonitorLGCtxSetVariableNames(), TSMonitorLGCtxGetVariableNames(), 6570 TSMonitorLGSetVariableNames(), TSMonitorLGGetVariableNames(), TSMonitorLGSetDisplayVariables(), TSMonitorLGCtxSetDisplayVariables(), 6571 TSMonitorLGCtxSetTransform(), TSMonitorLGSetTransform(), TSMonitorLGError(), TSMonitorLGSNESIterations(), TSMonitorLGKSPIterations(), 6572 TSMonitorEnvelopeCtxCreate(), TSMonitorEnvelopeGetBounds(), TSMonitorEnvelopeCtxDestroy(), TSMonitorEnvelop() 6573 @*/ 6574 PetscErrorCode TSMonitorLGSolution(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dctx) 6575 { 6576 PetscErrorCode ierr; 6577 TSMonitorLGCtx ctx = (TSMonitorLGCtx)dctx; 6578 const PetscScalar *yy; 6579 Vec v; 6580 6581 PetscFunctionBegin; 6582 if (step < 0) PetscFunctionReturn(0); /* -1 indicates interpolated solution */ 6583 if (!step) { 6584 PetscDrawAxis axis; 6585 PetscInt dim; 6586 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 6587 ierr = PetscDrawAxisSetLabels(axis,"Solution as function of time","Time","Solution");CHKERRQ(ierr); 6588 if (!ctx->names) { 6589 PetscBool flg; 6590 /* user provides names of variables to plot but no names has been set so assume names are integer values */ 6591 ierr = PetscOptionsHasName(((PetscObject)ts)->options,((PetscObject)ts)->prefix,"-ts_monitor_lg_solution_variables",&flg);CHKERRQ(ierr); 6592 if (flg) { 6593 PetscInt i,n; 6594 char **names; 6595 ierr = VecGetSize(u,&n);CHKERRQ(ierr); 6596 ierr = PetscMalloc1(n+1,&names);CHKERRQ(ierr); 6597 for (i=0; i<n; i++) { 6598 ierr = PetscMalloc1(5,&names[i]);CHKERRQ(ierr); 6599 ierr = PetscSNPrintf(names[i],5,"%D",i);CHKERRQ(ierr); 6600 } 6601 names[n] = NULL; 6602 ctx->names = names; 6603 } 6604 } 6605 if (ctx->names && !ctx->displaynames) { 6606 char **displaynames; 6607 PetscBool flg; 6608 ierr = VecGetLocalSize(u,&dim);CHKERRQ(ierr); 6609 ierr = PetscMalloc1(dim+1,&displaynames);CHKERRQ(ierr); 6610 ierr = PetscMemzero(displaynames,(dim+1)*sizeof(char*));CHKERRQ(ierr); 6611 ierr = PetscOptionsGetStringArray(((PetscObject)ts)->options,((PetscObject)ts)->prefix,"-ts_monitor_lg_solution_variables",displaynames,&dim,&flg);CHKERRQ(ierr); 6612 if (flg) { 6613 ierr = TSMonitorLGCtxSetDisplayVariables(ctx,(const char *const *)displaynames);CHKERRQ(ierr); 6614 } 6615 ierr = PetscStrArrayDestroy(&displaynames);CHKERRQ(ierr); 6616 } 6617 if (ctx->displaynames) { 6618 ierr = PetscDrawLGSetDimension(ctx->lg,ctx->ndisplayvariables);CHKERRQ(ierr); 6619 ierr = PetscDrawLGSetLegend(ctx->lg,(const char *const *)ctx->displaynames);CHKERRQ(ierr); 6620 } else if (ctx->names) { 6621 ierr = VecGetLocalSize(u,&dim);CHKERRQ(ierr); 6622 ierr = PetscDrawLGSetDimension(ctx->lg,dim);CHKERRQ(ierr); 6623 ierr = PetscDrawLGSetLegend(ctx->lg,(const char *const *)ctx->names);CHKERRQ(ierr); 6624 } else { 6625 ierr = VecGetLocalSize(u,&dim);CHKERRQ(ierr); 6626 ierr = PetscDrawLGSetDimension(ctx->lg,dim);CHKERRQ(ierr); 6627 } 6628 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 6629 } 6630 6631 if (!ctx->transform) v = u; 6632 else {ierr = (*ctx->transform)(ctx->transformctx,u,&v);CHKERRQ(ierr);} 6633 ierr = VecGetArrayRead(v,&yy);CHKERRQ(ierr); 6634 if (ctx->displaynames) { 6635 PetscInt i; 6636 for (i=0; i<ctx->ndisplayvariables; i++) 6637 ctx->displayvalues[i] = PetscRealPart(yy[ctx->displayvariables[i]]); 6638 ierr = PetscDrawLGAddCommonPoint(ctx->lg,ptime,ctx->displayvalues);CHKERRQ(ierr); 6639 } else { 6640 #if defined(PETSC_USE_COMPLEX) 6641 PetscInt i,n; 6642 PetscReal *yreal; 6643 ierr = VecGetLocalSize(v,&n);CHKERRQ(ierr); 6644 ierr = PetscMalloc1(n,&yreal);CHKERRQ(ierr); 6645 for (i=0; i<n; i++) yreal[i] = PetscRealPart(yy[i]); 6646 ierr = PetscDrawLGAddCommonPoint(ctx->lg,ptime,yreal);CHKERRQ(ierr); 6647 ierr = PetscFree(yreal);CHKERRQ(ierr); 6648 #else 6649 ierr = PetscDrawLGAddCommonPoint(ctx->lg,ptime,yy);CHKERRQ(ierr); 6650 #endif 6651 } 6652 ierr = VecRestoreArrayRead(v,&yy);CHKERRQ(ierr); 6653 if (ctx->transform) {ierr = VecDestroy(&v);CHKERRQ(ierr);} 6654 6655 if (((ctx->howoften > 0) && (!(step % ctx->howoften))) || ((ctx->howoften == -1) && ts->reason)) { 6656 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 6657 ierr = PetscDrawLGSave(ctx->lg);CHKERRQ(ierr); 6658 } 6659 PetscFunctionReturn(0); 6660 } 6661 6662 /*@C 6663 TSMonitorLGSetVariableNames - Sets the name of each component in the solution vector so that it may be displayed in the plot 6664 6665 Collective on TS 6666 6667 Input Parameters: 6668 + ts - the TS context 6669 - names - the names of the components, final string must be NULL 6670 6671 Level: intermediate 6672 6673 Notes: 6674 If the TS object does not have a TSMonitorLGCtx associated with it then this function is ignored 6675 6676 .keywords: TS, vector, monitor, view 6677 6678 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetDisplayVariables(), TSMonitorLGCtxSetVariableNames() 6679 @*/ 6680 PetscErrorCode TSMonitorLGSetVariableNames(TS ts,const char * const *names) 6681 { 6682 PetscErrorCode ierr; 6683 PetscInt i; 6684 6685 PetscFunctionBegin; 6686 for (i=0; i<ts->numbermonitors; i++) { 6687 if (ts->monitor[i] == TSMonitorLGSolution) { 6688 ierr = TSMonitorLGCtxSetVariableNames((TSMonitorLGCtx)ts->monitorcontext[i],names);CHKERRQ(ierr); 6689 break; 6690 } 6691 } 6692 PetscFunctionReturn(0); 6693 } 6694 6695 /*@C 6696 TSMonitorLGCtxSetVariableNames - Sets the name of each component in the solution vector so that it may be displayed in the plot 6697 6698 Collective on TS 6699 6700 Input Parameters: 6701 + ts - the TS context 6702 - names - the names of the components, final string must be NULL 6703 6704 Level: intermediate 6705 6706 .keywords: TS, vector, monitor, view 6707 6708 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetDisplayVariables(), TSMonitorLGSetVariableNames() 6709 @*/ 6710 PetscErrorCode TSMonitorLGCtxSetVariableNames(TSMonitorLGCtx ctx,const char * const *names) 6711 { 6712 PetscErrorCode ierr; 6713 6714 PetscFunctionBegin; 6715 ierr = PetscStrArrayDestroy(&ctx->names);CHKERRQ(ierr); 6716 ierr = PetscStrArrayallocpy(names,&ctx->names);CHKERRQ(ierr); 6717 PetscFunctionReturn(0); 6718 } 6719 6720 /*@C 6721 TSMonitorLGGetVariableNames - Gets the name of each component in the solution vector so that it may be displayed in the plot 6722 6723 Collective on TS 6724 6725 Input Parameter: 6726 . ts - the TS context 6727 6728 Output Parameter: 6729 . names - the names of the components, final string must be NULL 6730 6731 Level: intermediate 6732 6733 Notes: 6734 If the TS object does not have a TSMonitorLGCtx associated with it then this function is ignored 6735 6736 .keywords: TS, vector, monitor, view 6737 6738 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetDisplayVariables() 6739 @*/ 6740 PetscErrorCode TSMonitorLGGetVariableNames(TS ts,const char *const **names) 6741 { 6742 PetscInt i; 6743 6744 PetscFunctionBegin; 6745 *names = NULL; 6746 for (i=0; i<ts->numbermonitors; i++) { 6747 if (ts->monitor[i] == TSMonitorLGSolution) { 6748 TSMonitorLGCtx ctx = (TSMonitorLGCtx) ts->monitorcontext[i]; 6749 *names = (const char *const *)ctx->names; 6750 break; 6751 } 6752 } 6753 PetscFunctionReturn(0); 6754 } 6755 6756 /*@C 6757 TSMonitorLGCtxSetDisplayVariables - Sets the variables that are to be display in the monitor 6758 6759 Collective on TS 6760 6761 Input Parameters: 6762 + ctx - the TSMonitorLG context 6763 . displaynames - the names of the components, final string must be NULL 6764 6765 Level: intermediate 6766 6767 .keywords: TS, vector, monitor, view 6768 6769 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetVariableNames() 6770 @*/ 6771 PetscErrorCode TSMonitorLGCtxSetDisplayVariables(TSMonitorLGCtx ctx,const char * const *displaynames) 6772 { 6773 PetscInt j = 0,k; 6774 PetscErrorCode ierr; 6775 6776 PetscFunctionBegin; 6777 if (!ctx->names) PetscFunctionReturn(0); 6778 ierr = PetscStrArrayDestroy(&ctx->displaynames);CHKERRQ(ierr); 6779 ierr = PetscStrArrayallocpy(displaynames,&ctx->displaynames);CHKERRQ(ierr); 6780 while (displaynames[j]) j++; 6781 ctx->ndisplayvariables = j; 6782 ierr = PetscMalloc1(ctx->ndisplayvariables,&ctx->displayvariables);CHKERRQ(ierr); 6783 ierr = PetscMalloc1(ctx->ndisplayvariables,&ctx->displayvalues);CHKERRQ(ierr); 6784 j = 0; 6785 while (displaynames[j]) { 6786 k = 0; 6787 while (ctx->names[k]) { 6788 PetscBool flg; 6789 ierr = PetscStrcmp(displaynames[j],ctx->names[k],&flg);CHKERRQ(ierr); 6790 if (flg) { 6791 ctx->displayvariables[j] = k; 6792 break; 6793 } 6794 k++; 6795 } 6796 j++; 6797 } 6798 PetscFunctionReturn(0); 6799 } 6800 6801 /*@C 6802 TSMonitorLGSetDisplayVariables - Sets the variables that are to be display in the monitor 6803 6804 Collective on TS 6805 6806 Input Parameters: 6807 + ts - the TS context 6808 . displaynames - the names of the components, final string must be NULL 6809 6810 Notes: 6811 If the TS object does not have a TSMonitorLGCtx associated with it then this function is ignored 6812 6813 Level: intermediate 6814 6815 .keywords: TS, vector, monitor, view 6816 6817 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetVariableNames() 6818 @*/ 6819 PetscErrorCode TSMonitorLGSetDisplayVariables(TS ts,const char * const *displaynames) 6820 { 6821 PetscInt i; 6822 PetscErrorCode ierr; 6823 6824 PetscFunctionBegin; 6825 for (i=0; i<ts->numbermonitors; i++) { 6826 if (ts->monitor[i] == TSMonitorLGSolution) { 6827 ierr = TSMonitorLGCtxSetDisplayVariables((TSMonitorLGCtx)ts->monitorcontext[i],displaynames);CHKERRQ(ierr); 6828 break; 6829 } 6830 } 6831 PetscFunctionReturn(0); 6832 } 6833 6834 /*@C 6835 TSMonitorLGSetTransform - Solution vector will be transformed by provided function before being displayed 6836 6837 Collective on TS 6838 6839 Input Parameters: 6840 + ts - the TS context 6841 . transform - the transform function 6842 . destroy - function to destroy the optional context 6843 - ctx - optional context used by transform function 6844 6845 Notes: 6846 If the TS object does not have a TSMonitorLGCtx associated with it then this function is ignored 6847 6848 Level: intermediate 6849 6850 .keywords: TS, vector, monitor, view 6851 6852 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetVariableNames(), TSMonitorLGCtxSetTransform() 6853 @*/ 6854 PetscErrorCode TSMonitorLGSetTransform(TS ts,PetscErrorCode (*transform)(void*,Vec,Vec*),PetscErrorCode (*destroy)(void*),void *tctx) 6855 { 6856 PetscInt i; 6857 PetscErrorCode ierr; 6858 6859 PetscFunctionBegin; 6860 for (i=0; i<ts->numbermonitors; i++) { 6861 if (ts->monitor[i] == TSMonitorLGSolution) { 6862 ierr = TSMonitorLGCtxSetTransform((TSMonitorLGCtx)ts->monitorcontext[i],transform,destroy,tctx);CHKERRQ(ierr); 6863 } 6864 } 6865 PetscFunctionReturn(0); 6866 } 6867 6868 /*@C 6869 TSMonitorLGCtxSetTransform - Solution vector will be transformed by provided function before being displayed 6870 6871 Collective on TSLGCtx 6872 6873 Input Parameters: 6874 + ts - the TS context 6875 . transform - the transform function 6876 . destroy - function to destroy the optional context 6877 - ctx - optional context used by transform function 6878 6879 Level: intermediate 6880 6881 .keywords: TS, vector, monitor, view 6882 6883 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetVariableNames(), TSMonitorLGSetTransform() 6884 @*/ 6885 PetscErrorCode TSMonitorLGCtxSetTransform(TSMonitorLGCtx ctx,PetscErrorCode (*transform)(void*,Vec,Vec*),PetscErrorCode (*destroy)(void*),void *tctx) 6886 { 6887 PetscFunctionBegin; 6888 ctx->transform = transform; 6889 ctx->transformdestroy = destroy; 6890 ctx->transformctx = tctx; 6891 PetscFunctionReturn(0); 6892 } 6893 6894 /*@C 6895 TSMonitorLGError - Monitors progress of the TS solvers by plotting each component of the error 6896 in a time based line graph 6897 6898 Collective on TS 6899 6900 Input Parameters: 6901 + ts - the TS context 6902 . step - current time-step 6903 . ptime - current time 6904 . u - current solution 6905 - dctx - TSMonitorLGCtx object created with TSMonitorLGCtxCreate() 6906 6907 Level: intermediate 6908 6909 Notes: 6910 Each process in a parallel run displays its component errors in a separate window 6911 6912 The user must provide the solution using TSSetSolutionFunction() to use this monitor. 6913 6914 Options Database Keys: 6915 . -ts_monitor_lg_error - create a graphical monitor of error history 6916 6917 .keywords: TS, vector, monitor, view 6918 6919 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSSetSolutionFunction() 6920 @*/ 6921 PetscErrorCode TSMonitorLGError(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dummy) 6922 { 6923 PetscErrorCode ierr; 6924 TSMonitorLGCtx ctx = (TSMonitorLGCtx)dummy; 6925 const PetscScalar *yy; 6926 Vec y; 6927 6928 PetscFunctionBegin; 6929 if (!step) { 6930 PetscDrawAxis axis; 6931 PetscInt dim; 6932 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 6933 ierr = PetscDrawAxisSetLabels(axis,"Error in solution as function of time","Time","Error");CHKERRQ(ierr); 6934 ierr = VecGetLocalSize(u,&dim);CHKERRQ(ierr); 6935 ierr = PetscDrawLGSetDimension(ctx->lg,dim);CHKERRQ(ierr); 6936 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 6937 } 6938 ierr = VecDuplicate(u,&y);CHKERRQ(ierr); 6939 ierr = TSComputeSolutionFunction(ts,ptime,y);CHKERRQ(ierr); 6940 ierr = VecAXPY(y,-1.0,u);CHKERRQ(ierr); 6941 ierr = VecGetArrayRead(y,&yy);CHKERRQ(ierr); 6942 #if defined(PETSC_USE_COMPLEX) 6943 { 6944 PetscReal *yreal; 6945 PetscInt i,n; 6946 ierr = VecGetLocalSize(y,&n);CHKERRQ(ierr); 6947 ierr = PetscMalloc1(n,&yreal);CHKERRQ(ierr); 6948 for (i=0; i<n; i++) yreal[i] = PetscRealPart(yy[i]); 6949 ierr = PetscDrawLGAddCommonPoint(ctx->lg,ptime,yreal);CHKERRQ(ierr); 6950 ierr = PetscFree(yreal);CHKERRQ(ierr); 6951 } 6952 #else 6953 ierr = PetscDrawLGAddCommonPoint(ctx->lg,ptime,yy);CHKERRQ(ierr); 6954 #endif 6955 ierr = VecRestoreArrayRead(y,&yy);CHKERRQ(ierr); 6956 ierr = VecDestroy(&y);CHKERRQ(ierr); 6957 if (((ctx->howoften > 0) && (!(step % ctx->howoften))) || ((ctx->howoften == -1) && ts->reason)) { 6958 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 6959 ierr = PetscDrawLGSave(ctx->lg);CHKERRQ(ierr); 6960 } 6961 PetscFunctionReturn(0); 6962 } 6963 6964 /*@C 6965 TSMonitorSPSwarmSolution - Graphically displays phase plots of DMSwarm particles on a scatter plot 6966 6967 Input Parameters: 6968 + ts - the TS context 6969 . step - current time-step 6970 . ptime - current time 6971 . u - current solution 6972 - dctx - the TSMonitorSPCtx object that contains all the options for the monitoring, this is created with TSMonitorSPCtxCreate() 6973 6974 Options Database: 6975 . -ts_monitor_sp_swarm 6976 6977 Level: intermediate 6978 6979 .keywords: TS, vector, monitor, view, swarm 6980 @*/ 6981 PetscErrorCode TSMonitorSPSwarmSolution(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dctx) 6982 { 6983 PetscErrorCode ierr; 6984 TSMonitorSPCtx ctx = (TSMonitorSPCtx)dctx; 6985 const PetscScalar *yy; 6986 PetscReal *y,*x; 6987 PetscInt Np, p, dim=2; 6988 DM dm; 6989 6990 PetscFunctionBegin; 6991 6992 if (step < 0) PetscFunctionReturn(0); /* -1 indicates interpolated solution */ 6993 if (!step) { 6994 PetscDrawAxis axis; 6995 ierr = PetscDrawSPGetAxis(ctx->sp,&axis);CHKERRQ(ierr); 6996 ierr = PetscDrawAxisSetLabels(axis,"Particles","X","Y");CHKERRQ(ierr); 6997 ierr = PetscDrawAxisSetLimits(axis, -5, 5, -5, 5);CHKERRQ(ierr); 6998 ierr = PetscDrawAxisSetHoldLimits(axis, PETSC_TRUE);CHKERRQ(ierr); 6999 ierr = TSGetDM(ts, &dm);CHKERRQ(ierr); 7000 ierr = DMGetDimension(dm, &dim); 7001 if(dim!=2) SETERRQ(PETSC_COMM_SELF, ierr, "Dimensions improper for monitor arguments! Current support: two dimensions.");CHKERRQ(ierr); 7002 ierr = VecGetLocalSize(u, &Np);CHKERRQ(ierr); 7003 Np /= 2*dim; 7004 ierr = PetscDrawSPSetDimension(ctx->sp, Np);CHKERRQ(ierr); 7005 ierr = PetscDrawSPReset(ctx->sp);CHKERRQ(ierr); 7006 } 7007 7008 ierr = VecGetLocalSize(u, &Np);CHKERRQ(ierr); 7009 Np /= 2*dim; 7010 ierr = VecGetArrayRead(u,&yy);CHKERRQ(ierr); 7011 ierr = PetscMalloc2(Np, &x, Np, &y);CHKERRQ(ierr); 7012 /* get points from solution vector */ 7013 for (p=0; p<Np; ++p){ 7014 x[p] = PetscRealPart(yy[2*dim*p]); 7015 y[p] = PetscRealPart(yy[2*dim*p+1]); 7016 } 7017 ierr = VecRestoreArrayRead(u,&yy);CHKERRQ(ierr); 7018 7019 if (((ctx->howoften > 0) && (!(step % ctx->howoften))) || ((ctx->howoften == -1) && ts->reason)) { 7020 ierr = PetscDrawSPAddPoint(ctx->sp,x,y);CHKERRQ(ierr); 7021 ierr = PetscDrawSPDraw(ctx->sp,PETSC_FALSE);CHKERRQ(ierr); 7022 ierr = PetscDrawSPSave(ctx->sp);CHKERRQ(ierr); 7023 } 7024 7025 ierr = PetscFree2(x, y);CHKERRQ(ierr); 7026 7027 PetscFunctionReturn(0); 7028 } 7029 7030 7031 7032 /*@C 7033 TSMonitorError - Monitors progress of the TS solvers by printing the 2 norm of the error at each timestep 7034 7035 Collective on TS 7036 7037 Input Parameters: 7038 + ts - the TS context 7039 . step - current time-step 7040 . ptime - current time 7041 . u - current solution 7042 - dctx - unused context 7043 7044 Level: intermediate 7045 7046 The user must provide the solution using TSSetSolutionFunction() to use this monitor. 7047 7048 Options Database Keys: 7049 . -ts_monitor_error - create a graphical monitor of error history 7050 7051 .keywords: TS, vector, monitor, view 7052 7053 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSSetSolutionFunction() 7054 @*/ 7055 PetscErrorCode TSMonitorError(TS ts,PetscInt step,PetscReal ptime,Vec u,PetscViewerAndFormat *vf) 7056 { 7057 PetscErrorCode ierr; 7058 Vec y; 7059 PetscReal nrm; 7060 PetscBool flg; 7061 7062 PetscFunctionBegin; 7063 ierr = VecDuplicate(u,&y);CHKERRQ(ierr); 7064 ierr = TSComputeSolutionFunction(ts,ptime,y);CHKERRQ(ierr); 7065 ierr = VecAXPY(y,-1.0,u);CHKERRQ(ierr); 7066 ierr = PetscObjectTypeCompare((PetscObject)vf->viewer,PETSCVIEWERASCII,&flg);CHKERRQ(ierr); 7067 if (flg) { 7068 ierr = VecNorm(y,NORM_2,&nrm);CHKERRQ(ierr); 7069 ierr = PetscViewerASCIIPrintf(vf->viewer,"2-norm of error %g\n",(double)nrm);CHKERRQ(ierr); 7070 } 7071 ierr = PetscObjectTypeCompare((PetscObject)vf->viewer,PETSCVIEWERDRAW,&flg);CHKERRQ(ierr); 7072 if (flg) { 7073 ierr = VecView(y,vf->viewer);CHKERRQ(ierr); 7074 } 7075 ierr = VecDestroy(&y);CHKERRQ(ierr); 7076 PetscFunctionReturn(0); 7077 } 7078 7079 PetscErrorCode TSMonitorLGSNESIterations(TS ts,PetscInt n,PetscReal ptime,Vec v,void *monctx) 7080 { 7081 TSMonitorLGCtx ctx = (TSMonitorLGCtx) monctx; 7082 PetscReal x = ptime,y; 7083 PetscErrorCode ierr; 7084 PetscInt its; 7085 7086 PetscFunctionBegin; 7087 if (n < 0) PetscFunctionReturn(0); /* -1 indicates interpolated solution */ 7088 if (!n) { 7089 PetscDrawAxis axis; 7090 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 7091 ierr = PetscDrawAxisSetLabels(axis,"Nonlinear iterations as function of time","Time","SNES Iterations");CHKERRQ(ierr); 7092 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 7093 ctx->snes_its = 0; 7094 } 7095 ierr = TSGetSNESIterations(ts,&its);CHKERRQ(ierr); 7096 y = its - ctx->snes_its; 7097 ierr = PetscDrawLGAddPoint(ctx->lg,&x,&y);CHKERRQ(ierr); 7098 if (((ctx->howoften > 0) && (!(n % ctx->howoften)) && (n > -1)) || ((ctx->howoften == -1) && (n == -1))) { 7099 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 7100 ierr = PetscDrawLGSave(ctx->lg);CHKERRQ(ierr); 7101 } 7102 ctx->snes_its = its; 7103 PetscFunctionReturn(0); 7104 } 7105 7106 PetscErrorCode TSMonitorLGKSPIterations(TS ts,PetscInt n,PetscReal ptime,Vec v,void *monctx) 7107 { 7108 TSMonitorLGCtx ctx = (TSMonitorLGCtx) monctx; 7109 PetscReal x = ptime,y; 7110 PetscErrorCode ierr; 7111 PetscInt its; 7112 7113 PetscFunctionBegin; 7114 if (n < 0) PetscFunctionReturn(0); /* -1 indicates interpolated solution */ 7115 if (!n) { 7116 PetscDrawAxis axis; 7117 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 7118 ierr = PetscDrawAxisSetLabels(axis,"Linear iterations as function of time","Time","KSP Iterations");CHKERRQ(ierr); 7119 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 7120 ctx->ksp_its = 0; 7121 } 7122 ierr = TSGetKSPIterations(ts,&its);CHKERRQ(ierr); 7123 y = its - ctx->ksp_its; 7124 ierr = PetscDrawLGAddPoint(ctx->lg,&x,&y);CHKERRQ(ierr); 7125 if (((ctx->howoften > 0) && (!(n % ctx->howoften)) && (n > -1)) || ((ctx->howoften == -1) && (n == -1))) { 7126 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 7127 ierr = PetscDrawLGSave(ctx->lg);CHKERRQ(ierr); 7128 } 7129 ctx->ksp_its = its; 7130 PetscFunctionReturn(0); 7131 } 7132 7133 /*@ 7134 TSComputeLinearStability - computes the linear stability function at a point 7135 7136 Collective on TS and Vec 7137 7138 Input Parameters: 7139 + ts - the TS context 7140 - xr,xi - real and imaginary part of input arguments 7141 7142 Output Parameters: 7143 . yr,yi - real and imaginary part of function value 7144 7145 Level: developer 7146 7147 .keywords: TS, compute 7148 7149 .seealso: TSSetRHSFunction(), TSComputeIFunction() 7150 @*/ 7151 PetscErrorCode TSComputeLinearStability(TS ts,PetscReal xr,PetscReal xi,PetscReal *yr,PetscReal *yi) 7152 { 7153 PetscErrorCode ierr; 7154 7155 PetscFunctionBegin; 7156 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 7157 if (!ts->ops->linearstability) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"Linearized stability function not provided for this method"); 7158 ierr = (*ts->ops->linearstability)(ts,xr,xi,yr,yi);CHKERRQ(ierr); 7159 PetscFunctionReturn(0); 7160 } 7161 7162 /* ------------------------------------------------------------------------*/ 7163 /*@C 7164 TSMonitorEnvelopeCtxCreate - Creates a context for use with TSMonitorEnvelope() 7165 7166 Collective on TS 7167 7168 Input Parameters: 7169 . ts - the ODE solver object 7170 7171 Output Parameter: 7172 . ctx - the context 7173 7174 Level: intermediate 7175 7176 .keywords: TS, monitor, line graph, residual, seealso 7177 7178 .seealso: TSMonitorLGTimeStep(), TSMonitorSet(), TSMonitorLGSolution(), TSMonitorLGError() 7179 7180 @*/ 7181 PetscErrorCode TSMonitorEnvelopeCtxCreate(TS ts,TSMonitorEnvelopeCtx *ctx) 7182 { 7183 PetscErrorCode ierr; 7184 7185 PetscFunctionBegin; 7186 ierr = PetscNew(ctx);CHKERRQ(ierr); 7187 PetscFunctionReturn(0); 7188 } 7189 7190 /*@C 7191 TSMonitorEnvelope - Monitors the maximum and minimum value of each component of the solution 7192 7193 Collective on TS 7194 7195 Input Parameters: 7196 + ts - the TS context 7197 . step - current time-step 7198 . ptime - current time 7199 . u - current solution 7200 - dctx - the envelope context 7201 7202 Options Database: 7203 . -ts_monitor_envelope 7204 7205 Level: intermediate 7206 7207 Notes: 7208 after a solve you can use TSMonitorEnvelopeGetBounds() to access the envelope 7209 7210 .keywords: TS, vector, monitor, view 7211 7212 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorEnvelopeGetBounds(), TSMonitorEnvelopeCtxCreate() 7213 @*/ 7214 PetscErrorCode TSMonitorEnvelope(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dctx) 7215 { 7216 PetscErrorCode ierr; 7217 TSMonitorEnvelopeCtx ctx = (TSMonitorEnvelopeCtx)dctx; 7218 7219 PetscFunctionBegin; 7220 if (!ctx->max) { 7221 ierr = VecDuplicate(u,&ctx->max);CHKERRQ(ierr); 7222 ierr = VecDuplicate(u,&ctx->min);CHKERRQ(ierr); 7223 ierr = VecCopy(u,ctx->max);CHKERRQ(ierr); 7224 ierr = VecCopy(u,ctx->min);CHKERRQ(ierr); 7225 } else { 7226 ierr = VecPointwiseMax(ctx->max,u,ctx->max);CHKERRQ(ierr); 7227 ierr = VecPointwiseMin(ctx->min,u,ctx->min);CHKERRQ(ierr); 7228 } 7229 PetscFunctionReturn(0); 7230 } 7231 7232 /*@C 7233 TSMonitorEnvelopeGetBounds - Gets the bounds for the components of the solution 7234 7235 Collective on TS 7236 7237 Input Parameter: 7238 . ts - the TS context 7239 7240 Output Parameter: 7241 + max - the maximum values 7242 - min - the minimum values 7243 7244 Notes: 7245 If the TS does not have a TSMonitorEnvelopeCtx associated with it then this function is ignored 7246 7247 Level: intermediate 7248 7249 .keywords: TS, vector, monitor, view 7250 7251 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetDisplayVariables() 7252 @*/ 7253 PetscErrorCode TSMonitorEnvelopeGetBounds(TS ts,Vec *max,Vec *min) 7254 { 7255 PetscInt i; 7256 7257 PetscFunctionBegin; 7258 if (max) *max = NULL; 7259 if (min) *min = NULL; 7260 for (i=0; i<ts->numbermonitors; i++) { 7261 if (ts->monitor[i] == TSMonitorEnvelope) { 7262 TSMonitorEnvelopeCtx ctx = (TSMonitorEnvelopeCtx) ts->monitorcontext[i]; 7263 if (max) *max = ctx->max; 7264 if (min) *min = ctx->min; 7265 break; 7266 } 7267 } 7268 PetscFunctionReturn(0); 7269 } 7270 7271 /*@C 7272 TSMonitorEnvelopeCtxDestroy - Destroys a context that was created with TSMonitorEnvelopeCtxCreate(). 7273 7274 Collective on TSMonitorEnvelopeCtx 7275 7276 Input Parameter: 7277 . ctx - the monitor context 7278 7279 Level: intermediate 7280 7281 .keywords: TS, monitor, line graph, destroy 7282 7283 .seealso: TSMonitorLGCtxCreate(), TSMonitorSet(), TSMonitorLGTimeStep() 7284 @*/ 7285 PetscErrorCode TSMonitorEnvelopeCtxDestroy(TSMonitorEnvelopeCtx *ctx) 7286 { 7287 PetscErrorCode ierr; 7288 7289 PetscFunctionBegin; 7290 ierr = VecDestroy(&(*ctx)->min);CHKERRQ(ierr); 7291 ierr = VecDestroy(&(*ctx)->max);CHKERRQ(ierr); 7292 ierr = PetscFree(*ctx);CHKERRQ(ierr); 7293 PetscFunctionReturn(0); 7294 } 7295 7296 /*@ 7297 TSRestartStep - Flags the solver to restart the next step 7298 7299 Collective on TS 7300 7301 Input Parameter: 7302 . ts - the TS context obtained from TSCreate() 7303 7304 Level: advanced 7305 7306 Notes: 7307 Multistep methods like BDF or Runge-Kutta methods with FSAL property require restarting the solver in the event of 7308 discontinuities. These discontinuities may be introduced as a consequence of explicitly modifications to the solution 7309 vector (which PETSc attempts to detect and handle) or problem coefficients (which PETSc is not able to detect). For 7310 the sake of correctness and maximum safety, users are expected to call TSRestart() whenever they introduce 7311 discontinuities in callback routines (e.g. prestep and poststep routines, or implicit/rhs function routines with 7312 discontinuous source terms). 7313 7314 .keywords: TS, timestep, restart 7315 7316 .seealso: TSSolve(), TSSetPreStep(), TSSetPostStep() 7317 @*/ 7318 PetscErrorCode TSRestartStep(TS ts) 7319 { 7320 PetscFunctionBegin; 7321 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 7322 ts->steprestart = PETSC_TRUE; 7323 PetscFunctionReturn(0); 7324 } 7325 7326 /*@ 7327 TSRollBack - Rolls back one time step 7328 7329 Collective on TS 7330 7331 Input Parameter: 7332 . ts - the TS context obtained from TSCreate() 7333 7334 Level: advanced 7335 7336 .keywords: TS, timestep, rollback 7337 7338 .seealso: TSCreate(), TSSetUp(), TSDestroy(), TSSolve(), TSSetPreStep(), TSSetPreStage(), TSInterpolate() 7339 @*/ 7340 PetscErrorCode TSRollBack(TS ts) 7341 { 7342 PetscErrorCode ierr; 7343 7344 PetscFunctionBegin; 7345 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 7346 if (ts->steprollback) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_WRONGSTATE,"TSRollBack already called"); 7347 if (!ts->ops->rollback) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"TSRollBack not implemented for type '%s'",((PetscObject)ts)->type_name); 7348 ierr = (*ts->ops->rollback)(ts);CHKERRQ(ierr); 7349 ts->time_step = ts->ptime - ts->ptime_prev; 7350 ts->ptime = ts->ptime_prev; 7351 ts->ptime_prev = ts->ptime_prev_rollback; 7352 ts->steps--; 7353 ts->steprollback = PETSC_TRUE; 7354 PetscFunctionReturn(0); 7355 } 7356 7357 /*@ 7358 TSGetStages - Get the number of stages and stage values 7359 7360 Input Parameter: 7361 . ts - the TS context obtained from TSCreate() 7362 7363 Output Parameters: 7364 + ns - the number of stages 7365 - Y - the current stage vectors 7366 7367 Level: advanced 7368 7369 Notes: Both ns and Y can be NULL. 7370 7371 .keywords: TS, getstages 7372 7373 .seealso: TSCreate() 7374 @*/ 7375 PetscErrorCode TSGetStages(TS ts,PetscInt *ns,Vec **Y) 7376 { 7377 PetscErrorCode ierr; 7378 7379 PetscFunctionBegin; 7380 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 7381 if (ns) PetscValidPointer(ns,2); 7382 if (Y) PetscValidPointer(Y,3); 7383 if (!ts->ops->getstages) { 7384 if (ns) *ns = 0; 7385 if (Y) *Y = NULL; 7386 } else { 7387 ierr = (*ts->ops->getstages)(ts,ns,Y);CHKERRQ(ierr); 7388 } 7389 PetscFunctionReturn(0); 7390 } 7391 7392 /*@C 7393 TSComputeIJacobianDefaultColor - Computes the Jacobian using finite differences and coloring to exploit matrix sparsity. 7394 7395 Collective on SNES 7396 7397 Input Parameters: 7398 + ts - the TS context 7399 . t - current timestep 7400 . U - state vector 7401 . Udot - time derivative of state vector 7402 . shift - shift to apply, see note below 7403 - ctx - an optional user context 7404 7405 Output Parameters: 7406 + J - Jacobian matrix (not altered in this routine) 7407 - B - newly computed Jacobian matrix to use with preconditioner (generally the same as J) 7408 7409 Level: intermediate 7410 7411 Notes: 7412 If F(t,U,Udot)=0 is the DAE, the required Jacobian is 7413 7414 dF/dU + shift*dF/dUdot 7415 7416 Most users should not need to explicitly call this routine, as it 7417 is used internally within the nonlinear solvers. 7418 7419 This will first try to get the coloring from the DM. If the DM type has no coloring 7420 routine, then it will try to get the coloring from the matrix. This requires that the 7421 matrix have nonzero entries precomputed. 7422 7423 .keywords: TS, finite differences, Jacobian, coloring, sparse 7424 .seealso: TSSetIJacobian(), MatFDColoringCreate(), MatFDColoringSetFunction() 7425 @*/ 7426 PetscErrorCode TSComputeIJacobianDefaultColor(TS ts,PetscReal t,Vec U,Vec Udot,PetscReal shift,Mat J,Mat B,void *ctx) 7427 { 7428 SNES snes; 7429 MatFDColoring color; 7430 PetscBool hascolor, matcolor = PETSC_FALSE; 7431 PetscErrorCode ierr; 7432 7433 PetscFunctionBegin; 7434 ierr = PetscOptionsGetBool(((PetscObject)ts)->options,((PetscObject) ts)->prefix, "-ts_fd_color_use_mat", &matcolor, NULL);CHKERRQ(ierr); 7435 ierr = PetscObjectQuery((PetscObject) B, "TSMatFDColoring", (PetscObject *) &color);CHKERRQ(ierr); 7436 if (!color) { 7437 DM dm; 7438 ISColoring iscoloring; 7439 7440 ierr = TSGetDM(ts, &dm);CHKERRQ(ierr); 7441 ierr = DMHasColoring(dm, &hascolor);CHKERRQ(ierr); 7442 if (hascolor && !matcolor) { 7443 ierr = DMCreateColoring(dm, IS_COLORING_GLOBAL, &iscoloring);CHKERRQ(ierr); 7444 ierr = MatFDColoringCreate(B, iscoloring, &color);CHKERRQ(ierr); 7445 ierr = MatFDColoringSetFunction(color, (PetscErrorCode (*)(void)) SNESTSFormFunction, (void *) ts);CHKERRQ(ierr); 7446 ierr = MatFDColoringSetFromOptions(color);CHKERRQ(ierr); 7447 ierr = MatFDColoringSetUp(B, iscoloring, color);CHKERRQ(ierr); 7448 ierr = ISColoringDestroy(&iscoloring);CHKERRQ(ierr); 7449 } else { 7450 MatColoring mc; 7451 7452 ierr = MatColoringCreate(B, &mc);CHKERRQ(ierr); 7453 ierr = MatColoringSetDistance(mc, 2);CHKERRQ(ierr); 7454 ierr = MatColoringSetType(mc, MATCOLORINGSL);CHKERRQ(ierr); 7455 ierr = MatColoringSetFromOptions(mc);CHKERRQ(ierr); 7456 ierr = MatColoringApply(mc, &iscoloring);CHKERRQ(ierr); 7457 ierr = MatColoringDestroy(&mc);CHKERRQ(ierr); 7458 ierr = MatFDColoringCreate(B, iscoloring, &color);CHKERRQ(ierr); 7459 ierr = MatFDColoringSetFunction(color, (PetscErrorCode (*)(void)) SNESTSFormFunction, (void *) ts);CHKERRQ(ierr); 7460 ierr = MatFDColoringSetFromOptions(color);CHKERRQ(ierr); 7461 ierr = MatFDColoringSetUp(B, iscoloring, color);CHKERRQ(ierr); 7462 ierr = ISColoringDestroy(&iscoloring);CHKERRQ(ierr); 7463 } 7464 ierr = PetscObjectCompose((PetscObject) B, "TSMatFDColoring", (PetscObject) color);CHKERRQ(ierr); 7465 ierr = PetscObjectDereference((PetscObject) color);CHKERRQ(ierr); 7466 } 7467 ierr = TSGetSNES(ts, &snes);CHKERRQ(ierr); 7468 ierr = MatFDColoringApply(B, color, U, snes);CHKERRQ(ierr); 7469 if (J != B) { 7470 ierr = MatAssemblyBegin(J, MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); 7471 ierr = MatAssemblyEnd(J, MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); 7472 } 7473 PetscFunctionReturn(0); 7474 } 7475 7476 /*@ 7477 TSSetFunctionDomainError - Set the function testing if the current state vector is valid 7478 7479 Input Parameters: 7480 ts - the TS context 7481 func - function called within TSFunctionDomainError 7482 7483 Level: intermediate 7484 7485 .keywords: TS, state, domain 7486 .seealso: TSAdaptCheckStage(), TSFunctionDomainError() 7487 @*/ 7488 7489 PetscErrorCode TSSetFunctionDomainError(TS ts, PetscErrorCode (*func)(TS,PetscReal,Vec,PetscBool*)) 7490 { 7491 PetscFunctionBegin; 7492 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 7493 ts->functiondomainerror = func; 7494 PetscFunctionReturn(0); 7495 } 7496 7497 /*@ 7498 TSFunctionDomainError - Check if the current state is valid 7499 7500 Input Parameters: 7501 ts - the TS context 7502 stagetime - time of the simulation 7503 Y - state vector to check. 7504 7505 Output Parameter: 7506 accept - Set to PETSC_FALSE if the current state vector is valid. 7507 7508 Note: 7509 This function should be used to ensure the state is in a valid part of the space. 7510 For example, one can ensure here all values are positive. 7511 7512 Level: advanced 7513 @*/ 7514 PetscErrorCode TSFunctionDomainError(TS ts,PetscReal stagetime,Vec Y,PetscBool* accept) 7515 { 7516 PetscFunctionBegin; 7517 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 7518 *accept = PETSC_TRUE; 7519 if (ts->functiondomainerror) { 7520 PetscStackCallStandard((*ts->functiondomainerror),(ts,stagetime,Y,accept)); 7521 } 7522 PetscFunctionReturn(0); 7523 } 7524 7525 /*@C 7526 TSClone - This function clones a time step object. 7527 7528 Collective on MPI_Comm 7529 7530 Input Parameter: 7531 . tsin - The input TS 7532 7533 Output Parameter: 7534 . tsout - The output TS (cloned) 7535 7536 Notes: 7537 This function is used to create a clone of a TS object. It is used in ARKIMEX for initializing the slope for first stage explicit methods. It will likely be replaced in the future with a mechanism of switching methods on the fly. 7538 7539 When using TSDestroy() on a clone the user has to first reset the correct TS reference in the embedded SNES object: e.g.: by running SNES snes_dup=NULL; TSGetSNES(ts,&snes_dup); TSSetSNES(ts,snes_dup); 7540 7541 Level: developer 7542 7543 .keywords: TS, clone 7544 .seealso: TSCreate(), TSSetType(), TSSetUp(), TSDestroy(), TSSetProblemType() 7545 @*/ 7546 PetscErrorCode TSClone(TS tsin, TS *tsout) 7547 { 7548 TS t; 7549 PetscErrorCode ierr; 7550 SNES snes_start; 7551 DM dm; 7552 TSType type; 7553 7554 PetscFunctionBegin; 7555 PetscValidPointer(tsin,1); 7556 *tsout = NULL; 7557 7558 ierr = PetscHeaderCreate(t, TS_CLASSID, "TS", "Time stepping", "TS", PetscObjectComm((PetscObject)tsin), TSDestroy, TSView);CHKERRQ(ierr); 7559 7560 /* General TS description */ 7561 t->numbermonitors = 0; 7562 t->setupcalled = 0; 7563 t->ksp_its = 0; 7564 t->snes_its = 0; 7565 t->nwork = 0; 7566 t->rhsjacobian.time = -1e20; 7567 t->rhsjacobian.scale = 1.; 7568 t->ijacobian.shift = 1.; 7569 7570 ierr = TSGetSNES(tsin,&snes_start);CHKERRQ(ierr); 7571 ierr = TSSetSNES(t,snes_start);CHKERRQ(ierr); 7572 7573 ierr = TSGetDM(tsin,&dm);CHKERRQ(ierr); 7574 ierr = TSSetDM(t,dm);CHKERRQ(ierr); 7575 7576 t->adapt = tsin->adapt; 7577 ierr = PetscObjectReference((PetscObject)t->adapt);CHKERRQ(ierr); 7578 7579 t->trajectory = tsin->trajectory; 7580 ierr = PetscObjectReference((PetscObject)t->trajectory);CHKERRQ(ierr); 7581 7582 t->event = tsin->event; 7583 if (t->event) t->event->refct++; 7584 7585 t->problem_type = tsin->problem_type; 7586 t->ptime = tsin->ptime; 7587 t->ptime_prev = tsin->ptime_prev; 7588 t->time_step = tsin->time_step; 7589 t->max_time = tsin->max_time; 7590 t->steps = tsin->steps; 7591 t->max_steps = tsin->max_steps; 7592 t->equation_type = tsin->equation_type; 7593 t->atol = tsin->atol; 7594 t->rtol = tsin->rtol; 7595 t->max_snes_failures = tsin->max_snes_failures; 7596 t->max_reject = tsin->max_reject; 7597 t->errorifstepfailed = tsin->errorifstepfailed; 7598 7599 ierr = TSGetType(tsin,&type);CHKERRQ(ierr); 7600 ierr = TSSetType(t,type);CHKERRQ(ierr); 7601 7602 t->vec_sol = NULL; 7603 7604 t->cfltime = tsin->cfltime; 7605 t->cfltime_local = tsin->cfltime_local; 7606 t->exact_final_time = tsin->exact_final_time; 7607 7608 ierr = PetscMemcpy(t->ops,tsin->ops,sizeof(struct _TSOps));CHKERRQ(ierr); 7609 7610 if (((PetscObject)tsin)->fortran_func_pointers) { 7611 PetscInt i; 7612 ierr = PetscMalloc((10)*sizeof(void(*)(void)),&((PetscObject)t)->fortran_func_pointers);CHKERRQ(ierr); 7613 for (i=0; i<10; i++) { 7614 ((PetscObject)t)->fortran_func_pointers[i] = ((PetscObject)tsin)->fortran_func_pointers[i]; 7615 } 7616 } 7617 *tsout = t; 7618 PetscFunctionReturn(0); 7619 } 7620 7621 static PetscErrorCode RHSWrapperFunction_TSRHSJacobianTest(void* ctx,Vec x,Vec y) 7622 { 7623 PetscErrorCode ierr; 7624 TS ts = (TS) ctx; 7625 7626 PetscFunctionBegin; 7627 ierr = TSComputeRHSFunction(ts,0,x,y);CHKERRQ(ierr); 7628 PetscFunctionReturn(0); 7629 } 7630 7631 /*@ 7632 TSRHSJacobianTest - Compares the multiply routine provided to the MATSHELL with differencing on the TS given RHS function. 7633 7634 Logically Collective on TS and Mat 7635 7636 Input Parameters: 7637 TS - the time stepping routine 7638 7639 Output Parameter: 7640 . flg - PETSC_TRUE if the multiply is likely correct 7641 7642 Options Database: 7643 . -ts_rhs_jacobian_test_mult -mat_shell_test_mult_view - run the test at each timestep of the integrator 7644 7645 Level: advanced 7646 7647 Notes: 7648 This only works for problems defined only the RHS function and Jacobian NOT IFunction and IJacobian 7649 7650 .seealso: MatCreateShell(), MatShellGetContext(), MatShellGetOperation(), MatShellTestMultTranspose(), TSRHSJacobianTestTranspose() 7651 @*/ 7652 PetscErrorCode TSRHSJacobianTest(TS ts,PetscBool *flg) 7653 { 7654 Mat J,B; 7655 PetscErrorCode ierr; 7656 TSRHSJacobian func; 7657 void* ctx; 7658 7659 PetscFunctionBegin; 7660 ierr = TSGetRHSJacobian(ts,&J,&B,&func,&ctx);CHKERRQ(ierr); 7661 ierr = (*func)(ts,0.0,ts->vec_sol,J,B,ctx);CHKERRQ(ierr); 7662 ierr = MatShellTestMult(J,RHSWrapperFunction_TSRHSJacobianTest,ts->vec_sol,ts,flg);CHKERRQ(ierr); 7663 PetscFunctionReturn(0); 7664 } 7665 7666 /*@C 7667 TSRHSJacobianTestTranspose - Compares the multiply transpose routine provided to the MATSHELL with differencing on the TS given RHS function. 7668 7669 Logically Collective on TS and Mat 7670 7671 Input Parameters: 7672 TS - the time stepping routine 7673 7674 Output Parameter: 7675 . flg - PETSC_TRUE if the multiply is likely correct 7676 7677 Options Database: 7678 . -ts_rhs_jacobian_test_mult_transpose -mat_shell_test_mult_transpose_view - run the test at each timestep of the integrator 7679 7680 Notes: 7681 This only works for problems defined only the RHS function and Jacobian NOT IFunction and IJacobian 7682 7683 Level: advanced 7684 7685 .seealso: MatCreateShell(), MatShellGetContext(), MatShellGetOperation(), MatShellTestMultTranspose(), TSRHSJacobianTest() 7686 @*/ 7687 PetscErrorCode TSRHSJacobianTestTranspose(TS ts,PetscBool *flg) 7688 { 7689 Mat J,B; 7690 PetscErrorCode ierr; 7691 void *ctx; 7692 TSRHSJacobian func; 7693 7694 PetscFunctionBegin; 7695 ierr = TSGetRHSJacobian(ts,&J,&B,&func,&ctx);CHKERRQ(ierr); 7696 ierr = (*func)(ts,0.0,ts->vec_sol,J,B,ctx);CHKERRQ(ierr); 7697 ierr = MatShellTestMultTranspose(J,RHSWrapperFunction_TSRHSJacobianTest,ts->vec_sol,ts,flg);CHKERRQ(ierr); 7698 PetscFunctionReturn(0); 7699 } 7700 7701 /*@ 7702 TSSetUseSplitRHSFunction - Use the split RHSFunction when a multirate method is used. 7703 7704 Logically collective 7705 7706 Input Parameter: 7707 + ts - timestepping context 7708 - use_splitrhsfunction - PETSC_TRUE indicates that the split RHSFunction will be used 7709 7710 Options Database: 7711 . -ts_use_splitrhsfunction - <true,false> 7712 7713 Notes: 7714 This is only useful for multirate methods 7715 7716 Level: intermediate 7717 7718 .seealso: TSGetUseSplitRHSFunction() 7719 @*/ 7720 PetscErrorCode TSSetUseSplitRHSFunction(TS ts, PetscBool use_splitrhsfunction) 7721 { 7722 PetscFunctionBegin; 7723 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 7724 ts->use_splitrhsfunction = use_splitrhsfunction; 7725 PetscFunctionReturn(0); 7726 } 7727 7728 /*@ 7729 TSGetUseSplitRHSFunction - Gets whether to use the split RHSFunction when a multirate method is used. 7730 7731 Not collective 7732 7733 Input Parameter: 7734 . ts - timestepping context 7735 7736 Output Parameter: 7737 . use_splitrhsfunction - PETSC_TRUE indicates that the split RHSFunction will be used 7738 7739 Level: intermediate 7740 7741 .seealso: TSSetUseSplitRHSFunction() 7742 @*/ 7743 PetscErrorCode TSGetUseSplitRHSFunction(TS ts, PetscBool *use_splitrhsfunction) 7744 { 7745 PetscFunctionBegin; 7746 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 7747 *use_splitrhsfunction = ts->use_splitrhsfunction; 7748 PetscFunctionReturn(0); 7749 } 7750