Actual source code: ex7.c

petsc-3.6.1 2015-08-06
Report Typos and Errors
  2: static char help[] = "Solves the Stokes equation in a 2D rectangular\n\
  3: domain, using distributed arrays (DMDAs) to partition the parallel grid.\n\n";

  5: /*T
  6:    Concepts: SNES^parallel Stokes example
  7:    Concepts: DMDA^using distributed arrays;
  8:    Processors: n
  9: T*/

 11: /* ------------------------------------------------------------------------

 13:     The Stokes equation is given by the partial differential equation

 15:         -alpha*Laplacian u - \nabla p = f,  0 < x,y < 1,

 17:           \nabla \cdot u              = 0

 19:     with boundary conditions

 21:              u = 0  for  x = 0, x = 1, y = 0, y = 1.

 23:     A P2/P1 finite element approximation is used to discretize the boundary
 24:     value problem on the two triangles which make up each rectangle in the DMDA
 25:     to obtain a nonlinear system of equations.

 27:   ------------------------------------------------------------------------- */

 29: /*
 30:    Include "petscdmda.h" so that we can use distributed arrays (DMDAs).
 31:    Include "petscsnes.h" so that we can use SNES solvers.  Note that this
 32:    file automatically includes:
 33:      petscsys.h       - base PETSc routines   petscvec.h - vectors
 34:      petscmat.h - matrices
 35:      petscis.h     - index sets            petscksp.h - Krylov subspace methods
 36:      petscviewer.h - viewers               petscpc.h  - preconditioners
 37:      petscksp.h   - linear solvers
 38: */
 39: #include <petscsys.h>
 40: #include <petscbag.h>
 41: #include <petscdm.h>
 42: #include <petscdmda.h>
 43: #include <petscsnes.h>

 45: /*
 46:    User-defined application context - contains data needed by the
 47:    application-provided call-back routines, FormJacobianLocal() and
 48:    FormFunctionLocal().
 49: */
 50: typedef struct {
 51:   PetscReal alpha;          /* parameter controlling linearity */
 52:   PetscReal lambda;         /* parameter controlling nonlinearity */
 53: } AppCtx;

 55: typedef struct {
 56:   PetscScalar u;
 57:   PetscScalar v;
 58:   PetscScalar p;
 59: } Field;

 61: static PetscScalar Kref[36] = { 0.5,  0.5, -0.5,  0,  0, -0.5,
 62:                                 0.5,  0.5, -0.5,  0,  0, -0.5,
 63:                                -0.5, -0.5,  0.5,  0,  0,  0.5,
 64:                                   0,    0,    0,  0,  0,    0,
 65:                                   0,    0,    0,  0,  0,    0,
 66:                                -0.5, -0.5,  0.5,  0,  0,  0.5};

 68: static PetscScalar Gradient[18] = {-0.1666667, -0.1666667, -0.1666667,
 69:                                    -0.1666667, -0.1666667, -0.1666667,
 70:                                     0.1666667,  0.1666667,  0.1666667,
 71:                                     0.0,        0.0,        0.0,
 72:                                     0.0,        0.0,        0.0,
 73:                                     0.1666667,  0.1666667,  0.1666667};

 75: static PetscScalar Divergence[18] = {-0.1666667, 0.1666667, 0.0,
 76:                                      -0.1666667, 0.0,       0.1666667,
 77:                                      -0.1666667, 0.1666667, 0.0,
 78:                                      -0.1666667, 0.0,       0.1666667,
 79:                                      -0.1666667, 0.1666667, 0.0,
 80:                                      -0.1666667, 0.0,       0.1666667};

 82: /* These are */
 83: static PetscScalar quadPoints[8] = {0.17855873, 0.15505103,
 84:                                     0.07503111, 0.64494897,
 85:                                     0.66639025, 0.15505103,
 86:                                     0.28001992, 0.64494897};
 87: static PetscScalar quadWeights[4] = {0.15902069,  0.09097931,  0.15902069,  0.09097931};

 89: /*
 90:    User-defined routines
 91: */
 92: extern PetscErrorCode CreateNullSpace(DM, Vec*);
 93: extern PetscErrorCode FormInitialGuess(SNES,Vec,void*);
 94: extern PetscErrorCode FormFunctionLocal(DMDALocalInfo*,Field**,Field**,AppCtx*);
 95: extern PetscErrorCode FormJacobianLocal(DMDALocalInfo*,Field**,Mat,Mat,AppCtx*);
 96: extern PetscErrorCode L_2Error(DM, Vec, PetscReal*, AppCtx*);

100: int main(int argc,char **argv)
101: {
102:   DM                  da;
103:   SNES                snes;                    /* nonlinear solver */
104:   AppCtx              *user;                   /* user-defined work context */
105:   PetscBag            bag;
106:   PetscInt            its;                     /* iterations for convergence */
107:   PetscMPIInt         size;
108:   SNESConvergedReason reason;
109:   PetscErrorCode      ierr;
110:   PetscReal           lambda_max = 6.81, lambda_min = 0.0, error;
111:   Vec                 x;

113:   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
114:      Initialize program
115:      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
116:   PetscInitialize(&argc,&argv,(char*)0,help);
117:   MPI_Comm_size(PETSC_COMM_WORLD,&size);
118:   if (size != 1) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"Example only works for one process.");

120:   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
121:      Initialize problem parameters
122:   - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
123:   PetscBagCreate(PETSC_COMM_WORLD, sizeof(AppCtx), &bag);
124:   PetscBagGetData(bag, (void**) &user);
125:   PetscBagSetName(bag, "params", "Parameters for SNES example 4");
126:   PetscBagRegisterReal(bag, &user->alpha, 1.0, "alpha", "Linear coefficient");
127:   PetscBagRegisterReal(bag, &user->lambda, 6.0, "lambda", "Nonlinear coefficient");
128:   PetscBagSetFromOptions(bag);
129:   PetscOptionsGetReal(NULL,"-alpha",&user->alpha,NULL);
130:   PetscOptionsGetReal(NULL,"-lambda",&user->lambda,NULL);
131:   if (user->lambda > lambda_max || user->lambda < lambda_min) SETERRQ3(PETSC_COMM_SELF,1,"Lambda %g is out of range [%g, %g]", (double)user->lambda, (double)lambda_min, (double)lambda_max);

