Actual source code: ex15.c
1: static char help[] = "Time-dependent PDE in 2d. Modified from ex13.c for illustrating how to solve DAEs. \n";
2: /*
3: u_t = uxx + uyy
4: 0 < x < 1, 0 < y < 1;
5: At t=0: u(x,y) = exp(c*r*r*r), if r=PetscSqrtReal((x-.5)*(x-.5) + (y-.5)*(y-.5)) < .125
6: u(x,y) = 0.0 if r >= .125
8: Boundary conditions:
9: Drichlet BC:
10: At x=0, x=1, y=0, y=1: u = 0.0
12: Neumann BC:
13: At x=0, x=1: du(x,y,t)/dx = 0
14: At y=0, y=1: du(x,y,t)/dy = 0
16: mpiexec -n 2 ./ex15 -da_grid_x 40 -da_grid_y 40 -ts_max_steps 2 -snes_monitor -ksp_monitor
17: ./ex15 -da_grid_x 40 -da_grid_y 40 -draw_pause .1 -boundary 1 -ts_monitor_draw_solution
18: ./ex15 -da_grid_x 40 -da_grid_y 40 -draw_pause .1 -boundary 1 -Jtype 2 -nstencilpts 9
20: */
22: #include <petscdm.h>
23: #include <petscdmda.h>
24: #include <petscts.h>
26: /*
27: User-defined data structures and routines
28: */
30: /* AppCtx: used by FormIFunction() and FormIJacobian() */
31: typedef struct {
32: DM da;
33: PetscInt nstencilpts; /* number of stencil points: 5 or 9 */
34: PetscReal c;
35: PetscInt boundary; /* Type of boundary condition */
36: PetscBool viewJacobian;
37: } AppCtx;
39: extern PetscErrorCode FormIFunction(TS, PetscReal, Vec, Vec, Vec, void *);
40: extern PetscErrorCode FormIJacobian(TS, PetscReal, Vec, Vec, PetscReal, Mat, Mat, void *);
41: extern PetscErrorCode FormInitialSolution(Vec, void *);
43: int main(int argc, char **argv)
44: {
45: TS ts; /* nonlinear solver */
46: Vec u, r; /* solution, residual vectors */
47: Mat J, Jmf = NULL; /* Jacobian matrices */
48: DM da;
49: PetscReal dt;
50: AppCtx user; /* user-defined work context */
51: SNES snes;
52: PetscInt Jtype; /* Jacobian type
53: 0: user provide Jacobian;
54: 1: slow finite difference;
55: 2: fd with coloring; */
57: PetscFunctionBeginUser;
58: PetscCall(PetscInitialize(&argc, &argv, NULL, help));
59: /* Initialize user application context */
60: user.da = NULL;
61: user.nstencilpts = 5;
62: user.c = -30.0;
63: user.boundary = 0; /* 0: Drichlet BC; 1: Neumann BC */
64: user.viewJacobian = PETSC_FALSE;
66: PetscCall(PetscOptionsGetInt(NULL, NULL, "-nstencilpts", &user.nstencilpts, NULL));
67: PetscCall(PetscOptionsGetInt(NULL, NULL, "-boundary", &user.boundary, NULL));
68: PetscCall(PetscOptionsHasName(NULL, NULL, "-viewJacobian", &user.viewJacobian));
70: /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
71: Create distributed array (DMDA) to manage parallel grid and vectors
72: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
73: if (user.nstencilpts == 5) {
74: PetscCall(DMDACreate2d(PETSC_COMM_WORLD, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DMDA_STENCIL_STAR, 11, 11, PETSC_DECIDE, PETSC_DECIDE, 1, 1, NULL, NULL, &da));
75: } else if (user.nstencilpts == 9) {
76: PetscCall(DMDACreate2d(PETSC_COMM_WORLD, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DMDA_STENCIL_BOX, 11, 11, PETSC_DECIDE, PETSC_DECIDE, 1, 1, NULL, NULL, &da));
77: } else SETERRQ(PETSC_COMM_WORLD, PETSC_ERR_SUP, "nstencilpts %" PetscInt_FMT " is not supported", user.nstencilpts);
78: PetscCall(DMSetFromOptions(da));
79: PetscCall(DMSetUp(da));
80: user.da = da;
82: /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
83: Extract global vectors from DMDA;
84: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
85: PetscCall(DMCreateGlobalVector(da, &u));
86: PetscCall(VecDuplicate(u, &r));
88: /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
89: Create timestepping solver context
90: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
91: PetscCall(TSCreate(PETSC_COMM_WORLD, &ts));
92: PetscCall(TSSetProblemType(ts, TS_NONLINEAR));
93: PetscCall(TSSetType(ts, TSBEULER));
94: PetscCall(TSSetDM(ts, da));
95: PetscCall(TSSetIFunction(ts, r, FormIFunction, &user));
96: PetscCall(TSSetMaxTime(ts, 1.0));
97: PetscCall(TSSetExactFinalTime(ts, TS_EXACTFINALTIME_STEPOVER));
99: /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
100: Set initial conditions
101: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
102: PetscCall(FormInitialSolution(u, &user));
103: PetscCall(TSSetSolution(ts, u));
104: dt = .01;
105: PetscCall(TSSetTimeStep(ts, dt));
107: /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
108: Set Jacobian evaluation routine
109: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
110: PetscCall(DMSetMatType(da, MATAIJ));
111: PetscCall(DMCreateMatrix(da, &J));
112: Jtype = 0;
113: PetscCall(PetscOptionsGetInt(NULL, NULL, "-Jtype", &Jtype, NULL));
114: if (Jtype == 0) { /* use user provided Jacobian evaluation routine */
115: PetscCheck(user.nstencilpts == 5, PETSC_COMM_WORLD, PETSC_ERR_SUP, "user Jacobian routine FormIJacobian() does not support nstencilpts=%" PetscInt_FMT, user.nstencilpts);
116: PetscCall(TSSetIJacobian(ts, J, J, FormIJacobian, &user));
117: } else { /* use finite difference Jacobian J as preconditioner and '-snes_mf_operator' for Mat*vec */
118: PetscCall(TSGetSNES(ts, &snes));
119: PetscCall(MatCreateSNESMF(snes, &Jmf));
120: if (Jtype == 1) { /* slow finite difference J; */
121: PetscCall(SNESSetJacobian(snes, Jmf, J, SNESComputeJacobianDefault, NULL));
122: } else if (Jtype == 2) { /* Use coloring to compute finite difference J efficiently */
123: PetscCall(SNESSetJacobian(snes, Jmf, J, SNESComputeJacobianDefaultColor, 0));
124: } else SETERRQ(PETSC_COMM_SELF, PETSC_ERR_SUP, "Jtype is not supported");
125: }
127: /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
128: Sets various TS parameters from user options
129: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
130: PetscCall(TSSetFromOptions(ts));
132: /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
133: Solve nonlinear system
134: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
135: PetscCall(TSSolve(ts, u));
137: /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
138: Free work space.
139: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
140: PetscCall(MatDestroy(&J));
141: PetscCall(MatDestroy(&Jmf));
142: PetscCall(VecDestroy(&u));
143: PetscCall(VecDestroy(&r));
144: PetscCall(TSDestroy(&ts));
145: PetscCall(DMDestroy(&da));
147: PetscCall(PetscFinalize());
148: return 0;
149: }
151: /* --------------------------------------------------------------------- */
152: /*
153: FormIFunction = Udot - RHSFunction
154: */
155: PetscErrorCode FormIFunction(TS ts, PetscReal t, Vec U, Vec Udot, Vec F, void *ctx)
156: {
157: AppCtx *user = (AppCtx *)ctx;
158: DM da = user->da;
159: PetscInt i, j, Mx, My, xs, ys, xm, ym;
160: PetscReal hx, hy, sx, sy;
161: PetscScalar u, uxx, uyy, **uarray, **f, **udot;
162: Vec localU;
164: PetscFunctionBeginUser;
165: PetscCall(DMGetLocalVector(da, &localU));
166: PetscCall(DMDAGetInfo(da, PETSC_IGNORE, &Mx, &My, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE));
168: hx = 1.0 / (PetscReal)(Mx - 1);
169: sx = 1.0 / (hx * hx);
170: hy = 1.0 / (PetscReal)(My - 1);
171: sy = 1.0 / (hy * hy);
172: PetscCheck(user->nstencilpts != 9 || hx == hy, PETSC_COMM_WORLD, PETSC_ERR_SUP, "hx must equal hy when nstencilpts = 9 for this example");
174: /*
175: Scatter ghost points to local vector,using the 2-step process
176: DMGlobalToLocalBegin(),DMGlobalToLocalEnd().
177: By placing code between these two statements, computations can be
178: done while messages are in transition.
179: */
180: PetscCall(DMGlobalToLocalBegin(da, U, INSERT_VALUES, localU));
181: PetscCall(DMGlobalToLocalEnd(da, U, INSERT_VALUES, localU));
183: /* Get pointers to vector data */
184: PetscCall(DMDAVecGetArrayRead(da, localU, &uarray));
185: PetscCall(DMDAVecGetArray(da, F, &f));
186: PetscCall(DMDAVecGetArray(da, Udot, &udot));
188: /* Get local grid boundaries */
189: PetscCall(DMDAGetCorners(da, &xs, &ys, NULL, &xm, &ym, NULL));
191: /* Compute function over the locally owned part of the grid */
192: for (j = ys; j < ys + ym; j++) {
193: for (i = xs; i < xs + xm; i++) {
194: /* Boundary conditions */
195: if (i == 0 || j == 0 || i == Mx - 1 || j == My - 1) {
196: if (user->boundary == 0) { /* Drichlet BC */
197: f[j][i] = uarray[j][i]; /* F = U */
198: } else { /* Neumann BC */
199: if (i == 0 && j == 0) { /* SW corner */
200: f[j][i] = uarray[j][i] - uarray[j + 1][i + 1];
201: } else if (i == Mx - 1 && j == 0) { /* SE corner */
202: f[j][i] = uarray[j][i] - uarray[j + 1][i - 1];
203: } else if (i == 0 && j == My - 1) { /* NW corner */
204: f[j][i] = uarray[j][i] - uarray[j - 1][i + 1];
205: } else if (i == Mx - 1 && j == My - 1) { /* NE corner */
206: f[j][i] = uarray[j][i] - uarray[j - 1][i - 1];
207: } else if (i == 0) { /* Left */
208: f[j][i] = uarray[j][i] - uarray[j][i + 1];
209: } else if (i == Mx - 1) { /* Right */
210: f[j][i] = uarray[j][i] - uarray[j][i - 1];
211: } else if (j == 0) { /* Bottom */
212: f[j][i] = uarray[j][i] - uarray[j + 1][i];
213: } else if (j == My - 1) { /* Top */
214: f[j][i] = uarray[j][i] - uarray[j - 1][i];
215: }
216: }
217: } else { /* Interior */
218: u = uarray[j][i];
219: /* 5-point stencil */
220: uxx = (-2.0 * u + uarray[j][i - 1] + uarray[j][i + 1]);
221: uyy = (-2.0 * u + uarray[j - 1][i] + uarray[j + 1][i]);
222: if (user->nstencilpts == 9) {
223: /* 9-point stencil: assume hx=hy */
224: uxx = 2.0 * uxx / 3.0 + (0.5 * (uarray[j - 1][i - 1] + uarray[j - 1][i + 1] + uarray[j + 1][i - 1] + uarray[j + 1][i + 1]) - 2.0 * u) / 6.0;
225: uyy = 2.0 * uyy / 3.0 + (0.5 * (uarray[j - 1][i - 1] + uarray[j - 1][i + 1] + uarray[j + 1][i - 1] + uarray[j + 1][i + 1]) - 2.0 * u) / 6.0;
226: }
227: f[j][i] = udot[j][i] - (uxx * sx + uyy * sy);
228: }
229: }
230: }
232: /* Restore vectors */
233: PetscCall(DMDAVecRestoreArrayRead(da, localU, &uarray));
234: PetscCall(DMDAVecRestoreArray(da, F, &f));
235: PetscCall(DMDAVecRestoreArray(da, Udot, &udot));
236: PetscCall(DMRestoreLocalVector(da, &localU));
237: PetscCall(PetscLogFlops(11.0 * ym * xm));
238: PetscFunctionReturn(PETSC_SUCCESS);
239: }
241: /* --------------------------------------------------------------------- */
242: /*
243: FormIJacobian() - Compute IJacobian = dF/dU + a dF/dUdot
244: This routine is not used with option '-use_coloring'
245: */
246: PetscErrorCode FormIJacobian(TS ts, PetscReal t, Vec U, Vec Udot, PetscReal a, Mat J, Mat Jpre, void *ctx)
247: {
248: PetscInt i, j, Mx, My, xs, ys, xm, ym, nc;
249: AppCtx *user = (AppCtx *)ctx;
250: DM da = user->da;
251: MatStencil col[5], row;
252: PetscScalar vals[5], hx, hy, sx, sy;
254: PetscFunctionBeginUser;
255: PetscCall(DMDAGetInfo(da, PETSC_IGNORE, &Mx, &My, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE));
256: PetscCall(DMDAGetCorners(da, &xs, &ys, NULL, &xm, &ym, NULL));
258: hx = 1.0 / (PetscReal)(Mx - 1);
259: sx = 1.0 / (hx * hx);
260: hy = 1.0 / (PetscReal)(My - 1);
261: sy = 1.0 / (hy * hy);
263: for (j = ys; j < ys + ym; j++) {
264: for (i = xs; i < xs + xm; i++) {
265: nc = 0;
266: row.j = j;
267: row.i = i;
268: if (user->boundary == 0 && (i == 0 || i == Mx - 1 || j == 0 || j == My - 1)) {
269: col[nc].j = j;
270: col[nc].i = i;
271: vals[nc++] = 1.0;
273: } else if (user->boundary > 0 && i == 0) { /* Left Neumann */
274: col[nc].j = j;
275: col[nc].i = i;
276: vals[nc++] = 1.0;
277: col[nc].j = j;
278: col[nc].i = i + 1;
279: vals[nc++] = -1.0;
280: } else if (user->boundary > 0 && i == Mx - 1) { /* Right Neumann */
281: col[nc].j = j;
282: col[nc].i = i;
283: vals[nc++] = 1.0;
284: col[nc].j = j;
285: col[nc].i = i - 1;
286: vals[nc++] = -1.0;
287: } else if (user->boundary > 0 && j == 0) { /* Bottom Neumann */
288: col[nc].j = j;
289: col[nc].i = i;
290: vals[nc++] = 1.0;
291: col[nc].j = j + 1;
292: col[nc].i = i;
293: vals[nc++] = -1.0;
294: } else if (user->boundary > 0 && j == My - 1) { /* Top Neumann */
295: col[nc].j = j;
296: col[nc].i = i;
297: vals[nc++] = 1.0;
298: col[nc].j = j - 1;
299: col[nc].i = i;
300: vals[nc++] = -1.0;
301: } else { /* Interior */
302: col[nc].j = j - 1;
303: col[nc].i = i;
304: vals[nc++] = -sy;
305: col[nc].j = j;
306: col[nc].i = i - 1;
307: vals[nc++] = -sx;
308: col[nc].j = j;
309: col[nc].i = i;
310: vals[nc++] = 2.0 * (sx + sy) + a;
311: col[nc].j = j;
312: col[nc].i = i + 1;
313: vals[nc++] = -sx;
314: col[nc].j = j + 1;
315: col[nc].i = i;
316: vals[nc++] = -sy;
317: }
318: PetscCall(MatSetValuesStencil(Jpre, 1, &row, nc, col, vals, INSERT_VALUES));
319: }
320: }
321: PetscCall(MatAssemblyBegin(Jpre, MAT_FINAL_ASSEMBLY));
322: PetscCall(MatAssemblyEnd(Jpre, MAT_FINAL_ASSEMBLY));
323: if (J != Jpre) {
324: PetscCall(MatAssemblyBegin(J, MAT_FINAL_ASSEMBLY));
325: PetscCall(MatAssemblyEnd(J, MAT_FINAL_ASSEMBLY));
326: }
328: if (user->viewJacobian) {
329: PetscCall(PetscPrintf(PetscObjectComm((PetscObject)Jpre), "Jpre:\n"));
330: PetscCall(MatView(Jpre, PETSC_VIEWER_STDOUT_WORLD));
331: }
332: PetscFunctionReturn(PETSC_SUCCESS);
333: }
335: /* ------------------------------------------------------------------- */
336: PetscErrorCode FormInitialSolution(Vec U, void *ptr)
337: {
338: AppCtx *user = (AppCtx *)ptr;
339: DM da = user->da;
340: PetscReal c = user->c;
341: PetscInt i, j, xs, ys, xm, ym, Mx, My;
342: PetscScalar **u;
343: PetscReal hx, hy, x, y, r;
345: PetscFunctionBeginUser;
346: PetscCall(DMDAGetInfo(da, PETSC_IGNORE, &Mx, &My, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE, PETSC_IGNORE));
348: hx = 1.0 / (PetscReal)(Mx - 1);
349: hy = 1.0 / (PetscReal)(My - 1);
351: /* Get pointers to vector data */
352: PetscCall(DMDAVecGetArray(da, U, &u));
354: /* Get local grid boundaries */
355: PetscCall(DMDAGetCorners(da, &xs, &ys, NULL, &xm, &ym, NULL));
357: /* Compute function over the locally owned part of the grid */
358: for (j = ys; j < ys + ym; j++) {
359: y = j * hy;
360: for (i = xs; i < xs + xm; i++) {
361: x = i * hx;
362: r = PetscSqrtReal((x - .5) * (x - .5) + (y - .5) * (y - .5));
363: if (r < .125) u[j][i] = PetscExpReal(c * r * r * r);
364: else u[j][i] = 0.0;
365: }
366: }
368: /* Restore vectors */
369: PetscCall(DMDAVecRestoreArray(da, U, &u));
370: PetscFunctionReturn(PETSC_SUCCESS);
371: }
373: /*TEST
375: test:
376: args: -da_grid_x 20 -da_grid_y 20 -boundary 0 -ts_max_steps 10 -ts_monitor
378: test:
379: suffix: 2
380: args: -da_grid_x 20 -da_grid_y 20 -boundary 0 -ts_max_steps 10 -Jtype 2 -ts_monitor
382: test:
383: suffix: 3
384: requires: !single
385: args: -da_grid_x 20 -da_grid_y 20 -boundary 1 -ts_max_steps 10 -ts_monitor
387: test:
388: suffix: 4
389: requires: !single
390: nsize: 2
391: args: -da_grid_x 20 -da_grid_y 20 -boundary 1 -ts_max_steps 10 -ts_monitor
393: test:
394: suffix: 5
395: nsize: 1
396: args: -da_grid_x 20 -da_grid_y 20 -boundary 0 -ts_max_steps 10 -Jtype 1 -ts_monitor
398: TEST*/