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 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 ierr = DMGetDMTS(ts->dm,&sdm);CHKERRQ(ierr); 1922 ierr = DMTSView(sdm,viewer);CHKERRQ(ierr); 1923 if (ts->ops->view) { 1924 ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); 1925 ierr = (*ts->ops->view)(ts,viewer);CHKERRQ(ierr); 1926 ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); 1927 } 1928 } else if (isstring) { 1929 ierr = TSGetType(ts,&type);CHKERRQ(ierr); 1930 ierr = PetscViewerStringSPrintf(viewer," %-7.7s",type);CHKERRQ(ierr); 1931 } else if (isbinary) { 1932 PetscInt classid = TS_FILE_CLASSID; 1933 MPI_Comm comm; 1934 PetscMPIInt rank; 1935 char type[256]; 1936 1937 ierr = PetscObjectGetComm((PetscObject)ts,&comm);CHKERRQ(ierr); 1938 ierr = MPI_Comm_rank(comm,&rank);CHKERRQ(ierr); 1939 if (!rank) { 1940 ierr = PetscViewerBinaryWrite(viewer,&classid,1,PETSC_INT,PETSC_FALSE);CHKERRQ(ierr); 1941 ierr = PetscStrncpy(type,((PetscObject)ts)->type_name,256);CHKERRQ(ierr); 1942 ierr = PetscViewerBinaryWrite(viewer,type,256,PETSC_CHAR,PETSC_FALSE);CHKERRQ(ierr); 1943 } 1944 if (ts->ops->view) { 1945 ierr = (*ts->ops->view)(ts,viewer);CHKERRQ(ierr); 1946 } 1947 ierr = DMView(ts->dm,viewer);CHKERRQ(ierr); 1948 ierr = VecView(ts->vec_sol,viewer);CHKERRQ(ierr); 1949 ierr = DMGetDMTS(ts->dm,&sdm);CHKERRQ(ierr); 1950 ierr = DMTSView(sdm,viewer);CHKERRQ(ierr); 1951 } else if (isdraw) { 1952 PetscDraw draw; 1953 char str[36]; 1954 PetscReal x,y,bottom,h; 1955 1956 ierr = PetscViewerDrawGetDraw(viewer,0,&draw);CHKERRQ(ierr); 1957 ierr = PetscDrawGetCurrentPoint(draw,&x,&y);CHKERRQ(ierr); 1958 ierr = PetscStrcpy(str,"TS: ");CHKERRQ(ierr); 1959 ierr = PetscStrcat(str,((PetscObject)ts)->type_name);CHKERRQ(ierr); 1960 ierr = PetscDrawStringBoxed(draw,x,y,PETSC_DRAW_BLACK,PETSC_DRAW_BLACK,str,NULL,&h);CHKERRQ(ierr); 1961 bottom = y - h; 1962 ierr = PetscDrawPushCurrentPoint(draw,x,bottom);CHKERRQ(ierr); 1963 if (ts->ops->view) { 1964 ierr = (*ts->ops->view)(ts,viewer);CHKERRQ(ierr); 1965 } 1966 ierr = PetscDrawPopCurrentPoint(draw);CHKERRQ(ierr); 1967 #if defined(PETSC_HAVE_SAWS) 1968 } else if (issaws) { 1969 PetscMPIInt rank; 1970 const char *name; 1971 1972 ierr = PetscObjectGetName((PetscObject)ts,&name);CHKERRQ(ierr); 1973 ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr); 1974 if (!((PetscObject)ts)->amsmem && !rank) { 1975 char dir[1024]; 1976 1977 ierr = PetscObjectViewSAWs((PetscObject)ts,viewer);CHKERRQ(ierr); 1978 ierr = PetscSNPrintf(dir,1024,"/PETSc/Objects/%s/time_step",name);CHKERRQ(ierr); 1979 PetscStackCallSAWs(SAWs_Register,(dir,&ts->steps,1,SAWs_READ,SAWs_INT)); 1980 ierr = PetscSNPrintf(dir,1024,"/PETSc/Objects/%s/time",name);CHKERRQ(ierr); 1981 PetscStackCallSAWs(SAWs_Register,(dir,&ts->ptime,1,SAWs_READ,SAWs_DOUBLE)); 1982 } 1983 if (ts->ops->view) { 1984 ierr = (*ts->ops->view)(ts,viewer);CHKERRQ(ierr); 1985 } 1986 #endif 1987 } 1988 1989 ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); 1990 ierr = PetscObjectTypeCompare((PetscObject)ts,TSSUNDIALS,&isundials);CHKERRQ(ierr); 1991 ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); 1992 PetscFunctionReturn(0); 1993 } 1994 1995 1996 #undef __FUNCT__ 1997 #define __FUNCT__ "TSSetApplicationContext" 1998 /*@ 1999 TSSetApplicationContext - Sets an optional user-defined context for 2000 the timesteppers. 2001 2002 Logically Collective on TS 2003 2004 Input Parameters: 2005 + ts - the TS context obtained from TSCreate() 2006 - usrP - optional user context 2007 2008 Fortran Notes: To use this from Fortran you must write a Fortran interface definition for this 2009 function that tells Fortran the Fortran derived data type that you are passing in as the ctx argument. 2010 2011 Level: intermediate 2012 2013 .keywords: TS, timestep, set, application, context 2014 2015 .seealso: TSGetApplicationContext() 2016 @*/ 2017 PetscErrorCode TSSetApplicationContext(TS ts,void *usrP) 2018 { 2019 PetscFunctionBegin; 2020 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2021 ts->user = usrP; 2022 PetscFunctionReturn(0); 2023 } 2024 2025 #undef __FUNCT__ 2026 #define __FUNCT__ "TSGetApplicationContext" 2027 /*@ 2028 TSGetApplicationContext - Gets the user-defined context for the 2029 timestepper. 2030 2031 Not Collective 2032 2033 Input Parameter: 2034 . ts - the TS context obtained from TSCreate() 2035 2036 Output Parameter: 2037 . usrP - user context 2038 2039 Fortran Notes: To use this from Fortran you must write a Fortran interface definition for this 2040 function that tells Fortran the Fortran derived data type that you are passing in as the ctx argument. 2041 2042 Level: intermediate 2043 2044 .keywords: TS, timestep, get, application, context 2045 2046 .seealso: TSSetApplicationContext() 2047 @*/ 2048 PetscErrorCode TSGetApplicationContext(TS ts,void *usrP) 2049 { 2050 PetscFunctionBegin; 2051 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2052 *(void**)usrP = ts->user; 2053 PetscFunctionReturn(0); 2054 } 2055 2056 #undef __FUNCT__ 2057 #define __FUNCT__ "TSGetTimeStepNumber" 2058 /*@ 2059 TSGetTimeStepNumber - Gets the number of time steps completed. 2060 2061 Not Collective 2062 2063 Input Parameter: 2064 . ts - the TS context obtained from TSCreate() 2065 2066 Output Parameter: 2067 . iter - number of steps completed so far 2068 2069 Level: intermediate 2070 2071 .keywords: TS, timestep, get, iteration, number 2072 .seealso: TSGetTime(), TSGetTimeStep(), TSSetPreStep(), TSSetPreStage(), TSSetPostStage(), TSSetPostStep() 2073 @*/ 2074 PetscErrorCode TSGetTimeStepNumber(TS ts,PetscInt *iter) 2075 { 2076 PetscFunctionBegin; 2077 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2078 PetscValidIntPointer(iter,2); 2079 *iter = ts->steps; 2080 PetscFunctionReturn(0); 2081 } 2082 2083 #undef __FUNCT__ 2084 #define __FUNCT__ "TSSetInitialTimeStep" 2085 /*@ 2086 TSSetInitialTimeStep - Sets the initial timestep to be used, 2087 as well as the initial time. 2088 2089 Logically Collective on TS 2090 2091 Input Parameters: 2092 + ts - the TS context obtained from TSCreate() 2093 . initial_time - the initial time 2094 - time_step - the size of the timestep 2095 2096 Level: intermediate 2097 2098 .seealso: TSSetTimeStep(), TSGetTimeStep() 2099 2100 .keywords: TS, set, initial, timestep 2101 @*/ 2102 PetscErrorCode TSSetInitialTimeStep(TS ts,PetscReal initial_time,PetscReal time_step) 2103 { 2104 PetscErrorCode ierr; 2105 2106 PetscFunctionBegin; 2107 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2108 ierr = TSSetTimeStep(ts,time_step);CHKERRQ(ierr); 2109 ierr = TSSetTime(ts,initial_time);CHKERRQ(ierr); 2110 PetscFunctionReturn(0); 2111 } 2112 2113 #undef __FUNCT__ 2114 #define __FUNCT__ "TSSetTimeStep" 2115 /*@ 2116 TSSetTimeStep - Allows one to reset the timestep at any time, 2117 useful for simple pseudo-timestepping codes. 2118 2119 Logically Collective on TS 2120 2121 Input Parameters: 2122 + ts - the TS context obtained from TSCreate() 2123 - time_step - the size of the timestep 2124 2125 Level: intermediate 2126 2127 .seealso: TSSetInitialTimeStep(), TSGetTimeStep() 2128 2129 .keywords: TS, set, timestep 2130 @*/ 2131 PetscErrorCode TSSetTimeStep(TS ts,PetscReal time_step) 2132 { 2133 PetscFunctionBegin; 2134 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2135 PetscValidLogicalCollectiveReal(ts,time_step,2); 2136 ts->time_step = time_step; 2137 PetscFunctionReturn(0); 2138 } 2139 2140 #undef __FUNCT__ 2141 #define __FUNCT__ "TSSetExactFinalTime" 2142 /*@ 2143 TSSetExactFinalTime - Determines whether to adapt the final time step to 2144 match the exact final time, interpolate solution to the exact final time, 2145 or just return at the final time TS computed. 2146 2147 Logically Collective on TS 2148 2149 Input Parameter: 2150 + ts - the time-step context 2151 - eftopt - exact final time option 2152 2153 $ TS_EXACTFINALTIME_STEPOVER - Don't do anything if final time is exceeded 2154 $ TS_EXACTFINALTIME_INTERPOLATE - Interpolate back to final time 2155 $ TS_EXACTFINALTIME_MATCHSTEP - Adapt final time step to match the final time 2156 2157 Options Database: 2158 . -ts_exact_final_time <stepover,interpolate,matchstep> - select the final step at runtime 2159 2160 Warning: If you use the option TS_EXACTFINALTIME_STEPOVER the solution may be at a very different time 2161 then the final time you selected. 2162 2163 Level: beginner 2164 2165 .seealso: TSExactFinalTimeOption 2166 @*/ 2167 PetscErrorCode TSSetExactFinalTime(TS ts,TSExactFinalTimeOption eftopt) 2168 { 2169 PetscFunctionBegin; 2170 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2171 PetscValidLogicalCollectiveEnum(ts,eftopt,2); 2172 ts->exact_final_time = eftopt; 2173 PetscFunctionReturn(0); 2174 } 2175 2176 #undef __FUNCT__ 2177 #define __FUNCT__ "TSGetTimeStep" 2178 /*@ 2179 TSGetTimeStep - Gets the current timestep size. 2180 2181 Not Collective 2182 2183 Input Parameter: 2184 . ts - the TS context obtained from TSCreate() 2185 2186 Output Parameter: 2187 . dt - the current timestep size 2188 2189 Level: intermediate 2190 2191 .seealso: TSSetInitialTimeStep(), TSGetTimeStep() 2192 2193 .keywords: TS, get, timestep 2194 @*/ 2195 PetscErrorCode TSGetTimeStep(TS ts,PetscReal *dt) 2196 { 2197 PetscFunctionBegin; 2198 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2199 PetscValidRealPointer(dt,2); 2200 *dt = ts->time_step; 2201 PetscFunctionReturn(0); 2202 } 2203 2204 #undef __FUNCT__ 2205 #define __FUNCT__ "TSGetSolution" 2206 /*@ 2207 TSGetSolution - Returns the solution at the present timestep. It 2208 is valid to call this routine inside the function that you are evaluating 2209 in order to move to the new timestep. This vector not changed until 2210 the solution at the next timestep has been calculated. 2211 2212 Not Collective, but Vec returned is parallel if TS is parallel 2213 2214 Input Parameter: 2215 . ts - the TS context obtained from TSCreate() 2216 2217 Output Parameter: 2218 . v - the vector containing the solution 2219 2220 Note: If you used TSSetExactFinalTime(ts,TS_EXACTFINALTIME_MATCHSTEP); this does not return the solution at the requested 2221 final time. It returns the solution at the next timestep. 2222 2223 Level: intermediate 2224 2225 .seealso: TSGetTimeStep(), TSGetTime(), TSGetSolveTime() 2226 2227 .keywords: TS, timestep, get, solution 2228 @*/ 2229 PetscErrorCode TSGetSolution(TS ts,Vec *v) 2230 { 2231 PetscFunctionBegin; 2232 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2233 PetscValidPointer(v,2); 2234 *v = ts->vec_sol; 2235 PetscFunctionReturn(0); 2236 } 2237 2238 #undef __FUNCT__ 2239 #define __FUNCT__ "TSGetCostGradients" 2240 /*@ 2241 TSGetCostGradients - Returns the gradients from the TSAdjointSolve() 2242 2243 Not Collective, but Vec returned is parallel if TS is parallel 2244 2245 Input Parameter: 2246 . ts - the TS context obtained from TSCreate() 2247 2248 Output Parameter: 2249 + lambda - vectors containing the gradients of the cost functions with respect to the ODE/DAE solution variables 2250 - mu - vectors containing the gradients of the cost functions with respect to the problem parameters 2251 2252 Level: intermediate 2253 2254 .seealso: TSGetTimeStep() 2255 2256 .keywords: TS, timestep, get, sensitivity 2257 @*/ 2258 PetscErrorCode TSGetCostGradients(TS ts,PetscInt *numcost,Vec **lambda,Vec **mu) 2259 { 2260 PetscFunctionBegin; 2261 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2262 if (numcost) *numcost = ts->numcost; 2263 if (lambda) *lambda = ts->vecs_sensi; 2264 if (mu) *mu = ts->vecs_sensip; 2265 PetscFunctionReturn(0); 2266 } 2267 2268 /* ----- Routines to initialize and destroy a timestepper ---- */ 2269 #undef __FUNCT__ 2270 #define __FUNCT__ "TSSetProblemType" 2271 /*@ 2272 TSSetProblemType - Sets the type of problem to be solved. 2273 2274 Not collective 2275 2276 Input Parameters: 2277 + ts - The TS 2278 - type - One of TS_LINEAR, TS_NONLINEAR where these types refer to problems of the forms 2279 .vb 2280 U_t - A U = 0 (linear) 2281 U_t - A(t) U = 0 (linear) 2282 F(t,U,U_t) = 0 (nonlinear) 2283 .ve 2284 2285 Level: beginner 2286 2287 .keywords: TS, problem type 2288 .seealso: TSSetUp(), TSProblemType, TS 2289 @*/ 2290 PetscErrorCode TSSetProblemType(TS ts, TSProblemType type) 2291 { 2292 PetscErrorCode ierr; 2293 2294 PetscFunctionBegin; 2295 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 2296 ts->problem_type = type; 2297 if (type == TS_LINEAR) { 2298 SNES snes; 2299 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 2300 ierr = SNESSetType(snes,SNESKSPONLY);CHKERRQ(ierr); 2301 } 2302 PetscFunctionReturn(0); 2303 } 2304 2305 #undef __FUNCT__ 2306 #define __FUNCT__ "TSGetProblemType" 2307 /*@C 2308 TSGetProblemType - Gets the type of problem to be solved. 2309 2310 Not collective 2311 2312 Input Parameter: 2313 . ts - The TS 2314 2315 Output Parameter: 2316 . type - One of TS_LINEAR, TS_NONLINEAR where these types refer to problems of the forms 2317 .vb 2318 M U_t = A U 2319 M(t) U_t = A(t) U 2320 F(t,U,U_t) 2321 .ve 2322 2323 Level: beginner 2324 2325 .keywords: TS, problem type 2326 .seealso: TSSetUp(), TSProblemType, TS 2327 @*/ 2328 PetscErrorCode TSGetProblemType(TS ts, TSProblemType *type) 2329 { 2330 PetscFunctionBegin; 2331 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 2332 PetscValidIntPointer(type,2); 2333 *type = ts->problem_type; 2334 PetscFunctionReturn(0); 2335 } 2336 2337 #undef __FUNCT__ 2338 #define __FUNCT__ "TSSetUp" 2339 /*@ 2340 TSSetUp - Sets up the internal data structures for the later use 2341 of a timestepper. 2342 2343 Collective on TS 2344 2345 Input Parameter: 2346 . ts - the TS context obtained from TSCreate() 2347 2348 Notes: 2349 For basic use of the TS solvers the user need not explicitly call 2350 TSSetUp(), since these actions will automatically occur during 2351 the call to TSStep(). However, if one wishes to control this 2352 phase separately, TSSetUp() should be called after TSCreate() 2353 and optional routines of the form TSSetXXX(), but before TSStep(). 2354 2355 Level: advanced 2356 2357 .keywords: TS, timestep, setup 2358 2359 .seealso: TSCreate(), TSStep(), TSDestroy() 2360 @*/ 2361 PetscErrorCode TSSetUp(TS ts) 2362 { 2363 PetscErrorCode ierr; 2364 DM dm; 2365 PetscErrorCode (*func)(SNES,Vec,Vec,void*); 2366 PetscErrorCode (*jac)(SNES,Vec,Mat,Mat,void*); 2367 TSIFunction ifun; 2368 TSIJacobian ijac; 2369 TSI2Jacobian i2jac; 2370 TSRHSJacobian rhsjac; 2371 2372 PetscFunctionBegin; 2373 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2374 if (ts->setupcalled) PetscFunctionReturn(0); 2375 2376 ts->total_steps = 0; 2377 if (!((PetscObject)ts)->type_name) { 2378 ierr = TSGetIFunction(ts,NULL,&ifun,NULL);CHKERRQ(ierr); 2379 ierr = TSSetType(ts,ifun ? TSBEULER : TSEULER);CHKERRQ(ierr); 2380 } 2381 2382 if (!ts->vec_sol) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"Must call TSSetSolution() first"); 2383 2384 if (ts->rhsjacobian.reuse) { 2385 Mat Amat,Pmat; 2386 SNES snes; 2387 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 2388 ierr = SNESGetJacobian(snes,&Amat,&Pmat,NULL,NULL);CHKERRQ(ierr); 2389 /* Matching matrices implies that an IJacobian is NOT set, because if it had been set, the IJacobian's matrix would 2390 * have displaced the RHS matrix */ 2391 if (Amat == ts->Arhs) { 2392 ierr = MatDuplicate(ts->Arhs,MAT_DO_NOT_COPY_VALUES,&Amat);CHKERRQ(ierr); 2393 ierr = SNESSetJacobian(snes,Amat,NULL,NULL,NULL);CHKERRQ(ierr); 2394 ierr = MatDestroy(&Amat);CHKERRQ(ierr); 2395 } 2396 if (Pmat == ts->Brhs) { 2397 ierr = MatDuplicate(ts->Brhs,MAT_DO_NOT_COPY_VALUES,&Pmat);CHKERRQ(ierr); 2398 ierr = SNESSetJacobian(snes,NULL,Pmat,NULL,NULL);CHKERRQ(ierr); 2399 ierr = MatDestroy(&Pmat);CHKERRQ(ierr); 2400 } 2401 } 2402 if (ts->ops->setup) { 2403 ierr = (*ts->ops->setup)(ts);CHKERRQ(ierr); 2404 } 2405 2406 /* In the case where we've set a DMTSFunction or what have you, we need the default SNESFunction 2407 to be set right but can't do it elsewhere due to the overreliance on ctx=ts. 2408 */ 2409 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 2410 ierr = DMSNESGetFunction(dm,&func,NULL);CHKERRQ(ierr); 2411 if (!func) { 2412 ierr = DMSNESSetFunction(dm,SNESTSFormFunction,ts);CHKERRQ(ierr); 2413 } 2414 /* If the SNES doesn't have a jacobian set and the TS has an ijacobian or rhsjacobian set, set the SNES to use it. 2415 Otherwise, the SNES will use coloring internally to form the Jacobian. 2416 */ 2417 ierr = DMSNESGetJacobian(dm,&jac,NULL);CHKERRQ(ierr); 2418 ierr = DMTSGetIJacobian(dm,&ijac,NULL);CHKERRQ(ierr); 2419 ierr = DMTSGetI2Jacobian(dm,&i2jac,NULL);CHKERRQ(ierr); 2420 ierr = DMTSGetRHSJacobian(dm,&rhsjac,NULL);CHKERRQ(ierr); 2421 if (!jac && (ijac || i2jac || rhsjac)) { 2422 ierr = DMSNESSetJacobian(dm,SNESTSFormJacobian,ts);CHKERRQ(ierr); 2423 } 2424 ts->setupcalled = PETSC_TRUE; 2425 PetscFunctionReturn(0); 2426 } 2427 2428 #undef __FUNCT__ 2429 #define __FUNCT__ "TSAdjointSetUp" 2430 /*@ 2431 TSAdjointSetUp - Sets up the internal data structures for the later use 2432 of an adjoint solver 2433 2434 Collective on TS 2435 2436 Input Parameter: 2437 . ts - the TS context obtained from TSCreate() 2438 2439 Level: advanced 2440 2441 .keywords: TS, timestep, setup 2442 2443 .seealso: TSCreate(), TSAdjointStep(), TSSetCostGradients() 2444 @*/ 2445 PetscErrorCode TSAdjointSetUp(TS ts) 2446 { 2447 PetscErrorCode ierr; 2448 2449 PetscFunctionBegin; 2450 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2451 if (ts->adjointsetupcalled) PetscFunctionReturn(0); 2452 if (!ts->vecs_sensi) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"Must call TSSetCostGradients() first"); 2453 2454 if (ts->vec_costintegral) { /* if there is integral in the cost function*/ 2455 ierr = VecDuplicateVecs(ts->vecs_sensi[0],ts->numcost,&ts->vecs_drdy);CHKERRQ(ierr); 2456 if (ts->vecs_sensip){ 2457 ierr = VecDuplicateVecs(ts->vecs_sensip[0],ts->numcost,&ts->vecs_drdp);CHKERRQ(ierr); 2458 } 2459 } 2460 2461 if (ts->ops->adjointsetup) { 2462 ierr = (*ts->ops->adjointsetup)(ts);CHKERRQ(ierr); 2463 } 2464 ts->adjointsetupcalled = PETSC_TRUE; 2465 PetscFunctionReturn(0); 2466 } 2467 2468 #undef __FUNCT__ 2469 #define __FUNCT__ "TSReset" 2470 /*@ 2471 TSReset - Resets a TS context and removes any allocated Vecs and Mats. 2472 2473 Collective on TS 2474 2475 Input Parameter: 2476 . ts - the TS context obtained from TSCreate() 2477 2478 Level: beginner 2479 2480 .keywords: TS, timestep, reset 2481 2482 .seealso: TSCreate(), TSSetup(), TSDestroy() 2483 @*/ 2484 PetscErrorCode TSReset(TS ts) 2485 { 2486 PetscErrorCode ierr; 2487 2488 PetscFunctionBegin; 2489 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2490 2491 if (ts->ops->reset) { 2492 ierr = (*ts->ops->reset)(ts);CHKERRQ(ierr); 2493 } 2494 if (ts->snes) {ierr = SNESReset(ts->snes);CHKERRQ(ierr);} 2495 if (ts->adapt) {ierr = TSAdaptReset(ts->adapt);CHKERRQ(ierr);} 2496 2497 ierr = MatDestroy(&ts->Arhs);CHKERRQ(ierr); 2498 ierr = MatDestroy(&ts->Brhs);CHKERRQ(ierr); 2499 ierr = VecDestroy(&ts->Frhs);CHKERRQ(ierr); 2500 ierr = VecDestroy(&ts->vec_sol);CHKERRQ(ierr); 2501 ierr = VecDestroy(&ts->vec_dot);CHKERRQ(ierr); 2502 ierr = VecDestroy(&ts->vatol);CHKERRQ(ierr); 2503 ierr = VecDestroy(&ts->vrtol);CHKERRQ(ierr); 2504 ierr = VecDestroyVecs(ts->nwork,&ts->work);CHKERRQ(ierr); 2505 2506 if (ts->vec_costintegral) { 2507 ierr = VecDestroyVecs(ts->numcost,&ts->vecs_drdy);CHKERRQ(ierr); 2508 if (ts->vecs_drdp){ 2509 ierr = VecDestroyVecs(ts->numcost,&ts->vecs_drdp);CHKERRQ(ierr); 2510 } 2511 } 2512 ts->vecs_sensi = NULL; 2513 ts->vecs_sensip = NULL; 2514 ierr = MatDestroy(&ts->Jacp);CHKERRQ(ierr); 2515 ierr = VecDestroy(&ts->vec_costintegral);CHKERRQ(ierr); 2516 ierr = VecDestroy(&ts->vec_costintegrand);CHKERRQ(ierr); 2517 ts->setupcalled = PETSC_FALSE; 2518 PetscFunctionReturn(0); 2519 } 2520 2521 #undef __FUNCT__ 2522 #define __FUNCT__ "TSDestroy" 2523 /*@ 2524 TSDestroy - Destroys the timestepper context that was created 2525 with TSCreate(). 2526 2527 Collective on TS 2528 2529 Input Parameter: 2530 . ts - the TS context obtained from TSCreate() 2531 2532 Level: beginner 2533 2534 .keywords: TS, timestepper, destroy 2535 2536 .seealso: TSCreate(), TSSetUp(), TSSolve() 2537 @*/ 2538 PetscErrorCode TSDestroy(TS *ts) 2539 { 2540 PetscErrorCode ierr; 2541 2542 PetscFunctionBegin; 2543 if (!*ts) PetscFunctionReturn(0); 2544 PetscValidHeaderSpecific((*ts),TS_CLASSID,1); 2545 if (--((PetscObject)(*ts))->refct > 0) {*ts = 0; PetscFunctionReturn(0);} 2546 2547 ierr = TSReset((*ts));CHKERRQ(ierr); 2548 2549 /* if memory was published with SAWs then destroy it */ 2550 ierr = PetscObjectSAWsViewOff((PetscObject)*ts);CHKERRQ(ierr); 2551 if ((*ts)->ops->destroy) {ierr = (*(*ts)->ops->destroy)((*ts));CHKERRQ(ierr);} 2552 2553 ierr = TSTrajectoryDestroy(&(*ts)->trajectory);CHKERRQ(ierr); 2554 2555 ierr = TSAdaptDestroy(&(*ts)->adapt);CHKERRQ(ierr); 2556 ierr = TSEventDestroy(&(*ts)->event);CHKERRQ(ierr); 2557 2558 ierr = SNESDestroy(&(*ts)->snes);CHKERRQ(ierr); 2559 ierr = DMDestroy(&(*ts)->dm);CHKERRQ(ierr); 2560 ierr = TSMonitorCancel((*ts));CHKERRQ(ierr); 2561 ierr = TSAdjointMonitorCancel((*ts));CHKERRQ(ierr); 2562 2563 ierr = PetscHeaderDestroy(ts);CHKERRQ(ierr); 2564 PetscFunctionReturn(0); 2565 } 2566 2567 #undef __FUNCT__ 2568 #define __FUNCT__ "TSGetSNES" 2569 /*@ 2570 TSGetSNES - Returns the SNES (nonlinear solver) associated with 2571 a TS (timestepper) context. Valid only for nonlinear problems. 2572 2573 Not Collective, but SNES is parallel if TS is parallel 2574 2575 Input Parameter: 2576 . ts - the TS context obtained from TSCreate() 2577 2578 Output Parameter: 2579 . snes - the nonlinear solver context 2580 2581 Notes: 2582 The user can then directly manipulate the SNES context to set various 2583 options, etc. Likewise, the user can then extract and manipulate the 2584 KSP, KSP, and PC contexts as well. 2585 2586 TSGetSNES() does not work for integrators that do not use SNES; in 2587 this case TSGetSNES() returns NULL in snes. 2588 2589 Level: beginner 2590 2591 .keywords: timestep, get, SNES 2592 @*/ 2593 PetscErrorCode TSGetSNES(TS ts,SNES *snes) 2594 { 2595 PetscErrorCode ierr; 2596 2597 PetscFunctionBegin; 2598 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2599 PetscValidPointer(snes,2); 2600 if (!ts->snes) { 2601 ierr = SNESCreate(PetscObjectComm((PetscObject)ts),&ts->snes);CHKERRQ(ierr); 2602 ierr = SNESSetFunction(ts->snes,NULL,SNESTSFormFunction,ts);CHKERRQ(ierr); 2603 ierr = PetscLogObjectParent((PetscObject)ts,(PetscObject)ts->snes);CHKERRQ(ierr); 2604 ierr = PetscObjectIncrementTabLevel((PetscObject)ts->snes,(PetscObject)ts,1);CHKERRQ(ierr); 2605 if (ts->dm) {ierr = SNESSetDM(ts->snes,ts->dm);CHKERRQ(ierr);} 2606 if (ts->problem_type == TS_LINEAR) { 2607 ierr = SNESSetType(ts->snes,SNESKSPONLY);CHKERRQ(ierr); 2608 } 2609 } 2610 *snes = ts->snes; 2611 PetscFunctionReturn(0); 2612 } 2613 2614 #undef __FUNCT__ 2615 #define __FUNCT__ "TSSetSNES" 2616 /*@ 2617 TSSetSNES - Set the SNES (nonlinear solver) to be used by the timestepping context 2618 2619 Collective 2620 2621 Input Parameter: 2622 + ts - the TS context obtained from TSCreate() 2623 - snes - the nonlinear solver context 2624 2625 Notes: 2626 Most users should have the TS created by calling TSGetSNES() 2627 2628 Level: developer 2629 2630 .keywords: timestep, set, SNES 2631 @*/ 2632 PetscErrorCode TSSetSNES(TS ts,SNES snes) 2633 { 2634 PetscErrorCode ierr; 2635 PetscErrorCode (*func)(SNES,Vec,Mat,Mat,void*); 2636 2637 PetscFunctionBegin; 2638 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2639 PetscValidHeaderSpecific(snes,SNES_CLASSID,2); 2640 ierr = PetscObjectReference((PetscObject)snes);CHKERRQ(ierr); 2641 ierr = SNESDestroy(&ts->snes);CHKERRQ(ierr); 2642 2643 ts->snes = snes; 2644 2645 ierr = SNESSetFunction(ts->snes,NULL,SNESTSFormFunction,ts);CHKERRQ(ierr); 2646 ierr = SNESGetJacobian(ts->snes,NULL,NULL,&func,NULL);CHKERRQ(ierr); 2647 if (func == SNESTSFormJacobian) { 2648 ierr = SNESSetJacobian(ts->snes,NULL,NULL,SNESTSFormJacobian,ts);CHKERRQ(ierr); 2649 } 2650 PetscFunctionReturn(0); 2651 } 2652 2653 #undef __FUNCT__ 2654 #define __FUNCT__ "TSGetKSP" 2655 /*@ 2656 TSGetKSP - Returns the KSP (linear solver) associated with 2657 a TS (timestepper) context. 2658 2659 Not Collective, but KSP is parallel if TS is parallel 2660 2661 Input Parameter: 2662 . ts - the TS context obtained from TSCreate() 2663 2664 Output Parameter: 2665 . ksp - the nonlinear solver context 2666 2667 Notes: 2668 The user can then directly manipulate the KSP context to set various 2669 options, etc. Likewise, the user can then extract and manipulate the 2670 KSP and PC contexts as well. 2671 2672 TSGetKSP() does not work for integrators that do not use KSP; 2673 in this case TSGetKSP() returns NULL in ksp. 2674 2675 Level: beginner 2676 2677 .keywords: timestep, get, KSP 2678 @*/ 2679 PetscErrorCode TSGetKSP(TS ts,KSP *ksp) 2680 { 2681 PetscErrorCode ierr; 2682 SNES snes; 2683 2684 PetscFunctionBegin; 2685 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2686 PetscValidPointer(ksp,2); 2687 if (!((PetscObject)ts)->type_name) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NULL,"KSP is not created yet. Call TSSetType() first"); 2688 if (ts->problem_type != TS_LINEAR) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Linear only; use TSGetSNES()"); 2689 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 2690 ierr = SNESGetKSP(snes,ksp);CHKERRQ(ierr); 2691 PetscFunctionReturn(0); 2692 } 2693 2694 /* ----------- Routines to set solver parameters ---------- */ 2695 2696 #undef __FUNCT__ 2697 #define __FUNCT__ "TSGetDuration" 2698 /*@ 2699 TSGetDuration - Gets the maximum number of timesteps to use and 2700 maximum time for iteration. 2701 2702 Not Collective 2703 2704 Input Parameters: 2705 + ts - the TS context obtained from TSCreate() 2706 . maxsteps - maximum number of iterations to use, or NULL 2707 - maxtime - final time to iterate to, or NULL 2708 2709 Level: intermediate 2710 2711 .keywords: TS, timestep, get, maximum, iterations, time 2712 @*/ 2713 PetscErrorCode TSGetDuration(TS ts, PetscInt *maxsteps, PetscReal *maxtime) 2714 { 2715 PetscFunctionBegin; 2716 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 2717 if (maxsteps) { 2718 PetscValidIntPointer(maxsteps,2); 2719 *maxsteps = ts->max_steps; 2720 } 2721 if (maxtime) { 2722 PetscValidScalarPointer(maxtime,3); 2723 *maxtime = ts->max_time; 2724 } 2725 PetscFunctionReturn(0); 2726 } 2727 2728 #undef __FUNCT__ 2729 #define __FUNCT__ "TSSetDuration" 2730 /*@ 2731 TSSetDuration - Sets the maximum number of timesteps to use and 2732 maximum time for iteration. 2733 2734 Logically Collective on TS 2735 2736 Input Parameters: 2737 + ts - the TS context obtained from TSCreate() 2738 . maxsteps - maximum number of iterations to use 2739 - maxtime - final time to iterate to 2740 2741 Options Database Keys: 2742 . -ts_max_steps <maxsteps> - Sets maxsteps 2743 . -ts_final_time <maxtime> - Sets maxtime 2744 2745 Notes: 2746 The default maximum number of iterations is 5000. Default time is 5.0 2747 2748 Level: intermediate 2749 2750 .keywords: TS, timestep, set, maximum, iterations 2751 2752 .seealso: TSSetExactFinalTime() 2753 @*/ 2754 PetscErrorCode TSSetDuration(TS ts,PetscInt maxsteps,PetscReal maxtime) 2755 { 2756 PetscFunctionBegin; 2757 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2758 PetscValidLogicalCollectiveInt(ts,maxsteps,2); 2759 PetscValidLogicalCollectiveReal(ts,maxtime,2); 2760 if (maxsteps >= 0) ts->max_steps = maxsteps; 2761 if (maxtime != PETSC_DEFAULT) ts->max_time = maxtime; 2762 PetscFunctionReturn(0); 2763 } 2764 2765 #undef __FUNCT__ 2766 #define __FUNCT__ "TSSetSolution" 2767 /*@ 2768 TSSetSolution - Sets the initial solution vector 2769 for use by the TS routines. 2770 2771 Logically Collective on TS and Vec 2772 2773 Input Parameters: 2774 + ts - the TS context obtained from TSCreate() 2775 - u - the solution vector 2776 2777 Level: beginner 2778 2779 .keywords: TS, timestep, set, solution, initial conditions 2780 @*/ 2781 PetscErrorCode TSSetSolution(TS ts,Vec u) 2782 { 2783 PetscErrorCode ierr; 2784 DM dm; 2785 2786 PetscFunctionBegin; 2787 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2788 PetscValidHeaderSpecific(u,VEC_CLASSID,2); 2789 ierr = PetscObjectReference((PetscObject)u);CHKERRQ(ierr); 2790 ierr = VecDestroy(&ts->vec_sol);CHKERRQ(ierr); 2791 ts->vec_sol = u; 2792 2793 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 2794 ierr = DMShellSetGlobalVector(dm,u);CHKERRQ(ierr); 2795 PetscFunctionReturn(0); 2796 } 2797 2798 #undef __FUNCT__ 2799 #define __FUNCT__ "TSAdjointSetSteps" 2800 /*@ 2801 TSAdjointSetSteps - Sets the number of steps the adjoint solver should take backward in time 2802 2803 Logically Collective on TS 2804 2805 Input Parameters: 2806 + ts - the TS context obtained from TSCreate() 2807 . steps - number of steps to use 2808 2809 Level: intermediate 2810 2811 Notes: Normally one does not call this and TSAdjointSolve() integrates back to the original timestep. One can call this 2812 so as to integrate back to less than the original timestep 2813 2814 .keywords: TS, timestep, set, maximum, iterations 2815 2816 .seealso: TSSetExactFinalTime() 2817 @*/ 2818 PetscErrorCode TSAdjointSetSteps(TS ts,PetscInt steps) 2819 { 2820 PetscFunctionBegin; 2821 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2822 PetscValidLogicalCollectiveInt(ts,steps,2); 2823 if (steps < 0) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_OUTOFRANGE,"Cannot step back a negative number of steps"); 2824 if (steps > ts->total_steps) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_OUTOFRANGE,"Cannot step back more than the total number of forward steps"); 2825 ts->adjoint_max_steps = steps; 2826 PetscFunctionReturn(0); 2827 } 2828 2829 #undef __FUNCT__ 2830 #define __FUNCT__ "TSSetCostGradients" 2831 /*@ 2832 TSSetCostGradients - Sets the initial value of the gradients of the cost function w.r.t. initial conditions and w.r.t. the problem parameters 2833 for use by the TSAdjoint routines. 2834 2835 Logically Collective on TS and Vec 2836 2837 Input Parameters: 2838 + ts - the TS context obtained from TSCreate() 2839 . 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 2840 - mu - gradients with respect to the parameters, the number of entries in these vectors is the same as the number of parameters 2841 2842 Level: beginner 2843 2844 Notes: the entries in these vectors must be correctly initialized with the values lamda_i = df/dy|finaltime mu_i = df/dp|finaltime 2845 2846 .keywords: TS, timestep, set, sensitivity, initial conditions 2847 @*/ 2848 PetscErrorCode TSSetCostGradients(TS ts,PetscInt numcost,Vec *lambda,Vec *mu) 2849 { 2850 PetscFunctionBegin; 2851 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2852 PetscValidPointer(lambda,2); 2853 ts->vecs_sensi = lambda; 2854 ts->vecs_sensip = mu; 2855 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"); 2856 ts->numcost = numcost; 2857 PetscFunctionReturn(0); 2858 } 2859 2860 #undef __FUNCT__ 2861 #define __FUNCT__ "TSAdjointSetRHSJacobian" 2862 /*@C 2863 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. 2864 2865 Logically Collective on TS 2866 2867 Input Parameters: 2868 + ts - The TS context obtained from TSCreate() 2869 - func - The function 2870 2871 Calling sequence of func: 2872 $ func (TS ts,PetscReal t,Vec y,Mat A,void *ctx); 2873 + t - current timestep 2874 . y - input vector (current ODE solution) 2875 . A - output matrix 2876 - ctx - [optional] user-defined function context 2877 2878 Level: intermediate 2879 2880 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 2881 2882 .keywords: TS, sensitivity 2883 .seealso: 2884 @*/ 2885 PetscErrorCode TSAdjointSetRHSJacobian(TS ts,Mat Amat,PetscErrorCode (*func)(TS,PetscReal,Vec,Mat,void*),void *ctx) 2886 { 2887 PetscErrorCode ierr; 2888 2889 PetscFunctionBegin; 2890 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 2891 if (Amat) PetscValidHeaderSpecific(Amat,MAT_CLASSID,2); 2892 2893 ts->rhsjacobianp = func; 2894 ts->rhsjacobianpctx = ctx; 2895 if(Amat) { 2896 ierr = PetscObjectReference((PetscObject)Amat);CHKERRQ(ierr); 2897 ierr = MatDestroy(&ts->Jacp);CHKERRQ(ierr); 2898 ts->Jacp = Amat; 2899 } 2900 PetscFunctionReturn(0); 2901 } 2902 2903 #undef __FUNCT__ 2904 #define __FUNCT__ "TSAdjointComputeRHSJacobian" 2905 /*@C 2906 TSAdjointComputeRHSJacobian - Runs the user-defined Jacobian function. 2907 2908 Collective on TS 2909 2910 Input Parameters: 2911 . ts - The TS context obtained from TSCreate() 2912 2913 Level: developer 2914 2915 .keywords: TS, sensitivity 2916 .seealso: TSAdjointSetRHSJacobian() 2917 @*/ 2918 PetscErrorCode TSAdjointComputeRHSJacobian(TS ts,PetscReal t,Vec X,Mat Amat) 2919 { 2920 PetscErrorCode ierr; 2921 2922 PetscFunctionBegin; 2923 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2924 PetscValidHeaderSpecific(X,VEC_CLASSID,3); 2925 PetscValidPointer(Amat,4); 2926 2927 PetscStackPush("TS user JacobianP function for sensitivity analysis"); 2928 ierr = (*ts->rhsjacobianp)(ts,t,X,Amat,ts->rhsjacobianpctx); CHKERRQ(ierr); 2929 PetscStackPop; 2930 PetscFunctionReturn(0); 2931 } 2932 2933 #undef __FUNCT__ 2934 #define __FUNCT__ "TSSetCostIntegrand" 2935 /*@C 2936 TSSetCostIntegrand - Sets the routine for evaluating the integral term in one or more cost functions 2937 2938 Logically Collective on TS 2939 2940 Input Parameters: 2941 + ts - the TS context obtained from TSCreate() 2942 . numcost - number of gradients to be computed, this is the number of cost functions 2943 . rf - routine for evaluating the integrand function 2944 . drdyf - function that computes the gradients of the r's with respect to y,NULL if not a function y 2945 . drdpf - function that computes the gradients of the r's with respect to p, NULL if not a function of p 2946 . fwd － flag indicating whether to evaluate cost integral in the forward run or the adjoint run 2947 - ctx - [optional] user-defined context for private data for the function evaluation routine (may be NULL) 2948 2949 Calling sequence of rf: 2950 $ rf(TS ts,PetscReal t,Vec y,Vec f[],void *ctx); 2951 2952 + t - current timestep 2953 . y - input vector 2954 . f - function result; one vector entry for each cost function 2955 - ctx - [optional] user-defined function context 2956 2957 Calling sequence of drdyf: 2958 $ PetscErroCode drdyf(TS ts,PetscReal t,Vec y,Vec *drdy,void *ctx); 2959 2960 Calling sequence of drdpf: 2961 $ PetscErroCode drdpf(TS ts,PetscReal t,Vec y,Vec *drdp,void *ctx); 2962 2963 Level: intermediate 2964 2965 Notes: For optimization there is generally a single cost function, numcost = 1. For sensitivities there may be multiple cost functions 2966 2967 .keywords: TS, sensitivity analysis, timestep, set, quadrature, function 2968 2969 .seealso: TSAdjointSetRHSJacobian(),TSGetCostGradients(), TSSetCostGradients() 2970 @*/ 2971 PetscErrorCode TSSetCostIntegrand(TS ts,PetscInt numcost,PetscErrorCode (*rf)(TS,PetscReal,Vec,Vec,void*), 2972 PetscErrorCode (*drdyf)(TS,PetscReal,Vec,Vec*,void*), 2973 PetscErrorCode (*drdpf)(TS,PetscReal,Vec,Vec*,void*), 2974 PetscBool fwd,void *ctx) 2975 { 2976 PetscErrorCode ierr; 2977 2978 PetscFunctionBegin; 2979 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 2980 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()"); 2981 if (!ts->numcost) ts->numcost=numcost; 2982 2983 ts->costintegralfwd = fwd; /* Evaluate the cost integral in forward run if fwd is true */ 2984 ierr = VecCreateSeq(PETSC_COMM_SELF,numcost,&ts->vec_costintegral);CHKERRQ(ierr); 2985 ierr = VecDuplicate(ts->vec_costintegral,&ts->vec_costintegrand);CHKERRQ(ierr); 2986 ts->costintegrand = rf; 2987 ts->costintegrandctx = ctx; 2988 ts->drdyfunction = drdyf; 2989 ts->drdpfunction = drdpf; 2990 PetscFunctionReturn(0); 2991 } 2992 2993 #undef __FUNCT__ 2994 #define __FUNCT__ "TSGetCostIntegral" 2995 /*@ 2996 TSGetCostIntegral - Returns the values of the integral term in the cost functions. 2997 It is valid to call the routine after a backward run. 2998 2999 Not Collective 3000 3001 Input Parameter: 3002 . ts - the TS context obtained from TSCreate() 3003 3004 Output Parameter: 3005 . v - the vector containing the integrals for each cost function 3006 3007 Level: intermediate 3008 3009 .seealso: TSSetCostIntegrand() 3010 3011 .keywords: TS, sensitivity analysis 3012 @*/ 3013 PetscErrorCode TSGetCostIntegral(TS ts,Vec *v) 3014 { 3015 PetscFunctionBegin; 3016 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3017 PetscValidPointer(v,2); 3018 *v = ts->vec_costintegral; 3019 PetscFunctionReturn(0); 3020 } 3021 3022 #undef __FUNCT__ 3023 #define __FUNCT__ "TSAdjointComputeCostIntegrand" 3024 /*@ 3025 TSAdjointComputeCostIntegrand - Evaluates the integral function in the cost functions. 3026 3027 Input Parameters: 3028 + ts - the TS context 3029 . t - current time 3030 - y - state vector, i.e. current solution 3031 3032 Output Parameter: 3033 . q - vector of size numcost to hold the outputs 3034 3035 Note: 3036 Most users should not need to explicitly call this routine, as it 3037 is used internally within the sensitivity analysis context. 3038 3039 Level: developer 3040 3041 .keywords: TS, compute 3042 3043 .seealso: TSSetCostIntegrand() 3044 @*/ 3045 PetscErrorCode TSAdjointComputeCostIntegrand(TS ts,PetscReal t,Vec y,Vec q) 3046 { 3047 PetscErrorCode ierr; 3048 3049 PetscFunctionBegin; 3050 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3051 PetscValidHeaderSpecific(y,VEC_CLASSID,3); 3052 PetscValidHeaderSpecific(q,VEC_CLASSID,4); 3053 3054 ierr = PetscLogEventBegin(TS_FunctionEval,ts,y,q,0);CHKERRQ(ierr); 3055 if (ts->costintegrand) { 3056 PetscStackPush("TS user integrand in the cost function"); 3057 ierr = (*ts->costintegrand)(ts,t,y,q,ts->costintegrandctx);CHKERRQ(ierr); 3058 PetscStackPop; 3059 } else { 3060 ierr = VecZeroEntries(q);CHKERRQ(ierr); 3061 } 3062 3063 ierr = PetscLogEventEnd(TS_FunctionEval,ts,y,q,0);CHKERRQ(ierr); 3064 PetscFunctionReturn(0); 3065 } 3066 3067 #undef __FUNCT__ 3068 #define __FUNCT__ "TSAdjointComputeDRDYFunction" 3069 /*@ 3070 TSAdjointComputeDRDYFunction - Runs the user-defined DRDY function. 3071 3072 Collective on TS 3073 3074 Input Parameters: 3075 . ts - The TS context obtained from TSCreate() 3076 3077 Notes: 3078 TSAdjointComputeDRDYFunction() is typically used for sensitivity implementation, 3079 so most users would not generally call this routine themselves. 3080 3081 Level: developer 3082 3083 .keywords: TS, sensitivity 3084 .seealso: TSAdjointComputeDRDYFunction() 3085 @*/ 3086 PetscErrorCode TSAdjointComputeDRDYFunction(TS ts,PetscReal t,Vec y,Vec *drdy) 3087 { 3088 PetscErrorCode ierr; 3089 3090 PetscFunctionBegin; 3091 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3092 PetscValidHeaderSpecific(y,VEC_CLASSID,3); 3093 3094 PetscStackPush("TS user DRDY function for sensitivity analysis"); 3095 ierr = (*ts->drdyfunction)(ts,t,y,drdy,ts->costintegrandctx); CHKERRQ(ierr); 3096 PetscStackPop; 3097 PetscFunctionReturn(0); 3098 } 3099 3100 #undef __FUNCT__ 3101 #define __FUNCT__ "TSAdjointComputeDRDPFunction" 3102 /*@ 3103 TSAdjointComputeDRDPFunction - Runs the user-defined DRDP function. 3104 3105 Collective on TS 3106 3107 Input Parameters: 3108 . ts - The TS context obtained from TSCreate() 3109 3110 Notes: 3111 TSDRDPFunction() is typically used for sensitivity implementation, 3112 so most users would not generally call this routine themselves. 3113 3114 Level: developer 3115 3116 .keywords: TS, sensitivity 3117 .seealso: TSAdjointSetDRDPFunction() 3118 @*/ 3119 PetscErrorCode TSAdjointComputeDRDPFunction(TS ts,PetscReal t,Vec y,Vec *drdp) 3120 { 3121 PetscErrorCode ierr; 3122 3123 PetscFunctionBegin; 3124 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3125 PetscValidHeaderSpecific(y,VEC_CLASSID,3); 3126 3127 PetscStackPush("TS user DRDP function for sensitivity analysis"); 3128 ierr = (*ts->drdpfunction)(ts,t,y,drdp,ts->costintegrandctx); CHKERRQ(ierr); 3129 PetscStackPop; 3130 PetscFunctionReturn(0); 3131 } 3132 3133 #undef __FUNCT__ 3134 #define __FUNCT__ "TSSetPreStep" 3135 /*@C 3136 TSSetPreStep - Sets the general-purpose function 3137 called once at the beginning of each time step. 3138 3139 Logically Collective on TS 3140 3141 Input Parameters: 3142 + ts - The TS context obtained from TSCreate() 3143 - func - The function 3144 3145 Calling sequence of func: 3146 . func (TS ts); 3147 3148 Level: intermediate 3149 3150 Note: 3151 If a step is rejected, TSStep() will call this routine again before each attempt. 3152 The last completed time step number can be queried using TSGetTimeStepNumber(), the 3153 size of the step being attempted can be obtained using TSGetTimeStep(). 3154 3155 .keywords: TS, timestep 3156 .seealso: TSSetPreStage(), TSSetPostStage(), TSSetPostStep(), TSStep() 3157 @*/ 3158 PetscErrorCode TSSetPreStep(TS ts, PetscErrorCode (*func)(TS)) 3159 { 3160 PetscFunctionBegin; 3161 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 3162 ts->prestep = func; 3163 PetscFunctionReturn(0); 3164 } 3165 3166 #undef __FUNCT__ 3167 #define __FUNCT__ "TSPreStep" 3168 /*@ 3169 TSPreStep - Runs the user-defined pre-step function. 3170 3171 Collective on TS 3172 3173 Input Parameters: 3174 . ts - The TS context obtained from TSCreate() 3175 3176 Notes: 3177 TSPreStep() is typically used within time stepping implementations, 3178 so most users would not generally call this routine themselves. 3179 3180 Level: developer 3181 3182 .keywords: TS, timestep 3183 .seealso: TSSetPreStep(), TSPreStage(), TSPostStage(), TSPostStep() 3184 @*/ 3185 PetscErrorCode TSPreStep(TS ts) 3186 { 3187 PetscErrorCode ierr; 3188 3189 PetscFunctionBegin; 3190 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3191 if (ts->prestep) { 3192 PetscStackCallStandard((*ts->prestep),(ts)); 3193 } 3194 PetscFunctionReturn(0); 3195 } 3196 3197 #undef __FUNCT__ 3198 #define __FUNCT__ "TSSetPreStage" 3199 /*@C 3200 TSSetPreStage - Sets the general-purpose function 3201 called once at the beginning of each stage. 3202 3203 Logically Collective on TS 3204 3205 Input Parameters: 3206 + ts - The TS context obtained from TSCreate() 3207 - func - The function 3208 3209 Calling sequence of func: 3210 . PetscErrorCode func(TS ts, PetscReal stagetime); 3211 3212 Level: intermediate 3213 3214 Note: 3215 There may be several stages per time step. If the solve for a given stage fails, the step may be rejected and retried. 3216 The time step number being computed can be queried using TSGetTimeStepNumber() and the total size of the step being 3217 attempted can be obtained using TSGetTimeStep(). The time at the start of the step is available via TSGetTime(). 3218 3219 .keywords: TS, timestep 3220 .seealso: TSSetPostStage(), TSSetPreStep(), TSSetPostStep(), TSGetApplicationContext() 3221 @*/ 3222 PetscErrorCode TSSetPreStage(TS ts, PetscErrorCode (*func)(TS,PetscReal)) 3223 { 3224 PetscFunctionBegin; 3225 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 3226 ts->prestage = func; 3227 PetscFunctionReturn(0); 3228 } 3229 3230 #undef __FUNCT__ 3231 #define __FUNCT__ "TSSetPostStage" 3232 /*@C 3233 TSSetPostStage - Sets the general-purpose function 3234 called once at the end of each stage. 3235 3236 Logically Collective on TS 3237 3238 Input Parameters: 3239 + ts - The TS context obtained from TSCreate() 3240 - func - The function 3241 3242 Calling sequence of func: 3243 . PetscErrorCode func(TS ts, PetscReal stagetime, PetscInt stageindex, Vec* Y); 3244 3245 Level: intermediate 3246 3247 Note: 3248 There may be several stages per time step. If the solve for a given stage fails, the step may be rejected and retried. 3249 The time step number being computed can be queried using TSGetTimeStepNumber() and the total size of the step being 3250 attempted can be obtained using TSGetTimeStep(). The time at the start of the step is available via TSGetTime(). 3251 3252 .keywords: TS, timestep 3253 .seealso: TSSetPreStage(), TSSetPreStep(), TSSetPostStep(), TSGetApplicationContext() 3254 @*/ 3255 PetscErrorCode TSSetPostStage(TS ts, PetscErrorCode (*func)(TS,PetscReal,PetscInt,Vec*)) 3256 { 3257 PetscFunctionBegin; 3258 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 3259 ts->poststage = func; 3260 PetscFunctionReturn(0); 3261 } 3262 3263 #undef __FUNCT__ 3264 #define __FUNCT__ "TSPreStage" 3265 /*@ 3266 TSPreStage - Runs the user-defined pre-stage function set using TSSetPreStage() 3267 3268 Collective on TS 3269 3270 Input Parameters: 3271 . ts - The TS context obtained from TSCreate() 3272 stagetime - The absolute time of the current stage 3273 3274 Notes: 3275 TSPreStage() is typically used within time stepping implementations, 3276 most users would not generally call this routine themselves. 3277 3278 Level: developer 3279 3280 .keywords: TS, timestep 3281 .seealso: TSPostStage(), TSSetPreStep(), TSPreStep(), TSPostStep() 3282 @*/ 3283 PetscErrorCode TSPreStage(TS ts, PetscReal stagetime) 3284 { 3285 PetscErrorCode ierr; 3286 3287 PetscFunctionBegin; 3288 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3289 if (ts->prestage) { 3290 PetscStackCallStandard((*ts->prestage),(ts,stagetime)); 3291 } 3292 PetscFunctionReturn(0); 3293 } 3294 3295 #undef __FUNCT__ 3296 #define __FUNCT__ "TSPostStage" 3297 /*@ 3298 TSPostStage - Runs the user-defined post-stage function set using TSSetPostStage() 3299 3300 Collective on TS 3301 3302 Input Parameters: 3303 . ts - The TS context obtained from TSCreate() 3304 stagetime - The absolute time of the current stage 3305 stageindex - Stage number 3306 Y - Array of vectors (of size = total number 3307 of stages) with the stage solutions 3308 3309 Notes: 3310 TSPostStage() is typically used within time stepping implementations, 3311 most users would not generally call this routine themselves. 3312 3313 Level: developer 3314 3315 .keywords: TS, timestep 3316 .seealso: TSPreStage(), TSSetPreStep(), TSPreStep(), TSPostStep() 3317 @*/ 3318 PetscErrorCode TSPostStage(TS ts, PetscReal stagetime, PetscInt stageindex, Vec *Y) 3319 { 3320 PetscErrorCode ierr; 3321 3322 PetscFunctionBegin; 3323 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3324 if (ts->poststage) { 3325 PetscStackCallStandard((*ts->poststage),(ts,stagetime,stageindex,Y)); 3326 } 3327 PetscFunctionReturn(0); 3328 } 3329 3330 #undef __FUNCT__ 3331 #define __FUNCT__ "TSSetPostStep" 3332 /*@C 3333 TSSetPostStep - Sets the general-purpose function 3334 called once at the end of each time step. 3335 3336 Logically Collective on TS 3337 3338 Input Parameters: 3339 + ts - The TS context obtained from TSCreate() 3340 - func - The function 3341 3342 Calling sequence of func: 3343 $ func (TS ts); 3344 3345 Level: intermediate 3346 3347 .keywords: TS, timestep 3348 .seealso: TSSetPreStep(), TSSetPreStage(), TSGetTimeStep(), TSGetTimeStepNumber(), TSGetTime() 3349 @*/ 3350 PetscErrorCode TSSetPostStep(TS ts, PetscErrorCode (*func)(TS)) 3351 { 3352 PetscFunctionBegin; 3353 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 3354 ts->poststep = func; 3355 PetscFunctionReturn(0); 3356 } 3357 3358 #undef __FUNCT__ 3359 #define __FUNCT__ "TSPostStep" 3360 /*@ 3361 TSPostStep - Runs the user-defined post-step function. 3362 3363 Collective on TS 3364 3365 Input Parameters: 3366 . ts - The TS context obtained from TSCreate() 3367 3368 Notes: 3369 TSPostStep() is typically used within time stepping implementations, 3370 so most users would not generally call this routine themselves. 3371 3372 Level: developer 3373 3374 .keywords: TS, timestep 3375 @*/ 3376 PetscErrorCode TSPostStep(TS ts) 3377 { 3378 PetscErrorCode ierr; 3379 3380 PetscFunctionBegin; 3381 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3382 if (ts->poststep) { 3383 PetscStackCallStandard((*ts->poststep),(ts)); 3384 } 3385 PetscFunctionReturn(0); 3386 } 3387 3388 /* ------------ Routines to set performance monitoring options ----------- */ 3389 3390 #undef __FUNCT__ 3391 #define __FUNCT__ "TSMonitorSet" 3392 /*@C 3393 TSMonitorSet - Sets an ADDITIONAL function that is to be used at every 3394 timestep to display the iteration's progress. 3395 3396 Logically Collective on TS 3397 3398 Input Parameters: 3399 + ts - the TS context obtained from TSCreate() 3400 . monitor - monitoring routine 3401 . mctx - [optional] user-defined context for private data for the 3402 monitor routine (use NULL if no context is desired) 3403 - monitordestroy - [optional] routine that frees monitor context 3404 (may be NULL) 3405 3406 Calling sequence of monitor: 3407 $ int monitor(TS ts,PetscInt steps,PetscReal time,Vec u,void *mctx) 3408 3409 + ts - the TS context 3410 . 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) 3411 . time - current time 3412 . u - current iterate 3413 - mctx - [optional] monitoring context 3414 3415 Notes: 3416 This routine adds an additional monitor to the list of monitors that 3417 already has been loaded. 3418 3419 Fortran notes: Only a single monitor function can be set for each TS object 3420 3421 Level: intermediate 3422 3423 .keywords: TS, timestep, set, monitor 3424 3425 .seealso: TSMonitorDefault(), TSMonitorCancel() 3426 @*/ 3427 PetscErrorCode TSMonitorSet(TS ts,PetscErrorCode (*monitor)(TS,PetscInt,PetscReal,Vec,void*),void *mctx,PetscErrorCode (*mdestroy)(void**)) 3428 { 3429 PetscErrorCode ierr; 3430 PetscInt i; 3431 PetscBool identical; 3432 3433 PetscFunctionBegin; 3434 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3435 for (i=0; i<ts->numbermonitors;i++) { 3436 ierr = PetscMonitorCompare((PetscErrorCode (*)(void))monitor,mctx,mdestroy,(PetscErrorCode (*)(void))ts->monitor[i],ts->monitorcontext[i],ts->monitordestroy[i],&identical);CHKERRQ(ierr); 3437 if (identical) PetscFunctionReturn(0); 3438 } 3439 if (ts->numbermonitors >= MAXTSMONITORS) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Too many monitors set"); 3440 ts->monitor[ts->numbermonitors] = monitor; 3441 ts->monitordestroy[ts->numbermonitors] = mdestroy; 3442 ts->monitorcontext[ts->numbermonitors++] = (void*)mctx; 3443 PetscFunctionReturn(0); 3444 } 3445 3446 #undef __FUNCT__ 3447 #define __FUNCT__ "TSMonitorCancel" 3448 /*@C 3449 TSMonitorCancel - Clears all the monitors that have been set on a time-step object. 3450 3451 Logically Collective on TS 3452 3453 Input Parameters: 3454 . ts - the TS context obtained from TSCreate() 3455 3456 Notes: 3457 There is no way to remove a single, specific monitor. 3458 3459 Level: intermediate 3460 3461 .keywords: TS, timestep, set, monitor 3462 3463 .seealso: TSMonitorDefault(), TSMonitorSet() 3464 @*/ 3465 PetscErrorCode TSMonitorCancel(TS ts) 3466 { 3467 PetscErrorCode ierr; 3468 PetscInt i; 3469 3470 PetscFunctionBegin; 3471 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3472 for (i=0; i<ts->numbermonitors; i++) { 3473 if (ts->monitordestroy[i]) { 3474 ierr = (*ts->monitordestroy[i])(&ts->monitorcontext[i]);CHKERRQ(ierr); 3475 } 3476 } 3477 ts->numbermonitors = 0; 3478 PetscFunctionReturn(0); 3479 } 3480 3481 #undef __FUNCT__ 3482 #define __FUNCT__ "TSMonitorDefault" 3483 /*@C 3484 TSMonitorDefault - The Default monitor, prints the timestep and time for each step 3485 3486 Level: intermediate 3487 3488 .keywords: TS, set, monitor 3489 3490 .seealso: TSMonitorSet() 3491 @*/ 3492 PetscErrorCode TSMonitorDefault(TS ts,PetscInt step,PetscReal ptime,Vec v,PetscViewerAndFormat *vf) 3493 { 3494 PetscErrorCode ierr; 3495 PetscViewer viewer = vf->viewer; 3496 PetscBool iascii,ibinary; 3497 3498 PetscFunctionBegin; 3499 PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,4); 3500 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr); 3501 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERBINARY,&ibinary);CHKERRQ(ierr); 3502 ierr = PetscViewerPushFormat(viewer,vf->format);CHKERRQ(ierr); 3503 if (iascii) { 3504 ierr = PetscViewerASCIIAddTab(viewer,((PetscObject)ts)->tablevel);CHKERRQ(ierr); 3505 if (step == -1){ /* this indicates it is an interpolated solution */ 3506 ierr = PetscViewerASCIIPrintf(viewer,"Interpolated solution at time %g between steps %D and %D\n",(double)ptime,ts->steps-1,ts->steps);CHKERRQ(ierr); 3507 } else { 3508 ierr = PetscViewerASCIIPrintf(viewer,"%D TS dt %g time %g%s",step,(double)ts->time_step,(double)ptime,ts->steprollback ? " (r)\n" : "\n");CHKERRQ(ierr); 3509 } 3510 ierr = PetscViewerASCIISubtractTab(viewer,((PetscObject)ts)->tablevel);CHKERRQ(ierr); 3511 } else if (ibinary) { 3512 PetscMPIInt rank; 3513 ierr = MPI_Comm_rank(PetscObjectComm((PetscObject)viewer),&rank);CHKERRQ(ierr); 3514 if (!rank) { 3515 PetscBool skipHeader; 3516 PetscInt classid = REAL_FILE_CLASSID; 3517 3518 ierr = PetscViewerBinaryGetSkipHeader(viewer,&skipHeader);CHKERRQ(ierr); 3519 if (!skipHeader) { 3520 ierr = PetscViewerBinaryWrite(viewer,&classid,1,PETSC_INT,PETSC_FALSE);CHKERRQ(ierr); 3521 } 3522 ierr = PetscRealView(1,&ptime,viewer);CHKERRQ(ierr); 3523 } else { 3524 ierr = PetscRealView(0,&ptime,viewer);CHKERRQ(ierr); 3525 } 3526 } 3527 ierr = PetscViewerPopFormat(viewer);CHKERRQ(ierr); 3528 PetscFunctionReturn(0); 3529 } 3530 3531 #undef __FUNCT__ 3532 #define __FUNCT__ "TSAdjointMonitorSet" 3533 /*@C 3534 TSAdjointMonitorSet - Sets an ADDITIONAL function that is to be used at every 3535 timestep to display the iteration's progress. 3536 3537 Logically Collective on TS 3538 3539 Input Parameters: 3540 + ts - the TS context obtained from TSCreate() 3541 . adjointmonitor - monitoring routine 3542 . adjointmctx - [optional] user-defined context for private data for the 3543 monitor routine (use NULL if no context is desired) 3544 - adjointmonitordestroy - [optional] routine that frees monitor context 3545 (may be NULL) 3546 3547 Calling sequence of monitor: 3548 $ int adjointmonitor(TS ts,PetscInt steps,PetscReal time,Vec u,PetscInt numcost,Vec *lambda, Vec *mu,void *adjointmctx) 3549 3550 + ts - the TS context 3551 . 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 3552 been interpolated to) 3553 . time - current time 3554 . u - current iterate 3555 . numcost - number of cost functionos 3556 . lambda - sensitivities to initial conditions 3557 . mu - sensitivities to parameters 3558 - adjointmctx - [optional] adjoint monitoring context 3559 3560 Notes: 3561 This routine adds an additional monitor to the list of monitors that 3562 already has been loaded. 3563 3564 Fortran notes: Only a single monitor function can be set for each TS object 3565 3566 Level: intermediate 3567 3568 .keywords: TS, timestep, set, adjoint, monitor 3569 3570 .seealso: TSAdjointMonitorCancel() 3571 @*/ 3572 PetscErrorCode TSAdjointMonitorSet(TS ts,PetscErrorCode (*adjointmonitor)(TS,PetscInt,PetscReal,Vec,PetscInt,Vec*,Vec*,void*),void *adjointmctx,PetscErrorCode (*adjointmdestroy)(void**)) 3573 { 3574 PetscErrorCode ierr; 3575 PetscInt i; 3576 PetscBool identical; 3577 3578 PetscFunctionBegin; 3579 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3580 for (i=0; i<ts->numbermonitors;i++) { 3581 ierr = PetscMonitorCompare((PetscErrorCode (*)(void))adjointmonitor,adjointmctx,adjointmdestroy,(PetscErrorCode (*)(void))ts->adjointmonitor[i],ts->adjointmonitorcontext[i],ts->adjointmonitordestroy[i],&identical);CHKERRQ(ierr); 3582 if (identical) PetscFunctionReturn(0); 3583 } 3584 if (ts->numberadjointmonitors >= MAXTSMONITORS) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Too many adjoint monitors set"); 3585 ts->adjointmonitor[ts->numberadjointmonitors] = adjointmonitor; 3586 ts->adjointmonitordestroy[ts->numberadjointmonitors] = adjointmdestroy; 3587 ts->adjointmonitorcontext[ts->numberadjointmonitors++] = (void*)adjointmctx; 3588 PetscFunctionReturn(0); 3589 } 3590 3591 #undef __FUNCT__ 3592 #define __FUNCT__ "TSAdjointMonitorCancel" 3593 /*@C 3594 TSAdjointMonitorCancel - Clears all the adjoint monitors that have been set on a time-step object. 3595 3596 Logically Collective on TS 3597 3598 Input Parameters: 3599 . ts - the TS context obtained from TSCreate() 3600 3601 Notes: 3602 There is no way to remove a single, specific monitor. 3603 3604 Level: intermediate 3605 3606 .keywords: TS, timestep, set, adjoint, monitor 3607 3608 .seealso: TSAdjointMonitorSet() 3609 @*/ 3610 PetscErrorCode TSAdjointMonitorCancel(TS ts) 3611 { 3612 PetscErrorCode ierr; 3613 PetscInt i; 3614 3615 PetscFunctionBegin; 3616 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3617 for (i=0; i<ts->numberadjointmonitors; i++) { 3618 if (ts->adjointmonitordestroy[i]) { 3619 ierr = (*ts->adjointmonitordestroy[i])(&ts->adjointmonitorcontext[i]);CHKERRQ(ierr); 3620 } 3621 } 3622 ts->numberadjointmonitors = 0; 3623 PetscFunctionReturn(0); 3624 } 3625 3626 #undef __FUNCT__ 3627 #define __FUNCT__ "TSAdjointMonitorDefault" 3628 /*@C 3629 TSAdjointMonitorDefault - the default monitor of adjoint computations 3630 3631 Level: intermediate 3632 3633 .keywords: TS, set, monitor 3634 3635 .seealso: TSAdjointMonitorSet() 3636 @*/ 3637 PetscErrorCode TSAdjointMonitorDefault(TS ts,PetscInt step,PetscReal ptime,Vec v,PetscInt numcost,Vec *lambda,Vec *mu,PetscViewerAndFormat *vf) 3638 { 3639 PetscErrorCode ierr; 3640 PetscViewer viewer = vf->viewer; 3641 3642 PetscFunctionBegin; 3643 PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,4); 3644 ierr = PetscViewerPushFormat(viewer,vf->format);CHKERRQ(ierr); 3645 ierr = PetscViewerASCIIAddTab(viewer,((PetscObject)ts)->tablevel);CHKERRQ(ierr); 3646 ierr = PetscViewerASCIIPrintf(viewer,"%D TS dt %g time %g%s",step,(double)ts->time_step,(double)ptime,ts->steprollback ? " (r)\n" : "\n");CHKERRQ(ierr); 3647 ierr = PetscViewerASCIISubtractTab(viewer,((PetscObject)ts)->tablevel);CHKERRQ(ierr); 3648 ierr = PetscViewerPopFormat(viewer);CHKERRQ(ierr); 3649 PetscFunctionReturn(0); 3650 } 3651 3652 #undef __FUNCT__ 3653 #define __FUNCT__ "TSInterpolate" 3654 /*@ 3655 TSInterpolate - Interpolate the solution computed during the previous step to an arbitrary location in the interval 3656 3657 Collective on TS 3658 3659 Input Argument: 3660 + ts - time stepping context 3661 - t - time to interpolate to 3662 3663 Output Argument: 3664 . U - state at given time 3665 3666 Level: intermediate 3667 3668 Developer Notes: 3669 TSInterpolate() and the storing of previous steps/stages should be generalized to support delay differential equations and continuous adjoints. 3670 3671 .keywords: TS, set 3672 3673 .seealso: TSSetExactFinalTime(), TSSolve() 3674 @*/ 3675 PetscErrorCode TSInterpolate(TS ts,PetscReal t,Vec U) 3676 { 3677 PetscErrorCode ierr; 3678 3679 PetscFunctionBegin; 3680 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3681 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 3682 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); 3683 if (!ts->ops->interpolate) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"%s does not provide interpolation",((PetscObject)ts)->type_name); 3684 ierr = (*ts->ops->interpolate)(ts,t,U);CHKERRQ(ierr); 3685 PetscFunctionReturn(0); 3686 } 3687 3688 #undef __FUNCT__ 3689 #define __FUNCT__ "TSStep" 3690 /*@ 3691 TSStep - Steps one time step 3692 3693 Collective on TS 3694 3695 Input Parameter: 3696 . ts - the TS context obtained from TSCreate() 3697 3698 Level: developer 3699 3700 Notes: 3701 The public interface for the ODE/DAE solvers is TSSolve(), you should almost for sure be using that routine and not this routine. 3702 3703 The hook set using TSSetPreStep() is called before each attempt to take the step. In general, the time step size may 3704 be changed due to adaptive error controller or solve failures. Note that steps may contain multiple stages. 3705 3706 This may over-step the final time provided in TSSetDuration() depending on the time-step used. TSSolve() interpolates to exactly the 3707 time provided in TSSetDuration(). One can use TSInterpolate() to determine an interpolated solution within the final timestep. 3708 3709 .keywords: TS, timestep, solve 3710 3711 .seealso: TSCreate(), TSSetUp(), TSDestroy(), TSSolve(), TSSetPreStep(), TSSetPreStage(), TSSetPostStage(), TSInterpolate() 3712 @*/ 3713 PetscErrorCode TSStep(TS ts) 3714 { 3715 PetscErrorCode ierr; 3716 static PetscBool cite = PETSC_FALSE; 3717 PetscReal ptime; 3718 3719 PetscFunctionBegin; 3720 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3721 ierr = PetscCitationsRegister("@techreport{tspaper,\n" 3722 " title = {{PETSc/TS}: A Modern Scalable {DAE/ODE} Solver Library},\n" 3723 " author = {Shrirang Abhyankar and Jed Brown and Emil Constantinescu and Debojyoti Ghosh and Barry F. Smith},\n" 3724 " type = {Preprint},\n" 3725 " number = {ANL/MCS-P5061-0114},\n" 3726 " institution = {Argonne National Laboratory},\n" 3727 " year = {2014}\n}\n",&cite);CHKERRQ(ierr); 3728 3729 ierr = TSSetUp(ts);CHKERRQ(ierr); 3730 ierr = TSTrajectorySetUp(ts->trajectory,ts);CHKERRQ(ierr); 3731 3732 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()"); 3733 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"); 3734 3735 if (!ts->steps) ts->ptime_prev = ts->ptime; 3736 ts->reason = TS_CONVERGED_ITERATING; 3737 ptime = ts->ptime; ts->ptime_prev_rollback = ts->ptime_prev; 3738 if (!ts->ops->step) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"TSStep not implemented for type '%s'",((PetscObject)ts)->type_name); 3739 ierr = PetscLogEventBegin(TS_Step,ts,0,0,0);CHKERRQ(ierr); 3740 ierr = (*ts->ops->step)(ts);CHKERRQ(ierr); 3741 ierr = PetscLogEventEnd(TS_Step,ts,0,0,0);CHKERRQ(ierr); 3742 ts->ptime_prev = ptime; 3743 ts->steps++; ts->total_steps++; 3744 ts->steprollback = PETSC_FALSE; 3745 ts->steprestart = PETSC_FALSE; 3746 3747 if (ts->reason < 0) { 3748 if (ts->errorifstepfailed) { 3749 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]); 3750 else SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_NOT_CONVERGED,"TSStep has failed due to %s",TSConvergedReasons[ts->reason]); 3751 } 3752 } else if (!ts->reason) { 3753 if (ts->steps >= ts->max_steps) ts->reason = TS_CONVERGED_ITS; 3754 else if (ts->ptime >= ts->max_time) ts->reason = TS_CONVERGED_TIME; 3755 } 3756 PetscFunctionReturn(0); 3757 } 3758 3759 #undef __FUNCT__ 3760 #define __FUNCT__ "TSAdjointStep" 3761 /*@ 3762 TSAdjointStep - Steps one time step backward in the adjoint run 3763 3764 Collective on TS 3765 3766 Input Parameter: 3767 . ts - the TS context obtained from TSCreate() 3768 3769 Level: intermediate 3770 3771 .keywords: TS, adjoint, step 3772 3773 .seealso: TSAdjointSetUp(), TSAdjointSolve() 3774 @*/ 3775 PetscErrorCode TSAdjointStep(TS ts) 3776 { 3777 DM dm; 3778 PetscErrorCode ierr; 3779 3780 PetscFunctionBegin; 3781 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3782 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 3783 ierr = TSAdjointSetUp(ts);CHKERRQ(ierr); 3784 3785 ierr = VecViewFromOptions(ts->vec_sol,(PetscObject)ts,"-ts_view_solution");CHKERRQ(ierr); 3786 3787 ts->reason = TS_CONVERGED_ITERATING; 3788 ts->ptime_prev = ts->ptime; 3789 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); 3790 ierr = PetscLogEventBegin(TS_AdjointStep,ts,0,0,0);CHKERRQ(ierr); 3791 ierr = (*ts->ops->adjointstep)(ts);CHKERRQ(ierr); 3792 ierr = PetscLogEventEnd(TS_AdjointStep,ts,0,0,0);CHKERRQ(ierr); 3793 ts->steps++; ts->total_steps--; 3794 3795 if (ts->reason < 0) { 3796 if (ts->errorifstepfailed) { 3797 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]); 3798 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]); 3799 else SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_NOT_CONVERGED,"TSStep has failed due to %s",TSConvergedReasons[ts->reason]); 3800 } 3801 } else if (!ts->reason) { 3802 if (ts->steps >= ts->adjoint_max_steps) ts->reason = TS_CONVERGED_ITS; 3803 } 3804 PetscFunctionReturn(0); 3805 } 3806 3807 #undef __FUNCT__ 3808 #define __FUNCT__ "TSEvaluateWLTE" 3809 /*@ 3810 TSEvaluateWLTE - Evaluate the weighted local truncation error norm 3811 at the end of a time step with a given order of accuracy. 3812 3813 Collective on TS 3814 3815 Input Arguments: 3816 + ts - time stepping context 3817 . wnormtype - norm type, either NORM_2 or NORM_INFINITY 3818 - order - optional, desired order for the error evaluation or PETSC_DECIDE 3819 3820 Output Arguments: 3821 + order - optional, the actual order of the error evaluation 3822 - wlte - the weighted local truncation error norm 3823 3824 Level: advanced 3825 3826 Notes: 3827 If the timestepper cannot evaluate the error in a particular step 3828 (eg. in the first step or restart steps after event handling), 3829 this routine returns wlte=-1.0 . 3830 3831 .seealso: TSStep(), TSAdapt, TSErrorWeightedNorm() 3832 @*/ 3833 PetscErrorCode TSEvaluateWLTE(TS ts,NormType wnormtype,PetscInt *order,PetscReal *wlte) 3834 { 3835 PetscErrorCode ierr; 3836 3837 PetscFunctionBegin; 3838 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3839 PetscValidType(ts,1); 3840 PetscValidLogicalCollectiveEnum(ts,wnormtype,4); 3841 if (order) PetscValidIntPointer(order,3); 3842 if (order) PetscValidLogicalCollectiveInt(ts,*order,3); 3843 PetscValidRealPointer(wlte,4); 3844 if (wnormtype != NORM_2 && wnormtype != NORM_INFINITY) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"No support for norm type %s",NormTypes[wnormtype]); 3845 if (!ts->ops->evaluatewlte) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"TSEvaluateWLTE not implemented for type '%s'",((PetscObject)ts)->type_name); 3846 ierr = (*ts->ops->evaluatewlte)(ts,wnormtype,order,wlte);CHKERRQ(ierr); 3847 PetscFunctionReturn(0); 3848 } 3849 3850 #undef __FUNCT__ 3851 #define __FUNCT__ "TSEvaluateStep" 3852 /*@ 3853 TSEvaluateStep - Evaluate the solution at the end of a time step with a given order of accuracy. 3854 3855 Collective on TS 3856 3857 Input Arguments: 3858 + ts - time stepping context 3859 . order - desired order of accuracy 3860 - done - whether the step was evaluated at this order (pass NULL to generate an error if not available) 3861 3862 Output Arguments: 3863 . U - state at the end of the current step 3864 3865 Level: advanced 3866 3867 Notes: 3868 This function cannot be called until all stages have been evaluated. 3869 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. 3870 3871 .seealso: TSStep(), TSAdapt 3872 @*/ 3873 PetscErrorCode TSEvaluateStep(TS ts,PetscInt order,Vec U,PetscBool *done) 3874 { 3875 PetscErrorCode ierr; 3876 3877 PetscFunctionBegin; 3878 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3879 PetscValidType(ts,1); 3880 PetscValidHeaderSpecific(U,VEC_CLASSID,3); 3881 if (!ts->ops->evaluatestep) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"TSEvaluateStep not implemented for type '%s'",((PetscObject)ts)->type_name); 3882 ierr = (*ts->ops->evaluatestep)(ts,order,U,done);CHKERRQ(ierr); 3883 PetscFunctionReturn(0); 3884 } 3885 3886 #undef __FUNCT__ 3887 #define __FUNCT__ "TSForwardCostIntegral" 3888 /*@ 3889 TSForwardCostIntegral - Evaluate the cost integral in the forward run. 3890 3891 Collective on TS 3892 3893 Input Arguments: 3894 . ts - time stepping context 3895 3896 Level: advanced 3897 3898 Notes: 3899 This function cannot be called until TSStep() has been completed. 3900 3901 .seealso: TSSolve(), TSAdjointCostIntegral() 3902 @*/ 3903 PetscErrorCode TSForwardCostIntegral(TS ts) 3904 { 3905 PetscErrorCode ierr; 3906 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3907 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); 3908 ierr = (*ts->ops->forwardintegral)(ts);CHKERRQ(ierr); 3909 PetscFunctionReturn(0); 3910 } 3911 3912 #undef __FUNCT__ 3913 #define __FUNCT__ "TSSolve" 3914 /*@ 3915 TSSolve - Steps the requested number of timesteps. 3916 3917 Collective on TS 3918 3919 Input Parameter: 3920 + ts - the TS context obtained from TSCreate() 3921 - u - the solution vector (can be null if TSSetSolution() was used and TSSetExactFinalTime(ts,TS_EXACTFINALTIME_MATCHSTEP) was not used, 3922 otherwise must contain the initial conditions and will contain the solution at the final requested time 3923 3924 Level: beginner 3925 3926 Notes: 3927 The final time returned by this function may be different from the time of the internally 3928 held state accessible by TSGetSolution() and TSGetTime() because the method may have 3929 stepped over the final time. 3930 3931 .keywords: TS, timestep, solve 3932 3933 .seealso: TSCreate(), TSSetSolution(), TSStep(), TSGetTime(), TSGetSolveTime() 3934 @*/ 3935 PetscErrorCode TSSolve(TS ts,Vec u) 3936 { 3937 Vec solution; 3938 PetscErrorCode ierr; 3939 3940 PetscFunctionBegin; 3941 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 3942 if (u) PetscValidHeaderSpecific(u,VEC_CLASSID,2); 3943 3944 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 */ 3945 PetscValidHeaderSpecific(u,VEC_CLASSID,2); 3946 if (!ts->vec_sol || u == ts->vec_sol) { 3947 ierr = VecDuplicate(u,&solution);CHKERRQ(ierr); 3948 ierr = TSSetSolution(ts,solution);CHKERRQ(ierr); 3949 ierr = VecDestroy(&solution);CHKERRQ(ierr); /* grant ownership */ 3950 } 3951 ierr = VecCopy(u,ts->vec_sol);CHKERRQ(ierr); 3952 } else if (u) { 3953 ierr = TSSetSolution(ts,u);CHKERRQ(ierr); 3954 } 3955 ierr = TSSetUp(ts);CHKERRQ(ierr); 3956 ierr = TSTrajectorySetUp(ts->trajectory,ts);CHKERRQ(ierr); 3957 3958 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()"); 3959 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"); 3960 3961 /* reset time step and iteration counters */ 3962 ts->steps = 0; 3963 ts->ksp_its = 0; 3964 ts->snes_its = 0; 3965 ts->num_snes_failures = 0; 3966 ts->reject = 0; 3967 ts->reason = TS_CONVERGED_ITERATING; 3968 3969 ierr = TSViewFromOptions(ts,NULL,"-ts_view_pre");CHKERRQ(ierr); 3970 3971 if (ts->ops->solve) { /* This private interface is transitional and should be removed when all implementations are updated. */ 3972 ierr = (*ts->ops->solve)(ts);CHKERRQ(ierr); 3973 if (u) {ierr = VecCopy(ts->vec_sol,u);CHKERRQ(ierr);} 3974 ts->solvetime = ts->ptime; 3975 solution = ts->vec_sol; 3976 } else { /* Step the requested number of timesteps. */ 3977 if (ts->steps >= ts->max_steps) ts->reason = TS_CONVERGED_ITS; 3978 else if (ts->ptime >= ts->max_time) ts->reason = TS_CONVERGED_TIME; 3979 ierr = TSTrajectorySet(ts->trajectory,ts,ts->steps,ts->ptime,ts->vec_sol);CHKERRQ(ierr); 3980 ierr = TSEventInitialize(ts->event,ts,ts->ptime,ts->vec_sol);CHKERRQ(ierr); 3981 ts->steprollback = PETSC_FALSE; 3982 ts->steprestart = PETSC_TRUE; 3983 3984 while (!ts->reason) { 3985 ierr = TSMonitor(ts,ts->steps,ts->ptime,ts->vec_sol);CHKERRQ(ierr); 3986 if (!ts->steprollback) { 3987 ierr = TSPreStep(ts);CHKERRQ(ierr); 3988 } 3989 ierr = TSStep(ts);CHKERRQ(ierr); 3990 if (ts->vec_costintegral && ts->costintegralfwd) { /* Must evaluate the cost integral before event is handled. The cost integral value can also be rolled back. */ 3991 ierr = TSForwardCostIntegral(ts);CHKERRQ(ierr); 3992 } 3993 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. */ 3994 if (!ts->steprollback) { 3995 ierr = TSTrajectorySet(ts->trajectory,ts,ts->steps,ts->ptime,ts->vec_sol);CHKERRQ(ierr); 3996 ierr = TSPostStep(ts);CHKERRQ(ierr); 3997 } 3998 } 3999 ierr = TSMonitor(ts,ts->steps,ts->ptime,ts->vec_sol);CHKERRQ(ierr); 4000 4001 if (ts->exact_final_time == TS_EXACTFINALTIME_INTERPOLATE && ts->ptime > ts->max_time) { 4002 ierr = TSInterpolate(ts,ts->max_time,u);CHKERRQ(ierr); 4003 ts->solvetime = ts->max_time; 4004 solution = u; 4005 ierr = TSMonitor(ts,-1,ts->solvetime,solution);CHKERRQ(ierr); 4006 } else { 4007 if (u) {ierr = VecCopy(ts->vec_sol,u);CHKERRQ(ierr);} 4008 ts->solvetime = ts->ptime; 4009 solution = ts->vec_sol; 4010 } 4011 } 4012 4013 ierr = TSViewFromOptions(ts,NULL,"-ts_view");CHKERRQ(ierr); 4014 ierr = VecViewFromOptions(solution,NULL,"-ts_view_solution");CHKERRQ(ierr); 4015 ierr = PetscObjectSAWsBlock((PetscObject)ts);CHKERRQ(ierr); 4016 if (ts->adjoint_solve) { 4017 ierr = TSAdjointSolve(ts);CHKERRQ(ierr); 4018 } 4019 PetscFunctionReturn(0); 4020 } 4021 4022 #undef __FUNCT__ 4023 #define __FUNCT__ "TSAdjointCostIntegral" 4024 /*@ 4025 TSAdjointCostIntegral - Evaluate the cost integral in the adjoint run. 4026 4027 Collective on TS 4028 4029 Input Arguments: 4030 . ts - time stepping context 4031 4032 Level: advanced 4033 4034 Notes: 4035 This function cannot be called until TSAdjointStep() has been completed. 4036 4037 .seealso: TSAdjointSolve(), TSAdjointStep 4038 @*/ 4039 PetscErrorCode TSAdjointCostIntegral(TS ts) 4040 { 4041 PetscErrorCode ierr; 4042 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4043 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); 4044 ierr = (*ts->ops->adjointintegral)(ts);CHKERRQ(ierr); 4045 PetscFunctionReturn(0); 4046 } 4047 4048 #undef __FUNCT__ 4049 #define __FUNCT__ "TSAdjointSolve" 4050 /*@ 4051 TSAdjointSolve - Solves the discrete ajoint problem for an ODE/DAE 4052 4053 Collective on TS 4054 4055 Input Parameter: 4056 . ts - the TS context obtained from TSCreate() 4057 4058 Options Database: 4059 . -ts_adjoint_view_solution <viewerinfo> - views the first gradient with respect to the initial conditions 4060 4061 Level: intermediate 4062 4063 Notes: 4064 This must be called after a call to TSSolve() that solves the forward problem 4065 4066 By default this will integrate back to the initial time, one can use TSAdjointSetSteps() to step back to a later time 4067 4068 .keywords: TS, timestep, solve 4069 4070 .seealso: TSCreate(), TSSetCostGradients(), TSSetSolution(), TSAdjointStep() 4071 @*/ 4072 PetscErrorCode TSAdjointSolve(TS ts) 4073 { 4074 PetscErrorCode ierr; 4075 4076 PetscFunctionBegin; 4077 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4078 ierr = TSAdjointSetUp(ts);CHKERRQ(ierr); 4079 4080 /* reset time step and iteration counters */ 4081 ts->steps = 0; 4082 ts->ksp_its = 0; 4083 ts->snes_its = 0; 4084 ts->num_snes_failures = 0; 4085 ts->reject = 0; 4086 ts->reason = TS_CONVERGED_ITERATING; 4087 4088 if (!ts->adjoint_max_steps) ts->adjoint_max_steps = ts->total_steps; 4089 4090 if (ts->steps >= ts->adjoint_max_steps) ts->reason = TS_CONVERGED_ITS; 4091 while (!ts->reason) { 4092 ierr = TSTrajectoryGet(ts->trajectory,ts,ts->total_steps,&ts->ptime);CHKERRQ(ierr); 4093 ierr = TSAdjointMonitor(ts,ts->total_steps,ts->ptime,ts->vec_sol,ts->numcost,ts->vecs_sensi,ts->vecs_sensip);CHKERRQ(ierr); 4094 ierr = TSAdjointEventHandler(ts);CHKERRQ(ierr); 4095 ierr = TSAdjointStep(ts);CHKERRQ(ierr); 4096 if (ts->vec_costintegral && !ts->costintegralfwd) { 4097 ierr = TSAdjointCostIntegral(ts);CHKERRQ(ierr); 4098 } 4099 } 4100 ierr = TSTrajectoryGet(ts->trajectory,ts,ts->total_steps,&ts->ptime);CHKERRQ(ierr); 4101 ierr = TSAdjointMonitor(ts,ts->total_steps,ts->ptime,ts->vec_sol,ts->numcost,ts->vecs_sensi,ts->vecs_sensip);CHKERRQ(ierr); 4102 ts->solvetime = ts->ptime; 4103 ierr = TSTrajectoryViewFromOptions(ts->trajectory,NULL,"-ts_trajectory_view");CHKERRQ(ierr); 4104 ierr = VecViewFromOptions(ts->vecs_sensi[0],(PetscObject) ts, "-ts_adjoint_view_solution");CHKERRQ(ierr); 4105 PetscFunctionReturn(0); 4106 } 4107 4108 #undef __FUNCT__ 4109 #define __FUNCT__ "TSMonitor" 4110 /*@C 4111 TSMonitor - Runs all user-provided monitor routines set using TSMonitorSet() 4112 4113 Collective on TS 4114 4115 Input Parameters: 4116 + ts - time stepping context obtained from TSCreate() 4117 . step - step number that has just completed 4118 . ptime - model time of the state 4119 - u - state at the current model time 4120 4121 Notes: 4122 TSMonitor() is typically used automatically within the time stepping implementations. 4123 Users would almost never call this routine directly. 4124 4125 A step of -1 indicates that the monitor is being called on a solution obtained by interpolating from computed solutions 4126 4127 Level: developer 4128 4129 .keywords: TS, timestep 4130 @*/ 4131 PetscErrorCode TSMonitor(TS ts,PetscInt step,PetscReal ptime,Vec u) 4132 { 4133 DM dm; 4134 PetscInt i,n = ts->numbermonitors; 4135 PetscErrorCode ierr; 4136 4137 PetscFunctionBegin; 4138 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4139 PetscValidHeaderSpecific(u,VEC_CLASSID,4); 4140 4141 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 4142 ierr = DMSetOutputSequenceNumber(dm,step,ptime);CHKERRQ(ierr); 4143 4144 ierr = VecLockPush(u);CHKERRQ(ierr); 4145 for (i=0; i<n; i++) { 4146 ierr = (*ts->monitor[i])(ts,step,ptime,u,ts->monitorcontext[i]);CHKERRQ(ierr); 4147 } 4148 ierr = VecLockPop(u);CHKERRQ(ierr); 4149 PetscFunctionReturn(0); 4150 } 4151 4152 #undef __FUNCT__ 4153 #define __FUNCT__ "TSAdjointMonitor" 4154 /*@C 4155 TSAdjointMonitor - Runs all user-provided adjoint monitor routines set using TSAdjointMonitorSet() 4156 4157 Collective on TS 4158 4159 Input Parameters: 4160 + ts - time stepping context obtained from TSCreate() 4161 . step - step number that has just completed 4162 . ptime - model time of the state 4163 . u - state at the current model time 4164 . numcost - number of cost functions (dimension of lambda or mu) 4165 . lambda - vectors containing the gradients of the cost functions with respect to the ODE/DAE solution variables 4166 - mu - vectors containing the gradients of the cost functions with respect to the problem parameters 4167 4168 Notes: 4169 TSAdjointMonitor() is typically used automatically within the time stepping implementations. 4170 Users would almost never call this routine directly. 4171 4172 Level: developer 4173 4174 .keywords: TS, timestep 4175 @*/ 4176 PetscErrorCode TSAdjointMonitor(TS ts,PetscInt step,PetscReal ptime,Vec u,PetscInt numcost,Vec *lambda, Vec *mu) 4177 { 4178 PetscErrorCode ierr; 4179 PetscInt i,n = ts->numberadjointmonitors; 4180 4181 PetscFunctionBegin; 4182 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4183 PetscValidHeaderSpecific(u,VEC_CLASSID,4); 4184 ierr = VecLockPush(u);CHKERRQ(ierr); 4185 for (i=0; i<n; i++) { 4186 ierr = (*ts->adjointmonitor[i])(ts,step,ptime,u,numcost,lambda,mu,ts->adjointmonitorcontext[i]);CHKERRQ(ierr); 4187 } 4188 ierr = VecLockPop(u);CHKERRQ(ierr); 4189 PetscFunctionReturn(0); 4190 } 4191 4192 /* ------------------------------------------------------------------------*/ 4193 #undef __FUNCT__ 4194 #define __FUNCT__ "TSMonitorLGCtxCreate" 4195 /*@C 4196 TSMonitorLGCtxCreate - Creates a TSMonitorLGCtx context for use with 4197 TS to monitor the solution process graphically in various ways 4198 4199 Collective on TS 4200 4201 Input Parameters: 4202 + host - the X display to open, or null for the local machine 4203 . label - the title to put in the title bar 4204 . x, y - the screen coordinates of the upper left coordinate of the window 4205 . m, n - the screen width and height in pixels 4206 - howoften - if positive then determines the frequency of the plotting, if -1 then only at the final time 4207 4208 Output Parameter: 4209 . ctx - the context 4210 4211 Options Database Key: 4212 + -ts_monitor_lg_timestep - automatically sets line graph monitor 4213 . -ts_monitor_lg_solution - monitor the solution (or certain values of the solution by calling TSMonitorLGSetDisplayVariables() or TSMonitorLGCtxSetDisplayVariables()) 4214 . -ts_monitor_lg_error - monitor the error 4215 . -ts_monitor_lg_ksp_iterations - monitor the number of KSP iterations needed for each timestep 4216 . -ts_monitor_lg_snes_iterations - monitor the number of SNES iterations needed for each timestep 4217 - -lg_use_markers <true,false> - mark the data points (at each time step) on the plot; default is true 4218 4219 Notes: 4220 Use TSMonitorLGCtxDestroy() to destroy. 4221 4222 One can provide a function that transforms the solution before plotting it with TSMonitorLGCtxSetTransform() or TSMonitorLGSetTransform() 4223 4224 Many of the functions that control the monitoring have two forms: TSMonitorLGSet/GetXXXX() and TSMonitorLGCtxSet/GetXXXX() the first take a TS object as the 4225 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 4226 as the first argument. 4227 4228 One can control the names displayed for each solution or error variable with TSMonitorLGCtxSetVariableNames() or TSMonitorLGSetVariableNames() 4229 4230 4231 Level: intermediate 4232 4233 .keywords: TS, monitor, line graph, residual 4234 4235 .seealso: TSMonitorLGTimeStep(), TSMonitorSet(), TSMonitorLGSolution(), TSMonitorLGError(), TSMonitorDefault(), VecView(), 4236 TSMonitorLGCtxCreate(), TSMonitorLGCtxSetVariableNames(), TSMonitorLGCtxGetVariableNames(), 4237 TSMonitorLGSetVariableNames(), TSMonitorLGGetVariableNames(), TSMonitorLGSetDisplayVariables(), TSMonitorLGCtxSetDisplayVariables(), 4238 TSMonitorLGCtxSetTransform(), TSMonitorLGSetTransform(), TSMonitorLGError(), TSMonitorLGSNESIterations(), TSMonitorLGKSPIterations(), 4239 TSMonitorEnvelopeCtxCreate(), TSMonitorEnvelopeGetBounds(), TSMonitorEnvelopeCtxDestroy(), TSMonitorEnvelop() 4240 4241 @*/ 4242 PetscErrorCode TSMonitorLGCtxCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscInt howoften,TSMonitorLGCtx *ctx) 4243 { 4244 PetscDraw draw; 4245 PetscErrorCode ierr; 4246 4247 PetscFunctionBegin; 4248 ierr = PetscNew(ctx);CHKERRQ(ierr); 4249 ierr = PetscDrawCreate(comm,host,label,x,y,m,n,&draw);CHKERRQ(ierr); 4250 ierr = PetscDrawSetFromOptions(draw);CHKERRQ(ierr); 4251 ierr = PetscDrawLGCreate(draw,1,&(*ctx)->lg);CHKERRQ(ierr); 4252 ierr = PetscDrawLGSetFromOptions((*ctx)->lg);CHKERRQ(ierr); 4253 ierr = PetscDrawDestroy(&draw);CHKERRQ(ierr); 4254 (*ctx)->howoften = howoften; 4255 PetscFunctionReturn(0); 4256 } 4257 4258 #undef __FUNCT__ 4259 #define __FUNCT__ "TSMonitorLGTimeStep" 4260 PetscErrorCode TSMonitorLGTimeStep(TS ts,PetscInt step,PetscReal ptime,Vec v,void *monctx) 4261 { 4262 TSMonitorLGCtx ctx = (TSMonitorLGCtx) monctx; 4263 PetscReal x = ptime,y; 4264 PetscErrorCode ierr; 4265 4266 PetscFunctionBegin; 4267 if (step < 0) PetscFunctionReturn(0); /* -1 indicates an interpolated solution */ 4268 if (!step) { 4269 PetscDrawAxis axis; 4270 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 4271 ierr = PetscDrawAxisSetLabels(axis,"Timestep as function of time","Time","Time Step");CHKERRQ(ierr); 4272 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 4273 } 4274 ierr = TSGetTimeStep(ts,&y);CHKERRQ(ierr); 4275 ierr = PetscDrawLGAddPoint(ctx->lg,&x,&y);CHKERRQ(ierr); 4276 if (((ctx->howoften > 0) && (!(step % ctx->howoften))) || ((ctx->howoften == -1) && ts->reason)) { 4277 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 4278 ierr = PetscDrawLGSave(ctx->lg);CHKERRQ(ierr); 4279 } 4280 PetscFunctionReturn(0); 4281 } 4282 4283 #undef __FUNCT__ 4284 #define __FUNCT__ "TSMonitorLGCtxDestroy" 4285 /*@C 4286 TSMonitorLGCtxDestroy - Destroys a line graph context that was created 4287 with TSMonitorLGCtxCreate(). 4288 4289 Collective on TSMonitorLGCtx 4290 4291 Input Parameter: 4292 . ctx - the monitor context 4293 4294 Level: intermediate 4295 4296 .keywords: TS, monitor, line graph, destroy 4297 4298 .seealso: TSMonitorLGCtxCreate(), TSMonitorSet(), TSMonitorLGTimeStep(); 4299 @*/ 4300 PetscErrorCode TSMonitorLGCtxDestroy(TSMonitorLGCtx *ctx) 4301 { 4302 PetscErrorCode ierr; 4303 4304 PetscFunctionBegin; 4305 if ((*ctx)->transformdestroy) { 4306 ierr = ((*ctx)->transformdestroy)((*ctx)->transformctx);CHKERRQ(ierr); 4307 } 4308 ierr = PetscDrawLGDestroy(&(*ctx)->lg);CHKERRQ(ierr); 4309 ierr = PetscStrArrayDestroy(&(*ctx)->names);CHKERRQ(ierr); 4310 ierr = PetscStrArrayDestroy(&(*ctx)->displaynames);CHKERRQ(ierr); 4311 ierr = PetscFree((*ctx)->displayvariables);CHKERRQ(ierr); 4312 ierr = PetscFree((*ctx)->displayvalues);CHKERRQ(ierr); 4313 ierr = PetscFree(*ctx);CHKERRQ(ierr); 4314 PetscFunctionReturn(0); 4315 } 4316 4317 #undef __FUNCT__ 4318 #define __FUNCT__ "TSGetTime" 4319 /*@ 4320 TSGetTime - Gets the time of the most recently completed step. 4321 4322 Not Collective 4323 4324 Input Parameter: 4325 . ts - the TS context obtained from TSCreate() 4326 4327 Output Parameter: 4328 . t - the current time. This time may not corresponds to the final time set with TSSetDuration(), use TSGetSolveTime(). 4329 4330 Level: beginner 4331 4332 Note: 4333 When called during time step evaluation (e.g. during residual evaluation or via hooks set using TSSetPreStep(), 4334 TSSetPreStage(), TSSetPostStage(), or TSSetPostStep()), the time is the time at the start of the step being evaluated. 4335 4336 .seealso: TSSetInitialTimeStep(), TSGetTimeStep(), TSGetSolveTime() 4337 4338 .keywords: TS, get, time 4339 @*/ 4340 PetscErrorCode TSGetTime(TS ts,PetscReal *t) 4341 { 4342 PetscFunctionBegin; 4343 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4344 PetscValidRealPointer(t,2); 4345 *t = ts->ptime; 4346 PetscFunctionReturn(0); 4347 } 4348 4349 #undef __FUNCT__ 4350 #define __FUNCT__ "TSGetPrevTime" 4351 /*@ 4352 TSGetPrevTime - Gets the starting time of the previously completed step. 4353 4354 Not Collective 4355 4356 Input Parameter: 4357 . ts - the TS context obtained from TSCreate() 4358 4359 Output Parameter: 4360 . t - the previous time 4361 4362 Level: beginner 4363 4364 .seealso: TSSetInitialTimeStep(), TSGetTimeStep() 4365 4366 .keywords: TS, get, time 4367 @*/ 4368 PetscErrorCode TSGetPrevTime(TS ts,PetscReal *t) 4369 { 4370 PetscFunctionBegin; 4371 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4372 PetscValidRealPointer(t,2); 4373 *t = ts->ptime_prev; 4374 PetscFunctionReturn(0); 4375 } 4376 4377 #undef __FUNCT__ 4378 #define __FUNCT__ "TSSetTime" 4379 /*@ 4380 TSSetTime - Allows one to reset the time. 4381 4382 Logically Collective on TS 4383 4384 Input Parameters: 4385 + ts - the TS context obtained from TSCreate() 4386 - time - the time 4387 4388 Level: intermediate 4389 4390 .seealso: TSGetTime(), TSSetDuration() 4391 4392 .keywords: TS, set, time 4393 @*/ 4394 PetscErrorCode TSSetTime(TS ts, PetscReal t) 4395 { 4396 PetscFunctionBegin; 4397 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4398 PetscValidLogicalCollectiveReal(ts,t,2); 4399 ts->ptime = t; 4400 PetscFunctionReturn(0); 4401 } 4402 4403 #undef __FUNCT__ 4404 #define __FUNCT__ "TSSetOptionsPrefix" 4405 /*@C 4406 TSSetOptionsPrefix - Sets the prefix used for searching for all 4407 TS options in the database. 4408 4409 Logically Collective on TS 4410 4411 Input Parameter: 4412 + ts - The TS context 4413 - prefix - The prefix to prepend to all option names 4414 4415 Notes: 4416 A hyphen (-) must NOT be given at the beginning of the prefix name. 4417 The first character of all runtime options is AUTOMATICALLY the 4418 hyphen. 4419 4420 Level: advanced 4421 4422 .keywords: TS, set, options, prefix, database 4423 4424 .seealso: TSSetFromOptions() 4425 4426 @*/ 4427 PetscErrorCode TSSetOptionsPrefix(TS ts,const char prefix[]) 4428 { 4429 PetscErrorCode ierr; 4430 SNES snes; 4431 4432 PetscFunctionBegin; 4433 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4434 ierr = PetscObjectSetOptionsPrefix((PetscObject)ts,prefix);CHKERRQ(ierr); 4435 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 4436 ierr = SNESSetOptionsPrefix(snes,prefix);CHKERRQ(ierr); 4437 PetscFunctionReturn(0); 4438 } 4439 4440 4441 #undef __FUNCT__ 4442 #define __FUNCT__ "TSAppendOptionsPrefix" 4443 /*@C 4444 TSAppendOptionsPrefix - Appends to the prefix used for searching for all 4445 TS options in the database. 4446 4447 Logically Collective on TS 4448 4449 Input Parameter: 4450 + ts - The TS context 4451 - prefix - The prefix to prepend to all option names 4452 4453 Notes: 4454 A hyphen (-) must NOT be given at the beginning of the prefix name. 4455 The first character of all runtime options is AUTOMATICALLY the 4456 hyphen. 4457 4458 Level: advanced 4459 4460 .keywords: TS, append, options, prefix, database 4461 4462 .seealso: TSGetOptionsPrefix() 4463 4464 @*/ 4465 PetscErrorCode TSAppendOptionsPrefix(TS ts,const char prefix[]) 4466 { 4467 PetscErrorCode ierr; 4468 SNES snes; 4469 4470 PetscFunctionBegin; 4471 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4472 ierr = PetscObjectAppendOptionsPrefix((PetscObject)ts,prefix);CHKERRQ(ierr); 4473 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 4474 ierr = SNESAppendOptionsPrefix(snes,prefix);CHKERRQ(ierr); 4475 PetscFunctionReturn(0); 4476 } 4477 4478 #undef __FUNCT__ 4479 #define __FUNCT__ "TSGetOptionsPrefix" 4480 /*@C 4481 TSGetOptionsPrefix - Sets the prefix used for searching for all 4482 TS options in the database. 4483 4484 Not Collective 4485 4486 Input Parameter: 4487 . ts - The TS context 4488 4489 Output Parameter: 4490 . prefix - A pointer to the prefix string used 4491 4492 Notes: On the fortran side, the user should pass in a string 'prifix' of 4493 sufficient length to hold the prefix. 4494 4495 Level: intermediate 4496 4497 .keywords: TS, get, options, prefix, database 4498 4499 .seealso: TSAppendOptionsPrefix() 4500 @*/ 4501 PetscErrorCode TSGetOptionsPrefix(TS ts,const char *prefix[]) 4502 { 4503 PetscErrorCode ierr; 4504 4505 PetscFunctionBegin; 4506 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4507 PetscValidPointer(prefix,2); 4508 ierr = PetscObjectGetOptionsPrefix((PetscObject)ts,prefix);CHKERRQ(ierr); 4509 PetscFunctionReturn(0); 4510 } 4511 4512 #undef __FUNCT__ 4513 #define __FUNCT__ "TSGetRHSJacobian" 4514 /*@C 4515 TSGetRHSJacobian - Returns the Jacobian J at the present timestep. 4516 4517 Not Collective, but parallel objects are returned if TS is parallel 4518 4519 Input Parameter: 4520 . ts - The TS context obtained from TSCreate() 4521 4522 Output Parameters: 4523 + Amat - The (approximate) Jacobian J of G, where U_t = G(U,t) (or NULL) 4524 . Pmat - The matrix from which the preconditioner is constructed, usually the same as Amat (or NULL) 4525 . func - Function to compute the Jacobian of the RHS (or NULL) 4526 - ctx - User-defined context for Jacobian evaluation routine (or NULL) 4527 4528 Notes: You can pass in NULL for any return argument you do not need. 4529 4530 Level: intermediate 4531 4532 .seealso: TSGetTimeStep(), TSGetMatrices(), TSGetTime(), TSGetTimeStepNumber() 4533 4534 .keywords: TS, timestep, get, matrix, Jacobian 4535 @*/ 4536 PetscErrorCode TSGetRHSJacobian(TS ts,Mat *Amat,Mat *Pmat,TSRHSJacobian *func,void **ctx) 4537 { 4538 PetscErrorCode ierr; 4539 SNES snes; 4540 DM dm; 4541 4542 PetscFunctionBegin; 4543 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 4544 ierr = SNESGetJacobian(snes,Amat,Pmat,NULL,NULL);CHKERRQ(ierr); 4545 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 4546 ierr = DMTSGetRHSJacobian(dm,func,ctx);CHKERRQ(ierr); 4547 PetscFunctionReturn(0); 4548 } 4549 4550 #undef __FUNCT__ 4551 #define __FUNCT__ "TSGetIJacobian" 4552 /*@C 4553 TSGetIJacobian - Returns the implicit Jacobian at the present timestep. 4554 4555 Not Collective, but parallel objects are returned if TS is parallel 4556 4557 Input Parameter: 4558 . ts - The TS context obtained from TSCreate() 4559 4560 Output Parameters: 4561 + Amat - The (approximate) Jacobian of F(t,U,U_t) 4562 . Pmat - The matrix from which the preconditioner is constructed, often the same as Amat 4563 . f - The function to compute the matrices 4564 - ctx - User-defined context for Jacobian evaluation routine 4565 4566 Notes: You can pass in NULL for any return argument you do not need. 4567 4568 Level: advanced 4569 4570 .seealso: TSGetTimeStep(), TSGetRHSJacobian(), TSGetMatrices(), TSGetTime(), TSGetTimeStepNumber() 4571 4572 .keywords: TS, timestep, get, matrix, Jacobian 4573 @*/ 4574 PetscErrorCode TSGetIJacobian(TS ts,Mat *Amat,Mat *Pmat,TSIJacobian *f,void **ctx) 4575 { 4576 PetscErrorCode ierr; 4577 SNES snes; 4578 DM dm; 4579 4580 PetscFunctionBegin; 4581 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 4582 ierr = SNESSetUpMatrices(snes);CHKERRQ(ierr); 4583 ierr = SNESGetJacobian(snes,Amat,Pmat,NULL,NULL);CHKERRQ(ierr); 4584 ierr = TSGetDM(ts,&dm);CHKERRQ(ierr); 4585 ierr = DMTSGetIJacobian(dm,f,ctx);CHKERRQ(ierr); 4586 PetscFunctionReturn(0); 4587 } 4588 4589 4590 #undef __FUNCT__ 4591 #define __FUNCT__ "TSMonitorDrawSolution" 4592 /*@C 4593 TSMonitorDrawSolution - Monitors progress of the TS solvers by calling 4594 VecView() for the solution at each timestep 4595 4596 Collective on TS 4597 4598 Input Parameters: 4599 + ts - the TS context 4600 . step - current time-step 4601 . ptime - current time 4602 - dummy - either a viewer or NULL 4603 4604 Options Database: 4605 . -ts_monitor_draw_solution_initial - show initial solution as well as current solution 4606 4607 Notes: the initial solution and current solution are not display with a common axis scaling so generally the option -ts_monitor_draw_solution_initial 4608 will look bad 4609 4610 Level: intermediate 4611 4612 .keywords: TS, vector, monitor, view 4613 4614 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 4615 @*/ 4616 PetscErrorCode TSMonitorDrawSolution(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dummy) 4617 { 4618 PetscErrorCode ierr; 4619 TSMonitorDrawCtx ictx = (TSMonitorDrawCtx)dummy; 4620 PetscDraw draw; 4621 4622 PetscFunctionBegin; 4623 if (!step && ictx->showinitial) { 4624 if (!ictx->initialsolution) { 4625 ierr = VecDuplicate(u,&ictx->initialsolution);CHKERRQ(ierr); 4626 } 4627 ierr = VecCopy(u,ictx->initialsolution);CHKERRQ(ierr); 4628 } 4629 if (!(((ictx->howoften > 0) && (!(step % ictx->howoften))) || ((ictx->howoften == -1) && ts->reason))) PetscFunctionReturn(0); 4630 4631 if (ictx->showinitial) { 4632 PetscReal pause; 4633 ierr = PetscViewerDrawGetPause(ictx->viewer,&pause);CHKERRQ(ierr); 4634 ierr = PetscViewerDrawSetPause(ictx->viewer,0.0);CHKERRQ(ierr); 4635 ierr = VecView(ictx->initialsolution,ictx->viewer);CHKERRQ(ierr); 4636 ierr = PetscViewerDrawSetPause(ictx->viewer,pause);CHKERRQ(ierr); 4637 ierr = PetscViewerDrawSetHold(ictx->viewer,PETSC_TRUE);CHKERRQ(ierr); 4638 } 4639 ierr = VecView(u,ictx->viewer);CHKERRQ(ierr); 4640 if (ictx->showtimestepandtime) { 4641 PetscReal xl,yl,xr,yr,h; 4642 char time[32]; 4643 4644 ierr = PetscViewerDrawGetDraw(ictx->viewer,0,&draw);CHKERRQ(ierr); 4645 ierr = PetscSNPrintf(time,32,"Timestep %d Time %g",(int)step,(double)ptime);CHKERRQ(ierr); 4646 ierr = PetscDrawGetCoordinates(draw,&xl,&yl,&xr,&yr);CHKERRQ(ierr); 4647 h = yl + .95*(yr - yl); 4648 ierr = PetscDrawStringCentered(draw,.5*(xl+xr),h,PETSC_DRAW_BLACK,time);CHKERRQ(ierr); 4649 ierr = PetscDrawFlush(draw);CHKERRQ(ierr); 4650 } 4651 4652 if (ictx->showinitial) { 4653 ierr = PetscViewerDrawSetHold(ictx->viewer,PETSC_FALSE);CHKERRQ(ierr); 4654 } 4655 PetscFunctionReturn(0); 4656 } 4657 4658 #undef __FUNCT__ 4659 #define __FUNCT__ "TSAdjointMonitorDrawSensi" 4660 /*@C 4661 TSAdjointMonitorDrawSensi - Monitors progress of the adjoint TS solvers by calling 4662 VecView() for the sensitivities to initial states at each timestep 4663 4664 Collective on TS 4665 4666 Input Parameters: 4667 + ts - the TS context 4668 . step - current time-step 4669 . ptime - current time 4670 . u - current state 4671 . numcost - number of cost functions 4672 . lambda - sensitivities to initial conditions 4673 . mu - sensitivities to parameters 4674 - dummy - either a viewer or NULL 4675 4676 Level: intermediate 4677 4678 .keywords: TS, vector, adjoint, monitor, view 4679 4680 .seealso: TSAdjointMonitorSet(), TSAdjointMonitorDefault(), VecView() 4681 @*/ 4682 PetscErrorCode TSAdjointMonitorDrawSensi(TS ts,PetscInt step,PetscReal ptime,Vec u,PetscInt numcost,Vec *lambda,Vec *mu,void *dummy) 4683 { 4684 PetscErrorCode ierr; 4685 TSMonitorDrawCtx ictx = (TSMonitorDrawCtx)dummy; 4686 PetscDraw draw; 4687 PetscReal xl,yl,xr,yr,h; 4688 char time[32]; 4689 4690 PetscFunctionBegin; 4691 if (!(((ictx->howoften > 0) && (!(step % ictx->howoften))) || ((ictx->howoften == -1) && ts->reason))) PetscFunctionReturn(0); 4692 4693 ierr = VecView(lambda[0],ictx->viewer);CHKERRQ(ierr); 4694 ierr = PetscViewerDrawGetDraw(ictx->viewer,0,&draw);CHKERRQ(ierr); 4695 ierr = PetscSNPrintf(time,32,"Timestep %d Time %g",(int)step,(double)ptime);CHKERRQ(ierr); 4696 ierr = PetscDrawGetCoordinates(draw,&xl,&yl,&xr,&yr);CHKERRQ(ierr); 4697 h = yl + .95*(yr - yl); 4698 ierr = PetscDrawStringCentered(draw,.5*(xl+xr),h,PETSC_DRAW_BLACK,time);CHKERRQ(ierr); 4699 ierr = PetscDrawFlush(draw);CHKERRQ(ierr); 4700 PetscFunctionReturn(0); 4701 } 4702 4703 #undef __FUNCT__ 4704 #define __FUNCT__ "TSMonitorDrawSolutionPhase" 4705 /*@C 4706 TSMonitorDrawSolutionPhase - Monitors progress of the TS solvers by plotting the solution as a phase diagram 4707 4708 Collective on TS 4709 4710 Input Parameters: 4711 + ts - the TS context 4712 . step - current time-step 4713 . ptime - current time 4714 - dummy - either a viewer or NULL 4715 4716 Level: intermediate 4717 4718 .keywords: TS, vector, monitor, view 4719 4720 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 4721 @*/ 4722 PetscErrorCode TSMonitorDrawSolutionPhase(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dummy) 4723 { 4724 PetscErrorCode ierr; 4725 TSMonitorDrawCtx ictx = (TSMonitorDrawCtx)dummy; 4726 PetscDraw draw; 4727 PetscDrawAxis axis; 4728 PetscInt n; 4729 PetscMPIInt size; 4730 PetscReal U0,U1,xl,yl,xr,yr,h; 4731 char time[32]; 4732 const PetscScalar *U; 4733 4734 PetscFunctionBegin; 4735 ierr = MPI_Comm_size(PetscObjectComm((PetscObject)ts),&size);CHKERRQ(ierr); 4736 if (size != 1) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"Only allowed for sequential runs"); 4737 ierr = VecGetSize(u,&n);CHKERRQ(ierr); 4738 if (n != 2) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"Only for ODEs with two unknowns"); 4739 4740 ierr = PetscViewerDrawGetDraw(ictx->viewer,0,&draw);CHKERRQ(ierr); 4741 ierr = PetscViewerDrawGetDrawAxis(ictx->viewer,0,&axis);CHKERRQ(ierr); 4742 ierr = PetscDrawAxisGetLimits(axis,&xl,&xr,&yl,&yr);CHKERRQ(ierr); 4743 if (!step) { 4744 ierr = PetscDrawClear(draw);CHKERRQ(ierr); 4745 ierr = PetscDrawAxisDraw(axis);CHKERRQ(ierr); 4746 } 4747 4748 ierr = VecGetArrayRead(u,&U);CHKERRQ(ierr); 4749 U0 = PetscRealPart(U[0]); 4750 U1 = PetscRealPart(U[1]); 4751 ierr = VecRestoreArrayRead(u,&U);CHKERRQ(ierr); 4752 if ((U0 < xl) || (U1 < yl) || (U0 > xr) || (U1 > yr)) PetscFunctionReturn(0); 4753 4754 ierr = PetscDrawCollectiveBegin(draw);CHKERRQ(ierr); 4755 ierr = PetscDrawPoint(draw,U0,U1,PETSC_DRAW_BLACK);CHKERRQ(ierr); 4756 if (ictx->showtimestepandtime) { 4757 ierr = PetscDrawGetCoordinates(draw,&xl,&yl,&xr,&yr);CHKERRQ(ierr); 4758 ierr = PetscSNPrintf(time,32,"Timestep %d Time %g",(int)step,(double)ptime);CHKERRQ(ierr); 4759 h = yl + .95*(yr - yl); 4760 ierr = PetscDrawStringCentered(draw,.5*(xl+xr),h,PETSC_DRAW_BLACK,time);CHKERRQ(ierr); 4761 } 4762 ierr = PetscDrawCollectiveEnd(draw);CHKERRQ(ierr); 4763 ierr = PetscDrawFlush(draw);CHKERRQ(ierr); 4764 ierr = PetscDrawSave(draw);CHKERRQ(ierr); 4765 PetscFunctionReturn(0); 4766 } 4767 4768 4769 #undef __FUNCT__ 4770 #define __FUNCT__ "TSMonitorDrawCtxDestroy" 4771 /*@C 4772 TSMonitorDrawCtxDestroy - Destroys the monitor context for TSMonitorDrawSolution() 4773 4774 Collective on TS 4775 4776 Input Parameters: 4777 . ctx - the monitor context 4778 4779 Level: intermediate 4780 4781 .keywords: TS, vector, monitor, view 4782 4783 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorDrawSolution(), TSMonitorDrawError() 4784 @*/ 4785 PetscErrorCode TSMonitorDrawCtxDestroy(TSMonitorDrawCtx *ictx) 4786 { 4787 PetscErrorCode ierr; 4788 4789 PetscFunctionBegin; 4790 ierr = PetscViewerDestroy(&(*ictx)->viewer);CHKERRQ(ierr); 4791 ierr = VecDestroy(&(*ictx)->initialsolution);CHKERRQ(ierr); 4792 ierr = PetscFree(*ictx);CHKERRQ(ierr); 4793 PetscFunctionReturn(0); 4794 } 4795 4796 #undef __FUNCT__ 4797 #define __FUNCT__ "TSMonitorDrawCtxCreate" 4798 /*@C 4799 TSMonitorDrawCtxCreate - Creates the monitor context for TSMonitorDrawCtx 4800 4801 Collective on TS 4802 4803 Input Parameter: 4804 . ts - time-step context 4805 4806 Output Patameter: 4807 . ctx - the monitor context 4808 4809 Options Database: 4810 . -ts_monitor_draw_solution_initial - show initial solution as well as current solution 4811 4812 Level: intermediate 4813 4814 .keywords: TS, vector, monitor, view 4815 4816 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorDrawCtx() 4817 @*/ 4818 PetscErrorCode TSMonitorDrawCtxCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscInt howoften,TSMonitorDrawCtx *ctx) 4819 { 4820 PetscErrorCode ierr; 4821 4822 PetscFunctionBegin; 4823 ierr = PetscNew(ctx);CHKERRQ(ierr); 4824 ierr = PetscViewerDrawOpen(comm,host,label,x,y,m,n,&(*ctx)->viewer);CHKERRQ(ierr); 4825 ierr = PetscViewerSetFromOptions((*ctx)->viewer);CHKERRQ(ierr); 4826 4827 (*ctx)->howoften = howoften; 4828 (*ctx)->showinitial = PETSC_FALSE; 4829 ierr = PetscOptionsGetBool(NULL,NULL,"-ts_monitor_draw_solution_initial",&(*ctx)->showinitial,NULL);CHKERRQ(ierr); 4830 4831 (*ctx)->showtimestepandtime = PETSC_FALSE; 4832 ierr = PetscOptionsGetBool(NULL,NULL,"-ts_monitor_draw_solution_show_time",&(*ctx)->showtimestepandtime,NULL);CHKERRQ(ierr); 4833 PetscFunctionReturn(0); 4834 } 4835 4836 #undef __FUNCT__ 4837 #define __FUNCT__ "TSMonitorDrawError" 4838 /*@C 4839 TSMonitorDrawError - Monitors progress of the TS solvers by calling 4840 VecView() for the error at each timestep 4841 4842 Collective on TS 4843 4844 Input Parameters: 4845 + ts - the TS context 4846 . step - current time-step 4847 . ptime - current time 4848 - dummy - either a viewer or NULL 4849 4850 Level: intermediate 4851 4852 .keywords: TS, vector, monitor, view 4853 4854 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 4855 @*/ 4856 PetscErrorCode TSMonitorDrawError(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dummy) 4857 { 4858 PetscErrorCode ierr; 4859 TSMonitorDrawCtx ctx = (TSMonitorDrawCtx)dummy; 4860 PetscViewer viewer = ctx->viewer; 4861 Vec work; 4862 4863 PetscFunctionBegin; 4864 if (!(((ctx->howoften > 0) && (!(step % ctx->howoften))) || ((ctx->howoften == -1) && ts->reason))) PetscFunctionReturn(0); 4865 ierr = VecDuplicate(u,&work);CHKERRQ(ierr); 4866 ierr = TSComputeSolutionFunction(ts,ptime,work);CHKERRQ(ierr); 4867 ierr = VecAXPY(work,-1.0,u);CHKERRQ(ierr); 4868 ierr = VecView(work,viewer);CHKERRQ(ierr); 4869 ierr = VecDestroy(&work);CHKERRQ(ierr); 4870 PetscFunctionReturn(0); 4871 } 4872 4873 #include <petsc/private/dmimpl.h> 4874 #undef __FUNCT__ 4875 #define __FUNCT__ "TSSetDM" 4876 /*@ 4877 TSSetDM - Sets the DM that may be used by some nonlinear solvers or preconditioners under the TS 4878 4879 Logically Collective on TS and DM 4880 4881 Input Parameters: 4882 + ts - the ODE integrator object 4883 - dm - the dm, cannot be NULL 4884 4885 Level: intermediate 4886 4887 4888 .seealso: TSGetDM(), SNESSetDM(), SNESGetDM() 4889 @*/ 4890 PetscErrorCode TSSetDM(TS ts,DM dm) 4891 { 4892 PetscErrorCode ierr; 4893 SNES snes; 4894 DMTS tsdm; 4895 4896 PetscFunctionBegin; 4897 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4898 PetscValidHeaderSpecific(dm,DM_CLASSID,2); 4899 ierr = PetscObjectReference((PetscObject)dm);CHKERRQ(ierr); 4900 if (ts->dm) { /* Move the DMTS context over to the new DM unless the new DM already has one */ 4901 if (ts->dm->dmts && !dm->dmts) { 4902 ierr = DMCopyDMTS(ts->dm,dm);CHKERRQ(ierr); 4903 ierr = DMGetDMTS(ts->dm,&tsdm);CHKERRQ(ierr); 4904 if (tsdm->originaldm == ts->dm) { /* Grant write privileges to the replacement DM */ 4905 tsdm->originaldm = dm; 4906 } 4907 } 4908 ierr = DMDestroy(&ts->dm);CHKERRQ(ierr); 4909 } 4910 ts->dm = dm; 4911 4912 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 4913 ierr = SNESSetDM(snes,dm);CHKERRQ(ierr); 4914 PetscFunctionReturn(0); 4915 } 4916 4917 #undef __FUNCT__ 4918 #define __FUNCT__ "TSGetDM" 4919 /*@ 4920 TSGetDM - Gets the DM that may be used by some preconditioners 4921 4922 Not Collective 4923 4924 Input Parameter: 4925 . ts - the preconditioner context 4926 4927 Output Parameter: 4928 . dm - the dm 4929 4930 Level: intermediate 4931 4932 4933 .seealso: TSSetDM(), SNESSetDM(), SNESGetDM() 4934 @*/ 4935 PetscErrorCode TSGetDM(TS ts,DM *dm) 4936 { 4937 PetscErrorCode ierr; 4938 4939 PetscFunctionBegin; 4940 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 4941 if (!ts->dm) { 4942 ierr = DMShellCreate(PetscObjectComm((PetscObject)ts),&ts->dm);CHKERRQ(ierr); 4943 if (ts->snes) {ierr = SNESSetDM(ts->snes,ts->dm);CHKERRQ(ierr);} 4944 } 4945 *dm = ts->dm; 4946 PetscFunctionReturn(0); 4947 } 4948 4949 #undef __FUNCT__ 4950 #define __FUNCT__ "SNESTSFormFunction" 4951 /*@ 4952 SNESTSFormFunction - Function to evaluate nonlinear residual 4953 4954 Logically Collective on SNES 4955 4956 Input Parameter: 4957 + snes - nonlinear solver 4958 . U - the current state at which to evaluate the residual 4959 - ctx - user context, must be a TS 4960 4961 Output Parameter: 4962 . F - the nonlinear residual 4963 4964 Notes: 4965 This function is not normally called by users and is automatically registered with the SNES used by TS. 4966 It is most frequently passed to MatFDColoringSetFunction(). 4967 4968 Level: advanced 4969 4970 .seealso: SNESSetFunction(), MatFDColoringSetFunction() 4971 @*/ 4972 PetscErrorCode SNESTSFormFunction(SNES snes,Vec U,Vec F,void *ctx) 4973 { 4974 TS ts = (TS)ctx; 4975 PetscErrorCode ierr; 4976 4977 PetscFunctionBegin; 4978 PetscValidHeaderSpecific(snes,SNES_CLASSID,1); 4979 PetscValidHeaderSpecific(U,VEC_CLASSID,2); 4980 PetscValidHeaderSpecific(F,VEC_CLASSID,3); 4981 PetscValidHeaderSpecific(ts,TS_CLASSID,4); 4982 ierr = (ts->ops->snesfunction)(snes,U,F,ts);CHKERRQ(ierr); 4983 PetscFunctionReturn(0); 4984 } 4985 4986 #undef __FUNCT__ 4987 #define __FUNCT__ "SNESTSFormJacobian" 4988 /*@ 4989 SNESTSFormJacobian - Function to evaluate the Jacobian 4990 4991 Collective on SNES 4992 4993 Input Parameter: 4994 + snes - nonlinear solver 4995 . U - the current state at which to evaluate the residual 4996 - ctx - user context, must be a TS 4997 4998 Output Parameter: 4999 + A - the Jacobian 5000 . B - the preconditioning matrix (may be the same as A) 5001 - flag - indicates any structure change in the matrix 5002 5003 Notes: 5004 This function is not normally called by users and is automatically registered with the SNES used by TS. 5005 5006 Level: developer 5007 5008 .seealso: SNESSetJacobian() 5009 @*/ 5010 PetscErrorCode SNESTSFormJacobian(SNES snes,Vec U,Mat A,Mat B,void *ctx) 5011 { 5012 TS ts = (TS)ctx; 5013 PetscErrorCode ierr; 5014 5015 PetscFunctionBegin; 5016 PetscValidHeaderSpecific(snes,SNES_CLASSID,1); 5017 PetscValidHeaderSpecific(U,VEC_CLASSID,2); 5018 PetscValidPointer(A,3); 5019 PetscValidHeaderSpecific(A,MAT_CLASSID,3); 5020 PetscValidPointer(B,4); 5021 PetscValidHeaderSpecific(B,MAT_CLASSID,4); 5022 PetscValidHeaderSpecific(ts,TS_CLASSID,6); 5023 ierr = (ts->ops->snesjacobian)(snes,U,A,B,ts);CHKERRQ(ierr); 5024 PetscFunctionReturn(0); 5025 } 5026 5027 #undef __FUNCT__ 5028 #define __FUNCT__ "TSComputeRHSFunctionLinear" 5029 /*@C 5030 TSComputeRHSFunctionLinear - Evaluate the right hand side via the user-provided Jacobian, for linear problems Udot = A U only 5031 5032 Collective on TS 5033 5034 Input Arguments: 5035 + ts - time stepping context 5036 . t - time at which to evaluate 5037 . U - state at which to evaluate 5038 - ctx - context 5039 5040 Output Arguments: 5041 . F - right hand side 5042 5043 Level: intermediate 5044 5045 Notes: 5046 This function is intended to be passed to TSSetRHSFunction() to evaluate the right hand side for linear problems. 5047 The matrix (and optionally the evaluation context) should be passed to TSSetRHSJacobian(). 5048 5049 .seealso: TSSetRHSFunction(), TSSetRHSJacobian(), TSComputeRHSJacobianConstant() 5050 @*/ 5051 PetscErrorCode TSComputeRHSFunctionLinear(TS ts,PetscReal t,Vec U,Vec F,void *ctx) 5052 { 5053 PetscErrorCode ierr; 5054 Mat Arhs,Brhs; 5055 5056 PetscFunctionBegin; 5057 ierr = TSGetRHSMats_Private(ts,&Arhs,&Brhs);CHKERRQ(ierr); 5058 ierr = TSComputeRHSJacobian(ts,t,U,Arhs,Brhs);CHKERRQ(ierr); 5059 ierr = MatMult(Arhs,U,F);CHKERRQ(ierr); 5060 PetscFunctionReturn(0); 5061 } 5062 5063 #undef __FUNCT__ 5064 #define __FUNCT__ "TSComputeRHSJacobianConstant" 5065 /*@C 5066 TSComputeRHSJacobianConstant - Reuses a Jacobian that is time-independent. 5067 5068 Collective on TS 5069 5070 Input Arguments: 5071 + ts - time stepping context 5072 . t - time at which to evaluate 5073 . U - state at which to evaluate 5074 - ctx - context 5075 5076 Output Arguments: 5077 + A - pointer to operator 5078 . B - pointer to preconditioning matrix 5079 - flg - matrix structure flag 5080 5081 Level: intermediate 5082 5083 Notes: 5084 This function is intended to be passed to TSSetRHSJacobian() to evaluate the Jacobian for linear time-independent problems. 5085 5086 .seealso: TSSetRHSFunction(), TSSetRHSJacobian(), TSComputeRHSFunctionLinear() 5087 @*/ 5088 PetscErrorCode TSComputeRHSJacobianConstant(TS ts,PetscReal t,Vec U,Mat A,Mat B,void *ctx) 5089 { 5090 PetscFunctionBegin; 5091 PetscFunctionReturn(0); 5092 } 5093 5094 #undef __FUNCT__ 5095 #define __FUNCT__ "TSComputeIFunctionLinear" 5096 /*@C 5097 TSComputeIFunctionLinear - Evaluate the left hand side via the user-provided Jacobian, for linear problems only 5098 5099 Collective on TS 5100 5101 Input Arguments: 5102 + ts - time stepping context 5103 . t - time at which to evaluate 5104 . U - state at which to evaluate 5105 . Udot - time derivative of state vector 5106 - ctx - context 5107 5108 Output Arguments: 5109 . F - left hand side 5110 5111 Level: intermediate 5112 5113 Notes: 5114 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 5115 user is required to write their own TSComputeIFunction. 5116 This function is intended to be passed to TSSetIFunction() to evaluate the left hand side for linear problems. 5117 The matrix (and optionally the evaluation context) should be passed to TSSetIJacobian(). 5118 5119 Note that using this function is NOT equivalent to using TSComputeRHSFunctionLinear() since that solves Udot = A U 5120 5121 .seealso: TSSetIFunction(), TSSetIJacobian(), TSComputeIJacobianConstant(), TSComputeRHSFunctionLinear() 5122 @*/ 5123 PetscErrorCode TSComputeIFunctionLinear(TS ts,PetscReal t,Vec U,Vec Udot,Vec F,void *ctx) 5124 { 5125 PetscErrorCode ierr; 5126 Mat A,B; 5127 5128 PetscFunctionBegin; 5129 ierr = TSGetIJacobian(ts,&A,&B,NULL,NULL);CHKERRQ(ierr); 5130 ierr = TSComputeIJacobian(ts,t,U,Udot,1.0,A,B,PETSC_TRUE);CHKERRQ(ierr); 5131 ierr = MatMult(A,Udot,F);CHKERRQ(ierr); 5132 PetscFunctionReturn(0); 5133 } 5134 5135 #undef __FUNCT__ 5136 #define __FUNCT__ "TSComputeIJacobianConstant" 5137 /*@C 5138 TSComputeIJacobianConstant - Reuses a time-independent for a semi-implicit DAE or ODE 5139 5140 Collective on TS 5141 5142 Input Arguments: 5143 + ts - time stepping context 5144 . t - time at which to evaluate 5145 . U - state at which to evaluate 5146 . Udot - time derivative of state vector 5147 . shift - shift to apply 5148 - ctx - context 5149 5150 Output Arguments: 5151 + A - pointer to operator 5152 . B - pointer to preconditioning matrix 5153 - flg - matrix structure flag 5154 5155 Level: advanced 5156 5157 Notes: 5158 This function is intended to be passed to TSSetIJacobian() to evaluate the Jacobian for linear time-independent problems. 5159 5160 It is only appropriate for problems of the form 5161 5162 $ M Udot = F(U,t) 5163 5164 where M is constant and F is non-stiff. The user must pass M to TSSetIJacobian(). The current implementation only 5165 works with IMEX time integration methods such as TSROSW and TSARKIMEX, since there is no support for de-constructing 5166 an implicit operator of the form 5167 5168 $ shift*M + J 5169 5170 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 5171 a copy of M or reassemble it when requested. 5172 5173 .seealso: TSSetIFunction(), TSSetIJacobian(), TSComputeIFunctionLinear() 5174 @*/ 5175 PetscErrorCode TSComputeIJacobianConstant(TS ts,PetscReal t,Vec U,Vec Udot,PetscReal shift,Mat A,Mat B,void *ctx) 5176 { 5177 PetscErrorCode ierr; 5178 5179 PetscFunctionBegin; 5180 ierr = MatScale(A, shift / ts->ijacobian.shift);CHKERRQ(ierr); 5181 ts->ijacobian.shift = shift; 5182 PetscFunctionReturn(0); 5183 } 5184 5185 #undef __FUNCT__ 5186 #define __FUNCT__ "TSGetEquationType" 5187 /*@ 5188 TSGetEquationType - Gets the type of the equation that TS is solving. 5189 5190 Not Collective 5191 5192 Input Parameter: 5193 . ts - the TS context 5194 5195 Output Parameter: 5196 . equation_type - see TSEquationType 5197 5198 Level: beginner 5199 5200 .keywords: TS, equation type 5201 5202 .seealso: TSSetEquationType(), TSEquationType 5203 @*/ 5204 PetscErrorCode TSGetEquationType(TS ts,TSEquationType *equation_type) 5205 { 5206 PetscFunctionBegin; 5207 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5208 PetscValidPointer(equation_type,2); 5209 *equation_type = ts->equation_type; 5210 PetscFunctionReturn(0); 5211 } 5212 5213 #undef __FUNCT__ 5214 #define __FUNCT__ "TSSetEquationType" 5215 /*@ 5216 TSSetEquationType - Sets the type of the equation that TS is solving. 5217 5218 Not Collective 5219 5220 Input Parameter: 5221 + ts - the TS context 5222 - equation_type - see TSEquationType 5223 5224 Level: advanced 5225 5226 .keywords: TS, equation type 5227 5228 .seealso: TSGetEquationType(), TSEquationType 5229 @*/ 5230 PetscErrorCode TSSetEquationType(TS ts,TSEquationType equation_type) 5231 { 5232 PetscFunctionBegin; 5233 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5234 ts->equation_type = equation_type; 5235 PetscFunctionReturn(0); 5236 } 5237 5238 #undef __FUNCT__ 5239 #define __FUNCT__ "TSGetConvergedReason" 5240 /*@ 5241 TSGetConvergedReason - Gets the reason the TS iteration was stopped. 5242 5243 Not Collective 5244 5245 Input Parameter: 5246 . ts - the TS context 5247 5248 Output Parameter: 5249 . reason - negative value indicates diverged, positive value converged, see TSConvergedReason or the 5250 manual pages for the individual convergence tests for complete lists 5251 5252 Level: beginner 5253 5254 Notes: 5255 Can only be called after the call to TSSolve() is complete. 5256 5257 .keywords: TS, nonlinear, set, convergence, test 5258 5259 .seealso: TSSetConvergenceTest(), TSConvergedReason 5260 @*/ 5261 PetscErrorCode TSGetConvergedReason(TS ts,TSConvergedReason *reason) 5262 { 5263 PetscFunctionBegin; 5264 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5265 PetscValidPointer(reason,2); 5266 *reason = ts->reason; 5267 PetscFunctionReturn(0); 5268 } 5269 5270 #undef __FUNCT__ 5271 #define __FUNCT__ "TSSetConvergedReason" 5272 /*@ 5273 TSSetConvergedReason - Sets the reason for handling the convergence of TSSolve. 5274 5275 Not Collective 5276 5277 Input Parameter: 5278 + ts - the TS context 5279 . reason - negative value indicates diverged, positive value converged, see TSConvergedReason or the 5280 manual pages for the individual convergence tests for complete lists 5281 5282 Level: advanced 5283 5284 Notes: 5285 Can only be called during TSSolve() is active. 5286 5287 .keywords: TS, nonlinear, set, convergence, test 5288 5289 .seealso: TSConvergedReason 5290 @*/ 5291 PetscErrorCode TSSetConvergedReason(TS ts,TSConvergedReason reason) 5292 { 5293 PetscFunctionBegin; 5294 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5295 ts->reason = reason; 5296 PetscFunctionReturn(0); 5297 } 5298 5299 #undef __FUNCT__ 5300 #define __FUNCT__ "TSGetSolveTime" 5301 /*@ 5302 TSGetSolveTime - Gets the time after a call to TSSolve() 5303 5304 Not Collective 5305 5306 Input Parameter: 5307 . ts - the TS context 5308 5309 Output Parameter: 5310 . ftime - the final time. This time corresponds to the final time set with TSSetDuration() 5311 5312 Level: beginner 5313 5314 Notes: 5315 Can only be called after the call to TSSolve() is complete. 5316 5317 .keywords: TS, nonlinear, set, convergence, test 5318 5319 .seealso: TSSetConvergenceTest(), TSConvergedReason 5320 @*/ 5321 PetscErrorCode TSGetSolveTime(TS ts,PetscReal *ftime) 5322 { 5323 PetscFunctionBegin; 5324 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5325 PetscValidPointer(ftime,2); 5326 *ftime = ts->solvetime; 5327 PetscFunctionReturn(0); 5328 } 5329 5330 #undef __FUNCT__ 5331 #define __FUNCT__ "TSGetTotalSteps" 5332 /*@ 5333 TSGetTotalSteps - Gets the total number of steps done since the last call to TSSetUp() or TSCreate() 5334 5335 Not Collective 5336 5337 Input Parameter: 5338 . ts - the TS context 5339 5340 Output Parameter: 5341 . steps - the number of steps 5342 5343 Level: beginner 5344 5345 Notes: 5346 Includes the number of steps for all calls to TSSolve() since TSSetUp() was called 5347 5348 .keywords: TS, nonlinear, set, convergence, test 5349 5350 .seealso: TSSetConvergenceTest(), TSConvergedReason 5351 @*/ 5352 PetscErrorCode TSGetTotalSteps(TS ts,PetscInt *steps) 5353 { 5354 PetscFunctionBegin; 5355 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5356 PetscValidPointer(steps,2); 5357 *steps = ts->total_steps; 5358 PetscFunctionReturn(0); 5359 } 5360 5361 #undef __FUNCT__ 5362 #define __FUNCT__ "TSGetSNESIterations" 5363 /*@ 5364 TSGetSNESIterations - Gets the total number of nonlinear iterations 5365 used by the time integrator. 5366 5367 Not Collective 5368 5369 Input Parameter: 5370 . ts - TS context 5371 5372 Output Parameter: 5373 . nits - number of nonlinear iterations 5374 5375 Notes: 5376 This counter is reset to zero for each successive call to TSSolve(). 5377 5378 Level: intermediate 5379 5380 .keywords: TS, get, number, nonlinear, iterations 5381 5382 .seealso: TSGetKSPIterations() 5383 @*/ 5384 PetscErrorCode TSGetSNESIterations(TS ts,PetscInt *nits) 5385 { 5386 PetscFunctionBegin; 5387 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5388 PetscValidIntPointer(nits,2); 5389 *nits = ts->snes_its; 5390 PetscFunctionReturn(0); 5391 } 5392 5393 #undef __FUNCT__ 5394 #define __FUNCT__ "TSGetKSPIterations" 5395 /*@ 5396 TSGetKSPIterations - Gets the total number of linear iterations 5397 used by the time integrator. 5398 5399 Not Collective 5400 5401 Input Parameter: 5402 . ts - TS context 5403 5404 Output Parameter: 5405 . lits - number of linear iterations 5406 5407 Notes: 5408 This counter is reset to zero for each successive call to TSSolve(). 5409 5410 Level: intermediate 5411 5412 .keywords: TS, get, number, linear, iterations 5413 5414 .seealso: TSGetSNESIterations(), SNESGetKSPIterations() 5415 @*/ 5416 PetscErrorCode TSGetKSPIterations(TS ts,PetscInt *lits) 5417 { 5418 PetscFunctionBegin; 5419 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5420 PetscValidIntPointer(lits,2); 5421 *lits = ts->ksp_its; 5422 PetscFunctionReturn(0); 5423 } 5424 5425 #undef __FUNCT__ 5426 #define __FUNCT__ "TSGetStepRejections" 5427 /*@ 5428 TSGetStepRejections - Gets the total number of rejected steps. 5429 5430 Not Collective 5431 5432 Input Parameter: 5433 . ts - TS context 5434 5435 Output Parameter: 5436 . rejects - number of steps rejected 5437 5438 Notes: 5439 This counter is reset to zero for each successive call to TSSolve(). 5440 5441 Level: intermediate 5442 5443 .keywords: TS, get, number 5444 5445 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxStepRejections(), TSGetSNESFailures(), TSSetMaxSNESFailures(), TSSetErrorIfStepFails() 5446 @*/ 5447 PetscErrorCode TSGetStepRejections(TS ts,PetscInt *rejects) 5448 { 5449 PetscFunctionBegin; 5450 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5451 PetscValidIntPointer(rejects,2); 5452 *rejects = ts->reject; 5453 PetscFunctionReturn(0); 5454 } 5455 5456 #undef __FUNCT__ 5457 #define __FUNCT__ "TSGetSNESFailures" 5458 /*@ 5459 TSGetSNESFailures - Gets the total number of failed SNES solves 5460 5461 Not Collective 5462 5463 Input Parameter: 5464 . ts - TS context 5465 5466 Output Parameter: 5467 . fails - number of failed nonlinear solves 5468 5469 Notes: 5470 This counter is reset to zero for each successive call to TSSolve(). 5471 5472 Level: intermediate 5473 5474 .keywords: TS, get, number 5475 5476 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxStepRejections(), TSGetStepRejections(), TSSetMaxSNESFailures() 5477 @*/ 5478 PetscErrorCode TSGetSNESFailures(TS ts,PetscInt *fails) 5479 { 5480 PetscFunctionBegin; 5481 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5482 PetscValidIntPointer(fails,2); 5483 *fails = ts->num_snes_failures; 5484 PetscFunctionReturn(0); 5485 } 5486 5487 #undef __FUNCT__ 5488 #define __FUNCT__ "TSSetMaxStepRejections" 5489 /*@ 5490 TSSetMaxStepRejections - Sets the maximum number of step rejections before a step fails 5491 5492 Not Collective 5493 5494 Input Parameter: 5495 + ts - TS context 5496 - rejects - maximum number of rejected steps, pass -1 for unlimited 5497 5498 Notes: 5499 The counter is reset to zero for each step 5500 5501 Options Database Key: 5502 . -ts_max_reject - Maximum number of step rejections before a step fails 5503 5504 Level: intermediate 5505 5506 .keywords: TS, set, maximum, number 5507 5508 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxSNESFailures(), TSGetStepRejections(), TSGetSNESFailures(), TSSetErrorIfStepFails(), TSGetConvergedReason() 5509 @*/ 5510 PetscErrorCode TSSetMaxStepRejections(TS ts,PetscInt rejects) 5511 { 5512 PetscFunctionBegin; 5513 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5514 ts->max_reject = rejects; 5515 PetscFunctionReturn(0); 5516 } 5517 5518 #undef __FUNCT__ 5519 #define __FUNCT__ "TSSetMaxSNESFailures" 5520 /*@ 5521 TSSetMaxSNESFailures - Sets the maximum number of failed SNES solves 5522 5523 Not Collective 5524 5525 Input Parameter: 5526 + ts - TS context 5527 - fails - maximum number of failed nonlinear solves, pass -1 for unlimited 5528 5529 Notes: 5530 The counter is reset to zero for each successive call to TSSolve(). 5531 5532 Options Database Key: 5533 . -ts_max_snes_failures - Maximum number of nonlinear solve failures 5534 5535 Level: intermediate 5536 5537 .keywords: TS, set, maximum, number 5538 5539 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxStepRejections(), TSGetStepRejections(), TSGetSNESFailures(), SNESGetConvergedReason(), TSGetConvergedReason() 5540 @*/ 5541 PetscErrorCode TSSetMaxSNESFailures(TS ts,PetscInt fails) 5542 { 5543 PetscFunctionBegin; 5544 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5545 ts->max_snes_failures = fails; 5546 PetscFunctionReturn(0); 5547 } 5548 5549 #undef __FUNCT__ 5550 #define __FUNCT__ "TSSetErrorIfStepFails" 5551 /*@ 5552 TSSetErrorIfStepFails - Error if no step succeeds 5553 5554 Not Collective 5555 5556 Input Parameter: 5557 + ts - TS context 5558 - err - PETSC_TRUE to error if no step succeeds, PETSC_FALSE to return without failure 5559 5560 Options Database Key: 5561 . -ts_error_if_step_fails - Error if no step succeeds 5562 5563 Level: intermediate 5564 5565 .keywords: TS, set, error 5566 5567 .seealso: TSGetSNESIterations(), TSGetKSPIterations(), TSSetMaxStepRejections(), TSGetStepRejections(), TSGetSNESFailures(), TSSetErrorIfStepFails(), TSGetConvergedReason() 5568 @*/ 5569 PetscErrorCode TSSetErrorIfStepFails(TS ts,PetscBool err) 5570 { 5571 PetscFunctionBegin; 5572 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5573 ts->errorifstepfailed = err; 5574 PetscFunctionReturn(0); 5575 } 5576 5577 #undef __FUNCT__ 5578 #define __FUNCT__ "TSMonitorSolution" 5579 /*@C 5580 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 5581 5582 Collective on TS 5583 5584 Input Parameters: 5585 + ts - the TS context 5586 . step - current time-step 5587 . ptime - current time 5588 . u - current state 5589 - vf - viewer and its format 5590 5591 Level: intermediate 5592 5593 .keywords: TS, vector, monitor, view 5594 5595 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 5596 @*/ 5597 PetscErrorCode TSMonitorSolution(TS ts,PetscInt step,PetscReal ptime,Vec u,PetscViewerAndFormat *vf) 5598 { 5599 PetscErrorCode ierr; 5600 5601 PetscFunctionBegin; 5602 ierr = PetscViewerPushFormat(vf->viewer,vf->format);CHKERRQ(ierr); 5603 ierr = VecView(u,vf->viewer);CHKERRQ(ierr); 5604 ierr = PetscViewerPopFormat(vf->viewer);CHKERRQ(ierr); 5605 PetscFunctionReturn(0); 5606 } 5607 5608 #undef __FUNCT__ 5609 #define __FUNCT__ "TSMonitorSolutionVTK" 5610 /*@C 5611 TSMonitorSolutionVTK - Monitors progress of the TS solvers by VecView() for the solution at each timestep. 5612 5613 Collective on TS 5614 5615 Input Parameters: 5616 + ts - the TS context 5617 . step - current time-step 5618 . ptime - current time 5619 . u - current state 5620 - filenametemplate - string containing a format specifier for the integer time step (e.g. %03D) 5621 5622 Level: intermediate 5623 5624 Notes: 5625 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. 5626 These are named according to the file name template. 5627 5628 This function is normally passed as an argument to TSMonitorSet() along with TSMonitorSolutionVTKDestroy(). 5629 5630 .keywords: TS, vector, monitor, view 5631 5632 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView() 5633 @*/ 5634 PetscErrorCode TSMonitorSolutionVTK(TS ts,PetscInt step,PetscReal ptime,Vec u,void *filenametemplate) 5635 { 5636 PetscErrorCode ierr; 5637 char filename[PETSC_MAX_PATH_LEN]; 5638 PetscViewer viewer; 5639 5640 PetscFunctionBegin; 5641 if (step < 0) PetscFunctionReturn(0); /* -1 indicates interpolated solution */ 5642 ierr = PetscSNPrintf(filename,sizeof(filename),(const char*)filenametemplate,step);CHKERRQ(ierr); 5643 ierr = PetscViewerVTKOpen(PetscObjectComm((PetscObject)ts),filename,FILE_MODE_WRITE,&viewer);CHKERRQ(ierr); 5644 ierr = VecView(u,viewer);CHKERRQ(ierr); 5645 ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr); 5646 PetscFunctionReturn(0); 5647 } 5648 5649 #undef __FUNCT__ 5650 #define __FUNCT__ "TSMonitorSolutionVTKDestroy" 5651 /*@C 5652 TSMonitorSolutionVTKDestroy - Destroy context for monitoring 5653 5654 Collective on TS 5655 5656 Input Parameters: 5657 . filenametemplate - string containing a format specifier for the integer time step (e.g. %03D) 5658 5659 Level: intermediate 5660 5661 Note: 5662 This function is normally passed to TSMonitorSet() along with TSMonitorSolutionVTK(). 5663 5664 .keywords: TS, vector, monitor, view 5665 5666 .seealso: TSMonitorSet(), TSMonitorSolutionVTK() 5667 @*/ 5668 PetscErrorCode TSMonitorSolutionVTKDestroy(void *filenametemplate) 5669 { 5670 PetscErrorCode ierr; 5671 5672 PetscFunctionBegin; 5673 ierr = PetscFree(*(char**)filenametemplate);CHKERRQ(ierr); 5674 PetscFunctionReturn(0); 5675 } 5676 5677 #undef __FUNCT__ 5678 #define __FUNCT__ "TSGetAdapt" 5679 /*@ 5680 TSGetAdapt - Get the adaptive controller context for the current method 5681 5682 Collective on TS if controller has not been created yet 5683 5684 Input Arguments: 5685 . ts - time stepping context 5686 5687 Output Arguments: 5688 . adapt - adaptive controller 5689 5690 Level: intermediate 5691 5692 .seealso: TSAdapt, TSAdaptSetType(), TSAdaptChoose() 5693 @*/ 5694 PetscErrorCode TSGetAdapt(TS ts,TSAdapt *adapt) 5695 { 5696 PetscErrorCode ierr; 5697 5698 PetscFunctionBegin; 5699 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5700 PetscValidPointer(adapt,2); 5701 if (!ts->adapt) { 5702 ierr = TSAdaptCreate(PetscObjectComm((PetscObject)ts),&ts->adapt);CHKERRQ(ierr); 5703 ierr = PetscLogObjectParent((PetscObject)ts,(PetscObject)ts->adapt);CHKERRQ(ierr); 5704 ierr = PetscObjectIncrementTabLevel((PetscObject)ts->adapt,(PetscObject)ts,1);CHKERRQ(ierr); 5705 } 5706 *adapt = ts->adapt; 5707 PetscFunctionReturn(0); 5708 } 5709 5710 #undef __FUNCT__ 5711 #define __FUNCT__ "TSSetTolerances" 5712 /*@ 5713 TSSetTolerances - Set tolerances for local truncation error when using adaptive controller 5714 5715 Logically Collective 5716 5717 Input Arguments: 5718 + ts - time integration context 5719 . atol - scalar absolute tolerances, PETSC_DECIDE to leave current value 5720 . vatol - vector of absolute tolerances or NULL, used in preference to atol if present 5721 . rtol - scalar relative tolerances, PETSC_DECIDE to leave current value 5722 - vrtol - vector of relative tolerances or NULL, used in preference to atol if present 5723 5724 Options Database keys: 5725 + -ts_rtol <rtol> - relative tolerance for local truncation error 5726 - -ts_atol <atol> Absolute tolerance for local truncation error 5727 5728 Notes: 5729 With PETSc's implicit schemes for DAE problems, the calculation of the local truncation error 5730 (LTE) includes both the differential and the algebraic variables. If one wants the LTE to be 5731 computed only for the differential or the algebraic part then this can be done using the vector of 5732 tolerances vatol. For example, by setting the tolerance vector with the desired tolerance for the 5733 differential part and infinity for the algebraic part, the LTE calculation will include only the 5734 differential variables. 5735 5736 Level: beginner 5737 5738 .seealso: TS, TSAdapt, TSVecNormWRMS(), TSGetTolerances() 5739 @*/ 5740 PetscErrorCode TSSetTolerances(TS ts,PetscReal atol,Vec vatol,PetscReal rtol,Vec vrtol) 5741 { 5742 PetscErrorCode ierr; 5743 5744 PetscFunctionBegin; 5745 if (atol != PETSC_DECIDE && atol != PETSC_DEFAULT) ts->atol = atol; 5746 if (vatol) { 5747 ierr = PetscObjectReference((PetscObject)vatol);CHKERRQ(ierr); 5748 ierr = VecDestroy(&ts->vatol);CHKERRQ(ierr); 5749 ts->vatol = vatol; 5750 } 5751 if (rtol != PETSC_DECIDE && rtol != PETSC_DEFAULT) ts->rtol = rtol; 5752 if (vrtol) { 5753 ierr = PetscObjectReference((PetscObject)vrtol);CHKERRQ(ierr); 5754 ierr = VecDestroy(&ts->vrtol);CHKERRQ(ierr); 5755 ts->vrtol = vrtol; 5756 } 5757 PetscFunctionReturn(0); 5758 } 5759 5760 #undef __FUNCT__ 5761 #define __FUNCT__ "TSGetTolerances" 5762 /*@ 5763 TSGetTolerances - Get tolerances for local truncation error when using adaptive controller 5764 5765 Logically Collective 5766 5767 Input Arguments: 5768 . ts - time integration context 5769 5770 Output Arguments: 5771 + atol - scalar absolute tolerances, NULL to ignore 5772 . vatol - vector of absolute tolerances, NULL to ignore 5773 . rtol - scalar relative tolerances, NULL to ignore 5774 - vrtol - vector of relative tolerances, NULL to ignore 5775 5776 Level: beginner 5777 5778 .seealso: TS, TSAdapt, TSVecNormWRMS(), TSSetTolerances() 5779 @*/ 5780 PetscErrorCode TSGetTolerances(TS ts,PetscReal *atol,Vec *vatol,PetscReal *rtol,Vec *vrtol) 5781 { 5782 PetscFunctionBegin; 5783 if (atol) *atol = ts->atol; 5784 if (vatol) *vatol = ts->vatol; 5785 if (rtol) *rtol = ts->rtol; 5786 if (vrtol) *vrtol = ts->vrtol; 5787 PetscFunctionReturn(0); 5788 } 5789 5790 #undef __FUNCT__ 5791 #define __FUNCT__ "TSErrorWeightedNorm2" 5792 /*@ 5793 TSErrorWeightedNorm2 - compute a weighted 2-norm of the difference between two state vectors 5794 5795 Collective on TS 5796 5797 Input Arguments: 5798 + ts - time stepping context 5799 . U - state vector, usually ts->vec_sol 5800 - Y - state vector to be compared to U 5801 5802 Output Arguments: 5803 . norm - weighted norm, a value of 1.0 is considered small 5804 5805 Level: developer 5806 5807 .seealso: TSErrorWeightedNorm(), TSErrorWeightedNormInfinity() 5808 @*/ 5809 PetscErrorCode TSErrorWeightedNorm2(TS ts,Vec U,Vec Y,PetscReal *norm) 5810 { 5811 PetscErrorCode ierr; 5812 PetscInt i,n,N,rstart; 5813 const PetscScalar *u,*y; 5814 PetscReal sum,gsum; 5815 PetscReal tol; 5816 5817 PetscFunctionBegin; 5818 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5819 PetscValidHeaderSpecific(U,VEC_CLASSID,2); 5820 PetscValidHeaderSpecific(Y,VEC_CLASSID,3); 5821 PetscValidType(U,2); 5822 PetscValidType(Y,3); 5823 PetscCheckSameComm(U,2,Y,3); 5824 PetscValidPointer(norm,4); 5825 if (U == Y) SETERRQ(PetscObjectComm((PetscObject)U),PETSC_ERR_ARG_IDN,"U and Y cannot be the same vector"); 5826 5827 ierr = VecGetSize(U,&N);CHKERRQ(ierr); 5828 ierr = VecGetLocalSize(U,&n);CHKERRQ(ierr); 5829 ierr = VecGetOwnershipRange(U,&rstart,NULL);CHKERRQ(ierr); 5830 ierr = VecGetArrayRead(U,&u);CHKERRQ(ierr); 5831 ierr = VecGetArrayRead(Y,&y);CHKERRQ(ierr); 5832 sum = 0.; 5833 if (ts->vatol && ts->vrtol) { 5834 const PetscScalar *atol,*rtol; 5835 ierr = VecGetArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5836 ierr = VecGetArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5837 for (i=0; i<n; i++) { 5838 tol = PetscRealPart(atol[i]) + PetscRealPart(rtol[i]) * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5839 sum += PetscSqr(PetscAbsScalar(y[i] - u[i]) / tol); 5840 } 5841 ierr = VecRestoreArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5842 ierr = VecRestoreArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5843 } else if (ts->vatol) { /* vector atol, scalar rtol */ 5844 const PetscScalar *atol; 5845 ierr = VecGetArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5846 for (i=0; i<n; i++) { 5847 tol = PetscRealPart(atol[i]) + ts->rtol * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5848 sum += PetscSqr(PetscAbsScalar(y[i] - u[i]) / tol); 5849 } 5850 ierr = VecRestoreArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5851 } else if (ts->vrtol) { /* scalar atol, vector rtol */ 5852 const PetscScalar *rtol; 5853 ierr = VecGetArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5854 for (i=0; i<n; i++) { 5855 tol = ts->atol + PetscRealPart(rtol[i]) * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5856 sum += PetscSqr(PetscAbsScalar(y[i] - u[i]) / tol); 5857 } 5858 ierr = VecRestoreArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5859 } else { /* scalar atol, scalar rtol */ 5860 for (i=0; i<n; i++) { 5861 tol = ts->atol + ts->rtol * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5862 sum += PetscSqr(PetscAbsScalar(y[i] - u[i]) / tol); 5863 } 5864 } 5865 ierr = VecRestoreArrayRead(U,&u);CHKERRQ(ierr); 5866 ierr = VecRestoreArrayRead(Y,&y);CHKERRQ(ierr); 5867 5868 ierr = MPIU_Allreduce(&sum,&gsum,1,MPIU_REAL,MPIU_SUM,PetscObjectComm((PetscObject)ts));CHKERRQ(ierr); 5869 *norm = PetscSqrtReal(gsum / N); 5870 5871 if (PetscIsInfOrNanScalar(*norm)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in norm"); 5872 PetscFunctionReturn(0); 5873 } 5874 5875 #undef __FUNCT__ 5876 #define __FUNCT__ "TSErrorWeightedNormInfinity" 5877 /*@ 5878 TSErrorWeightedNormInfinity - compute a weighted infinity-norm of the difference between two state vectors 5879 5880 Collective on TS 5881 5882 Input Arguments: 5883 + ts - time stepping context 5884 . U - state vector, usually ts->vec_sol 5885 - Y - state vector to be compared to U 5886 5887 Output Arguments: 5888 . norm - weighted norm, a value of 1.0 is considered small 5889 5890 Level: developer 5891 5892 .seealso: TSErrorWeightedNorm(), TSErrorWeightedNorm2() 5893 @*/ 5894 PetscErrorCode TSErrorWeightedNormInfinity(TS ts,Vec U,Vec Y,PetscReal *norm) 5895 { 5896 PetscErrorCode ierr; 5897 PetscInt i,n,N,rstart,k; 5898 const PetscScalar *u,*y; 5899 PetscReal max,gmax; 5900 PetscReal tol; 5901 5902 PetscFunctionBegin; 5903 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 5904 PetscValidHeaderSpecific(U,VEC_CLASSID,2); 5905 PetscValidHeaderSpecific(Y,VEC_CLASSID,3); 5906 PetscValidType(U,2); 5907 PetscValidType(Y,3); 5908 PetscCheckSameComm(U,2,Y,3); 5909 PetscValidPointer(norm,4); 5910 if (U == Y) SETERRQ(PetscObjectComm((PetscObject)U),PETSC_ERR_ARG_IDN,"U and Y cannot be the same vector"); 5911 5912 ierr = VecGetSize(U,&N);CHKERRQ(ierr); 5913 ierr = VecGetLocalSize(U,&n);CHKERRQ(ierr); 5914 ierr = VecGetOwnershipRange(U,&rstart,NULL);CHKERRQ(ierr); 5915 ierr = VecGetArrayRead(U,&u);CHKERRQ(ierr); 5916 ierr = VecGetArrayRead(Y,&y);CHKERRQ(ierr); 5917 if (ts->vatol && ts->vrtol) { 5918 const PetscScalar *atol,*rtol; 5919 ierr = VecGetArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5920 ierr = VecGetArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5921 k = 0; 5922 tol = PetscRealPart(atol[k]) + PetscRealPart(rtol[k]) * PetscMax(PetscAbsScalar(u[k]),PetscAbsScalar(y[k])); 5923 max = PetscAbsScalar(y[k] - u[k]) / tol; 5924 for (i=1; i<n; i++) { 5925 tol = PetscRealPart(atol[i]) + PetscRealPart(rtol[i]) * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5926 max = PetscMax(max,PetscAbsScalar(y[i] - u[i]) / tol); 5927 } 5928 ierr = VecRestoreArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5929 ierr = VecRestoreArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5930 } else if (ts->vatol) { /* vector atol, scalar rtol */ 5931 const PetscScalar *atol; 5932 ierr = VecGetArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5933 k = 0; 5934 tol = PetscRealPart(atol[k]) + ts->rtol * PetscMax(PetscAbsScalar(u[k]),PetscAbsScalar(y[k])); 5935 max = PetscAbsScalar(y[k] - u[k]) / tol; 5936 for (i=1; i<n; i++) { 5937 tol = PetscRealPart(atol[i]) + ts->rtol * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5938 max = PetscMax(max,PetscAbsScalar(y[i] - u[i]) / tol); 5939 } 5940 ierr = VecRestoreArrayRead(ts->vatol,&atol);CHKERRQ(ierr); 5941 } else if (ts->vrtol) { /* scalar atol, vector rtol */ 5942 const PetscScalar *rtol; 5943 ierr = VecGetArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5944 k = 0; 5945 tol = ts->atol + PetscRealPart(rtol[k]) * PetscMax(PetscAbsScalar(u[k]),PetscAbsScalar(y[k])); 5946 max = PetscAbsScalar(y[k] - u[k]) / tol; 5947 for (i=1; i<n; i++) { 5948 tol = ts->atol + PetscRealPart(rtol[i]) * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5949 max = PetscMax(max,PetscAbsScalar(y[i] - u[i]) / tol); 5950 } 5951 ierr = VecRestoreArrayRead(ts->vrtol,&rtol);CHKERRQ(ierr); 5952 } else { /* scalar atol, scalar rtol */ 5953 k = 0; 5954 tol = ts->atol + ts->rtol * PetscMax(PetscAbsScalar(u[k]),PetscAbsScalar(y[k])); 5955 max = PetscAbsScalar(y[k] - u[k]) / tol; 5956 for (i=1; i<n; i++) { 5957 tol = ts->atol + ts->rtol * PetscMax(PetscAbsScalar(u[i]),PetscAbsScalar(y[i])); 5958 max = PetscMax(max,PetscAbsScalar(y[i] - u[i]) / tol); 5959 } 5960 } 5961 ierr = VecRestoreArrayRead(U,&u);CHKERRQ(ierr); 5962 ierr = VecRestoreArrayRead(Y,&y);CHKERRQ(ierr); 5963 5964 ierr = MPIU_Allreduce(&max,&gmax,1,MPIU_REAL,MPIU_MAX,PetscObjectComm((PetscObject)ts));CHKERRQ(ierr); 5965 *norm = gmax; 5966 5967 if (PetscIsInfOrNanScalar(*norm)) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_FP,"Infinite or not-a-number generated in norm"); 5968 PetscFunctionReturn(0); 5969 } 5970 5971 #undef __FUNCT__ 5972 #define __FUNCT__ "TSErrorWeightedNorm" 5973 /*@ 5974 TSErrorWeightedNorm - compute a weighted norm of the difference between two state vectors 5975 5976 Collective on TS 5977 5978 Input Arguments: 5979 + ts - time stepping context 5980 . U - state vector, usually ts->vec_sol 5981 . Y - state vector to be compared to U 5982 - wnormtype - norm type, either NORM_2 or NORM_INFINITY 5983 5984 Output Arguments: 5985 . norm - weighted norm, a value of 1.0 is considered small 5986 5987 5988 Options Database Keys: 5989 . -ts_adapt_wnormtype <wnormtype> - 2, INFINITY 5990 5991 Level: developer 5992 5993 .seealso: TSErrorWeightedNormInfinity(), TSErrorWeightedNorm2() 5994 @*/ 5995 PetscErrorCode TSErrorWeightedNorm(TS ts,Vec U,Vec Y,NormType wnormtype,PetscReal *norm) 5996 { 5997 PetscErrorCode ierr; 5998 5999 PetscFunctionBegin; 6000 if (wnormtype == NORM_2) { 6001 ierr = TSErrorWeightedNorm2(ts,U,Y,norm);CHKERRQ(ierr); 6002 } else if(wnormtype == NORM_INFINITY) { 6003 ierr = TSErrorWeightedNormInfinity(ts,U,Y,norm);CHKERRQ(ierr); 6004 } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"No support for norm type %s",NormTypes[wnormtype]); 6005 PetscFunctionReturn(0); 6006 } 6007 6008 #undef __FUNCT__ 6009 #define __FUNCT__ "TSSetCFLTimeLocal" 6010 /*@ 6011 TSSetCFLTimeLocal - Set the local CFL constraint relative to forward Euler 6012 6013 Logically Collective on TS 6014 6015 Input Arguments: 6016 + ts - time stepping context 6017 - cfltime - maximum stable time step if using forward Euler (value can be different on each process) 6018 6019 Note: 6020 After calling this function, the global CFL time can be obtained by calling TSGetCFLTime() 6021 6022 Level: intermediate 6023 6024 .seealso: TSGetCFLTime(), TSADAPTCFL 6025 @*/ 6026 PetscErrorCode TSSetCFLTimeLocal(TS ts,PetscReal cfltime) 6027 { 6028 PetscFunctionBegin; 6029 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 6030 ts->cfltime_local = cfltime; 6031 ts->cfltime = -1.; 6032 PetscFunctionReturn(0); 6033 } 6034 6035 #undef __FUNCT__ 6036 #define __FUNCT__ "TSGetCFLTime" 6037 /*@ 6038 TSGetCFLTime - Get the maximum stable time step according to CFL criteria applied to forward Euler 6039 6040 Collective on TS 6041 6042 Input Arguments: 6043 . ts - time stepping context 6044 6045 Output Arguments: 6046 . cfltime - maximum stable time step for forward Euler 6047 6048 Level: advanced 6049 6050 .seealso: TSSetCFLTimeLocal() 6051 @*/ 6052 PetscErrorCode TSGetCFLTime(TS ts,PetscReal *cfltime) 6053 { 6054 PetscErrorCode ierr; 6055 6056 PetscFunctionBegin; 6057 if (ts->cfltime < 0) { 6058 ierr = MPIU_Allreduce(&ts->cfltime_local,&ts->cfltime,1,MPIU_REAL,MPIU_MIN,PetscObjectComm((PetscObject)ts));CHKERRQ(ierr); 6059 } 6060 *cfltime = ts->cfltime; 6061 PetscFunctionReturn(0); 6062 } 6063 6064 #undef __FUNCT__ 6065 #define __FUNCT__ "TSVISetVariableBounds" 6066 /*@ 6067 TSVISetVariableBounds - Sets the lower and upper bounds for the solution vector. xl <= x <= xu 6068 6069 Input Parameters: 6070 . ts - the TS context. 6071 . xl - lower bound. 6072 . xu - upper bound. 6073 6074 Notes: 6075 If this routine is not called then the lower and upper bounds are set to 6076 PETSC_NINFINITY and PETSC_INFINITY respectively during SNESSetUp(). 6077 6078 Level: advanced 6079 6080 @*/ 6081 PetscErrorCode TSVISetVariableBounds(TS ts, Vec xl, Vec xu) 6082 { 6083 PetscErrorCode ierr; 6084 SNES snes; 6085 6086 PetscFunctionBegin; 6087 ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr); 6088 ierr = SNESVISetVariableBounds(snes,xl,xu);CHKERRQ(ierr); 6089 PetscFunctionReturn(0); 6090 } 6091 6092 #if defined(PETSC_HAVE_MATLAB_ENGINE) 6093 #include <mex.h> 6094 6095 typedef struct {char *funcname; mxArray *ctx;} TSMatlabContext; 6096 6097 #undef __FUNCT__ 6098 #define __FUNCT__ "TSComputeFunction_Matlab" 6099 /* 6100 TSComputeFunction_Matlab - Calls the function that has been set with 6101 TSSetFunctionMatlab(). 6102 6103 Collective on TS 6104 6105 Input Parameters: 6106 + snes - the TS context 6107 - u - input vector 6108 6109 Output Parameter: 6110 . y - function vector, as set by TSSetFunction() 6111 6112 Notes: 6113 TSComputeFunction() is typically used within nonlinear solvers 6114 implementations, so most users would not generally call this routine 6115 themselves. 6116 6117 Level: developer 6118 6119 .keywords: TS, nonlinear, compute, function 6120 6121 .seealso: TSSetFunction(), TSGetFunction() 6122 */ 6123 PetscErrorCode TSComputeFunction_Matlab(TS snes,PetscReal time,Vec u,Vec udot,Vec y, void *ctx) 6124 { 6125 PetscErrorCode ierr; 6126 TSMatlabContext *sctx = (TSMatlabContext*)ctx; 6127 int nlhs = 1,nrhs = 7; 6128 mxArray *plhs[1],*prhs[7]; 6129 long long int lx = 0,lxdot = 0,ly = 0,ls = 0; 6130 6131 PetscFunctionBegin; 6132 PetscValidHeaderSpecific(snes,TS_CLASSID,1); 6133 PetscValidHeaderSpecific(u,VEC_CLASSID,3); 6134 PetscValidHeaderSpecific(udot,VEC_CLASSID,4); 6135 PetscValidHeaderSpecific(y,VEC_CLASSID,5); 6136 PetscCheckSameComm(snes,1,u,3); 6137 PetscCheckSameComm(snes,1,y,5); 6138 6139 ierr = PetscMemcpy(&ls,&snes,sizeof(snes));CHKERRQ(ierr); 6140 ierr = PetscMemcpy(&lx,&u,sizeof(u));CHKERRQ(ierr); 6141 ierr = PetscMemcpy(&lxdot,&udot,sizeof(udot));CHKERRQ(ierr); 6142 ierr = PetscMemcpy(&ly,&y,sizeof(u));CHKERRQ(ierr); 6143 6144 prhs[0] = mxCreateDoubleScalar((double)ls); 6145 prhs[1] = mxCreateDoubleScalar(time); 6146 prhs[2] = mxCreateDoubleScalar((double)lx); 6147 prhs[3] = mxCreateDoubleScalar((double)lxdot); 6148 prhs[4] = mxCreateDoubleScalar((double)ly); 6149 prhs[5] = mxCreateString(sctx->funcname); 6150 prhs[6] = sctx->ctx; 6151 ierr = mexCallMATLAB(nlhs,plhs,nrhs,prhs,"PetscTSComputeFunctionInternal");CHKERRQ(ierr); 6152 ierr = mxGetScalar(plhs[0]);CHKERRQ(ierr); 6153 mxDestroyArray(prhs[0]); 6154 mxDestroyArray(prhs[1]); 6155 mxDestroyArray(prhs[2]); 6156 mxDestroyArray(prhs[3]); 6157 mxDestroyArray(prhs[4]); 6158 mxDestroyArray(prhs[5]); 6159 mxDestroyArray(plhs[0]); 6160 PetscFunctionReturn(0); 6161 } 6162 6163 6164 #undef __FUNCT__ 6165 #define __FUNCT__ "TSSetFunctionMatlab" 6166 /* 6167 TSSetFunctionMatlab - Sets the function evaluation routine and function 6168 vector for use by the TS routines in solving ODEs 6169 equations from MATLAB. Here the function is a string containing the name of a MATLAB function 6170 6171 Logically Collective on TS 6172 6173 Input Parameters: 6174 + ts - the TS context 6175 - func - function evaluation routine 6176 6177 Calling sequence of func: 6178 $ func (TS ts,PetscReal time,Vec u,Vec udot,Vec f,void *ctx); 6179 6180 Level: beginner 6181 6182 .keywords: TS, nonlinear, set, function 6183 6184 .seealso: TSGetFunction(), TSComputeFunction(), TSSetJacobian(), TSSetFunction() 6185 */ 6186 PetscErrorCode TSSetFunctionMatlab(TS ts,const char *func,mxArray *ctx) 6187 { 6188 PetscErrorCode ierr; 6189 TSMatlabContext *sctx; 6190 6191 PetscFunctionBegin; 6192 /* currently sctx is memory bleed */ 6193 ierr = PetscNew(&sctx);CHKERRQ(ierr); 6194 ierr = PetscStrallocpy(func,&sctx->funcname);CHKERRQ(ierr); 6195 /* 6196 This should work, but it doesn't 6197 sctx->ctx = ctx; 6198 mexMakeArrayPersistent(sctx->ctx); 6199 */ 6200 sctx->ctx = mxDuplicateArray(ctx); 6201 6202 ierr = TSSetIFunction(ts,NULL,TSComputeFunction_Matlab,sctx);CHKERRQ(ierr); 6203 PetscFunctionReturn(0); 6204 } 6205 6206 #undef __FUNCT__ 6207 #define __FUNCT__ "TSComputeJacobian_Matlab" 6208 /* 6209 TSComputeJacobian_Matlab - Calls the function that has been set with 6210 TSSetJacobianMatlab(). 6211 6212 Collective on TS 6213 6214 Input Parameters: 6215 + ts - the TS context 6216 . u - input vector 6217 . A, B - the matrices 6218 - ctx - user context 6219 6220 Level: developer 6221 6222 .keywords: TS, nonlinear, compute, function 6223 6224 .seealso: TSSetFunction(), TSGetFunction() 6225 @*/ 6226 PetscErrorCode TSComputeJacobian_Matlab(TS ts,PetscReal time,Vec u,Vec udot,PetscReal shift,Mat A,Mat B,void *ctx) 6227 { 6228 PetscErrorCode ierr; 6229 TSMatlabContext *sctx = (TSMatlabContext*)ctx; 6230 int nlhs = 2,nrhs = 9; 6231 mxArray *plhs[2],*prhs[9]; 6232 long long int lx = 0,lxdot = 0,lA = 0,ls = 0, lB = 0; 6233 6234 PetscFunctionBegin; 6235 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 6236 PetscValidHeaderSpecific(u,VEC_CLASSID,3); 6237 6238 /* call Matlab function in ctx with arguments u and y */ 6239 6240 ierr = PetscMemcpy(&ls,&ts,sizeof(ts));CHKERRQ(ierr); 6241 ierr = PetscMemcpy(&lx,&u,sizeof(u));CHKERRQ(ierr); 6242 ierr = PetscMemcpy(&lxdot,&udot,sizeof(u));CHKERRQ(ierr); 6243 ierr = PetscMemcpy(&lA,A,sizeof(u));CHKERRQ(ierr); 6244 ierr = PetscMemcpy(&lB,B,sizeof(u));CHKERRQ(ierr); 6245 6246 prhs[0] = mxCreateDoubleScalar((double)ls); 6247 prhs[1] = mxCreateDoubleScalar((double)time); 6248 prhs[2] = mxCreateDoubleScalar((double)lx); 6249 prhs[3] = mxCreateDoubleScalar((double)lxdot); 6250 prhs[4] = mxCreateDoubleScalar((double)shift); 6251 prhs[5] = mxCreateDoubleScalar((double)lA); 6252 prhs[6] = mxCreateDoubleScalar((double)lB); 6253 prhs[7] = mxCreateString(sctx->funcname); 6254 prhs[8] = sctx->ctx; 6255 ierr = mexCallMATLAB(nlhs,plhs,nrhs,prhs,"PetscTSComputeJacobianInternal");CHKERRQ(ierr); 6256 ierr = mxGetScalar(plhs[0]);CHKERRQ(ierr); 6257 mxDestroyArray(prhs[0]); 6258 mxDestroyArray(prhs[1]); 6259 mxDestroyArray(prhs[2]); 6260 mxDestroyArray(prhs[3]); 6261 mxDestroyArray(prhs[4]); 6262 mxDestroyArray(prhs[5]); 6263 mxDestroyArray(prhs[6]); 6264 mxDestroyArray(prhs[7]); 6265 mxDestroyArray(plhs[0]); 6266 mxDestroyArray(plhs[1]); 6267 PetscFunctionReturn(0); 6268 } 6269 6270 6271 #undef __FUNCT__ 6272 #define __FUNCT__ "TSSetJacobianMatlab" 6273 /* 6274 TSSetJacobianMatlab - Sets the Jacobian function evaluation routine and two empty Jacobian matrices 6275 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 6276 6277 Logically Collective on TS 6278 6279 Input Parameters: 6280 + ts - the TS context 6281 . A,B - Jacobian matrices 6282 . func - function evaluation routine 6283 - ctx - user context 6284 6285 Calling sequence of func: 6286 $ flag = func (TS ts,PetscReal time,Vec u,Vec udot,Mat A,Mat B,void *ctx); 6287 6288 6289 Level: developer 6290 6291 .keywords: TS, nonlinear, set, function 6292 6293 .seealso: TSGetFunction(), TSComputeFunction(), TSSetJacobian(), TSSetFunction() 6294 */ 6295 PetscErrorCode TSSetJacobianMatlab(TS ts,Mat A,Mat B,const char *func,mxArray *ctx) 6296 { 6297 PetscErrorCode ierr; 6298 TSMatlabContext *sctx; 6299 6300 PetscFunctionBegin; 6301 /* currently sctx is memory bleed */ 6302 ierr = PetscNew(&sctx);CHKERRQ(ierr); 6303 ierr = PetscStrallocpy(func,&sctx->funcname);CHKERRQ(ierr); 6304 /* 6305 This should work, but it doesn't 6306 sctx->ctx = ctx; 6307 mexMakeArrayPersistent(sctx->ctx); 6308 */ 6309 sctx->ctx = mxDuplicateArray(ctx); 6310 6311 ierr = TSSetIJacobian(ts,A,B,TSComputeJacobian_Matlab,sctx);CHKERRQ(ierr); 6312 PetscFunctionReturn(0); 6313 } 6314 6315 #undef __FUNCT__ 6316 #define __FUNCT__ "TSMonitor_Matlab" 6317 /* 6318 TSMonitor_Matlab - Calls the function that has been set with TSMonitorSetMatlab(). 6319 6320 Collective on TS 6321 6322 .seealso: TSSetFunction(), TSGetFunction() 6323 @*/ 6324 PetscErrorCode TSMonitor_Matlab(TS ts,PetscInt it, PetscReal time,Vec u, void *ctx) 6325 { 6326 PetscErrorCode ierr; 6327 TSMatlabContext *sctx = (TSMatlabContext*)ctx; 6328 int nlhs = 1,nrhs = 6; 6329 mxArray *plhs[1],*prhs[6]; 6330 long long int lx = 0,ls = 0; 6331 6332 PetscFunctionBegin; 6333 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 6334 PetscValidHeaderSpecific(u,VEC_CLASSID,4); 6335 6336 ierr = PetscMemcpy(&ls,&ts,sizeof(ts));CHKERRQ(ierr); 6337 ierr = PetscMemcpy(&lx,&u,sizeof(u));CHKERRQ(ierr); 6338 6339 prhs[0] = mxCreateDoubleScalar((double)ls); 6340 prhs[1] = mxCreateDoubleScalar((double)it); 6341 prhs[2] = mxCreateDoubleScalar((double)time); 6342 prhs[3] = mxCreateDoubleScalar((double)lx); 6343 prhs[4] = mxCreateString(sctx->funcname); 6344 prhs[5] = sctx->ctx; 6345 ierr = mexCallMATLAB(nlhs,plhs,nrhs,prhs,"PetscTSMonitorInternal");CHKERRQ(ierr); 6346 ierr = mxGetScalar(plhs[0]);CHKERRQ(ierr); 6347 mxDestroyArray(prhs[0]); 6348 mxDestroyArray(prhs[1]); 6349 mxDestroyArray(prhs[2]); 6350 mxDestroyArray(prhs[3]); 6351 mxDestroyArray(prhs[4]); 6352 mxDestroyArray(plhs[0]); 6353 PetscFunctionReturn(0); 6354 } 6355 6356 6357 #undef __FUNCT__ 6358 #define __FUNCT__ "TSMonitorSetMatlab" 6359 /* 6360 TSMonitorSetMatlab - Sets the monitor function from Matlab 6361 6362 Level: developer 6363 6364 .keywords: TS, nonlinear, set, function 6365 6366 .seealso: TSGetFunction(), TSComputeFunction(), TSSetJacobian(), TSSetFunction() 6367 */ 6368 PetscErrorCode TSMonitorSetMatlab(TS ts,const char *func,mxArray *ctx) 6369 { 6370 PetscErrorCode ierr; 6371 TSMatlabContext *sctx; 6372 6373 PetscFunctionBegin; 6374 /* currently sctx is memory bleed */ 6375 ierr = PetscNew(&sctx);CHKERRQ(ierr); 6376 ierr = PetscStrallocpy(func,&sctx->funcname);CHKERRQ(ierr); 6377 /* 6378 This should work, but it doesn't 6379 sctx->ctx = ctx; 6380 mexMakeArrayPersistent(sctx->ctx); 6381 */ 6382 sctx->ctx = mxDuplicateArray(ctx); 6383 6384 ierr = TSMonitorSet(ts,TSMonitor_Matlab,sctx,NULL);CHKERRQ(ierr); 6385 PetscFunctionReturn(0); 6386 } 6387 #endif 6388 6389 #undef __FUNCT__ 6390 #define __FUNCT__ "TSMonitorLGSolution" 6391 /*@C 6392 TSMonitorLGSolution - Monitors progress of the TS solvers by plotting each component of the solution vector 6393 in a time based line graph 6394 6395 Collective on TS 6396 6397 Input Parameters: 6398 + ts - the TS context 6399 . step - current time-step 6400 . ptime - current time 6401 . u - current solution 6402 - dctx - the TSMonitorLGCtx object that contains all the options for the monitoring, this is created with TSMonitorLGCtxCreate() 6403 6404 Options Database: 6405 . -ts_monitor_lg_solution_variables 6406 6407 Level: intermediate 6408 6409 Notes: Each process in a parallel run displays its component solutions in a separate window 6410 6411 .keywords: TS, vector, monitor, view 6412 6413 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGCtxCreate(), TSMonitorLGCtxSetVariableNames(), TSMonitorLGCtxGetVariableNames(), 6414 TSMonitorLGSetVariableNames(), TSMonitorLGGetVariableNames(), TSMonitorLGSetDisplayVariables(), TSMonitorLGCtxSetDisplayVariables(), 6415 TSMonitorLGCtxSetTransform(), TSMonitorLGSetTransform(), TSMonitorLGError(), TSMonitorLGSNESIterations(), TSMonitorLGKSPIterations(), 6416 TSMonitorEnvelopeCtxCreate(), TSMonitorEnvelopeGetBounds(), TSMonitorEnvelopeCtxDestroy(), TSMonitorEnvelop() 6417 @*/ 6418 PetscErrorCode TSMonitorLGSolution(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dctx) 6419 { 6420 PetscErrorCode ierr; 6421 TSMonitorLGCtx ctx = (TSMonitorLGCtx)dctx; 6422 const PetscScalar *yy; 6423 Vec v; 6424 6425 PetscFunctionBegin; 6426 if (step < 0) PetscFunctionReturn(0); /* -1 indicates interpolated solution */ 6427 if (!step) { 6428 PetscDrawAxis axis; 6429 PetscInt dim; 6430 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 6431 ierr = PetscDrawAxisSetLabels(axis,"Solution as function of time","Time","Solution");CHKERRQ(ierr); 6432 if (!ctx->names) { 6433 PetscBool flg; 6434 /* user provides names of variables to plot but no names has been set so assume names are integer values */ 6435 ierr = PetscOptionsHasName(((PetscObject)ts)->options,((PetscObject)ts)->prefix,"-ts_monitor_lg_solution_variables",&flg);CHKERRQ(ierr); 6436 if (flg) { 6437 PetscInt i,n; 6438 char **names; 6439 ierr = VecGetSize(u,&n);CHKERRQ(ierr); 6440 ierr = PetscMalloc1(n+1,&names);CHKERRQ(ierr); 6441 for (i=0; i<n; i++) { 6442 ierr = PetscMalloc1(5,&names[i]);CHKERRQ(ierr); 6443 ierr = PetscSNPrintf(names[i],5,"%D",i);CHKERRQ(ierr); 6444 } 6445 names[n] = NULL; 6446 ctx->names = names; 6447 } 6448 } 6449 if (ctx->names && !ctx->displaynames) { 6450 char **displaynames; 6451 PetscBool flg; 6452 ierr = VecGetLocalSize(u,&dim);CHKERRQ(ierr); 6453 ierr = PetscMalloc1(dim+1,&displaynames);CHKERRQ(ierr); 6454 ierr = PetscMemzero(displaynames,(dim+1)*sizeof(char*));CHKERRQ(ierr); 6455 ierr = PetscOptionsGetStringArray(((PetscObject)ts)->options,((PetscObject)ts)->prefix,"-ts_monitor_lg_solution_variables",displaynames,&dim,&flg);CHKERRQ(ierr); 6456 if (flg) { 6457 ierr = TSMonitorLGCtxSetDisplayVariables(ctx,(const char *const *)displaynames);CHKERRQ(ierr); 6458 } 6459 ierr = PetscStrArrayDestroy(&displaynames);CHKERRQ(ierr); 6460 } 6461 if (ctx->displaynames) { 6462 ierr = PetscDrawLGSetDimension(ctx->lg,ctx->ndisplayvariables);CHKERRQ(ierr); 6463 ierr = PetscDrawLGSetLegend(ctx->lg,(const char *const *)ctx->displaynames);CHKERRQ(ierr); 6464 } else if (ctx->names) { 6465 ierr = VecGetLocalSize(u,&dim);CHKERRQ(ierr); 6466 ierr = PetscDrawLGSetDimension(ctx->lg,dim);CHKERRQ(ierr); 6467 ierr = PetscDrawLGSetLegend(ctx->lg,(const char *const *)ctx->names);CHKERRQ(ierr); 6468 } else { 6469 ierr = VecGetLocalSize(u,&dim);CHKERRQ(ierr); 6470 ierr = PetscDrawLGSetDimension(ctx->lg,dim);CHKERRQ(ierr); 6471 } 6472 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 6473 } 6474 6475 if (!ctx->transform) v = u; 6476 else {ierr = (*ctx->transform)(ctx->transformctx,u,&v);CHKERRQ(ierr);} 6477 ierr = VecGetArrayRead(v,&yy);CHKERRQ(ierr); 6478 if (ctx->displaynames) { 6479 PetscInt i; 6480 for (i=0; i<ctx->ndisplayvariables; i++) 6481 ctx->displayvalues[i] = PetscRealPart(yy[ctx->displayvariables[i]]); 6482 ierr = PetscDrawLGAddCommonPoint(ctx->lg,ptime,ctx->displayvalues);CHKERRQ(ierr); 6483 } else { 6484 #if defined(PETSC_USE_COMPLEX) 6485 PetscInt i,n; 6486 PetscReal *yreal; 6487 ierr = VecGetLocalSize(v,&n);CHKERRQ(ierr); 6488 ierr = PetscMalloc1(n,&yreal);CHKERRQ(ierr); 6489 for (i=0; i<n; i++) yreal[i] = PetscRealPart(yy[i]); 6490 ierr = PetscDrawLGAddCommonPoint(ctx->lg,ptime,yreal);CHKERRQ(ierr); 6491 ierr = PetscFree(yreal);CHKERRQ(ierr); 6492 #else 6493 ierr = PetscDrawLGAddCommonPoint(ctx->lg,ptime,yy);CHKERRQ(ierr); 6494 #endif 6495 } 6496 ierr = VecRestoreArrayRead(v,&yy);CHKERRQ(ierr); 6497 if (ctx->transform) {ierr = VecDestroy(&v);CHKERRQ(ierr);} 6498 6499 if (((ctx->howoften > 0) && (!(step % ctx->howoften))) || ((ctx->howoften == -1) && ts->reason)) { 6500 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 6501 ierr = PetscDrawLGSave(ctx->lg);CHKERRQ(ierr); 6502 } 6503 PetscFunctionReturn(0); 6504 } 6505 6506 6507 #undef __FUNCT__ 6508 #define __FUNCT__ "TSMonitorLGSetVariableNames" 6509 /*@C 6510 TSMonitorLGSetVariableNames - Sets the name of each component in the solution vector so that it may be displayed in the plot 6511 6512 Collective on TS 6513 6514 Input Parameters: 6515 + ts - the TS context 6516 - names - the names of the components, final string must be NULL 6517 6518 Level: intermediate 6519 6520 Notes: If the TS object does not have a TSMonitorLGCtx associated with it then this function is ignored 6521 6522 .keywords: TS, vector, monitor, view 6523 6524 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetDisplayVariables(), TSMonitorLGCtxSetVariableNames() 6525 @*/ 6526 PetscErrorCode TSMonitorLGSetVariableNames(TS ts,const char * const *names) 6527 { 6528 PetscErrorCode ierr; 6529 PetscInt i; 6530 6531 PetscFunctionBegin; 6532 for (i=0; i<ts->numbermonitors; i++) { 6533 if (ts->monitor[i] == TSMonitorLGSolution) { 6534 ierr = TSMonitorLGCtxSetVariableNames((TSMonitorLGCtx)ts->monitorcontext[i],names);CHKERRQ(ierr); 6535 break; 6536 } 6537 } 6538 PetscFunctionReturn(0); 6539 } 6540 6541 #undef __FUNCT__ 6542 #define __FUNCT__ "TSMonitorLGCtxSetVariableNames" 6543 /*@C 6544 TSMonitorLGCtxSetVariableNames - Sets the name of each component in the solution vector so that it may be displayed in the plot 6545 6546 Collective on TS 6547 6548 Input Parameters: 6549 + ts - the TS context 6550 - names - the names of the components, final string must be NULL 6551 6552 Level: intermediate 6553 6554 .keywords: TS, vector, monitor, view 6555 6556 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetDisplayVariables(), TSMonitorLGSetVariableNames() 6557 @*/ 6558 PetscErrorCode TSMonitorLGCtxSetVariableNames(TSMonitorLGCtx ctx,const char * const *names) 6559 { 6560 PetscErrorCode ierr; 6561 6562 PetscFunctionBegin; 6563 ierr = PetscStrArrayDestroy(&ctx->names);CHKERRQ(ierr); 6564 ierr = PetscStrArrayallocpy(names,&ctx->names);CHKERRQ(ierr); 6565 PetscFunctionReturn(0); 6566 } 6567 6568 #undef __FUNCT__ 6569 #define __FUNCT__ "TSMonitorLGGetVariableNames" 6570 /*@C 6571 TSMonitorLGGetVariableNames - Gets the name of each component in the solution vector so that it may be displayed in the plot 6572 6573 Collective on TS 6574 6575 Input Parameter: 6576 . ts - the TS context 6577 6578 Output Parameter: 6579 . names - the names of the components, final string must be NULL 6580 6581 Level: intermediate 6582 6583 Notes: If the TS object does not have a TSMonitorLGCtx associated with it then this function is ignored 6584 6585 .keywords: TS, vector, monitor, view 6586 6587 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetDisplayVariables() 6588 @*/ 6589 PetscErrorCode TSMonitorLGGetVariableNames(TS ts,const char *const **names) 6590 { 6591 PetscInt i; 6592 6593 PetscFunctionBegin; 6594 *names = NULL; 6595 for (i=0; i<ts->numbermonitors; i++) { 6596 if (ts->monitor[i] == TSMonitorLGSolution) { 6597 TSMonitorLGCtx ctx = (TSMonitorLGCtx) ts->monitorcontext[i]; 6598 *names = (const char *const *)ctx->names; 6599 break; 6600 } 6601 } 6602 PetscFunctionReturn(0); 6603 } 6604 6605 #undef __FUNCT__ 6606 #define __FUNCT__ "TSMonitorLGCtxSetDisplayVariables" 6607 /*@C 6608 TSMonitorLGCtxSetDisplayVariables - Sets the variables that are to be display in the monitor 6609 6610 Collective on TS 6611 6612 Input Parameters: 6613 + ctx - the TSMonitorLG context 6614 . displaynames - the names of the components, final string must be NULL 6615 6616 Level: intermediate 6617 6618 .keywords: TS, vector, monitor, view 6619 6620 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetVariableNames() 6621 @*/ 6622 PetscErrorCode TSMonitorLGCtxSetDisplayVariables(TSMonitorLGCtx ctx,const char * const *displaynames) 6623 { 6624 PetscInt j = 0,k; 6625 PetscErrorCode ierr; 6626 6627 PetscFunctionBegin; 6628 if (!ctx->names) PetscFunctionReturn(0); 6629 ierr = PetscStrArrayDestroy(&ctx->displaynames);CHKERRQ(ierr); 6630 ierr = PetscStrArrayallocpy(displaynames,&ctx->displaynames);CHKERRQ(ierr); 6631 while (displaynames[j]) j++; 6632 ctx->ndisplayvariables = j; 6633 ierr = PetscMalloc1(ctx->ndisplayvariables,&ctx->displayvariables);CHKERRQ(ierr); 6634 ierr = PetscMalloc1(ctx->ndisplayvariables,&ctx->displayvalues);CHKERRQ(ierr); 6635 j = 0; 6636 while (displaynames[j]) { 6637 k = 0; 6638 while (ctx->names[k]) { 6639 PetscBool flg; 6640 ierr = PetscStrcmp(displaynames[j],ctx->names[k],&flg);CHKERRQ(ierr); 6641 if (flg) { 6642 ctx->displayvariables[j] = k; 6643 break; 6644 } 6645 k++; 6646 } 6647 j++; 6648 } 6649 PetscFunctionReturn(0); 6650 } 6651 6652 6653 #undef __FUNCT__ 6654 #define __FUNCT__ "TSMonitorLGSetDisplayVariables" 6655 /*@C 6656 TSMonitorLGSetDisplayVariables - Sets the variables that are to be display in the monitor 6657 6658 Collective on TS 6659 6660 Input Parameters: 6661 + ts - the TS context 6662 . displaynames - the names of the components, final string must be NULL 6663 6664 Notes: If the TS object does not have a TSMonitorLGCtx associated with it then this function is ignored 6665 6666 Level: intermediate 6667 6668 .keywords: TS, vector, monitor, view 6669 6670 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetVariableNames() 6671 @*/ 6672 PetscErrorCode TSMonitorLGSetDisplayVariables(TS ts,const char * const *displaynames) 6673 { 6674 PetscInt i; 6675 PetscErrorCode ierr; 6676 6677 PetscFunctionBegin; 6678 for (i=0; i<ts->numbermonitors; i++) { 6679 if (ts->monitor[i] == TSMonitorLGSolution) { 6680 ierr = TSMonitorLGCtxSetDisplayVariables((TSMonitorLGCtx)ts->monitorcontext[i],displaynames);CHKERRQ(ierr); 6681 break; 6682 } 6683 } 6684 PetscFunctionReturn(0); 6685 } 6686 6687 #undef __FUNCT__ 6688 #define __FUNCT__ "TSMonitorLGSetTransform" 6689 /*@C 6690 TSMonitorLGSetTransform - Solution vector will be transformed by provided function before being displayed 6691 6692 Collective on TS 6693 6694 Input Parameters: 6695 + ts - the TS context 6696 . transform - the transform function 6697 . destroy - function to destroy the optional context 6698 - ctx - optional context used by transform function 6699 6700 Notes: If the TS object does not have a TSMonitorLGCtx associated with it then this function is ignored 6701 6702 Level: intermediate 6703 6704 .keywords: TS, vector, monitor, view 6705 6706 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetVariableNames(), TSMonitorLGCtxSetTransform() 6707 @*/ 6708 PetscErrorCode TSMonitorLGSetTransform(TS ts,PetscErrorCode (*transform)(void*,Vec,Vec*),PetscErrorCode (*destroy)(void*),void *tctx) 6709 { 6710 PetscInt i; 6711 PetscErrorCode ierr; 6712 6713 PetscFunctionBegin; 6714 for (i=0; i<ts->numbermonitors; i++) { 6715 if (ts->monitor[i] == TSMonitorLGSolution) { 6716 ierr = TSMonitorLGCtxSetTransform((TSMonitorLGCtx)ts->monitorcontext[i],transform,destroy,tctx);CHKERRQ(ierr); 6717 } 6718 } 6719 PetscFunctionReturn(0); 6720 } 6721 6722 #undef __FUNCT__ 6723 #define __FUNCT__ "TSMonitorLGCtxSetTransform" 6724 /*@C 6725 TSMonitorLGCtxSetTransform - Solution vector will be transformed by provided function before being displayed 6726 6727 Collective on TSLGCtx 6728 6729 Input Parameters: 6730 + ts - the TS context 6731 . transform - the transform function 6732 . destroy - function to destroy the optional context 6733 - ctx - optional context used by transform function 6734 6735 Level: intermediate 6736 6737 .keywords: TS, vector, monitor, view 6738 6739 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetVariableNames(), TSMonitorLGSetTransform() 6740 @*/ 6741 PetscErrorCode TSMonitorLGCtxSetTransform(TSMonitorLGCtx ctx,PetscErrorCode (*transform)(void*,Vec,Vec*),PetscErrorCode (*destroy)(void*),void *tctx) 6742 { 6743 PetscFunctionBegin; 6744 ctx->transform = transform; 6745 ctx->transformdestroy = destroy; 6746 ctx->transformctx = tctx; 6747 PetscFunctionReturn(0); 6748 } 6749 6750 #undef __FUNCT__ 6751 #define __FUNCT__ "TSMonitorLGError" 6752 /*@C 6753 TSMonitorLGError - Monitors progress of the TS solvers by plotting each component of the solution vector 6754 in a time based line graph 6755 6756 Collective on TS 6757 6758 Input Parameters: 6759 + ts - the TS context 6760 . step - current time-step 6761 . ptime - current time 6762 . u - current solution 6763 - dctx - TSMonitorLGCtx object created with TSMonitorLGCtxCreate() 6764 6765 Level: intermediate 6766 6767 Notes: Each process in a parallel run displays its component errors in a separate window 6768 6769 The user must provide the solution using TSSetSolutionFunction() to use this monitor. 6770 6771 Options Database Keys: 6772 . -ts_monitor_lg_error - create a graphical monitor of error history 6773 6774 .keywords: TS, vector, monitor, view 6775 6776 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSSetSolutionFunction() 6777 @*/ 6778 PetscErrorCode TSMonitorLGError(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dummy) 6779 { 6780 PetscErrorCode ierr; 6781 TSMonitorLGCtx ctx = (TSMonitorLGCtx)dummy; 6782 const PetscScalar *yy; 6783 Vec y; 6784 6785 PetscFunctionBegin; 6786 if (!step) { 6787 PetscDrawAxis axis; 6788 PetscInt dim; 6789 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 6790 ierr = PetscDrawAxisSetLabels(axis,"Error in solution as function of time","Time","Solution");CHKERRQ(ierr); 6791 ierr = VecGetLocalSize(u,&dim);CHKERRQ(ierr); 6792 ierr = PetscDrawLGSetDimension(ctx->lg,dim);CHKERRQ(ierr); 6793 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 6794 } 6795 ierr = VecDuplicate(u,&y);CHKERRQ(ierr); 6796 ierr = TSComputeSolutionFunction(ts,ptime,y);CHKERRQ(ierr); 6797 ierr = VecAXPY(y,-1.0,u);CHKERRQ(ierr); 6798 ierr = VecGetArrayRead(y,&yy);CHKERRQ(ierr); 6799 #if defined(PETSC_USE_COMPLEX) 6800 { 6801 PetscReal *yreal; 6802 PetscInt i,n; 6803 ierr = VecGetLocalSize(y,&n);CHKERRQ(ierr); 6804 ierr = PetscMalloc1(n,&yreal);CHKERRQ(ierr); 6805 for (i=0; i<n; i++) yreal[i] = PetscRealPart(yy[i]); 6806 ierr = PetscDrawLGAddCommonPoint(ctx->lg,ptime,yreal);CHKERRQ(ierr); 6807 ierr = PetscFree(yreal);CHKERRQ(ierr); 6808 } 6809 #else 6810 ierr = PetscDrawLGAddCommonPoint(ctx->lg,ptime,yy);CHKERRQ(ierr); 6811 #endif 6812 ierr = VecRestoreArrayRead(y,&yy);CHKERRQ(ierr); 6813 ierr = VecDestroy(&y);CHKERRQ(ierr); 6814 if (((ctx->howoften > 0) && (!(step % ctx->howoften))) || ((ctx->howoften == -1) && ts->reason)) { 6815 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 6816 ierr = PetscDrawLGSave(ctx->lg);CHKERRQ(ierr); 6817 } 6818 PetscFunctionReturn(0); 6819 } 6820 6821 #undef __FUNCT__ 6822 #define __FUNCT__ "TSMonitorLGSNESIterations" 6823 PetscErrorCode TSMonitorLGSNESIterations(TS ts,PetscInt n,PetscReal ptime,Vec v,void *monctx) 6824 { 6825 TSMonitorLGCtx ctx = (TSMonitorLGCtx) monctx; 6826 PetscReal x = ptime,y; 6827 PetscErrorCode ierr; 6828 PetscInt its; 6829 6830 PetscFunctionBegin; 6831 if (n < 0) PetscFunctionReturn(0); /* -1 indicates interpolated solution */ 6832 if (!n) { 6833 PetscDrawAxis axis; 6834 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 6835 ierr = PetscDrawAxisSetLabels(axis,"Nonlinear iterations as function of time","Time","SNES Iterations");CHKERRQ(ierr); 6836 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 6837 ctx->snes_its = 0; 6838 } 6839 ierr = TSGetSNESIterations(ts,&its);CHKERRQ(ierr); 6840 y = its - ctx->snes_its; 6841 ierr = PetscDrawLGAddPoint(ctx->lg,&x,&y);CHKERRQ(ierr); 6842 if (((ctx->howoften > 0) && (!(n % ctx->howoften)) && (n > -1)) || ((ctx->howoften == -1) && (n == -1))) { 6843 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 6844 ierr = PetscDrawLGSave(ctx->lg);CHKERRQ(ierr); 6845 } 6846 ctx->snes_its = its; 6847 PetscFunctionReturn(0); 6848 } 6849 6850 #undef __FUNCT__ 6851 #define __FUNCT__ "TSMonitorLGKSPIterations" 6852 PetscErrorCode TSMonitorLGKSPIterations(TS ts,PetscInt n,PetscReal ptime,Vec v,void *monctx) 6853 { 6854 TSMonitorLGCtx ctx = (TSMonitorLGCtx) monctx; 6855 PetscReal x = ptime,y; 6856 PetscErrorCode ierr; 6857 PetscInt its; 6858 6859 PetscFunctionBegin; 6860 if (n < 0) PetscFunctionReturn(0); /* -1 indicates interpolated solution */ 6861 if (!n) { 6862 PetscDrawAxis axis; 6863 ierr = PetscDrawLGGetAxis(ctx->lg,&axis);CHKERRQ(ierr); 6864 ierr = PetscDrawAxisSetLabels(axis,"Linear iterations as function of time","Time","KSP Iterations");CHKERRQ(ierr); 6865 ierr = PetscDrawLGReset(ctx->lg);CHKERRQ(ierr); 6866 ctx->ksp_its = 0; 6867 } 6868 ierr = TSGetKSPIterations(ts,&its);CHKERRQ(ierr); 6869 y = its - ctx->ksp_its; 6870 ierr = PetscDrawLGAddPoint(ctx->lg,&x,&y);CHKERRQ(ierr); 6871 if (((ctx->howoften > 0) && (!(n % ctx->howoften)) && (n > -1)) || ((ctx->howoften == -1) && (n == -1))) { 6872 ierr = PetscDrawLGDraw(ctx->lg);CHKERRQ(ierr); 6873 ierr = PetscDrawLGSave(ctx->lg);CHKERRQ(ierr); 6874 } 6875 ctx->ksp_its = its; 6876 PetscFunctionReturn(0); 6877 } 6878 6879 #undef __FUNCT__ 6880 #define __FUNCT__ "TSComputeLinearStability" 6881 /*@ 6882 TSComputeLinearStability - computes the linear stability function at a point 6883 6884 Collective on TS and Vec 6885 6886 Input Parameters: 6887 + ts - the TS context 6888 - xr,xi - real and imaginary part of input arguments 6889 6890 Output Parameters: 6891 . yr,yi - real and imaginary part of function value 6892 6893 Level: developer 6894 6895 .keywords: TS, compute 6896 6897 .seealso: TSSetRHSFunction(), TSComputeIFunction() 6898 @*/ 6899 PetscErrorCode TSComputeLinearStability(TS ts,PetscReal xr,PetscReal xi,PetscReal *yr,PetscReal *yi) 6900 { 6901 PetscErrorCode ierr; 6902 6903 PetscFunctionBegin; 6904 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 6905 if (!ts->ops->linearstability) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"Linearized stability function not provided for this method"); 6906 ierr = (*ts->ops->linearstability)(ts,xr,xi,yr,yi);CHKERRQ(ierr); 6907 PetscFunctionReturn(0); 6908 } 6909 6910 /* ------------------------------------------------------------------------*/ 6911 #undef __FUNCT__ 6912 #define __FUNCT__ "TSMonitorEnvelopeCtxCreate" 6913 /*@C 6914 TSMonitorEnvelopeCtxCreate - Creates a context for use with TSMonitorEnvelope() 6915 6916 Collective on TS 6917 6918 Input Parameters: 6919 . ts - the ODE solver object 6920 6921 Output Parameter: 6922 . ctx - the context 6923 6924 Level: intermediate 6925 6926 .keywords: TS, monitor, line graph, residual, seealso 6927 6928 .seealso: TSMonitorLGTimeStep(), TSMonitorSet(), TSMonitorLGSolution(), TSMonitorLGError() 6929 6930 @*/ 6931 PetscErrorCode TSMonitorEnvelopeCtxCreate(TS ts,TSMonitorEnvelopeCtx *ctx) 6932 { 6933 PetscErrorCode ierr; 6934 6935 PetscFunctionBegin; 6936 ierr = PetscNew(ctx);CHKERRQ(ierr); 6937 PetscFunctionReturn(0); 6938 } 6939 6940 #undef __FUNCT__ 6941 #define __FUNCT__ "TSMonitorEnvelope" 6942 /*@C 6943 TSMonitorEnvelope - Monitors the maximum and minimum value of each component of the solution 6944 6945 Collective on TS 6946 6947 Input Parameters: 6948 + ts - the TS context 6949 . step - current time-step 6950 . ptime - current time 6951 . u - current solution 6952 - dctx - the envelope context 6953 6954 Options Database: 6955 . -ts_monitor_envelope 6956 6957 Level: intermediate 6958 6959 Notes: after a solve you can use TSMonitorEnvelopeGetBounds() to access the envelope 6960 6961 .keywords: TS, vector, monitor, view 6962 6963 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorEnvelopeGetBounds(), TSMonitorEnvelopeCtxCreate() 6964 @*/ 6965 PetscErrorCode TSMonitorEnvelope(TS ts,PetscInt step,PetscReal ptime,Vec u,void *dctx) 6966 { 6967 PetscErrorCode ierr; 6968 TSMonitorEnvelopeCtx ctx = (TSMonitorEnvelopeCtx)dctx; 6969 6970 PetscFunctionBegin; 6971 if (!ctx->max) { 6972 ierr = VecDuplicate(u,&ctx->max);CHKERRQ(ierr); 6973 ierr = VecDuplicate(u,&ctx->min);CHKERRQ(ierr); 6974 ierr = VecCopy(u,ctx->max);CHKERRQ(ierr); 6975 ierr = VecCopy(u,ctx->min);CHKERRQ(ierr); 6976 } else { 6977 ierr = VecPointwiseMax(ctx->max,u,ctx->max);CHKERRQ(ierr); 6978 ierr = VecPointwiseMin(ctx->min,u,ctx->min);CHKERRQ(ierr); 6979 } 6980 PetscFunctionReturn(0); 6981 } 6982 6983 6984 #undef __FUNCT__ 6985 #define __FUNCT__ "TSMonitorEnvelopeGetBounds" 6986 /*@C 6987 TSMonitorEnvelopeGetBounds - Gets the bounds for the components of the solution 6988 6989 Collective on TS 6990 6991 Input Parameter: 6992 . ts - the TS context 6993 6994 Output Parameter: 6995 + max - the maximum values 6996 - min - the minimum values 6997 6998 Notes: If the TS does not have a TSMonitorEnvelopeCtx associated with it then this function is ignored 6999 7000 Level: intermediate 7001 7002 .keywords: TS, vector, monitor, view 7003 7004 .seealso: TSMonitorSet(), TSMonitorDefault(), VecView(), TSMonitorLGSetDisplayVariables() 7005 @*/ 7006 PetscErrorCode TSMonitorEnvelopeGetBounds(TS ts,Vec *max,Vec *min) 7007 { 7008 PetscInt i; 7009 7010 PetscFunctionBegin; 7011 if (max) *max = NULL; 7012 if (min) *min = NULL; 7013 for (i=0; i<ts->numbermonitors; i++) { 7014 if (ts->monitor[i] == TSMonitorEnvelope) { 7015 TSMonitorEnvelopeCtx ctx = (TSMonitorEnvelopeCtx) ts->monitorcontext[i]; 7016 if (max) *max = ctx->max; 7017 if (min) *min = ctx->min; 7018 break; 7019 } 7020 } 7021 PetscFunctionReturn(0); 7022 } 7023 7024 #undef __FUNCT__ 7025 #define __FUNCT__ "TSMonitorEnvelopeCtxDestroy" 7026 /*@C 7027 TSMonitorEnvelopeCtxDestroy - Destroys a context that was created with TSMonitorEnvelopeCtxCreate(). 7028 7029 Collective on TSMonitorEnvelopeCtx 7030 7031 Input Parameter: 7032 . ctx - the monitor context 7033 7034 Level: intermediate 7035 7036 .keywords: TS, monitor, line graph, destroy 7037 7038 .seealso: TSMonitorLGCtxCreate(), TSMonitorSet(), TSMonitorLGTimeStep() 7039 @*/ 7040 PetscErrorCode TSMonitorEnvelopeCtxDestroy(TSMonitorEnvelopeCtx *ctx) 7041 { 7042 PetscErrorCode ierr; 7043 7044 PetscFunctionBegin; 7045 ierr = VecDestroy(&(*ctx)->min);CHKERRQ(ierr); 7046 ierr = VecDestroy(&(*ctx)->max);CHKERRQ(ierr); 7047 ierr = PetscFree(*ctx);CHKERRQ(ierr); 7048 PetscFunctionReturn(0); 7049 } 7050 7051 #undef __FUNCT__ 7052 #define __FUNCT__ "TSRollBack" 7053 /*@ 7054 TSRollBack - Rolls back one time step 7055 7056 Collective on TS 7057 7058 Input Parameter: 7059 . ts - the TS context obtained from TSCreate() 7060 7061 Level: advanced 7062 7063 .keywords: TS, timestep, rollback 7064 7065 .seealso: TSCreate(), TSSetUp(), TSDestroy(), TSSolve(), TSSetPreStep(), TSSetPreStage(), TSInterpolate() 7066 @*/ 7067 PetscErrorCode TSRollBack(TS ts) 7068 { 7069 PetscErrorCode ierr; 7070 7071 PetscFunctionBegin; 7072 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 7073 if (ts->steprollback) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_WRONGSTATE,"TSRollBack already called"); 7074 if (!ts->ops->rollback) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"TSRollBack not implemented for type '%s'",((PetscObject)ts)->type_name); 7075 ierr = (*ts->ops->rollback)(ts);CHKERRQ(ierr); 7076 ts->time_step = ts->ptime - ts->ptime_prev; 7077 ts->ptime = ts->ptime_prev; 7078 ts->ptime_prev = ts->ptime_prev_rollback; 7079 ts->steps--; ts->total_steps--; 7080 ts->steprollback = PETSC_TRUE; 7081 PetscFunctionReturn(0); 7082 } 7083 7084 #undef __FUNCT__ 7085 #define __FUNCT__ "TSGetStages" 7086 /*@ 7087 TSGetStages - Get the number of stages and stage values 7088 7089 Input Parameter: 7090 . ts - the TS context obtained from TSCreate() 7091 7092 Level: advanced 7093 7094 .keywords: TS, getstages 7095 7096 .seealso: TSCreate() 7097 @*/ 7098 PetscErrorCode TSGetStages(TS ts,PetscInt *ns,Vec **Y) 7099 { 7100 PetscErrorCode ierr; 7101 7102 PetscFunctionBegin; 7103 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 7104 PetscValidPointer(ns,2); 7105 7106 if (!ts->ops->getstages) *ns=0; 7107 else { 7108 ierr = (*ts->ops->getstages)(ts,ns,Y);CHKERRQ(ierr); 7109 } 7110 PetscFunctionReturn(0); 7111 } 7112 7113 #undef __FUNCT__ 7114 #define __FUNCT__ "TSComputeIJacobianDefaultColor" 7115 /*@C 7116 TSComputeIJacobianDefaultColor - Computes the Jacobian using finite differences and coloring to exploit matrix sparsity. 7117 7118 Collective on SNES 7119 7120 Input Parameters: 7121 + ts - the TS context 7122 . t - current timestep 7123 . U - state vector 7124 . Udot - time derivative of state vector 7125 . shift - shift to apply, see note below 7126 - ctx - an optional user context 7127 7128 Output Parameters: 7129 + J - Jacobian matrix (not altered in this routine) 7130 - B - newly computed Jacobian matrix to use with preconditioner (generally the same as J) 7131 7132 Level: intermediate 7133 7134 Notes: 7135 If F(t,U,Udot)=0 is the DAE, the required Jacobian is 7136 7137 dF/dU + shift*dF/dUdot 7138 7139 Most users should not need to explicitly call this routine, as it 7140 is used internally within the nonlinear solvers. 7141 7142 This will first try to get the coloring from the DM. If the DM type has no coloring 7143 routine, then it will try to get the coloring from the matrix. This requires that the 7144 matrix have nonzero entries precomputed. 7145 7146 .keywords: TS, finite differences, Jacobian, coloring, sparse 7147 .seealso: TSSetIJacobian(), MatFDColoringCreate(), MatFDColoringSetFunction() 7148 @*/ 7149 PetscErrorCode TSComputeIJacobianDefaultColor(TS ts,PetscReal t,Vec U,Vec Udot,PetscReal shift,Mat J,Mat B,void *ctx) 7150 { 7151 SNES snes; 7152 MatFDColoring color; 7153 PetscBool hascolor, matcolor = PETSC_FALSE; 7154 PetscErrorCode ierr; 7155 7156 PetscFunctionBegin; 7157 ierr = PetscOptionsGetBool(((PetscObject)ts)->options,((PetscObject) ts)->prefix, "-ts_fd_color_use_mat", &matcolor, NULL);CHKERRQ(ierr); 7158 ierr = PetscObjectQuery((PetscObject) B, "TSMatFDColoring", (PetscObject *) &color);CHKERRQ(ierr); 7159 if (!color) { 7160 DM dm; 7161 ISColoring iscoloring; 7162 7163 ierr = TSGetDM(ts, &dm);CHKERRQ(ierr); 7164 ierr = DMHasColoring(dm, &hascolor);CHKERRQ(ierr); 7165 if (hascolor && !matcolor) { 7166 ierr = DMCreateColoring(dm, IS_COLORING_GLOBAL, &iscoloring);CHKERRQ(ierr); 7167 ierr = MatFDColoringCreate(B, iscoloring, &color);CHKERRQ(ierr); 7168 ierr = MatFDColoringSetFunction(color, (PetscErrorCode (*)(void)) SNESTSFormFunction, (void *) ts);CHKERRQ(ierr); 7169 ierr = MatFDColoringSetFromOptions(color);CHKERRQ(ierr); 7170 ierr = MatFDColoringSetUp(B, iscoloring, color);CHKERRQ(ierr); 7171 ierr = ISColoringDestroy(&iscoloring);CHKERRQ(ierr); 7172 } else { 7173 MatColoring mc; 7174 7175 ierr = MatColoringCreate(B, &mc);CHKERRQ(ierr); 7176 ierr = MatColoringSetDistance(mc, 2);CHKERRQ(ierr); 7177 ierr = MatColoringSetType(mc, MATCOLORINGSL);CHKERRQ(ierr); 7178 ierr = MatColoringSetFromOptions(mc);CHKERRQ(ierr); 7179 ierr = MatColoringApply(mc, &iscoloring);CHKERRQ(ierr); 7180 ierr = MatColoringDestroy(&mc);CHKERRQ(ierr); 7181 ierr = MatFDColoringCreate(B, iscoloring, &color);CHKERRQ(ierr); 7182 ierr = MatFDColoringSetFunction(color, (PetscErrorCode (*)(void)) SNESTSFormFunction, (void *) ts);CHKERRQ(ierr); 7183 ierr = MatFDColoringSetFromOptions(color);CHKERRQ(ierr); 7184 ierr = MatFDColoringSetUp(B, iscoloring, color);CHKERRQ(ierr); 7185 ierr = ISColoringDestroy(&iscoloring);CHKERRQ(ierr); 7186 } 7187 ierr = PetscObjectCompose((PetscObject) B, "TSMatFDColoring", (PetscObject) color);CHKERRQ(ierr); 7188 ierr = PetscObjectDereference((PetscObject) color);CHKERRQ(ierr); 7189 } 7190 ierr = TSGetSNES(ts, &snes);CHKERRQ(ierr); 7191 ierr = MatFDColoringApply(B, color, U, snes);CHKERRQ(ierr); 7192 if (J != B) { 7193 ierr = MatAssemblyBegin(J, MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); 7194 ierr = MatAssemblyEnd(J, MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); 7195 } 7196 PetscFunctionReturn(0); 7197 } 7198 7199 #undef __FUNCT__ 7200 #define __FUNCT__ "TSSetFunctionDomainError" 7201 /*@ 7202 TSSetFunctionDomainError - Set the function testing if the current state vector is valid 7203 7204 Input Parameters: 7205 ts - the TS context 7206 func - function called within TSFunctionDomainError 7207 7208 Level: intermediate 7209 7210 .keywords: TS, state, domain 7211 .seealso: TSAdaptCheckStage(), TSFunctionDomainError() 7212 @*/ 7213 7214 PetscErrorCode TSSetFunctionDomainError(TS ts, PetscErrorCode (*func)(TS,PetscReal,Vec,PetscBool*)) 7215 { 7216 PetscFunctionBegin; 7217 PetscValidHeaderSpecific(ts, TS_CLASSID,1); 7218 ts->functiondomainerror = func; 7219 PetscFunctionReturn(0); 7220 } 7221 7222 #undef __FUNCT__ 7223 #define __FUNCT__ "TSFunctionDomainError" 7224 /*@ 7225 TSFunctionDomainError - Check if the current state is valid 7226 7227 Input Parameters: 7228 ts - the TS context 7229 stagetime - time of the simulation 7230 Y - state vector to check. 7231 7232 Output Parameter: 7233 accept - Set to PETSC_FALSE if the current state vector is valid. 7234 7235 Note: 7236 This function should be used to ensure the state is in a valid part of the space. 7237 For example, one can ensure here all values are positive. 7238 7239 Level: advanced 7240 @*/ 7241 PetscErrorCode TSFunctionDomainError(TS ts,PetscReal stagetime,Vec Y,PetscBool* accept) 7242 { 7243 PetscErrorCode ierr; 7244 7245 PetscFunctionBegin; 7246 7247 PetscValidHeaderSpecific(ts,TS_CLASSID,1); 7248 *accept = PETSC_TRUE; 7249 if (ts->functiondomainerror) { 7250 PetscStackCallStandard((*ts->functiondomainerror),(ts,stagetime,Y,accept)); 7251 } 7252 PetscFunctionReturn(0); 7253 } 7254 7255 #undef __FUNCT__ 7256 #define __FUNCT__ "TSClone" 7257 /*@C 7258 TSClone - This function clones a time step object. 7259 7260 Collective on MPI_Comm 7261 7262 Input Parameter: 7263 . tsin - The input TS 7264 7265 Output Parameter: 7266 . tsout - The output TS (cloned) 7267 7268 Notes: 7269 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. 7270 7271 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); 7272 7273 Level: developer 7274 7275 .keywords: TS, clone 7276 .seealso: TSCreate(), TSSetType(), TSSetUp(), TSDestroy(), TSSetProblemType() 7277 @*/ 7278 PetscErrorCode TSClone(TS tsin, TS *tsout) 7279 { 7280 TS t; 7281 PetscErrorCode ierr; 7282 SNES snes_start; 7283 DM dm; 7284 TSType type; 7285 7286 PetscFunctionBegin; 7287 PetscValidPointer(tsin,1); 7288 *tsout = NULL; 7289 7290 ierr = PetscHeaderCreate(t, TS_CLASSID, "TS", "Time stepping", "TS", PetscObjectComm((PetscObject)tsin), TSDestroy, TSView);CHKERRQ(ierr); 7291 7292 /* General TS description */ 7293 t->numbermonitors = 0; 7294 t->setupcalled = 0; 7295 t->ksp_its = 0; 7296 t->snes_its = 0; 7297 t->nwork = 0; 7298 t->rhsjacobian.time = -1e20; 7299 t->rhsjacobian.scale = 1.; 7300 t->ijacobian.shift = 1.; 7301 7302 ierr = TSGetSNES(tsin,&snes_start);CHKERRQ(ierr); 7303 ierr = TSSetSNES(t,snes_start);CHKERRQ(ierr); 7304 7305 ierr = TSGetDM(tsin,&dm);CHKERRQ(ierr); 7306 ierr = TSSetDM(t,dm);CHKERRQ(ierr); 7307 7308 t->adapt = tsin->adapt; 7309 ierr = PetscObjectReference((PetscObject)t->adapt);CHKERRQ(ierr); 7310 7311 t->problem_type = tsin->problem_type; 7312 t->ptime = tsin->ptime; 7313 t->time_step = tsin->time_step; 7314 t->max_time = tsin->max_time; 7315 t->steps = tsin->steps; 7316 t->max_steps = tsin->max_steps; 7317 t->equation_type = tsin->equation_type; 7318 t->atol = tsin->atol; 7319 t->rtol = tsin->rtol; 7320 t->max_snes_failures = tsin->max_snes_failures; 7321 t->max_reject = tsin->max_reject; 7322 t->errorifstepfailed = tsin->errorifstepfailed; 7323 7324 ierr = TSGetType(tsin,&type);CHKERRQ(ierr); 7325 ierr = TSSetType(t,type);CHKERRQ(ierr); 7326 7327 t->vec_sol = NULL; 7328 7329 t->cfltime = tsin->cfltime; 7330 t->cfltime_local = tsin->cfltime_local; 7331 t->exact_final_time = tsin->exact_final_time; 7332 7333 ierr = PetscMemcpy(t->ops,tsin->ops,sizeof(struct _TSOps));CHKERRQ(ierr); 7334 7335 if (((PetscObject)tsin)->fortran_func_pointers) { 7336 PetscInt i; 7337 ierr = PetscMalloc((10)*sizeof(void(*)(void)),&((PetscObject)t)->fortran_func_pointers);CHKERRQ(ierr); 7338 for (i=0; i<10; i++) { 7339 ((PetscObject)t)->fortran_func_pointers[i] = ((PetscObject)tsin)->fortran_func_pointers[i]; 7340 } 7341 } 7342 *tsout = t; 7343 PetscFunctionReturn(0); 7344 } 7345