Date: 2013-07-02T14:50:44+00:00

Actual source code: dmplexsnes.c
petsc-3.4.2 2013-07-02

      1: #include <petscdmplex.h> /*I "petscdmplex.h" I*/
      2: #include <petscsnes.h>      /*I "petscsnes.h" I*/
      3: #include <petsc-private/petscimpl.h>

      7: PetscErrorCode DMInterpolationCreate(MPI_Comm comm, DMInterpolationInfo *ctx)
      8: {

     13:   PetscMalloc(sizeof(struct _DMInterpolationInfo), ctx);

     15:   (*ctx)->comm   = comm;
     16:   (*ctx)->dim    = -1;
     17:   (*ctx)->nInput = 0;
     18:   (*ctx)->points = NULL;
     19:   (*ctx)->cells  = NULL;
     20:   (*ctx)->n      = -1;
     21:   (*ctx)->coords = NULL;
     22:   return(0);
     23: }

     27: PetscErrorCode DMInterpolationSetDim(DMInterpolationInfo ctx, PetscInt dim)
     28: {
     30:   if ((dim < 1) || (dim > 3)) SETERRQ1(ctx->comm, PETSC_ERR_ARG_OUTOFRANGE, "Invalid dimension for points: %d", dim);
     31:   ctx->dim = dim;
     32:   return(0);
     33: }

     37: PetscErrorCode DMInterpolationGetDim(DMInterpolationInfo ctx, PetscInt *dim)
     38: {
     41:   *dim = ctx->dim;
     42:   return(0);
     43: }

     47: PetscErrorCode DMInterpolationSetDof(DMInterpolationInfo ctx, PetscInt dof)
     48: {
     50:   if (dof < 1) SETERRQ1(ctx->comm, PETSC_ERR_ARG_OUTOFRANGE, "Invalid number of components: %d", dof);
     51:   ctx->dof = dof;
     52:   return(0);
     53: }

     57: PetscErrorCode DMInterpolationGetDof(DMInterpolationInfo ctx, PetscInt *dof)
     58: {
     61:   *dof = ctx->dof;
     62:   return(0);
     63: }

     67: PetscErrorCode DMInterpolationAddPoints(DMInterpolationInfo ctx, PetscInt n, PetscReal points[])
     68: {

     72:   if (ctx->dim < 0) SETERRQ(ctx->comm, PETSC_ERR_ARG_WRONGSTATE, "The spatial dimension has not been set");
     73:   if (ctx->points)  SETERRQ(ctx->comm, PETSC_ERR_ARG_WRONGSTATE, "Cannot add points multiple times yet");
     74:   ctx->nInput = n;

     76:   PetscMalloc(n*ctx->dim * sizeof(PetscReal), &ctx->points);
     77:   PetscMemcpy(ctx->points, points, n*ctx->dim * sizeof(PetscReal));
     78:   return(0);
     79: }

     83: PetscErrorCode DMInterpolationSetUp(DMInterpolationInfo ctx, DM dm, PetscBool redundantPoints)
     84: {
     85:   MPI_Comm       comm = ctx->comm;
     86:   PetscScalar    *a;
     87:   PetscInt       p, q, i;
     88:   PetscMPIInt    rank, size;
     90:   Vec            pointVec;
     91:   IS             cellIS;
     92:   PetscLayout    layout;
     93:   PetscReal      *globalPoints;
     94:   PetscScalar    *globalPointsScalar;
     95:   const PetscInt *ranges;
     96:   PetscMPIInt    *counts, *displs;
     97:   const PetscInt *foundCells;
     98:   PetscMPIInt    *foundProcs, *globalProcs;
     99:   PetscInt       n, N;

    103:   MPI_Comm_size(comm, &size);
    104:   MPI_Comm_rank(comm, &rank);
    105:   if (ctx->dim < 0) SETERRQ(comm, PETSC_ERR_ARG_WRONGSTATE, "The spatial dimension has not been set");
    106:   /* Locate points */
    107:   n = ctx->nInput;
    108:   if (!redundantPoints) {
    109:     PetscLayoutCreate(comm, &layout);
    110:     PetscLayoutSetBlockSize(layout, 1);
    111:     PetscLayoutSetLocalSize(layout, n);
    112:     PetscLayoutSetUp(layout);
    113:     PetscLayoutGetSize(layout, &N);
    114:     /* Communicate all points to all processes */
    115:     PetscMalloc3(N*ctx->dim,PetscReal,&globalPoints,size,PetscMPIInt,&counts,size,PetscMPIInt,&displs);
    116:     PetscLayoutGetRanges(layout, &ranges);
    117:     for (p = 0; p < size; ++p) {
    118:       counts[p] = (ranges[p+1] - ranges[p])*ctx->dim;
    119:       displs[p] = ranges[p]*ctx->dim;
    120:     }
    121:     MPI_Allgatherv(ctx->points, n*ctx->dim, MPIU_REAL, globalPoints, counts, displs, MPIU_REAL, comm);
    122:   } else {
    123:     N = n;

    125:     globalPoints = ctx->points;
    126:   }
    127: #if 0
    128:   PetscMalloc3(N,PetscInt,&foundCells,N,PetscMPIInt,&foundProcs,N,PetscMPIInt,&globalProcs);
    129:   /* foundCells[p] = m->locatePoint(&globalPoints[p*ctx->dim]); */
    130: #else
    131: #if defined(PETSC_USE_COMPLEX)
    132:   PetscMalloc(N*sizeof(PetscScalar),&globalPointsScalar);
    133:   for (i=0; i<N; i++) globalPointsScalar[i] = globalPoints[i];
    134: #else
    135:   globalPointsScalar = globalPoints;
    136: #endif
    137:   VecCreateSeqWithArray(PETSC_COMM_SELF, ctx->dim, N*ctx->dim, globalPointsScalar, &pointVec);
    138:   PetscMalloc2(N,PetscMPIInt,&foundProcs,N,PetscMPIInt,&globalProcs);
    139:   DMLocatePoints(dm, pointVec, &cellIS);
    140:   ISGetIndices(cellIS, &foundCells);
    141: #endif
    142:   for (p = 0; p < N; ++p) {
    143:     if (foundCells[p] >= 0) foundProcs[p] = rank;
    144:     else foundProcs[p] = size;
    145:   }
    146:   /* Let the lowest rank process own each point */
    147:   MPI_Allreduce(foundProcs, globalProcs, N, MPI_INT, MPI_MIN, comm);
    148:   ctx->n = 0;
    149:   for (p = 0; p < N; ++p) {
    150:     if (globalProcs[p] == size) SETERRQ4(comm, PETSC_ERR_PLIB, "Point %d: %g %g %g not located in mesh", p, globalPoints[p*ctx->dim+0], ctx->dim > 1 ? globalPoints[p*ctx->dim+1] : 0.0, ctx->dim > 2 ? globalPoints[p*ctx->dim+2] : 0.0);
    151:     else if (globalProcs[p] == rank) ctx->n++;
    152:   }
    153:   /* Create coordinates vector and array of owned cells */
    154:   PetscMalloc(ctx->n * sizeof(PetscInt), &ctx->cells);
    155:   VecCreate(comm, &ctx->coords);
    156:   VecSetSizes(ctx->coords, ctx->n*ctx->dim, PETSC_DECIDE);
    157:   VecSetBlockSize(ctx->coords, ctx->dim);
    158:   VecSetFromOptions(ctx->coords);
    159:   VecGetArray(ctx->coords, &a);
    160:   for (p = 0, q = 0, i = 0; p < N; ++p) {
    161:     if (globalProcs[p] == rank) {
    162:       PetscInt d;

    164:       for (d = 0; d < ctx->dim; ++d, ++i) a[i] = globalPoints[p*ctx->dim+d];
    165:       ctx->cells[q++] = foundCells[p];
    166:     }
    167:   }
    168:   VecRestoreArray(ctx->coords, &a);
    169: #if 0
    170:   PetscFree3(foundCells,foundProcs,globalProcs);
    171: #else
    172:   PetscFree2(foundProcs,globalProcs);
    173:   ISRestoreIndices(cellIS, &foundCells);
    174:   ISDestroy(&cellIS);
    175:   VecDestroy(&pointVec);
    176: #endif
    177:   if ((void*)globalPointsScalar != (void*)globalPoints) {PetscFree(globalPointsScalar);}
    178:   if (!redundantPoints) {
    179:     PetscFree3(globalPoints,counts,displs);
    180:     PetscLayoutDestroy(&layout);
    181:   }
    182:   return(0);
    183: }

    187: PetscErrorCode DMInterpolationGetCoordinates(DMInterpolationInfo ctx, Vec *coordinates)
    188: {
    191:   if (!ctx->coords) SETERRQ(ctx->comm, PETSC_ERR_ARG_WRONGSTATE, "The interpolation context has not been setup.");
    192:   *coordinates = ctx->coords;
    193:   return(0);
    194: }

    198: PetscErrorCode DMInterpolationGetVector(DMInterpolationInfo ctx, Vec *v)
    199: {

    204:   if (!ctx->coords) SETERRQ(ctx->comm, PETSC_ERR_ARG_WRONGSTATE, "The interpolation context has not been setup.");
    205:   VecCreate(ctx->comm, v);
    206:   VecSetSizes(*v, ctx->n*ctx->dof, PETSC_DECIDE);
    207:   VecSetBlockSize(*v, ctx->dof);
    208:   VecSetFromOptions(*v);
    209:   return(0);
    210: }

    214: PetscErrorCode DMInterpolationRestoreVector(DMInterpolationInfo ctx, Vec *v)
    215: {

    220:   if (!ctx->coords) SETERRQ(ctx->comm, PETSC_ERR_ARG_WRONGSTATE, "The interpolation context has not been setup.");
    221:   VecDestroy(v);
    222:   return(0);
    223: }

    227: PETSC_STATIC_INLINE PetscErrorCode DMInterpolate_Simplex_Private(DMInterpolationInfo ctx, DM dm, Vec xLocal, Vec v)
    228: {
    229:   PetscReal      *v0, *J, *invJ, detJ;
    230:   PetscScalar    *a, *coords;
    231:   PetscInt       p;

    235:   PetscMalloc3(ctx->dim,PetscReal,&v0,ctx->dim*ctx->dim,PetscReal,&J,ctx->dim*ctx->dim,PetscReal,&invJ);
    236:   VecGetArray(ctx->coords, &coords);
    237:   VecGetArray(v, &a);
    238:   for (p = 0; p < ctx->n; ++p) {
    239:     PetscInt     c = ctx->cells[p];
    240:     PetscScalar *x;
    241:     PetscReal    xi[4];
    242:     PetscInt     d, f, comp;

    244:     DMPlexComputeCellGeometry(dm, c, v0, J, invJ, &detJ);
    245:     if (detJ <= 0.0) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Invalid determinant %g for element %d", detJ, c);
    246:     DMPlexVecGetClosure(dm, NULL, xLocal, c, NULL, &x);
    247:     for (comp = 0; comp < ctx->dof; ++comp) a[p*ctx->dof+comp] = x[0*ctx->dof+comp];

    249:     for (d = 0; d < ctx->dim; ++d) {
    250:       xi[d] = 0.0;
    251:       for (f = 0; f < ctx->dim; ++f) xi[d] += invJ[d*ctx->dim+f]*0.5*PetscRealPart(coords[p*ctx->dim+f] - v0[f]);
    252:       for (comp = 0; comp < ctx->dof; ++comp) a[p*ctx->dof+comp] += PetscRealPart(x[(d+1)*ctx->dof+comp] - x[0*ctx->dof+comp])*xi[d];
    253:     }
    254:     DMPlexVecRestoreClosure(dm, NULL, xLocal, c, NULL, &x);
    255:   }
    256:   VecRestoreArray(v, &a);
    257:   VecRestoreArray(ctx->coords, &coords);
    258:   PetscFree3(v0, J, invJ);
    259:   return(0);
    260: }

    264: PETSC_STATIC_INLINE PetscErrorCode QuadMap_Private(SNES snes, Vec Xref, Vec Xreal, void *ctx)
    265: {
    266:   const PetscScalar *vertices = (const PetscScalar*) ctx;
    267:   const PetscScalar x0        = vertices[0];
    268:   const PetscScalar y0        = vertices[1];
    269:   const PetscScalar x1        = vertices[2];
    270:   const PetscScalar y1        = vertices[3];
    271:   const PetscScalar x2        = vertices[4];
    272:   const PetscScalar y2        = vertices[5];
    273:   const PetscScalar x3        = vertices[6];
    274:   const PetscScalar y3        = vertices[7];
    275:   const PetscScalar f_1       = x1 - x0;
    276:   const PetscScalar g_1       = y1 - y0;
    277:   const PetscScalar f_3       = x3 - x0;
    278:   const PetscScalar g_3       = y3 - y0;
    279:   const PetscScalar f_01      = x2 - x1 - x3 + x0;
    280:   const PetscScalar g_01      = y2 - y1 - y3 + y0;
    281:   PetscScalar       *ref, *real;
    282:   PetscErrorCode    ierr;

    285:   VecGetArray(Xref,  &ref);
    286:   VecGetArray(Xreal, &real);
    287:   {
    288:     const PetscScalar p0 = ref[0];
    289:     const PetscScalar p1 = ref[1];

    291:     real[0] = x0 + f_1 * p0 + f_3 * p1 + f_01 * p0 * p1;
    292:     real[1] = y0 + g_1 * p0 + g_3 * p1 + g_01 * p0 * p1;
    293:   }
    294:   PetscLogFlops(28);
    295:   VecRestoreArray(Xref,  &ref);
    296:   VecRestoreArray(Xreal, &real);
    297:   return(0);
    298: }

    302: PETSC_STATIC_INLINE PetscErrorCode QuadJacobian_Private(SNES snes, Vec Xref, Mat *J, Mat *M, MatStructure *flag, void *ctx)
    303: {
    304:   const PetscScalar *vertices = (const PetscScalar*) ctx;
    305:   const PetscScalar x0        = vertices[0];
    306:   const PetscScalar y0        = vertices[1];
    307:   const PetscScalar x1        = vertices[2];
    308:   const PetscScalar y1        = vertices[3];
    309:   const PetscScalar x2        = vertices[4];
    310:   const PetscScalar y2        = vertices[5];
    311:   const PetscScalar x3        = vertices[6];
    312:   const PetscScalar y3        = vertices[7];
    313:   const PetscScalar f_01      = x2 - x1 - x3 + x0;
    314:   const PetscScalar g_01      = y2 - y1 - y3 + y0;
    315:   PetscScalar       *ref;
    316:   PetscErrorCode    ierr;

    319:   VecGetArray(Xref,  &ref);
    320:   {
    321:     const PetscScalar x       = ref[0];
    322:     const PetscScalar y       = ref[1];
    323:     const PetscInt    rows[2] = {0, 1};
    324:     PetscScalar       values[4];

    326:     values[0] = (x1 - x0 + f_01*y) * 0.5; values[1] = (x3 - x0 + f_01*x) * 0.5;
    327:     values[2] = (y1 - y0 + g_01*y) * 0.5; values[3] = (y3 - y0 + g_01*x) * 0.5;
    328:     MatSetValues(*J, 2, rows, 2, rows, values, INSERT_VALUES);
    329:   }
    330:   PetscLogFlops(30);
    331:   VecRestoreArray(Xref,  &ref);
    332:   MatAssemblyBegin(*J, MAT_FINAL_ASSEMBLY);
    333:   MatAssemblyEnd(*J, MAT_FINAL_ASSEMBLY);
    334:   return(0);
    335: }

    339: PETSC_STATIC_INLINE PetscErrorCode DMInterpolate_Quad_Private(DMInterpolationInfo ctx, DM dm, Vec xLocal, Vec v)
    340: {
    341:   DM             dmCoord;
    342:   SNES           snes;
    343:   KSP            ksp;
    344:   PC             pc;
    345:   Vec            coordsLocal, r, ref, real;
    346:   Mat            J;
    347:   PetscScalar    *a, *coords;
    348:   PetscInt       p;

    352:   DMGetCoordinatesLocal(dm, &coordsLocal);
    353:   DMGetCoordinateDM(dm, &dmCoord);
    354:   SNESCreate(PETSC_COMM_SELF, &snes);
    355:   SNESSetOptionsPrefix(snes, "quad_interp_");
    356:   VecCreate(PETSC_COMM_SELF, &r);
    357:   VecSetSizes(r, 2, 2);
    358:   VecSetFromOptions(r);
    359:   VecDuplicate(r, &ref);
    360:   VecDuplicate(r, &real);
    361:   MatCreate(PETSC_COMM_SELF, &J);
    362:   MatSetSizes(J, 2, 2, 2, 2);
    363:   MatSetType(J, MATSEQDENSE);
    364:   MatSetUp(J);
    365:   SNESSetFunction(snes, r, QuadMap_Private, NULL);
    366:   SNESSetJacobian(snes, J, J, QuadJacobian_Private, NULL);
    367:   SNESGetKSP(snes, &ksp);
    368:   KSPGetPC(ksp, &pc);
    369:   PCSetType(pc, PCLU);
    370:   SNESSetFromOptions(snes);

    372:   VecGetArray(ctx->coords, &coords);
    373:   VecGetArray(v, &a);
    374:   for (p = 0; p < ctx->n; ++p) {
    375:     PetscScalar *x, *vertices;
    376:     PetscScalar *xi;
    377:     PetscReal    xir[2];
    378:     PetscInt     c = ctx->cells[p], comp, coordSize, xSize;

    380:     /* Can make this do all points at once */
    381:     DMPlexVecGetClosure(dmCoord, NULL, coordsLocal, c, &coordSize, &vertices);
    382:     if (4*2 != coordSize) SETERRQ2(ctx->comm, PETSC_ERR_ARG_SIZ, "Invalid closure size %d should be %d", coordSize, 4*2);
    383:     DMPlexVecGetClosure(dm, NULL, xLocal, c, &xSize, &x);
    384:     if (4*ctx->dof != xSize) SETERRQ2(ctx->comm, PETSC_ERR_ARG_SIZ, "Invalid closure size %d should be %d", xSize, 4*ctx->dof);
    385:     SNESSetFunction(snes, NULL, NULL, (void*) vertices);
    386:     SNESSetJacobian(snes, NULL, NULL, NULL, (void*) vertices);
    387:     VecGetArray(real, &xi);
    388:     xi[0]  = coords[p*ctx->dim+0];
    389:     xi[1]  = coords[p*ctx->dim+1];
    390:     VecRestoreArray(real, &xi);
    391:     SNESSolve(snes, real, ref);
    392:     VecGetArray(ref, &xi);
    393:     xir[0] = PetscRealPart(xi[0]);
    394:     xir[1] = PetscRealPart(xi[1]);
    395:     for (comp = 0; comp < ctx->dof; ++comp) a[p*ctx->dof+comp] = x[0*ctx->dof+comp]*(1 - xir[0])*(1 - xir[1]) + x[1*ctx->dof+comp]*xir[0]*(1 - xir[1]) + x[2*ctx->dof+comp]*xir[0]*xir[1] + x[3*ctx->dof+comp]*(1 - xir[0])*xir[1];

    397:     VecRestoreArray(ref, &xi);
    398:     DMPlexVecRestoreClosure(dmCoord, NULL, coordsLocal, c, &coordSize, &vertices);
    399:     DMPlexVecRestoreClosure(dm, NULL, xLocal, c, &xSize, &x);
    400:   }
    401:   VecRestoreArray(v, &a);
    402:   VecRestoreArray(ctx->coords, &coords);

    404:   SNESDestroy(&snes);
    405:   VecDestroy(&r);
    406:   VecDestroy(&ref);
    407:   VecDestroy(&real);
    408:   MatDestroy(&J);
    409:   return(0);
    410: }

    414: PETSC_STATIC_INLINE PetscErrorCode HexMap_Private(SNES snes, Vec Xref, Vec Xreal, void *ctx)
    415: {
    416:   const PetscScalar *vertices = (const PetscScalar*) ctx;
    417:   const PetscScalar x0        = vertices[0];
    418:   const PetscScalar y0        = vertices[1];
    419:   const PetscScalar z0        = vertices[2];
    420:   const PetscScalar x1        = vertices[3];
    421:   const PetscScalar y1        = vertices[4];
    422:   const PetscScalar z1        = vertices[5];
    423:   const PetscScalar x2        = vertices[6];
    424:   const PetscScalar y2        = vertices[7];
    425:   const PetscScalar z2        = vertices[8];
    426:   const PetscScalar x3        = vertices[9];
    427:   const PetscScalar y3        = vertices[10];
    428:   const PetscScalar z3        = vertices[11];
    429:   const PetscScalar x4        = vertices[12];
    430:   const PetscScalar y4        = vertices[13];
    431:   const PetscScalar z4        = vertices[14];
    432:   const PetscScalar x5        = vertices[15];
    433:   const PetscScalar y5        = vertices[16];
    434:   const PetscScalar z5        = vertices[17];
    435:   const PetscScalar x6        = vertices[18];
    436:   const PetscScalar y6        = vertices[19];
    437:   const PetscScalar z6        = vertices[20];
    438:   const PetscScalar x7        = vertices[21];
    439:   const PetscScalar y7        = vertices[22];
    440:   const PetscScalar z7        = vertices[23];
    441:   const PetscScalar f_1       = x1 - x0;
    442:   const PetscScalar g_1       = y1 - y0;
    443:   const PetscScalar h_1       = z1 - z0;
    444:   const PetscScalar f_3       = x3 - x0;
    445:   const PetscScalar g_3       = y3 - y0;
    446:   const PetscScalar h_3       = z3 - z0;
    447:   const PetscScalar f_4       = x4 - x0;
    448:   const PetscScalar g_4       = y4 - y0;
    449:   const PetscScalar h_4       = z4 - z0;
    450:   const PetscScalar f_01      = x2 - x1 - x3 + x0;
    451:   const PetscScalar g_01      = y2 - y1 - y3 + y0;
    452:   const PetscScalar h_01      = z2 - z1 - z3 + z0;
    453:   const PetscScalar f_12      = x7 - x3 - x4 + x0;
    454:   const PetscScalar g_12      = y7 - y3 - y4 + y0;
    455:   const PetscScalar h_12      = z7 - z3 - z4 + z0;
    456:   const PetscScalar f_02      = x5 - x1 - x4 + x0;
    457:   const PetscScalar g_02      = y5 - y1 - y4 + y0;
    458:   const PetscScalar h_02      = z5 - z1 - z4 + z0;
    459:   const PetscScalar f_012     = x6 - x0 + x1 - x2 + x3 + x4 - x5 - x7;
    460:   const PetscScalar g_012     = y6 - y0 + y1 - y2 + y3 + y4 - y5 - y7;
    461:   const PetscScalar h_012     = z6 - z0 + z1 - z2 + z3 + z4 - z5 - z7;
    462:   PetscScalar       *ref, *real;
    463:   PetscErrorCode    ierr;

    466:   VecGetArray(Xref,  &ref);
    467:   VecGetArray(Xreal, &real);
    468:   {
    469:     const PetscScalar p0 = ref[0];
    470:     const PetscScalar p1 = ref[1];
    471:     const PetscScalar p2 = ref[2];

    473:     real[0] = x0 + f_1*p0 + f_3*p1 + f_4*p2 + f_01*p0*p1 + f_12*p1*p2 + f_02*p0*p2 + f_012*p0*p1*p2;
    474:     real[1] = y0 + g_1*p0 + g_3*p1 + g_4*p2 + g_01*p0*p1 + g_01*p0*p1 + g_12*p1*p2 + g_02*p0*p2 + g_012*p0*p1*p2;
    475:     real[2] = z0 + h_1*p0 + h_3*p1 + h_4*p2 + h_01*p0*p1 + h_01*p0*p1 + h_12*p1*p2 + h_02*p0*p2 + h_012*p0*p1*p2;
    476:   }
    477:   PetscLogFlops(114);
    478:   VecRestoreArray(Xref,  &ref);
    479:   VecRestoreArray(Xreal, &real);
    480:   return(0);
    481: }

    485: PETSC_STATIC_INLINE PetscErrorCode HexJacobian_Private(SNES snes, Vec Xref, Mat *J, Mat *M, MatStructure *flag, void *ctx)
    486: {
    487:   const PetscScalar *vertices = (const PetscScalar*) ctx;
    488:   const PetscScalar x0        = vertices[0];
    489:   const PetscScalar y0        = vertices[1];
    490:   const PetscScalar z0        = vertices[2];
    491:   const PetscScalar x1        = vertices[3];
    492:   const PetscScalar y1        = vertices[4];
    493:   const PetscScalar z1        = vertices[5];
    494:   const PetscScalar x2        = vertices[6];
    495:   const PetscScalar y2        = vertices[7];
    496:   const PetscScalar z2        = vertices[8];
    497:   const PetscScalar x3        = vertices[9];
    498:   const PetscScalar y3        = vertices[10];
    499:   const PetscScalar z3        = vertices[11];
    500:   const PetscScalar x4        = vertices[12];
    501:   const PetscScalar y4        = vertices[13];
    502:   const PetscScalar z4        = vertices[14];
    503:   const PetscScalar x5        = vertices[15];
    504:   const PetscScalar y5        = vertices[16];
    505:   const PetscScalar z5        = vertices[17];
    506:   const PetscScalar x6        = vertices[18];
    507:   const PetscScalar y6        = vertices[19];
    508:   const PetscScalar z6        = vertices[20];
    509:   const PetscScalar x7        = vertices[21];
    510:   const PetscScalar y7        = vertices[22];
    511:   const PetscScalar z7        = vertices[23];
    512:   const PetscScalar f_xy      = x2 - x1 - x3 + x0;
    513:   const PetscScalar g_xy      = y2 - y1 - y3 + y0;
    514:   const PetscScalar h_xy      = z2 - z1 - z3 + z0;
    515:   const PetscScalar f_yz      = x7 - x3 - x4 + x0;
    516:   const PetscScalar g_yz      = y7 - y3 - y4 + y0;
    517:   const PetscScalar h_yz      = z7 - z3 - z4 + z0;
    518:   const PetscScalar f_xz      = x5 - x1 - x4 + x0;
    519:   const PetscScalar g_xz      = y5 - y1 - y4 + y0;
    520:   const PetscScalar h_xz      = z5 - z1 - z4 + z0;
    521:   const PetscScalar f_xyz     = x6 - x0 + x1 - x2 + x3 + x4 - x5 - x7;
    522:   const PetscScalar g_xyz     = y6 - y0 + y1 - y2 + y3 + y4 - y5 - y7;
    523:   const PetscScalar h_xyz     = z6 - z0 + z1 - z2 + z3 + z4 - z5 - z7;
    524:   PetscScalar       *ref;
    525:   PetscErrorCode    ierr;

    528:   VecGetArray(Xref,  &ref);
    529:   {
    530:     const PetscScalar x       = ref[0];
    531:     const PetscScalar y       = ref[1];
    532:     const PetscScalar z       = ref[2];
    533:     const PetscInt    rows[3] = {0, 1, 2};
    534:     PetscScalar       values[9];

    536:     values[0] = (x1 - x0 + f_xy*y + f_xz*z + f_xyz*y*z) / 2.0;
    537:     values[1] = (x3 - x0 + f_xy*x + f_yz*z + f_xyz*x*z) / 2.0;
    538:     values[2] = (x4 - x0 + f_yz*y + f_xz*x + f_xyz*x*y) / 2.0;
    539:     values[3] = (y1 - y0 + g_xy*y + g_xz*z + g_xyz*y*z) / 2.0;
    540:     values[4] = (y3 - y0 + g_xy*x + g_yz*z + g_xyz*x*z) / 2.0;
    541:     values[5] = (y4 - y0 + g_yz*y + g_xz*x + g_xyz*x*y) / 2.0;
    542:     values[6] = (z1 - z0 + h_xy*y + h_xz*z + h_xyz*y*z) / 2.0;
    543:     values[7] = (z3 - z0 + h_xy*x + h_yz*z + h_xyz*x*z) / 2.0;
    544:     values[8] = (z4 - z0 + h_yz*y + h_xz*x + h_xyz*x*y) / 2.0;

    546:     MatSetValues(*J, 3, rows, 3, rows, values, INSERT_VALUES);
    547:   }
    548:   PetscLogFlops(152);
    549:   VecRestoreArray(Xref,  &ref);
    550:   MatAssemblyBegin(*J, MAT_FINAL_ASSEMBLY);
    551:   MatAssemblyEnd(*J, MAT_FINAL_ASSEMBLY);
    552:   return(0);
    553: }

    557: PETSC_STATIC_INLINE PetscErrorCode DMInterpolate_Hex_Private(DMInterpolationInfo ctx, DM dm, Vec xLocal, Vec v)
    558: {
    559:   DM             dmCoord;
    560:   SNES           snes;
    561:   KSP            ksp;
    562:   PC             pc;
    563:   Vec            coordsLocal, r, ref, real;
    564:   Mat            J;
    565:   PetscScalar    *a, *coords;
    566:   PetscInt       p;

    570:   DMGetCoordinatesLocal(dm, &coordsLocal);
    571:   DMGetCoordinateDM(dm, &dmCoord);
    572:   SNESCreate(PETSC_COMM_SELF, &snes);
    573:   SNESSetOptionsPrefix(snes, "hex_interp_");
    574:   VecCreate(PETSC_COMM_SELF, &r);
    575:   VecSetSizes(r, 3, 3);
    576:   VecSetFromOptions(r);
    577:   VecDuplicate(r, &ref);
    578:   VecDuplicate(r, &real);
    579:   MatCreate(PETSC_COMM_SELF, &J);
    580:   MatSetSizes(J, 3, 3, 3, 3);
    581:   MatSetType(J, MATSEQDENSE);
    582:   MatSetUp(J);
    583:   SNESSetFunction(snes, r, HexMap_Private, NULL);
    584:   SNESSetJacobian(snes, J, J, HexJacobian_Private, NULL);
    585:   SNESGetKSP(snes, &ksp);
    586:   KSPGetPC(ksp, &pc);
    587:   PCSetType(pc, PCLU);
    588:   SNESSetFromOptions(snes);

    590:   VecGetArray(ctx->coords, &coords);
    591:   VecGetArray(v, &a);
    592:   for (p = 0; p < ctx->n; ++p) {
    593:     PetscScalar *x, *vertices;
    594:     PetscScalar *xi;
    595:     PetscReal    xir[3];
    596:     PetscInt     c = ctx->cells[p], comp, coordSize, xSize;

    598:     /* Can make this do all points at once */
    599:     DMPlexVecGetClosure(dmCoord, NULL, coordsLocal, c, &coordSize, &vertices);
    600:     if (8*3 != coordSize) SETERRQ2(ctx->comm, PETSC_ERR_ARG_SIZ, "Invalid closure size %d should be %d", coordSize, 8*3);
    601:     DMPlexVecGetClosure(dm, NULL, xLocal, c, &xSize, &x);
    602:     if (8*ctx->dof != xSize) SETERRQ2(ctx->comm, PETSC_ERR_ARG_SIZ, "Invalid closure size %d should be %d", xSize, 8*ctx->dof);
    603:     SNESSetFunction(snes, NULL, NULL, (void*) vertices);
    604:     SNESSetJacobian(snes, NULL, NULL, NULL, (void*) vertices);
    605:     VecGetArray(real, &xi);
    606:     xi[0]  = coords[p*ctx->dim+0];
    607:     xi[1]  = coords[p*ctx->dim+1];
    608:     xi[2]  = coords[p*ctx->dim+2];
    609:     VecRestoreArray(real, &xi);
    610:     SNESSolve(snes, real, ref);
    611:     VecGetArray(ref, &xi);
    612:     xir[0] = PetscRealPart(xi[0]);
    613:     xir[1] = PetscRealPart(xi[1]);
    614:     xir[2] = PetscRealPart(xi[2]);
    615:     for (comp = 0; comp < ctx->dof; ++comp) {
    616:       a[p*ctx->dof+comp] =
    617:         x[0*ctx->dof+comp]*(1-xir[0])*(1-xir[1])*(1-xir[2]) +
    618:         x[1*ctx->dof+comp]*    xir[0]*(1-xir[1])*(1-xir[2]) +
    619:         x[2*ctx->dof+comp]*    xir[0]*    xir[1]*(1-xir[2]) +
    620:         x[3*ctx->dof+comp]*(1-xir[0])*    xir[1]*(1-xir[2]) +
    621:         x[4*ctx->dof+comp]*(1-xir[0])*(1-xir[1])*   xir[2] +
    622:         x[5*ctx->dof+comp]*    xir[0]*(1-xir[1])*   xir[2] +
    623:         x[6*ctx->dof+comp]*    xir[0]*    xir[1]*   xir[2] +
    624:         x[7*ctx->dof+comp]*(1-xir[0])*    xir[1]*   xir[2];
    625:     }
    626:     VecRestoreArray(ref, &xi);
    627:     DMPlexVecRestoreClosure(dmCoord, NULL, coordsLocal, c, &coordSize, &vertices);
    628:     DMPlexVecRestoreClosure(dm, NULL, xLocal, c, &xSize, &x);
    629:   }
    630:   VecRestoreArray(v, &a);
    631:   VecRestoreArray(ctx->coords, &coords);

    633:   SNESDestroy(&snes);
    634:   VecDestroy(&r);
    635:   VecDestroy(&ref);
    636:   VecDestroy(&real);
    637:   MatDestroy(&J);
    638:   return(0);
    639: }

    643: /*
    644:   Input Parameters:
    645: + ctx - The DMInterpolationInfo context
    646: . dm  - The DM
    647: - x   - The local vector containing the field to be interpolated

    649:   Output Parameters:
    650: . v   - The vector containing the interpolated values
    651: */
    652: PetscErrorCode DMInterpolationEvaluate(DMInterpolationInfo ctx, DM dm, Vec x, Vec v)
    653: {
    654:   PetscInt       dim, coneSize, n;

    661:   VecGetLocalSize(v, &n);
    662:   if (n != ctx->n*ctx->dof) SETERRQ2(ctx->comm, PETSC_ERR_ARG_SIZ, "Invalid input vector size %d should be %d", n, ctx->n*ctx->dof);
    663:   if (n) {
    664:     DMPlexGetDimension(dm, &dim);
    665:     DMPlexGetConeSize(dm, ctx->cells[0], &coneSize);
    666:     if (dim == 2) {
    667:       if (coneSize == 3) {
    668:         DMInterpolate_Simplex_Private(ctx, dm, x, v);
    669:       } else if (coneSize == 4) {
    670:         DMInterpolate_Quad_Private(ctx, dm, x, v);
    671:       } else SETERRQ1(ctx->comm, PETSC_ERR_ARG_OUTOFRANGE, "Unsupported dimension %d for point interpolation", dim);
    672:     } else if (dim == 3) {
    673:       if (coneSize == 4) {
    674:         DMInterpolate_Simplex_Private(ctx, dm, x, v);
    675:       } else {
    676:         DMInterpolate_Hex_Private(ctx, dm, x, v);
    677:       }
    678:     } else SETERRQ1(ctx->comm, PETSC_ERR_ARG_OUTOFRANGE, "Unsupported dimension %d for point interpolation", dim);
    679:   }
    680:   return(0);
    681: }

    685: PetscErrorCode DMInterpolationDestroy(DMInterpolationInfo *ctx)
    686: {

    691:   VecDestroy(&(*ctx)->coords);
    692:   PetscFree((*ctx)->points);
    693:   PetscFree((*ctx)->cells);
    694:   PetscFree(*ctx);
    695:   *ctx = NULL;
    696:   return(0);
    697: }