133:   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
134:      Create multilevel DM data structure (SNES) to manage hierarchical solvers
135:   - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
136:   SNESCreate(PETSC_COMM_WORLD,&snes);

138:   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
139:      Create distributed array (DMDA) to manage parallel grid and vectors
140:   - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
141:   DMDACreate2d(PETSC_COMM_WORLD, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE,DMDA_STENCIL_BOX,-3,-3,PETSC_DECIDE,PETSC_DECIDE,3,1,NULL,NULL,&da);
142:   DMDASetFieldName(da, 0, "ooblek");
143:   DMSetApplicationContext(da,user);
144:   SNESSetDM(snes, (DM) da);

146:   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
147:      Set the discretization functions
148:      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
149:   DMDASNESSetFunctionLocal(da,INSERT_VALUES,(PetscErrorCode (*)(DMDALocalInfo*,void*,void*,void*))FormFunctionLocal,user);
150:   DMDASNESSetJacobianLocal(da,(PetscErrorCode (*)(DMDALocalInfo*,void*,Mat,Mat,void*))FormJacobianLocal,user);
151:   SNESSetFromOptions(snes);

153:   SNESSetComputeInitialGuess(snes, FormInitialGuess,NULL);

155:   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
156:      Solve nonlinear system
157:      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
158:   SNESSolve(snes,NULL,NULL);
159:   SNESGetIterationNumber(snes,&its);
160:   SNESGetConvergedReason(snes, &reason);

162:   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
163:   PetscPrintf(PETSC_COMM_WORLD,"Number of SNES iterations = %D, %s\n",its,SNESConvergedReasons[reason]);
164:   DMDestroy(&da);
165:   SNESGetDM(snes,&da);
166:   SNESGetSolution(snes,&x);
167:   L_2Error(da, x, &error, user);
168:   PetscPrintf(PETSC_COMM_WORLD,"L_2 error in the solution: %g\n", (double)error);

170:   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
171:      Free work space.  All PETSc objects should be destroyed when they
172:      are no longer needed.
173:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
174:   SNESDestroy(&snes);
175:   PetscBagDestroy(&bag);
176:   PetscFinalize();
177:   return(0);
178: }

182: PetscErrorCode ExactSolution(PetscReal x, PetscReal y, Field *u)
183: {
185:   (*u).u = x;
186:   (*u).v = -y;
187:   (*u).p = 0.0;
188:   return(0);
189: }

193: PetscErrorCode CreateNullSpace(DM da, Vec *N)
194: {
195:   Field          **x;
196:   PetscInt       xs,ys,xm,ym,i,j;

200:   DMDAGetCorners(da, &xs, &ys, NULL, &xm, &ym, NULL);
201:   DMCreateGlobalVector(da,N);
202:   DMDAVecGetArray(da, *N, &x);
203:   for (j = ys; j < ys+ym; j++) {
204:     for (i = xs; i < xs+xm; i++) {
205:       x[j][i].u = 0.0;
206:       x[j][i].v = 0.0;
207:       x[j][i].p = 1.0;
208:     }
209:   }
210:   DMDAVecRestoreArray(da, *N, &x);
211:   return(0);
212: }

216: /*
217:    FormInitialGuess - Forms initial approximation.

219:    Input Parameters:
220:    dm - The DM context
221:    X - vector

223:    Output Parameter:
224:    X - vector
225: */
226: PetscErrorCode FormInitialGuess(SNES snes,Vec X,void *ctx)
227: {
228:   AppCtx         *user;
229:   PetscInt       i,j,Mx,My,xs,ys,xm,ym;
231:   PetscReal      lambda,hx,hy;
232:   PETSC_UNUSED PetscReal temp1;
233:   Field          **x;
234:   DM             da;

237:   SNESGetDM(snes,&da);
238:   DMGetApplicationContext(da,&user);
239:   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);

241:   lambda = user->lambda;
242:   hx     = 1.0/(PetscReal)(Mx-1);
243:   hy     = 1.0/(PetscReal)(My-1);
244:   if (lambda == 0.0) temp1 = 0.0;
245:   else temp1 = lambda/(lambda + 1.0);

247:   /*
248:      Get a pointer to vector data.
249:        - For default PETSc vectors, VecGetArray() returns a pointer to
250:          the data array.  Otherwise, the routine is implementation dependent.
251:        - You MUST call VecRestoreArray() when you no longer need access to
252:          the array.
253:   */
254:   DMDAVecGetArray(da,X,&x);

256:   /*
257:      Get local grid boundaries (for 2-dimensional DMDA):
258:        xs, ys   - starting grid indices (no ghost points)
259:        xm, ym   - widths of local grid (no ghost points)

261:   */
262:   DMDAGetCorners(da,&xs,&ys,NULL,&xm,&ym,NULL);

264:   /*
265:      Compute initial guess over the locally owned part of the grid
266:   */
267:   for (j=ys; j<ys+ym; j++) {
268:     for (i=xs; i<xs+xm; i++) {
269: #define CHECK_SOLUTION
270: #if defined(CHECK_SOLUTION)
271:       ExactSolution(i*hx, j*hy, &x[j][i]);
272: #else
273:       if (i == 0 || j == 0 || i == Mx-1 || j == My-1) {
274:         /* Boundary conditions are usually zero Dirichlet */
275:         ExactSolution(i*hx, j*hy, &x[j][i]);
276:       } else {
277:         PetscReal temp = (PetscReal)(PetscMin(j,My-j-1))*hy;
278:         x[j][i].u = temp1*PetscSqrtReal(PetscMin((PetscReal)(PetscMin(i,Mx-i-1))*hx,temp));
279:         x[j][i].v = temp1*PetscSqrtReal(PetscMin((PetscReal)(PetscMin(i,Mx-i-1))*hx,temp));
280:         x[j][i].p = 1.0;
281:       }
282: #endif
283:     }
284:   }

286:   /*
287:      Restore vector
288:   */
289:   DMDAVecRestoreArray(da,X,&x);
290:   return(0);
291: }

