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