Actual source code: ex70.c
petsc-3.12.5 2020-03-29
1: static char help[] = "Poiseuille flow problem. Viscous, laminar flow in a 2D channel with parabolic velocity\n\
2: profile and linear pressure drop, exact solution of the 2D Stokes\n";
4: /*---------------------------------------------------------------------------- */
5: /* M A R I T I M E R E S E A R C H I N S T I T U T E N E T H E R L A N D S */
6: /*---------------------------------------------------------------------------- */
7: /* author : Christiaan M. Klaij */
8: /*---------------------------------------------------------------------------- */
9: /* */
10: /* Poiseuille flow problem. */
11: /* */
12: /* Viscous, laminar flow in a 2D channel with parabolic velocity */
13: /* profile and linear pressure drop, exact solution of the 2D Stokes */
14: /* equations. */
15: /* */
16: /* Discretized with the cell-centered finite-volume method on a */
17: /* Cartesian grid with co-located variables. Variables ordered as */
18: /* [u1...uN v1...vN p1...pN]^T. Matrix [A00 A01; A10, A11] solved with */
19: /* PCFIELDSPLIT. Lower factorization is used to mimick the Semi-Implicit */
20: /* Method for Pressure Linked Equations (SIMPLE) used as preconditioner */
21: /* instead of solver. */
22: /* */
23: /* Disclaimer: does not contain the pressure-weighed interpolation */
24: /* method needed to suppress spurious pressure modes in real-life */
25: /* problems. */
26: /* */
27: /* Usage: */
28: /* */
29: /* mpiexec -n 2 ./ex70 -nx 32 -ny 48 -ksp_type fgmres -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_fact_type lower -fieldsplit_1_pc_type none */
30: /* */
31: /* Runs with PCFIELDSPLIT on 32x48 grid, no PC for the Schur */
32: /* complement because A11 is zero. FGMRES is needed because */
33: /* PCFIELDSPLIT is a variable preconditioner. */
34: /* */
35: /* mpiexec -n 2 ./ex70 -nx 32 -ny 48 -ksp_type fgmres -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_fact_type lower -user_pc */
36: /* */
37: /* Same as above but with user defined PC for the true Schur */
38: /* complement. PC based on the SIMPLE-type approximation (inverse of */
39: /* A00 approximated by inverse of its diagonal). */
40: /* */
41: /* mpiexec -n 2 ./ex70 -nx 32 -ny 48 -ksp_type fgmres -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_fact_type lower -user_ksp */
42: /* */
43: /* Replace the true Schur complement with a user defined Schur */
44: /* complement based on the SIMPLE-type approximation. Same matrix is */
45: /* used as PC. */
46: /* */
47: /* mpiexec -n 2 ./ex70 -nx 32 -ny 48 -ksp_type fgmres -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_fact_type lower -fieldsplit_0_ksp_type gmres -fieldsplit_0_pc_type bjacobi -fieldsplit_1_pc_type jacobi -fieldsplit_1_inner_ksp_type preonly -fieldsplit_1_inner_pc_type jacobi -fieldsplit_1_upper_ksp_type preonly -fieldsplit_1_upper_pc_type jacobi */
48: /* */
49: /* Out-of-the-box SIMPLE-type preconditioning. The major advantage */
50: /* is that the user neither needs to provide the approximation of */
51: /* the Schur complement, nor the corresponding preconditioner. */
52: /* */
53: /*---------------------------------------------------------------------------- */
56: #include <petscksp.h>
58: typedef struct {
59: PetscBool userPC, userKSP, matsymmetric; /* user defined preconditioner and matrix for the Schur complement */
60: PetscInt nx, ny; /* nb of cells in x- and y-direction */
61: PetscReal hx, hy; /* mesh size in x- and y-direction */
62: Mat A; /* block matrix */
63: Mat subA[4]; /* the four blocks */
64: Mat myS; /* the approximation of the Schur complement */
65: Vec x, b, y; /* solution, rhs and temporary vector */
66: IS isg[2]; /* index sets of split "0" and "1" */
67: } Stokes;
69: PetscErrorCode StokesSetupMatBlock00(Stokes*); /* setup the block Q */
70: PetscErrorCode StokesSetupMatBlock01(Stokes*); /* setup the block G */
71: PetscErrorCode StokesSetupMatBlock10(Stokes*); /* setup the block D (equal to the transpose of G) */
72: PetscErrorCode StokesSetupMatBlock11(Stokes*); /* setup the block C (equal to zero) */
74: PetscErrorCode StokesGetPosition(Stokes*, PetscInt, PetscInt*, PetscInt*); /* row number j*nx+i corresponds to position (i,j) in grid */
76: PetscErrorCode StokesStencilLaplacian(Stokes*, PetscInt, PetscInt, PetscInt*, PetscInt*, PetscScalar*); /* stencil of the Laplacian operator */
77: PetscErrorCode StokesStencilGradientX(Stokes*, PetscInt, PetscInt, PetscInt*, PetscInt*, PetscScalar*); /* stencil of the Gradient operator (x-component) */
78: PetscErrorCode StokesStencilGradientY(Stokes*, PetscInt, PetscInt, PetscInt*, PetscInt*, PetscScalar*); /* stencil of the Gradient operator (y-component) */
80: PetscErrorCode StokesRhs(Stokes*); /* rhs vector */
81: PetscErrorCode StokesRhsMomX(Stokes*, PetscInt, PetscInt, PetscScalar*); /* right hand side of velocity (x-component) */
82: PetscErrorCode StokesRhsMomY(Stokes*, PetscInt, PetscInt, PetscScalar*); /* right hand side of velocity (y-component) */
83: PetscErrorCode StokesRhsMass(Stokes*, PetscInt, PetscInt, PetscScalar*); /* right hand side of pressure */
85: PetscErrorCode StokesSetupApproxSchur(Stokes*); /* approximation of the Schur complement */
87: PetscErrorCode StokesExactSolution(Stokes*); /* exact solution vector */
88: PetscErrorCode StokesWriteSolution(Stokes*); /* write solution to file */
90: /* exact solution for the velocity (x-component, y-component is zero) */
91: PetscScalar StokesExactVelocityX(const PetscScalar y)
92: {
93: return 4.0*y*(1.0-y);
94: }
96: /* exact solution for the pressure */
97: PetscScalar StokesExactPressure(const PetscScalar x)
98: {
99: return 8.0*(2.0-x);
100: }
102: PetscErrorCode StokesSetupPC(Stokes *s, KSP ksp)
103: {
104: KSP *subksp;
105: PC pc;
106: PetscInt n = 1;
110: KSPGetPC(ksp, &pc);
111: PCFieldSplitSetIS(pc, "0", s->isg[0]);
112: PCFieldSplitSetIS(pc, "1", s->isg[1]);
113: if (s->userPC) {
114: PCFieldSplitSetSchurPre(pc, PC_FIELDSPLIT_SCHUR_PRE_USER, s->myS);
115: }
116: if (s->userKSP) {
117: PCSetUp(pc);
118: PCFieldSplitGetSubKSP(pc, &n, &subksp);
119: KSPSetOperators(subksp[1], s->myS, s->myS);
120: PetscFree(subksp);
121: }
122: return(0);
123: }
125: PetscErrorCode StokesWriteSolution(Stokes *s)
126: {
127: PetscMPIInt size;
128: PetscInt n,i,j;
129: const PetscScalar *array;
130: PetscErrorCode ierr;
133: /* write data (*warning* only works sequential) */
134: MPI_Comm_size(MPI_COMM_WORLD,&size);
135: /*PetscPrintf(PETSC_COMM_WORLD," number of processors = %D\n",size);*/
136: if (size == 1) {
137: PetscViewer viewer;
138: VecGetArrayRead(s->x, &array);
139: PetscViewerASCIIOpen(PETSC_COMM_WORLD, "solution.dat", &viewer);
140: PetscViewerASCIIPrintf(viewer, "# x, y, u, v, p\n");
141: for (j = 0; j < s->ny; j++) {
142: for (i = 0; i < s->nx; i++) {
143: n = j*s->nx+i;
144: PetscViewerASCIIPrintf(viewer, "%.12g %.12g %.12g %.12g %.12g\n", (double)(i*s->hx+s->hx/2),(double)(j*s->hy+s->hy/2), (double)PetscRealPart(array[n]), (double)PetscRealPart(array[n+s->nx*s->ny]),(double)PetscRealPart(array[n+2*s->nx*s->ny]));
145: }
146: }
147: VecRestoreArrayRead(s->x, &array);
148: PetscViewerDestroy(&viewer);
149: }
150: return(0);
151: }
153: PetscErrorCode StokesSetupIndexSets(Stokes *s)
154: {
158: /* the two index sets */
159: MatNestGetISs(s->A, s->isg, NULL);
160: /* ISView(isg[0],PETSC_VIEWER_STDOUT_WORLD); */
161: /* ISView(isg[1],PETSC_VIEWER_STDOUT_WORLD); */
162: return(0);
163: }
165: PetscErrorCode StokesSetupVectors(Stokes *s)
166: {
170: /* solution vector x */
171: VecCreate(PETSC_COMM_WORLD, &s->x);
172: VecSetSizes(s->x, PETSC_DECIDE, 3*s->nx*s->ny);
173: VecSetType(s->x, VECMPI);
174: /* VecSetRandom(s->x, NULL); */
175: /* VecView(s->x, (PetscViewer) PETSC_VIEWER_DEFAULT); */
177: /* exact solution y */
178: VecDuplicate(s->x, &s->y);
179: StokesExactSolution(s);
180: /* VecView(s->y, (PetscViewer) PETSC_VIEWER_DEFAULT); */
182: /* rhs vector b */
183: VecDuplicate(s->x, &s->b);
184: StokesRhs(s);
185: /*VecView(s->b, (PetscViewer) PETSC_VIEWER_DEFAULT);*/
186: return(0);
187: }
189: PetscErrorCode StokesGetPosition(Stokes *s, PetscInt row, PetscInt *i, PetscInt *j)
190: {
191: PetscInt n;
194: /* cell number n=j*nx+i has position (i,j) in grid */
195: n = row%(s->nx*s->ny);
196: *i = n%s->nx;
197: *j = (n-(*i))/s->nx;
198: return(0);
199: }
201: PetscErrorCode StokesExactSolution(Stokes *s)
202: {
203: PetscInt row, start, end, i, j;
204: PetscScalar val;
205: Vec y0,y1;
209: /* velocity part */
210: VecGetSubVector(s->y, s->isg[0], &y0);
211: VecGetOwnershipRange(y0, &start, &end);
212: for (row = start; row < end; row++) {
213: StokesGetPosition(s, row,&i,&j);
214: if (row < s->nx*s->ny) {
215: val = StokesExactVelocityX(j*s->hy+s->hy/2);
216: } else {
217: val = 0;
218: }
219: VecSetValue(y0, row, val, INSERT_VALUES);
220: }
221: VecRestoreSubVector(s->y, s->isg[0], &y0);
223: /* pressure part */
224: VecGetSubVector(s->y, s->isg[1], &y1);
225: VecGetOwnershipRange(y1, &start, &end);
226: for (row = start; row < end; row++) {
227: StokesGetPosition(s, row, &i, &j);
228: val = StokesExactPressure(i*s->hx+s->hx/2);
229: VecSetValue(y1, row, val, INSERT_VALUES);
230: }
231: VecRestoreSubVector(s->y, s->isg[1], &y1);
232: return(0);
233: }
235: PetscErrorCode StokesRhs(Stokes *s)
236: {
237: PetscInt row, start, end, i, j;
238: PetscScalar val;
239: Vec b0,b1;
243: /* velocity part */
244: VecGetSubVector(s->b, s->isg[0], &b0);
245: VecGetOwnershipRange(b0, &start, &end);
246: for (row = start; row < end; row++) {
247: StokesGetPosition(s, row, &i, &j);
248: if (row < s->nx*s->ny) {
249: StokesRhsMomX(s, i, j, &val);
250: } else {
251: StokesRhsMomY(s, i, j, &val);
252: }
253: VecSetValue(b0, row, val, INSERT_VALUES);
254: }
255: VecRestoreSubVector(s->b, s->isg[0], &b0);
257: /* pressure part */
258: VecGetSubVector(s->b, s->isg[1], &b1);
259: VecGetOwnershipRange(b1, &start, &end);
260: for (row = start; row < end; row++) {
261: StokesGetPosition(s, row, &i, &j);
262: StokesRhsMass(s, i, j, &val);
263: if (s->matsymmetric) {
264: val = -1.0*val;
265: }
266: VecSetValue(b1, row, val, INSERT_VALUES);
267: }
268: VecRestoreSubVector(s->b, s->isg[1], &b1);
269: return(0);
270: }
272: PetscErrorCode StokesSetupMatBlock00(Stokes *s)
273: {
274: PetscInt row, start, end, sz, i, j;
275: PetscInt cols[5];
276: PetscScalar vals[5];
280: /* A[0] is 2N-by-2N */
281: MatCreate(PETSC_COMM_WORLD,&s->subA[0]);
282: MatSetOptionsPrefix(s->subA[0],"a00_");
283: MatSetSizes(s->subA[0],PETSC_DECIDE,PETSC_DECIDE,2*s->nx*s->ny,2*s->nx*s->ny);
284: MatSetType(s->subA[0],MATMPIAIJ);
285: MatMPIAIJSetPreallocation(s->subA[0],5,NULL,5,NULL);
286: MatGetOwnershipRange(s->subA[0], &start, &end);
288: for (row = start; row < end; row++) {
289: StokesGetPosition(s, row, &i, &j);
290: /* first part: rows 0 to (nx*ny-1) */
291: StokesStencilLaplacian(s, i, j, &sz, cols, vals);
292: /* second part: rows (nx*ny) to (2*nx*ny-1) */
293: if (row >= s->nx*s->ny) {
294: for (i = 0; i < sz; i++) cols[i] += s->nx*s->ny;
295: }
296: for (i = 0; i < sz; i++) vals[i] = -1.0*vals[i]; /* dynamic viscosity coef mu=-1 */
297: MatSetValues(s->subA[0], 1, &row, sz, cols, vals, INSERT_VALUES);
298: }
299: MatAssemblyBegin(s->subA[0], MAT_FINAL_ASSEMBLY);
300: MatAssemblyEnd(s->subA[0], MAT_FINAL_ASSEMBLY);
301: return(0);
302: }
304: PetscErrorCode StokesSetupMatBlock01(Stokes *s)
305: {
306: PetscInt row, start, end, sz, i, j;
307: PetscInt cols[5];
308: PetscScalar vals[5];
312: /* A[1] is 2N-by-N */
313: MatCreate(PETSC_COMM_WORLD, &s->subA[1]);
314: MatSetOptionsPrefix(s->subA[1],"a01_");
315: MatSetSizes(s->subA[1],PETSC_DECIDE,PETSC_DECIDE,2*s->nx*s->ny,s->nx*s->ny);
316: MatSetType(s->subA[1],MATMPIAIJ);
317: MatMPIAIJSetPreallocation(s->subA[1],5,NULL,5,NULL);
318: MatGetOwnershipRange(s->subA[1],&start,&end);
320: MatSetOption(s->subA[1],MAT_IGNORE_ZERO_ENTRIES,PETSC_TRUE);
322: for (row = start; row < end; row++) {
323: StokesGetPosition(s, row, &i, &j);
324: /* first part: rows 0 to (nx*ny-1) */
325: if (row < s->nx*s->ny) {
326: StokesStencilGradientX(s, i, j, &sz, cols, vals);
327: } else { /* second part: rows (nx*ny) to (2*nx*ny-1) */
328: StokesStencilGradientY(s, i, j, &sz, cols, vals);
329: }
330: MatSetValues(s->subA[1], 1, &row, sz, cols, vals, INSERT_VALUES);
331: }
332: MatAssemblyBegin(s->subA[1], MAT_FINAL_ASSEMBLY);
333: MatAssemblyEnd(s->subA[1], MAT_FINAL_ASSEMBLY);
334: return(0);
335: }
337: PetscErrorCode StokesSetupMatBlock10(Stokes *s)
338: {
342: /* A[2] is minus transpose of A[1] */
343: MatTranspose(s->subA[1], MAT_INITIAL_MATRIX, &s->subA[2]);
344: if (!s->matsymmetric) {
345: MatScale(s->subA[2], -1.0);
346: }
347: MatSetOptionsPrefix(s->subA[2], "a10_");
348: return(0);
349: }
351: PetscErrorCode StokesSetupMatBlock11(Stokes *s)
352: {
356: /* A[3] is N-by-N null matrix */
357: MatCreate(PETSC_COMM_WORLD, &s->subA[3]);
358: MatSetOptionsPrefix(s->subA[3], "a11_");
359: MatSetSizes(s->subA[3], PETSC_DECIDE, PETSC_DECIDE, s->nx*s->ny, s->nx*s->ny);
360: MatSetType(s->subA[3], MATMPIAIJ);
361: MatMPIAIJSetPreallocation(s->subA[3], 0, NULL, 0, NULL);
362: MatAssemblyBegin(s->subA[3], MAT_FINAL_ASSEMBLY);
363: MatAssemblyEnd(s->subA[3], MAT_FINAL_ASSEMBLY);
364: return(0);
365: }
367: PetscErrorCode StokesSetupApproxSchur(Stokes *s)
368: {
369: Vec diag;
373: /* Schur complement approximation: myS = A11 - A10 diag(A00)^(-1) A01 */
374: /* note: A11 is zero */
375: /* note: in real life this matrix would be build directly, */
376: /* i.e. without MatMatMult */
378: /* inverse of diagonal of A00 */
379: VecCreate(PETSC_COMM_WORLD,&diag);
380: VecSetSizes(diag,PETSC_DECIDE,2*s->nx*s->ny);
381: VecSetType(diag,VECMPI);
382: MatGetDiagonal(s->subA[0],diag);
383: VecReciprocal(diag);
385: /* compute: - A10 diag(A00)^(-1) A01 */
386: MatDiagonalScale(s->subA[1],diag,NULL); /* (*warning* overwrites subA[1]) */
387: MatMatMult(s->subA[2],s->subA[1],MAT_INITIAL_MATRIX,PETSC_DEFAULT,&s->myS);
388: MatScale(s->myS,-1.0);
390: /* restore A10 */
391: MatGetDiagonal(s->subA[0],diag);
392: MatDiagonalScale(s->subA[1],diag,NULL);
393: VecDestroy(&diag);
394: return(0);
395: }
397: PetscErrorCode StokesSetupMatrix(Stokes *s)
398: {
402: StokesSetupMatBlock00(s);
403: StokesSetupMatBlock01(s);
404: StokesSetupMatBlock10(s);
405: StokesSetupMatBlock11(s);
406: MatCreateNest(PETSC_COMM_WORLD, 2, NULL, 2, NULL, s->subA, &s->A);
407: StokesSetupApproxSchur(s);
408: return(0);
409: }
411: PetscErrorCode StokesStencilLaplacian(Stokes *s, PetscInt i, PetscInt j, PetscInt *sz, PetscInt *cols, PetscScalar *vals)
412: {
413: PetscInt p =j*s->nx+i, w=p-1, e=p+1, s2=p-s->nx, n=p+s->nx;
414: PetscScalar ae=s->hy/s->hx, aeb=0;
415: PetscScalar aw=s->hy/s->hx, awb=s->hy/(s->hx/2);
416: PetscScalar as=s->hx/s->hy, asb=s->hx/(s->hy/2);
417: PetscScalar an=s->hx/s->hy, anb=s->hx/(s->hy/2);
420: if (i==0 && j==0) { /* south-west corner */
421: *sz =3;
422: cols[0]=p; vals[0]=-(ae+awb+asb+an);
423: cols[1]=e; vals[1]=ae;
424: cols[2]=n; vals[2]=an;
425: } else if (i==0 && j==s->ny-1) { /* north-west corner */
426: *sz =3;
427: cols[0]=s2; vals[0]=as;
428: cols[1]=p; vals[1]=-(ae+awb+as+anb);
429: cols[2]=e; vals[2]=ae;
430: } else if (i==s->nx-1 && j==0) { /* south-east corner */
431: *sz =3;
432: cols[0]=w; vals[0]=aw;
433: cols[1]=p; vals[1]=-(aeb+aw+asb+an);
434: cols[2]=n; vals[2]=an;
435: } else if (i==s->nx-1 && j==s->ny-1) { /* north-east corner */
436: *sz =3;
437: cols[0]=s2; vals[0]=as;
438: cols[1]=w; vals[1]=aw;
439: cols[2]=p; vals[2]=-(aeb+aw+as+anb);
440: } else if (i==0) { /* west boundary */
441: *sz =4;
442: cols[0]=s2; vals[0]=as;
443: cols[1]=p; vals[1]=-(ae+awb+as+an);
444: cols[2]=e; vals[2]=ae;
445: cols[3]=n; vals[3]=an;
446: } else if (i==s->nx-1) { /* east boundary */
447: *sz =4;
448: cols[0]=s2; vals[0]=as;
449: cols[1]=w; vals[1]=aw;
450: cols[2]=p; vals[2]=-(aeb+aw+as+an);
451: cols[3]=n; vals[3]=an;
452: } else if (j==0) { /* south boundary */
453: *sz =4;
454: cols[0]=w; vals[0]=aw;
455: cols[1]=p; vals[1]=-(ae+aw+asb+an);
456: cols[2]=e; vals[2]=ae;
457: cols[3]=n; vals[3]=an;
458: } else if (j==s->ny-1) { /* north boundary */
459: *sz =4;
460: cols[0]=s2; vals[0]=as;
461: cols[1]=w; vals[1]=aw;
462: cols[2]=p; vals[2]=-(ae+aw+as+anb);
463: cols[3]=e; vals[3]=ae;
464: } else { /* interior */
465: *sz =5;
466: cols[0]=s2; vals[0]=as;
467: cols[1]=w; vals[1]=aw;
468: cols[2]=p; vals[2]=-(ae+aw+as+an);
469: cols[3]=e; vals[3]=ae;
470: cols[4]=n; vals[4]=an;
471: }
472: return(0);
473: }
475: PetscErrorCode StokesStencilGradientX(Stokes *s, PetscInt i, PetscInt j, PetscInt *sz, PetscInt *cols, PetscScalar *vals)
476: {
477: PetscInt p =j*s->nx+i, w=p-1, e=p+1;
478: PetscScalar ae= s->hy/2, aeb=s->hy;
479: PetscScalar aw=-s->hy/2, awb=0;
482: if (i==0 && j==0) { /* south-west corner */
483: *sz =2;
484: cols[0]=p; vals[0]=-(ae+awb);
485: cols[1]=e; vals[1]=ae;
486: } else if (i==0 && j==s->ny-1) { /* north-west corner */
487: *sz =2;
488: cols[0]=p; vals[0]=-(ae+awb);
489: cols[1]=e; vals[1]=ae;
490: } else if (i==s->nx-1 && j==0) { /* south-east corner */
491: *sz =2;
492: cols[0]=w; vals[0]=aw;
493: cols[1]=p; vals[1]=-(aeb+aw);
494: } else if (i==s->nx-1 && j==s->ny-1) { /* north-east corner */
495: *sz =2;
496: cols[0]=w; vals[0]=aw;
497: cols[1]=p; vals[1]=-(aeb+aw);
498: } else if (i==0) { /* west boundary */
499: *sz =2;
500: cols[0]=p; vals[0]=-(ae+awb);
501: cols[1]=e; vals[1]=ae;
502: } else if (i==s->nx-1) { /* east boundary */
503: *sz =2;
504: cols[0]=w; vals[0]=aw;
505: cols[1]=p; vals[1]=-(aeb+aw);
506: } else if (j==0) { /* south boundary */
507: *sz =3;
508: cols[0]=w; vals[0]=aw;
509: cols[1]=p; vals[1]=-(ae+aw);
510: cols[2]=e; vals[2]=ae;
511: } else if (j==s->ny-1) { /* north boundary */
512: *sz =3;
513: cols[0]=w; vals[0]=aw;
514: cols[1]=p; vals[1]=-(ae+aw);
515: cols[2]=e; vals[2]=ae;
516: } else { /* interior */
517: *sz =3;
518: cols[0]=w; vals[0]=aw;
519: cols[1]=p; vals[1]=-(ae+aw);
520: cols[2]=e; vals[2]=ae;
521: }
522: return(0);
523: }
525: PetscErrorCode StokesStencilGradientY(Stokes *s, PetscInt i, PetscInt j, PetscInt *sz, PetscInt *cols, PetscScalar *vals)
526: {
527: PetscInt p =j*s->nx+i, s2=p-s->nx, n=p+s->nx;
528: PetscScalar as=-s->hx/2, asb=0;
529: PetscScalar an= s->hx/2, anb=0;
532: if (i==0 && j==0) { /* south-west corner */
533: *sz =2;
534: cols[0]=p; vals[0]=-(asb+an);
535: cols[1]=n; vals[1]=an;
536: } else if (i==0 && j==s->ny-1) { /* north-west corner */
537: *sz =2;
538: cols[0]=s2; vals[0]=as;
539: cols[1]=p; vals[1]=-(as+anb);
540: } else if (i==s->nx-1 && j==0) { /* south-east corner */
541: *sz =2;
542: cols[0]=p; vals[0]=-(asb+an);
543: cols[1]=n; vals[1]=an;
544: } else if (i==s->nx-1 && j==s->ny-1) { /* north-east corner */
545: *sz =2;
546: cols[0]=s2; vals[0]=as;
547: cols[1]=p; vals[1]=-(as+anb);
548: } else if (i==0) { /* west boundary */
549: *sz =3;
550: cols[0]=s2; vals[0]=as;
551: cols[1]=p; vals[1]=-(as+an);
552: cols[2]=n; vals[2]=an;
553: } else if (i==s->nx-1) { /* east boundary */
554: *sz =3;
555: cols[0]=s2; vals[0]=as;
556: cols[1]=p; vals[1]=-(as+an);
557: cols[2]=n; vals[2]=an;
558: } else if (j==0) { /* south boundary */
559: *sz =2;
560: cols[0]=p; vals[0]=-(asb+an);
561: cols[1]=n; vals[1]=an;
562: } else if (j==s->ny-1) { /* north boundary */
563: *sz =2;
564: cols[0]=s2; vals[0]=as;
565: cols[1]=p; vals[1]=-(as+anb);
566: } else { /* interior */
567: *sz =3;
568: cols[0]=s2; vals[0]=as;
569: cols[1]=p; vals[1]=-(as+an);
570: cols[2]=n; vals[2]=an;
571: }
572: return(0);
573: }
575: PetscErrorCode StokesRhsMomX(Stokes *s, PetscInt i, PetscInt j, PetscScalar *val)
576: {
577: PetscScalar y = j*s->hy+s->hy/2;
578: PetscScalar awb = s->hy/(s->hx/2);
581: if (i == 0) { /* west boundary */
582: *val = awb*StokesExactVelocityX(y);
583: } else {
584: *val = 0.0;
585: }
586: return(0);
587: }
589: PetscErrorCode StokesRhsMomY(Stokes *s, PetscInt i, PetscInt j, PetscScalar *val)
590: {
592: *val = 0.0;
593: return(0);
594: }
596: PetscErrorCode StokesRhsMass(Stokes *s, PetscInt i, PetscInt j, PetscScalar *val)
597: {
598: PetscScalar y = j*s->hy+s->hy/2;
599: PetscScalar aeb = s->hy;
602: if (i == 0) { /* west boundary */
603: *val = aeb*StokesExactVelocityX(y);
604: } else {
605: *val = 0.0;
606: }
607: return(0);
608: }
610: PetscErrorCode StokesCalcResidual(Stokes *s)
611: {
612: PetscReal val;
613: Vec b0, b1;
617: /* residual Ax-b (*warning* overwrites b) */
618: VecScale(s->b, -1.0);
619: MatMultAdd(s->A, s->x, s->b, s->b);
620: /* VecView(s->b, (PetscViewer)PETSC_VIEWER_DEFAULT); */
622: /* residual velocity */
623: VecGetSubVector(s->b, s->isg[0], &b0);
624: VecNorm(b0, NORM_2, &val);
625: PetscPrintf(PETSC_COMM_WORLD," residual u = %g\n",(double)val);
626: VecRestoreSubVector(s->b, s->isg[0], &b0);
628: /* residual pressure */
629: VecGetSubVector(s->b, s->isg[1], &b1);
630: VecNorm(b1, NORM_2, &val);
631: PetscPrintf(PETSC_COMM_WORLD," residual p = %g\n",(double)val);
632: VecRestoreSubVector(s->b, s->isg[1], &b1);
634: /* total residual */
635: VecNorm(s->b, NORM_2, &val);
636: PetscPrintf(PETSC_COMM_WORLD," residual [u,p] = %g\n", (double)val);
637: return(0);
638: }
640: PetscErrorCode StokesCalcError(Stokes *s)
641: {
642: PetscScalar scale = PetscSqrtReal((double)s->nx*s->ny);
643: PetscReal val;
644: Vec y0, y1;
648: /* error y-x */
649: VecAXPY(s->y, -1.0, s->x);
650: /* VecView(s->y, (PetscViewer)PETSC_VIEWER_DEFAULT); */
652: /* error in velocity */
653: VecGetSubVector(s->y, s->isg[0], &y0);
654: VecNorm(y0, NORM_2, &val);
655: PetscPrintf(PETSC_COMM_WORLD," discretization error u = %g\n",(double)(PetscRealPart(val/scale)));
656: VecRestoreSubVector(s->y, s->isg[0], &y0);
658: /* error in pressure */
659: VecGetSubVector(s->y, s->isg[1], &y1);
660: VecNorm(y1, NORM_2, &val);
661: PetscPrintf(PETSC_COMM_WORLD," discretization error p = %g\n",(double)(PetscRealPart(val/scale)));
662: VecRestoreSubVector(s->y, s->isg[1], &y1);
664: /* total error */
665: VecNorm(s->y, NORM_2, &val);
666: PetscPrintf(PETSC_COMM_WORLD," discretization error [u,p] = %g\n", (double)PetscRealPart((val/scale)));
667: return(0);
668: }
670: int main(int argc, char **argv)
671: {
672: Stokes s;
673: KSP ksp;
676: PetscInitialize(&argc, &argv, NULL,help);if (ierr) return ierr;
677: s.nx = 4;
678: s.ny = 6;
679: PetscOptionsGetInt(NULL,NULL, "-nx", &s.nx, NULL);
680: PetscOptionsGetInt(NULL,NULL, "-ny", &s.ny, NULL);
681: s.hx = 2.0/s.nx;
682: s.hy = 1.0/s.ny;
683: s.matsymmetric = PETSC_FALSE;
684: PetscOptionsGetBool(NULL,NULL, "-mat_set_symmetric", &s.matsymmetric,NULL);
685: s.userPC = s.userKSP = PETSC_FALSE;
686: PetscOptionsHasName(NULL,NULL, "-user_pc", &s.userPC);
687: PetscOptionsHasName(NULL,NULL, "-user_ksp", &s.userKSP);
689: StokesSetupMatrix(&s);
690: StokesSetupIndexSets(&s);
691: StokesSetupVectors(&s);
693: KSPCreate(PETSC_COMM_WORLD, &ksp);
694: KSPSetOperators(ksp, s.A, s.A);
695: KSPSetFromOptions(ksp);
696: StokesSetupPC(&s, ksp);
697: KSPSolve(ksp, s.b, s.x);
699: /* don't trust, verify! */
700: StokesCalcResidual(&s);
701: StokesCalcError(&s);
702: StokesWriteSolution(&s);
704: KSPDestroy(&ksp);
705: MatDestroy(&s.subA[0]);
706: MatDestroy(&s.subA[1]);
707: MatDestroy(&s.subA[2]);
708: MatDestroy(&s.subA[3]);
709: MatDestroy(&s.A);
710: VecDestroy(&s.x);
711: VecDestroy(&s.b);
712: VecDestroy(&s.y);
713: MatDestroy(&s.myS);
714: PetscFinalize();
715: return ierr;
716: }
719: /*TEST
721: test:
722: nsize: 2
723: args: -nx 16 -ny 24 -ksp_type fgmres -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_fact_type lower -fieldsplit_1_pc_type none
725: test:
726: suffix: 2
727: nsize: 2
728: args: -nx 16 -ny 24 -ksp_type fgmres -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_fact_type lower -user_pc
730: test:
731: suffix: 3
732: nsize: 2
733: args: -nx 16 -ny 24 -ksp_type fgmres -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_fact_type lower -user_pc
735: test:
736: suffix: 4
737: nsize: 2
738: args: -nx 16 -ny 24 -ksp_type fgmres -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_fact_type lower -fieldsplit_0_ksp_type gmres -fieldsplit_0_pc_type bjacobi -fieldsplit_1_pc_type jacobi -fieldsplit_1_inner_ksp_type preonly -fieldsplit_1_inner_pc_type jacobi -fieldsplit_1_upper_ksp_type preonly -fieldsplit_1_upper_pc_type jacobi
740: test:
741: suffix: 4_pcksp
742: nsize: 2
743: args: -nx 16 -ny 24 -ksp_type fgmres -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_fact_type lower -fieldsplit_0_ksp_type gmres -fieldsplit_0_pc_type bjacobi -fieldsplit_1_pc_type jacobi -fieldsplit_1_inner_ksp_type preonly -fieldsplit_1_upper_ksp_type preonly -fieldsplit_1_upper_pc_type jacobi
745: test:
746: suffix: 5
747: nsize: 2
748: args: -nx 4 -ny 8 -mat_set_symmetric -ksp_type fgmres -pc_type fieldsplit -pc_fieldsplit_type gkb -fieldsplit_0_ksp_type cg -fieldsplit_0_pc_type jacobi -fieldsplit_0_ksp_rtol 1e-10
750: test:
751: suffix: 6
752: nsize: 2
753: args: -nx 4 -ny 8 -mat_set_symmetric -ksp_type preonly -pc_type fieldsplit -pc_fieldsplit_type gkb -fieldsplit_0_ksp_type cg -fieldsplit_0_pc_type jacobi -fieldsplit_0_ksp_rtol 1e-10
755: test:
756: suffix: 7
757: nsize: 2
758: args: -nx 4 -ny 8 -mat_set_symmetric -ksp_type preonly -pc_type fieldsplit -pc_fieldsplit_type gkb -pc_fieldsplit_gkb_tol 1e-4 -pc_fieldsplit_gkb_nu 5 -fieldsplit_0_ksp_type cg -fieldsplit_0_pc_type jacobi -fieldsplit_0_ksp_rtol 1e-6
761: TEST*/