295: PetscErrorCode constantResidual(PetscReal lambda, PetscBool isLower, int i, int j, PetscReal hx, PetscReal hy, Field r[])
296: {
298:   Field          rLocal[3];
299:   PetscScalar    phi[3]    = {0.0, 0.0, 0.0};
300:   PetscReal      xI = i*hx, yI = j*hy, hxhy = hx*hy;
301:   Field          res;
302:   PetscInt       q, k;

305:   PetscMemzero(&rLocal,sizeof(rLocal));
306:   for (q = 0; q < 4; q++) {
307:     PETSC_UNUSED PetscReal x, y;
308:     phi[0] = 1.0 - quadPoints[q*2] - quadPoints[q*2+1];
309:     phi[1] = quadPoints[q*2];
310:     phi[2] = quadPoints[q*2+1];
311:     if (isLower) {
312:       x = xI + PetscAbsScalar(quadPoints[q*2])*hx;
313:       y = yI + PetscAbsScalar(quadPoints[q*2+1])*hy;
314:     } else {
315:       x = xI + 1.0 - PetscAbsScalar(quadPoints[q*2])*hx;
316:       y = yI + 1.0 - PetscAbsScalar(quadPoints[q*2+1])*hy;
317:     }
318:     res.u = quadWeights[q]*(0.0);
319:     res.v = quadWeights[q]*(0.0);
320:     res.p = quadWeights[q]*(0.0);
321:     for (k = 0; k < 3; k++) {
322:       rLocal[k].u += phi[k]*res.u;
323:       rLocal[k].v += phi[k]*res.v;
324:       rLocal[k].p += phi[k]*res.p;
325:     }
326:   }
327:   for (k = 0; k < 3; k++) {
328:     /*printf("  constLocal[%d] = (%g, %g, %g)\n", k, lambda*hxhy*rLocal[k].u, lambda*hxhy*rLocal[k].v, hxhy*rLocal[k].p); */
329:     r[k].u += lambda*hxhy*rLocal[k].u;
330:     r[k].v += lambda*hxhy*rLocal[k].v;
331:     r[k].p += hxhy*rLocal[k].p;
332:   }
333:   return(0);
334: }

338: PetscErrorCode nonlinearResidual(PetscReal lambda, Field u[], Field r[])
339: {
341:   Field          rLocal[3];
342:   PetscScalar    phi[3]    = {0.0, 0.0, 0.0};
343:   Field          res;
344:   PetscInt       q;

347:   PetscMemzero(&rLocal,sizeof(rLocal));
348:   for (q = 0; q < 4; q++) {
349:     phi[0] = 1.0 - quadPoints[q*2] - quadPoints[q*2+1];
350:     phi[1] = quadPoints[q*2];
351:     phi[2] = quadPoints[q*2+1];
352:     res.u  = quadWeights[q]*PetscExpScalar(u[0].u*phi[0] + u[1].u*phi[1] + u[2].u*phi[2]);
353:     res.v  = quadWeights[q]*PetscExpScalar(u[0].v*phi[0] + u[1].v*phi[1] + u[2].v*phi[2]);

355:     rLocal[0].u += phi[0]*res.u;
356:     rLocal[0].v += phi[0]*res.v;
357:     rLocal[1].u += phi[1]*res.u;
358:     rLocal[1].v += phi[1]*res.v;
359:     rLocal[2].u += phi[2]*res.u;
360:     rLocal[2].v += phi[2]*res.v;
361:   }
362:   r[0].u += lambda*rLocal[0].u;
363:   r[0].v += lambda*rLocal[0].v;
364:   r[1].u += lambda*rLocal[1].u;
365:   r[1].v += lambda*rLocal[1].v;
366:   r[2].u += lambda*rLocal[2].u;
367:   r[2].v += lambda*rLocal[2].v;
368:   return(0);
369: }

373: /*
374:    FormFunctionLocal - Evaluates nonlinear function, F(x).

376:  */
377: PetscErrorCode FormFunctionLocal(DMDALocalInfo *info, Field **x, Field **f, AppCtx *user)
378: {
379:   Field          uLocal[3];
380:   Field          rLocal[3];
381:   PetscScalar    G[4];
382:   Field          uExact;
383:   PetscReal      alpha,lambda,hx,hy,hxhy,sc,detJInv;
384:   PetscInt       i,j,k,l;

388:   /* Naive Jacobian calculation:

390:      J = / 1/hx  0   \ J^{-1} = / hx   0 \  1/|J| = hx*hy = |J^{-1}|
391:          \  0   1/hy /          \  0  hy /
392:    */
393:   alpha   = user->alpha;
394:   lambda  = user->lambda;
395:   hx      = 1.0/(PetscReal)(info->mx-1);
396:   hy      = 1.0/(PetscReal)(info->my-1);
397:   sc      = hx*hy*lambda;
398:   hxhy    = hx*hy;
399:   detJInv = hxhy;

401:   G[0] = (1.0/(hx*hx)) * detJInv;
402:   G[1] = 0.0;
403:   G[2] = G[1];
404:   G[3] = (1.0/(hy*hy)) * detJInv;
405:   for (k = 0; k < 4; k++) {
406:     /* printf("G[%d] = %g\n", k, G[k]);*/
407:   }

409:   /* Zero the vector */
410:   PetscMemzero((void*) &(f[info->xs][info->ys]), info->xm*info->ym*sizeof(Field));
411:   /* Compute function over the locally owned part of the grid. For each
412:      vertex (i,j), we consider the element below:

414:        2 (1)    (0)
415:      i,j+1 --- i+1,j+1
416:        |  \      |
417:        |   \     |
418:        |    \    |
419:        |     \   |
420:        |      \  |
421:       i,j  --- i+1,j
422:        0         1 (2)

424:      and therefore we do not loop over the last vertex in each dimension.
425:   */
426:   for (j = info->ys; j < info->ys+info->ym-1; j++) {
427:     for (i = info->xs; i < info->xs+info->xm-1; i++) {
428:       /* Lower element */
429:       uLocal[0] = x[j][i];
430:       uLocal[1] = x[j][i+1];
431:       uLocal[2] = x[j+1][i];
432:       /* printf("Lower Solution ElementVector for (%d, %d)\n", i, j);*/
433:       for (k = 0; k < 3; k++) {
434:         /* printf("  uLocal[%d] = (%g, %g, %g)\n", k, uLocal[k].u, uLocal[k].v, uLocal[k].p);*/
435:       }
436:       for (k = 0; k < 3; k++) {
437:         rLocal[k].u = 0.0;
438:         rLocal[k].v = 0.0;
439:         rLocal[k].p = 0.0;
440:         for (l = 0; l < 3; l++) {
441:           rLocal[k].u += alpha*(G[0]*Kref[(k*2*3 + l)*2]+G[1]*Kref[(k*2*3 + l)*2+1]+G[2]*Kref[((k*2+1)*3 + l)*2]+G[3]*Kref[((k*2+1)*3 + l)*2+1])*uLocal[l].u;
442:           rLocal[k].v += alpha*(G[0]*Kref[(k*2*3 + l)*2]+G[1]*Kref[(k*2*3 + l)*2+1]+G[2]*Kref[((k*2+1)*3 + l)*2]+G[3]*Kref[((k*2+1)*3 + l)*2+1])*uLocal[l].v;
443:           /* rLocal[k].u += hxhy*Identity[k*3+l]*uLocal[l].u; */
444:           /* rLocal[k].p += hxhy*Identity[k*3+l]*uLocal[l].p; */
445:           /* Gradient */
446:           rLocal[k].u += hx*Gradient[(k*2+0)*3 + l]*uLocal[l].p;
447:           rLocal[k].v += hy*Gradient[(k*2+1)*3 + l]*uLocal[l].p;
448:           /* Divergence */
449:           rLocal[k].p += hx*Divergence[(k*2+0)*3 + l]*uLocal[l].u + hy*Divergence[(k*2+1)*3 + l]*uLocal[l].v;
450:         }
451:       }
452:       /* printf("Lower Laplacian ElementVector for (%d, %d)\n", i, j);*/
453:       for (k = 0; k < 3; k++) {
454:         /* printf("  rLocal[%d] = (%g, %g, %g)\n", k, rLocal[k].u, rLocal[k].v, rLocal[k].p);*/
455:       }
456:       constantResidual(1.0, PETSC_TRUE, i, j, hx, hy, rLocal);
457:       /* printf("Lower Laplacian+Constant ElementVector for (%d, %d)\n", i, j);*/
458:       for (k = 0; k < 3; k++) {
459:         /* printf("  rLocal[%d] = (%g, %g, %g)\n", k, rLocal[k].u, rLocal[k].v, rLocal[k].p);*/
460:       }
461:       nonlinearResidual(0.0*sc, uLocal, rLocal);
462:       /* printf("Lower Full nonlinear ElementVector for (%d, %d)\n", i, j);*/
463:       for (k = 0; k < 3; k++) {
464:         /* printf("  rLocal[%d] = (%g, %g, %g)\n", k, rLocal[k].u, rLocal[k].v, rLocal[k].p);*/
465:       }
466:       f[j][i].u   += rLocal[0].u;
467:       f[j][i].v   += rLocal[0].v;
468:       f[j][i].p   += rLocal[0].p;
469:       f[j][i+1].u += rLocal[1].u;
470:       f[j][i+1].v += rLocal[1].v;
471:       f[j][i+1].p += rLocal[1].p;
472:       f[j+1][i].u += rLocal[2].u;
473:       f[j+1][i].v += rLocal[2].v;
474:       f[j+1][i].p += rLocal[2].p;
475:       /* Upper element */
476:       uLocal[0] = x[j+1][i+1];
477:       uLocal[1] = x[j+1][i];
478:       uLocal[2] = x[j][i+1];
479:       /* printf("Upper Solution ElementVector for (%d, %d)\n", i, j);*/
480:       for (k = 0; k < 3; k++) {
481:         /* printf("  uLocal[%d] = (%g, %g, %g)\n", k, uLocal[k].u, uLocal[k].v, uLocal[k].p);*/
482:       }
483:       for (k = 0; k < 3; k++) {
484:         rLocal[k].u = 0.0;
485:         rLocal[k].v = 0.0;
486:         rLocal[k].p = 0.0;
487:         for (l = 0; l < 3; l++) {
488:           rLocal[k].u += alpha*(G[0]*Kref[(k*2*3 + l)*2]+G[1]*Kref[(k*2*3 + l)*2+1]+G[2]*Kref[((k*2+1)*3 + l)*2]+G[3]*Kref[((k*2+1)*3 + l)*2+1])*uLocal[l].u;
489:           rLocal[k].v += alpha*(G[0]*Kref[(k*2*3 + l)*2]+G[1]*Kref[(k*2*3 + l)*2+1]+G[2]*Kref[((k*2+1)*3 + l)*2]+G[3]*Kref[((k*2+1)*3 + l)*2+1])*uLocal[l].v;
490:           /* rLocal[k].p += Identity[k*3+l]*uLocal[l].p; */
491:           /* Gradient */
492:           rLocal[k].u += hx*Gradient[(k*2+0)*3 + l]*uLocal[l].p;
493:           rLocal[k].v += hy*Gradient[(k*2+1)*3 + l]*uLocal[l].p;
494:           /* Divergence */
495:           rLocal[k].p += hx*Divergence[(k*2+0)*3 + l]*uLocal[l].u + hy*Divergence[(k*2+1)*3 + l]*uLocal[l].v;
496:         }
497:       }
498:       /* printf("Upper Laplacian ElementVector for (%d, %d)\n", i, j);*/
499:       for (k = 0; k < 3; k++) {
500:         /* printf("  rLocal[%d] = (%g, %g, %g)\n", k, rLocal[k].u, rLocal[k].v, rLocal[k].p);*/
501:       }
502:       constantResidual(1.0, PETSC_TRUE, i, j, hx, hy, rLocal);
503:       /* printf("Upper Laplacian+Constant ElementVector for (%d, %d)\n", i, j);*/
504:       for (k = 0; k < 3; k++) {
505:         /* printf("  rLocal[%d] = (%g, %g, %g)\n", k, rLocal[k].u, rLocal[k].v, rLocal[k].p);*/
506:       }
507:       nonlinearResidual(0.0*sc, uLocal, rLocal);
508:       /* printf("Upper Full nonlinear ElementVector for (%d, %d)\n", i, j);*/
509:       for (k = 0; k < 3; k++) {
510:         /* printf("  rLocal[%d] = (%g, %g, %g)\n", k, rLocal[k].u, rLocal[k].v, rLocal[k].p);*/
511:       }
512:       f[j+1][i+1].u += rLocal[0].u;
513:       f[j+1][i+1].v += rLocal[0].v;
514:       f[j+1][i+1].p += rLocal[0].p;
515:       f[j+1][i].u   += rLocal[1].u;
516:       f[j+1][i].v   += rLocal[1].v;
517:       f[j+1][i].p   += rLocal[1].p;
518:       f[j][i+1].u   += rLocal[2].u;
519:       f[j][i+1].v   += rLocal[2].v;
520:       f[j][i+1].p   += rLocal[2].p;
521:       /* Boundary conditions */
522:       if (i == 0 || j == 0) {
523:         ExactSolution(i*hx, j*hy, &uExact);

525:         f[j][i].u = x[j][i].u - uExact.u;
526:         f[j][i].v = x[j][i].v - uExact.v;
527:         f[j][i].p = x[j][i].p - uExact.p;
528:       }
529:       if ((i == info->mx-2) || (j == 0)) {
530:         ExactSolution((i+1)*hx, j*hy, &uExact);

532:         f[j][i+1].u = x[j][i+1].u - uExact.u;
533:         f[j][i+1].v = x[j][i+1].v - uExact.v;
534:         f[j][i+1].p = x[j][i+1].p - uExact.p;
535:       }
536:       if ((i == info->mx-2) || (j == info->my-2)) {
537:         ExactSolution((i+1)*hx, (j+1)*hy, &uExact);

539:         f[j+1][i+1].u = x[j+1][i+1].u - uExact.u;
540:         f[j+1][i+1].v = x[j+1][i+1].v - uExact.v;
541:         f[j+1][i+1].p = x[j+1][i+1].p - uExact.p;
542:       }
543:       if ((i == 0) || (j == info->my-2)) {
544:         ExactSolution(i*hx, (j+1)*hy, &uExact);

546:         f[j+1][i].u = x[j+1][i].u - uExact.u;
547:         f[j+1][i].v = x[j+1][i].v - uExact.v;
548:         f[j+1][i].p = x[j+1][i].p - uExact.p;
549:       }
550:     }
551:   }

553:   for (j = info->ys+info->ym-1; j >= info->ys; j--) {
554:     for (i = info->xs; i < info->xs+info->xm; i++) {
555:       /* printf("f[%d][%d] = (%g, %g, %g) ", j, i, f[j][i].u, f[j][i].v, f[j][i].p);*/
556:     }
557:     /*printf("\n");*/
558:   }
559:   PetscLogFlops(68.0*(info->ym-1)*(info->xm-1));
560:   return(0);
561: }

565: PetscErrorCode nonlinearJacobian(PetscReal lambda, Field u[], PetscScalar J[])
566: {
568:   return(0);
569: }

573: /*
574:    FormJacobianLocal - Evaluates Jacobian matrix.
575: */
576: PetscErrorCode FormJacobianLocal(DMDALocalInfo *info, Field **x, Mat A,Mat jac, AppCtx *user)
577: {
578:   Field          uLocal[4];
579:   PetscScalar    JLocal[144];
580:   MatStencil     rows[4*3], cols[4*3], ident;
581:   PetscInt       lowerRow[3] = {0, 1, 3};
582:   PetscInt       upperRow[3] = {2, 3, 1};
583:   PetscInt       hasLower[3], hasUpper[3], velocityRows[4], pressureRows[4];
584:   PetscScalar    alpha,lambda,hx,hy,hxhy,detJInv,G[4],sc,one = 1.0;
585:   PetscInt       i,j,k,l,numRows,dof = info->dof;
587:   MatNullSpace   nullspace;
588:   Vec            N;

591:   alpha   = user->alpha;
592:   lambda  = user->lambda;
593:   hx      = 1.0/(PetscReal)(info->mx-1);
594:   hy      = 1.0/(PetscReal)(info->my-1);
595:   sc      = hx*hy*lambda;
596:   hxhy    = hx*hy;
597:   detJInv = hxhy;

599:   G[0] = (1.0/(hx*hx)) * detJInv;
600:   G[1] = 0.0;
601:   G[2] = G[1];
602:   G[3] = (1.0/(hy*hy)) * detJInv;
603:   for (k = 0; k < 4; k++) {
604:     /* printf("G[%d] = %g\n", k, G[k]);*/
605:   }

607:   MatZeroEntries(jac);
608:   /*
609:      Compute entries for the locally owned part of the Jacobian.
610:       - Currently, all PETSc parallel matrix formats are partitioned by
611:         contiguous chunks of rows across the processors.
612:       - Each processor needs to insert only elements that it owns
613:         locally (but any non-local elements will be sent to the
614:         appropriate processor during matrix assembly).
615:       - Here, we set all entries for a particular row at once.
616:       - We can set matrix entries either using either
617:         MatSetValuesLocal() or MatSetValues(), as discussed above.
618:   */
619: #define NOT_PRES_BC 1
620:   for (j=info->ys; j<info->ys+info->ym-1; j++) {
621:     for (i=info->xs; i<info->xs+info->xm-1; i++) {
622:       PetscMemzero(JLocal, 144 * sizeof(PetscScalar));
623:       numRows = 0;
624:       /* Lower element */
625:       uLocal[0] = x[j][i];
626:       uLocal[1] = x[j][i+1];
627:       uLocal[2] = x[j+1][i+1];
628:       uLocal[3] = x[j+1][i];
629:       /* i,j */
630:       if (i == 0 || j == 0) {
631:         hasLower[0] = 0;

633:         MatAssemblyBegin(jac,MAT_FLUSH_ASSEMBLY);
634:         MatAssemblyEnd(jac,MAT_FLUSH_ASSEMBLY);

636:         ident.i = i; ident.j = j; ident.c = 0;

638:         MatSetValuesStencil(jac,1,&ident,1,&ident,&one,INSERT_VALUES);

640:         ident.i = i; ident.j = j; ident.c = 1;

642:         MatSetValuesStencil(jac,1,&ident,1,&ident,&one,INSERT_VALUES);
643: #if defined(PRES_BC)
644:         ident.i = i; ident.j = j; ident.c = 2;

646:         MatSetValuesStencil(jac,1,&ident,1,&ident,&one,INSERT_VALUES);
647: #endif
648:         MatAssemblyBegin(jac,MAT_FLUSH_ASSEMBLY);
649:         MatAssemblyEnd(jac,MAT_FLUSH_ASSEMBLY);
650:       } else {
651:         hasLower[0]     = 1;
652:         velocityRows[0] = numRows;
653:         rows[numRows].i = i; rows[numRows].j = j; rows[numRows].c = 0;
654:         numRows++;
655:         rows[numRows].i = i; rows[numRows].j = j; rows[numRows].c = 1;
656:         numRows++;
657: #if defined(PRES_BC)
658:         pressureRows[0] = numRows;
659:         rows[numRows].i = i; rows[numRows].j = j; rows[numRows].c = 2;
660:         numRows++;
661: #endif
662:       }
663: #if !defined(PRES_BC)
664:       pressureRows[0] = numRows;
665:       rows[numRows].i = i; rows[numRows].j = j; rows[numRows].c = 2;
666:       numRows++;
667: #endif
668:       cols[0*dof+0].i = i; cols[0*dof+0].j = j; cols[0*dof+0].c = 0;
669:       cols[0*dof+1].i = i; cols[0*dof+1].j = j; cols[0*dof+1].c = 1;
670:       cols[0*dof+2].i = i; cols[0*dof+2].j = j; cols[0*dof+2].c = 2;
671:       /* i+1,j */
672:       if ((i == info->mx-2) || (j == 0)) {
673:         hasLower[1] = 0;
674:         hasUpper[2] = 0;

676:         MatAssemblyBegin(jac,MAT_FLUSH_ASSEMBLY);
677:         MatAssemblyEnd(jac,MAT_FLUSH_ASSEMBLY);

679:         ident.i = i+1; ident.j = j; ident.c = 0;

681:         MatSetValuesStencil(jac,1,&ident,1,&ident,&one,INSERT_VALUES);

683:         ident.i = i+1; ident.j = j; ident.c = 1;

685:         MatSetValuesStencil(jac,1,&ident,1,&ident,&one,INSERT_VALUES);
686: #if defined(PRES_BC)
687:         ident.i = i+1; ident.j = j; ident.c = 2;

689:         MatSetValuesStencil(jac,1,&ident,1,&ident,&one,INSERT_VALUES);
690: #endif
691:         MatAssemblyBegin(jac,MAT_FLUSH_ASSEMBLY);
692:         MatAssemblyEnd(jac,MAT_FLUSH_ASSEMBLY);
693:       } else {
694:         hasLower[1]     = 1;
695:         hasUpper[2]     = 1;
696:         velocityRows[1] = numRows;
697:         rows[numRows].i = i+1; rows[numRows].j = j; rows[numRows].c = 0;
698:         numRows++;
699:         rows[numRows].i = i+1; rows[numRows].j = j; rows[numRows].c = 1;
700:         numRows++;
701: #if defined(PRES_BC)
702:         pressureRows[1] = numRows;
703:         rows[numRows].i = i+1; rows[numRows].j = j; rows[numRows].c = 2;
704:         numRows++;
705: #endif
706:       }
707: #if !defined(PRES_BC)
708:       pressureRows[1] = numRows;
709:       rows[numRows].i = i+1; rows[numRows].j = j; rows[numRows].c = 2;
710:       numRows++;
711: #endif
712:       cols[1*dof+0].i = i+1; cols[1*dof+0].j = j; cols[1*dof+0].c = 0;
713:       cols[1*dof+1].i = i+1; cols[1*dof+1].j = j; cols[1*dof+1].c = 1;
714:       cols[1*dof+2].i = i+1; cols[1*dof+2].j = j; cols[1*dof+2].c = 2;
715:       /* i+1,j+1 */
716:       if ((i == info->mx-2) || (j == info->my-2)) {
717:         hasUpper[0] = 0;
718:         MatAssemblyBegin(jac,MAT_FLUSH_ASSEMBLY);
719:         MatAssemblyEnd(jac,MAT_FLUSH_ASSEMBLY);

721:         ident.i = i+1; ident.j = j+1; ident.c = 0;

723:         MatSetValuesStencil(jac,1,&ident,1,&ident,&one,INSERT_VALUES);

725:         ident.i = i+1; ident.j = j+1; ident.c = 1;

727:         MatSetValuesStencil(jac,1,&ident,1,&ident,&one,INSERT_VALUES);
728: #if defined(PRES_BC)
729:         ident.i = i+1; ident.j = j+1; ident.c = 2;

731:         MatSetValuesStencil(jac,1,&ident,1,&ident,&one,INSERT_VALUES);
732: #endif
733:         MatAssemblyBegin(jac,MAT_FLUSH_ASSEMBLY);
734:         MatAssemblyEnd(jac,MAT_FLUSH_ASSEMBLY);
735:       } else {
736:         hasUpper[0]     = 1;
737:         velocityRows[2] = numRows;
738:         rows[numRows].i = i+1; rows[numRows].j = j+1; rows[numRows].c = 0;
739:         numRows++;
740:         rows[numRows].i = i+1; rows[numRows].j = j+1; rows[numRows].c = 1;
741:         numRows++;
742: #if defined(PRES_BC)
743:         pressureRows[2] = numRows;
744:         rows[numRows].i = i+1; rows[numRows].j = j+1; rows[numRows].c = 2;
745:         numRows++;
746: #endif
747:       }
748: #if !defined(PRES_BC)
749:       pressureRows[2] = numRows;
750:       rows[numRows].i = i+1; rows[numRows].j = j+1; rows[numRows].c = 2;
751:       numRows++;
752: #endif
753:       cols[2*dof+0].i = i+1; cols[2*dof+0].j = j+1; cols[2*dof+0].c = 0;
754:       cols[2*dof+1].i = i+1; cols[2*dof+1].j = j+1; cols[2*dof+1].c = 1;
755:       cols[2*dof+2].i = i+1; cols[2*dof+2].j = j+1; cols[2*dof+2].c = 2;
756:       /* i,j+1 */
757:       if ((i == 0) || (j == info->my-2)) {
758:         hasLower[2] = 0;
759:         hasUpper[1] = 0;
760:         MatAssemblyBegin(jac,MAT_FLUSH_ASSEMBLY);
761:         MatAssemblyEnd(jac,MAT_FLUSH_ASSEMBLY);

763:         ident.i = i; ident.j = j+1; ident.c = 0;

765:         MatSetValuesStencil(jac,1,&ident,1,&ident,&one,INSERT_VALUES);

767:         ident.i = i; ident.j = j+1; ident.c = 1;

769:         MatSetValuesStencil(jac,1,&ident,1,&ident,&one,INSERT_VALUES);
770: #if defined(PRES_BC)
771:         ident.i = i; ident.j = j+1; ident.c = 2;

773:         MatSetValuesStencil(jac,1,&ident,1,&ident,&one,INSERT_VALUES);
774: #endif
775:         MatAssemblyBegin(jac,MAT_FLUSH_ASSEMBLY);
776:         MatAssemblyEnd(jac,MAT_FLUSH_ASSEMBLY);
777:       } else {
778:         hasLower[2]     = 1;
779:         hasUpper[1]     = 1;
780:         velocityRows[3] = numRows;
781:         rows[numRows].i = i; rows[numRows].j = j+1; rows[numRows].c = 0;
782:         numRows++;
783:         rows[numRows].i = i; rows[numRows].j = j+1; rows[numRows].c = 1;
784:         numRows++;
785: #if defined(PRES_BC)
786:         pressureRows[3] = numRows;
787:         rows[numRows].i = i; rows[numRows].j = j+1; rows[numRows].c = 2;
788:         numRows++;
789: #endif
790:       }
791: #if !defined(PRES_BC)
792:       pressureRows[3] = numRows;
793:       rows[numRows].i = i; rows[numRows].j = j+1; rows[numRows].c = 2;
794:       numRows++;
795: #endif
796:       cols[3*dof+0].i = i; cols[3*dof+0].j = j+1; cols[3*dof+0].c = 0;
797:       cols[3*dof+1].i = i; cols[3*dof+1].j = j+1; cols[3*dof+1].c = 1;
798:       cols[3*dof+2].i = i; cols[3*dof+2].j = j+1; cols[3*dof+2].c = 2;

800:       /* Lower Element */
801:       for (k = 0; k < 3; k++) {
802: #if defined(PRES_BC)
803:         if (!hasLower[k]) continue;
804: #endif
805:         for (l = 0; l < 3; l++) {
806:           /* Divergence */
807:           JLocal[pressureRows[lowerRow[k]]*dof*4 + lowerRow[l]*dof+0] += hx*Divergence[(k*2+0)*3 + l];
808:           JLocal[pressureRows[lowerRow[k]]*dof*4 + lowerRow[l]*dof+1] += hy*Divergence[(k*2+1)*3 + l];
809: /*        JLocal[pressureRows[lowerRow[k]]*dof*4 + lowerRow[l]*dof+2] += Identity[k*3 + l]; */
810:         }
811:         if (!hasLower[k]) continue;
812:         for (l = 0; l < 3; l++) {
813:           /* Laplacian */
814:           JLocal[velocityRows[lowerRow[k]]*dof*4     + lowerRow[l]*dof+0] += alpha*(G[0]*Kref[(k*2*3 + l)*2]+G[1]*Kref[(k*2*3 + l)*2+1]+G[2]*Kref[((k*2+1)*3 + l)*2]+G[3]*Kref[((k*2+1)*3 + l)*2+1]);
815:           JLocal[(velocityRows[lowerRow[k]]+1)*dof*4 + lowerRow[l]*dof+1] += alpha*(G[0]*Kref[(k*2*3 + l)*2]+G[1]*Kref[(k*2*3 + l)*2+1]+G[2]*Kref[((k*2+1)*3 + l)*2]+G[3]*Kref[((k*2+1)*3 + l)*2+1]);
816: /*        JLocal[velocityRows[lowerRow[k]]*dof*4     + lowerRow[l]*dof+0] += Identity[k*3 + l]; */
817: /*        JLocal[(velocityRows[lowerRow[k]]+1)*dof*4 + lowerRow[l]*dof+1] += Identity[k*3 + l]; */
818:           /* Gradient */
819:           JLocal[velocityRows[lowerRow[k]]*dof*4     + lowerRow[l]*dof+2] += hx*Gradient[(k*2+0)*3 + l];
820:           JLocal[(velocityRows[lowerRow[k]]+1)*dof*4 + lowerRow[l]*dof+2] += hy*Gradient[(k*2+1)*3 + l];
821:         }
822:       }
823:       /* Upper Element */
824:       for (k = 0; k < 3; k++) {
825: #if defined(PRES_BC)
826:         if (!hasUpper[k]) continue;
827: #endif
828:         for (l = 0; l < 3; l++) {
829:           /* Divergence */
830:           JLocal[pressureRows[upperRow[k]]*dof*4 + upperRow[l]*dof+0] += hx*Divergence[(k*2+0)*3 + l];
831:           JLocal[pressureRows[upperRow[k]]*dof*4 + upperRow[l]*dof+1] += hy*Divergence[(k*2+1)*3 + l];
832: /*        JLocal[pressureRows[upperRow[k]]*dof*4 + upperRow[l]*dof+2] += Identity[k*3 + l]; */
833:         }
834:         if (!hasUpper[k]) continue;
835:         for (l = 0; l < 3; l++) {
836:           /* Laplacian */
837:           JLocal[velocityRows[upperRow[k]]*dof*4     + upperRow[l]*dof+0] += alpha*(G[0]*Kref[(k*2*3 + l)*2]+G[1]*Kref[(k*2*3 + l)*2+1]+G[2]*Kref[((k*2+1)*3 + l)*2]+G[3]*Kref[((k*2+1)*3 + l)*2+1]);
838:           JLocal[(velocityRows[upperRow[k]]+1)*dof*4 + upperRow[l]*dof+1] += alpha*(G[0]*Kref[(k*2*3 + l)*2]+G[1]*Kref[(k*2*3 + l)*2+1]+G[2]*Kref[((k*2+1)*3 + l)*2]+G[3]*Kref[((k*2+1)*3 + l)*2+1]);
839:           /* Gradient */
840:           JLocal[velocityRows[upperRow[k]]*dof*4     + upperRow[l]*dof+2] += hx*Gradient[(k*2+0)*3 + l];
841:           JLocal[(velocityRows[upperRow[k]]+1)*dof*4 + upperRow[l]*dof+2] += hy*Gradient[(k*2+1)*3 + l];
842:         }
843:       }

845:       nonlinearJacobian(-1.0*PetscAbsScalar(sc), uLocal, JLocal);
846:       /* printf("Element matrix for (%d, %d)\n", i, j);*/
847:       /* printf("   col         ");*/
848:       for (l = 0; l < 4*3; l++) {
849:         /* printf("(%d, %d, %d) ", cols[l].i, cols[l].j, cols[l].c);*/
850:       }
851:       /* printf("\n");*/
852:       for (k = 0; k < numRows; k++) {
853:         /* printf("row (%d, %d, %d): ", rows[k].i, rows[k].j, rows[k].c);*/
854:         for (l = 0; l < 4; l++) {
855:           /* printf("%9.6g %9.6g %9.6g ", JLocal[k*dof*4 + l*dof+0], JLocal[k*dof*4 + l*dof+1], JLocal[k*dof*4 + l*dof+2]);*/
856:         }
857:         /* printf("\n");*/
858:       }
859:       MatSetValuesStencil(jac,numRows,rows,4*dof,cols, JLocal,ADD_VALUES);
860:     }
861:   }

863:   /*
864:      Assemble matrix, using the 2-step process:
865:        MatAssemblyBegin(), MatAssemblyEnd().
866:   */
867:   MatAssemblyBegin(jac,MAT_FINAL_ASSEMBLY);
868:   MatAssemblyEnd(jac,MAT_FINAL_ASSEMBLY);
869:   if (A != jac) {
870:     MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);
871:     MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);
872:   }

874:   /*
875:      Tell the matrix we will never add a new nonzero location to the
876:      matrix. If we do, it will generate an error.
877:   */
878:   MatSetOption(jac,MAT_NEW_NONZERO_LOCATION_ERR,PETSC_TRUE);

880:   CreateNullSpace(info->da,&N);
881:   MatNullSpaceCreate(PETSC_COMM_WORLD,PETSC_FALSE,1,&N,&nullspace);
882:   VecDestroy(&N);
883:   MatSetNullSpace(A,nullspace);
884:   MatNullSpaceDestroy(&nullspace);
885:   return(0);
886: }

890: /*
891:   L_2Error - Integrate the L_2 error of our solution over each face
892: */
893: PetscErrorCode L_2Error(DM da, Vec fVec, PetscReal *error, AppCtx *user)
894: {
895:   DMDALocalInfo  info;
896:   Vec            fLocalVec;
897:   Field          **f;
898:   Field          u, uExact, uLocal[4];
899:   PetscScalar    hx, hy, hxhy, x, y, phi[3];
900:   PetscInt       i, j, q;

904:   DMDAGetLocalInfo(da, &info);
905:   DMGetLocalVector(da, &fLocalVec);
906:   DMGlobalToLocalBegin(da,fVec, INSERT_VALUES, fLocalVec);
907:   DMGlobalToLocalEnd(da,fVec, INSERT_VALUES, fLocalVec);
908:   DMDAVecGetArray(da, fLocalVec, &f);

910:   *error = 0.0;
911:   hx     = 1.0/(PetscReal)(info.mx-1);
912:   hy     = 1.0/(PetscReal)(info.my-1);
913:   hxhy   = hx*hy;
914:   for (j = info.ys; j < info.ys+info.ym-1; j++) {
915:     for (i = info.xs; i < info.xs+info.xm-1; i++) {
916:       uLocal[0] = f[j][i];
917:       uLocal[1] = f[j][i+1];
918:       uLocal[2] = f[j+1][i+1];
919:       uLocal[3] = f[j+1][i];
920:       /* Lower element */
921:       for (q = 0; q < 4; q++) {
922:         phi[0]  = 1.0 - quadPoints[q*2] - quadPoints[q*2+1];
923:         phi[1]  = quadPoints[q*2];
924:         phi[2]  = quadPoints[q*2+1];
925:         u.u     = uLocal[0].u*phi[0]+ uLocal[1].u*phi[1] + uLocal[3].u*phi[2];
926:         u.v     = uLocal[0].v*phi[0]+ uLocal[1].v*phi[1] + uLocal[3].v*phi[2];
927:         u.p     = uLocal[0].p*phi[0]+ uLocal[1].p*phi[1] + uLocal[3].p*phi[2];
928:         x       = (quadPoints[q*2] + (PetscReal)i)*hx;
929:         y       = (quadPoints[q*2+1] + (PetscReal)j)*hy;
930:         ExactSolution(PetscAbsScalar(x), PetscAbsScalar(y), &uExact);
931:         *error += PetscAbsScalar(hxhy*quadWeights[q]*((u.u - uExact.u)*(u.u - uExact.u) + (u.v - uExact.v)*(u.v - uExact.v) + (u.p - uExact.p)*(u.p - uExact.p)));
932:       }
933:       /* Upper element */
934:       /*
935:         The affine map from the lower to the upper is

937:         / x_U \ = / -1  0 \ / x_L \ + / hx \
938:         \ y_U /   \  0 -1 / \ y_L /   \ hy /
939:        */
940:       for (q = 0; q < 4; q++) {
941:         phi[0]  = 1.0 - quadPoints[q*2] - quadPoints[q*2+1];
942:         phi[1]  = quadPoints[q*2];
943:         phi[2]  = quadPoints[q*2+1];
944:         u.u     = uLocal[2].u*phi[0]+ uLocal[3].u*phi[1] + uLocal[1].u*phi[2];
945:         u.v     = uLocal[2].v*phi[0]+ uLocal[3].v*phi[1] + uLocal[1].v*phi[2];
946:         u.p     = uLocal[0].p*phi[0]+ uLocal[1].p*phi[1] + uLocal[3].p*phi[2];
947:         x       = (1.0 - quadPoints[q*2] + (PetscReal)i)*hx;
948:         y       = (1.0 - quadPoints[q*2+1] + (PetscReal)j)*hy;
949:         ExactSolution(PetscAbsScalar(x), PetscAbsScalar(y), &uExact);
950:         *error += PetscAbsScalar(hxhy*quadWeights[q]*((u.u - uExact.u)*(u.u - uExact.u) + (u.v - uExact.v)*(u.v - uExact.v) + (u.p - uExact.p)*(u.p - uExact.p)));
951:       }
952:     }
953:   }

955:   DMDAVecRestoreArray(da, fLocalVec, &f);
956:   DMRestoreLocalVector(da, &fLocalVec);
957:   return(0);
958: }