Actual source code: plexgeometry.c
petsc-3.7.1 2016-05-15
Report Typos and Errors

      1: #include <petsc/private/dmpleximpl.h>   /*I      "petscdmplex.h"   I*/

      5: static PetscErrorCode DMPlexGetLineIntersection_2D_Internal(const PetscReal segmentA[], const PetscReal segmentB[], PetscReal intersection[], PetscBool *hasIntersection)
      6: {
      7:   const PetscReal p0_x  = segmentA[0*2+0];
      8:   const PetscReal p0_y  = segmentA[0*2+1];
      9:   const PetscReal p1_x  = segmentA[1*2+0];
     10:   const PetscReal p1_y  = segmentA[1*2+1];
     11:   const PetscReal p2_x  = segmentB[0*2+0];
     12:   const PetscReal p2_y  = segmentB[0*2+1];
     13:   const PetscReal p3_x  = segmentB[1*2+0];
     14:   const PetscReal p3_y  = segmentB[1*2+1];
     15:   const PetscReal s1_x  = p1_x - p0_x;
     16:   const PetscReal s1_y  = p1_y - p0_y;
     17:   const PetscReal s2_x  = p3_x - p2_x;
     18:   const PetscReal s2_y  = p3_y - p2_y;
     19:   const PetscReal denom = (-s2_x * s1_y + s1_x * s2_y);

     22:   *hasIntersection = PETSC_FALSE;
     23:   /* Non-parallel lines */
     24:   if (denom != 0.0) {
     25:     const PetscReal s = (-s1_y * (p0_x - p2_x) + s1_x * (p0_y - p2_y)) / denom;
     26:     const PetscReal t = ( s2_x * (p0_y - p2_y) - s2_y * (p0_x - p2_x)) / denom;

     28:     if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
     29:       *hasIntersection = PETSC_TRUE;
     30:       if (intersection) {
     31:         intersection[0] = p0_x + (t * s1_x);
     32:         intersection[1] = p0_y + (t * s1_y);
     33:       }
     34:     }
     35:   }
     36:   return(0);
     37: }

     41: static PetscErrorCode DMPlexLocatePoint_Simplex_2D_Internal(DM dm, const PetscScalar point[], PetscInt c, PetscInt *cell)
     42: {
     43:   const PetscInt  embedDim = 2;
     44:   const PetscReal eps      = PETSC_SQRT_MACHINE_EPSILON;
     45:   PetscReal       x        = PetscRealPart(point[0]);
     46:   PetscReal       y        = PetscRealPart(point[1]);
     47:   PetscReal       v0[2], J[4], invJ[4], detJ;
     48:   PetscReal       xi, eta;
     49:   PetscErrorCode  ierr;

     52:   DMPlexComputeCellGeometryFEM(dm, c, NULL, v0, J, invJ, &detJ);
     53:   xi  = invJ[0*embedDim+0]*(x - v0[0]) + invJ[0*embedDim+1]*(y - v0[1]);
     54:   eta = invJ[1*embedDim+0]*(x - v0[0]) + invJ[1*embedDim+1]*(y - v0[1]);

     56:   if ((xi >= -eps) && (eta >= -eps) && (xi + eta <= 2.0+eps)) *cell = c;
     57:   else *cell = -1;
     58:   return(0);
     59: }

     63: static PetscErrorCode DMPlexLocatePoint_General_2D_Internal(DM dm, const PetscScalar point[], PetscInt c, PetscInt *cell)
     64: {
     65:   PetscSection       coordSection;
     66:   Vec             coordsLocal;
     67:   PetscScalar    *coords = NULL;
     68:   const PetscInt  faces[8]  = {0, 1, 1, 2, 2, 3, 3, 0};
     69:   PetscReal       x         = PetscRealPart(point[0]);
     70:   PetscReal       y         = PetscRealPart(point[1]);
     71:   PetscInt        crossings = 0, f;
     72:   PetscErrorCode  ierr;

     75:   DMGetCoordinatesLocal(dm, &coordsLocal);
     76:   DMGetCoordinateSection(dm, &coordSection);
     77:   DMPlexVecGetClosure(dm, coordSection, coordsLocal, c, NULL, &coords);
     78:   for (f = 0; f < 4; ++f) {
     79:     PetscReal x_i   = PetscRealPart(coords[faces[2*f+0]*2+0]);
     80:     PetscReal y_i   = PetscRealPart(coords[faces[2*f+0]*2+1]);
     81:     PetscReal x_j   = PetscRealPart(coords[faces[2*f+1]*2+0]);
     82:     PetscReal y_j   = PetscRealPart(coords[faces[2*f+1]*2+1]);
     83:     PetscReal slope = (y_j - y_i) / (x_j - x_i);
     84:     PetscBool cond1 = (x_i <= x) && (x < x_j) ? PETSC_TRUE : PETSC_FALSE;
     85:     PetscBool cond2 = (x_j <= x) && (x < x_i) ? PETSC_TRUE : PETSC_FALSE;
     86:     PetscBool above = (y < slope * (x - x_i) + y_i) ? PETSC_TRUE : PETSC_FALSE;
     87:     if ((cond1 || cond2)  && above) ++crossings;
     88:   }
     89:   if (crossings % 2) *cell = c;
     90:   else *cell = -1;
     91:   DMPlexVecRestoreClosure(dm, coordSection, coordsLocal, c, NULL, &coords);
     92:   return(0);
     93: }

     97: static PetscErrorCode DMPlexLocatePoint_Simplex_3D_Internal(DM dm, const PetscScalar point[], PetscInt c, PetscInt *cell)
     98: {
     99:   const PetscInt embedDim = 3;
    100:   PetscReal      v0[3], J[9], invJ[9], detJ;
    101:   PetscReal      x = PetscRealPart(point[0]);
    102:   PetscReal      y = PetscRealPart(point[1]);
    103:   PetscReal      z = PetscRealPart(point[2]);
    104:   PetscReal      xi, eta, zeta;

    108:   DMPlexComputeCellGeometryFEM(dm, c, NULL, v0, J, invJ, &detJ);
    109:   xi   = invJ[0*embedDim+0]*(x - v0[0]) + invJ[0*embedDim+1]*(y - v0[1]) + invJ[0*embedDim+2]*(z - v0[2]);
    110:   eta  = invJ[1*embedDim+0]*(x - v0[0]) + invJ[1*embedDim+1]*(y - v0[1]) + invJ[1*embedDim+2]*(z - v0[2]);
    111:   zeta = invJ[2*embedDim+0]*(x - v0[0]) + invJ[2*embedDim+1]*(y - v0[1]) + invJ[2*embedDim+2]*(z - v0[2]);

    113:   if ((xi >= 0.0) && (eta >= 0.0) && (zeta >= 0.0) && (xi + eta + zeta <= 2.0)) *cell = c;
    114:   else *cell = -1;
    115:   return(0);
    116: }

    120: static PetscErrorCode DMPlexLocatePoint_General_3D_Internal(DM dm, const PetscScalar point[], PetscInt c, PetscInt *cell)
    121: {
    122:   PetscSection   coordSection;
    123:   Vec            coordsLocal;
    124:   PetscScalar   *coords;
    125:   const PetscInt faces[24] = {0, 3, 2, 1,  5, 4, 7, 6,  3, 0, 4, 5,
    126:                               1, 2, 6, 7,  3, 5, 6, 2,  0, 1, 7, 4};
    127:   PetscBool      found = PETSC_TRUE;
    128:   PetscInt       f;

    132:   DMGetCoordinatesLocal(dm, &coordsLocal);
    133:   DMGetCoordinateSection(dm, &coordSection);
    134:   DMPlexVecGetClosure(dm, coordSection, coordsLocal, c, NULL, &coords);
    135:   for (f = 0; f < 6; ++f) {
    136:     /* Check the point is under plane */
    137:     /*   Get face normal */
    138:     PetscReal v_i[3];
    139:     PetscReal v_j[3];
    140:     PetscReal normal[3];
    141:     PetscReal pp[3];
    142:     PetscReal dot;

    144:     v_i[0]    = PetscRealPart(coords[faces[f*4+3]*3+0]-coords[faces[f*4+0]*3+0]);
    145:     v_i[1]    = PetscRealPart(coords[faces[f*4+3]*3+1]-coords[faces[f*4+0]*3+1]);
    146:     v_i[2]    = PetscRealPart(coords[faces[f*4+3]*3+2]-coords[faces[f*4+0]*3+2]);
    147:     v_j[0]    = PetscRealPart(coords[faces[f*4+1]*3+0]-coords[faces[f*4+0]*3+0]);
    148:     v_j[1]    = PetscRealPart(coords[faces[f*4+1]*3+1]-coords[faces[f*4+0]*3+1]);
    149:     v_j[2]    = PetscRealPart(coords[faces[f*4+1]*3+2]-coords[faces[f*4+0]*3+2]);
    150:     normal[0] = v_i[1]*v_j[2] - v_i[2]*v_j[1];
    151:     normal[1] = v_i[2]*v_j[0] - v_i[0]*v_j[2];
    152:     normal[2] = v_i[0]*v_j[1] - v_i[1]*v_j[0];
    153:     pp[0]     = PetscRealPart(coords[faces[f*4+0]*3+0] - point[0]);
    154:     pp[1]     = PetscRealPart(coords[faces[f*4+0]*3+1] - point[1]);
    155:     pp[2]     = PetscRealPart(coords[faces[f*4+0]*3+2] - point[2]);
    156:     dot       = normal[0]*pp[0] + normal[1]*pp[1] + normal[2]*pp[2];

    158:     /* Check that projected point is in face (2D location problem) */
    159:     if (dot < 0.0) {
    160:       found = PETSC_FALSE;
    161:       break;
    162:     }
    163:   }
    164:   if (found) *cell = c;
    165:   else *cell = -1;
    166:   DMPlexVecRestoreClosure(dm, coordSection, coordsLocal, c, NULL, &coords);
    167:   return(0);
    168: }

    172: static PetscErrorCode PetscGridHashInitialize_Internal(PetscGridHash box, PetscInt dim, const PetscScalar point[])
    173: {
    174:   PetscInt d;

    177:   box->dim = dim;
    178:   for (d = 0; d < dim; ++d) box->lower[d] = box->upper[d] = PetscRealPart(point[d]);
    179:   return(0);
    180: }

    184: PetscErrorCode PetscGridHashCreate(MPI_Comm comm, PetscInt dim, const PetscScalar point[], PetscGridHash *box)
    185: {

    189:   PetscMalloc1(1, box);
    190:   PetscGridHashInitialize_Internal(*box, dim, point);
    191:   return(0);
    192: }

    196: PetscErrorCode PetscGridHashEnlarge(PetscGridHash box, const PetscScalar point[])
    197: {
    198:   PetscInt d;

    201:   for (d = 0; d < box->dim; ++d) {
    202:     box->lower[d] = PetscMin(box->lower[d], PetscRealPart(point[d]));
    203:     box->upper[d] = PetscMax(box->upper[d], PetscRealPart(point[d]));
    204:   }
    205:   return(0);
    206: }

    210: PetscErrorCode PetscGridHashSetGrid(PetscGridHash box, const PetscInt n[], const PetscReal h[])
    211: {
    212:   PetscInt d;

    215:   for (d = 0; d < box->dim; ++d) {
    216:     box->extent[d] = box->upper[d] - box->lower[d];
    217:     if (n[d] == PETSC_DETERMINE) {
    218:       box->h[d] = h[d];
    219:       box->n[d] = PetscCeilReal(box->extent[d]/h[d]);
    220:     } else {
    221:       box->n[d] = n[d];
    222:       box->h[d] = box->extent[d]/n[d];
    223:     }
    224:   }
    225:   return(0);
    226: }

    230: PetscErrorCode PetscGridHashGetEnclosingBox(PetscGridHash box, PetscInt numPoints, const PetscScalar points[], PetscInt dboxes[], PetscInt boxes[])
    231: {
    232:   const PetscReal *lower = box->lower;
    233:   const PetscReal *upper = box->upper;
    234:   const PetscReal *h     = box->h;
    235:   const PetscInt  *n     = box->n;
    236:   const PetscInt   dim   = box->dim;
    237:   PetscInt         d, p;

    240:   for (p = 0; p < numPoints; ++p) {
    241:     for (d = 0; d < dim; ++d) {
    242:       PetscInt dbox = PetscFloorReal((PetscRealPart(points[p*dim+d]) - lower[d])/h[d]);

    244:       if (dbox == n[d] && PetscAbsReal(PetscRealPart(points[p*dim+d]) - upper[d]) < 1.0e-9) dbox = n[d]-1;
    245:       if (dbox < 0 || dbox >= n[d]) SETERRQ4(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Input point %d (%g, %g, %g) is outside of our bounding box",
    246:                                              p, PetscRealPart(points[p*dim+0]), dim > 1 ? PetscRealPart(points[p*dim+1]) : 0.0, dim > 2 ? PetscRealPart(points[p*dim+2]) : 0.0);
    247:       dboxes[p*dim+d] = dbox;
    248:     }
    249:     if (boxes) for (d = 1, boxes[p] = dboxes[p*dim]; d < dim; ++d) boxes[p] += dboxes[p*dim+d]*n[d-1];
    250:   }
    251:   return(0);
    252: }

    256: PetscErrorCode PetscGridHashDestroy(PetscGridHash *box)
    257: {

    261:   if (*box) {
    262:     PetscSectionDestroy(&(*box)->cellSection);
    263:     ISDestroy(&(*box)->cells);
    264:     DMLabelDestroy(&(*box)->cellsSparse);
    265:   }
    266:   PetscFree(*box);
    267:   return(0);
    268: }

    272: PetscErrorCode DMPlexLocatePoint_Internal(DM dm, PetscInt dim, const PetscScalar point[], PetscInt cellStart, PetscInt *cell)
    273: {
    274:   PetscInt       coneSize;

    278:   switch (dim) {
    279:   case 2:
    280:     DMPlexGetConeSize(dm, cellStart, &coneSize);
    281:     switch (coneSize) {
    282:     case 3:
    283:       DMPlexLocatePoint_Simplex_2D_Internal(dm, point, cellStart, cell);
    284:       break;
    285:     case 4:
    286:       DMPlexLocatePoint_General_2D_Internal(dm, point, cellStart, cell);
    287:       break;
    288:     default:
    289:       SETERRQ1(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_OUTOFRANGE, "No point location for cell with cone size %D", coneSize);
    290:     }
    291:     break;
    292:   case 3:
    293:     DMPlexGetConeSize(dm, cellStart, &coneSize);
    294:     switch (coneSize) {
    295:     case 4:
    296:       DMPlexLocatePoint_Simplex_3D_Internal(dm, point, cellStart, cell);
    297:       break;
    298:     case 6:
    299:       DMPlexLocatePoint_General_3D_Internal(dm, point, cellStart, cell);
    300:       break;
    301:     default:
    302:       SETERRQ1(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_OUTOFRANGE, "No point location for cell with cone size %D", coneSize);
    303:     }
    304:     break;
    305:   default:
    306:     SETERRQ1(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_OUTOFRANGE, "No point location for mesh dimension %D", dim);
    307:   }
    308:   return(0);
    309: }

    313: PetscErrorCode DMPlexComputeGridHash_Internal(DM dm, PetscGridHash *localBox)
    314: {
    315:   MPI_Comm           comm;
    316:   PetscGridHash      lbox;
    317:   Vec                coordinates;
    318:   PetscSection       coordSection;
    319:   Vec                coordsLocal;
    320:   const PetscScalar *coords;
    321:   PetscInt          *dboxes, *boxes;
    322:   PetscInt           n[3] = {10, 10, 10};
    323:   PetscInt           dim, N, cStart, cEnd, cMax, c, i;
    324:   PetscErrorCode     ierr;

    327:   PetscObjectGetComm((PetscObject) dm, &comm);
    328:   DMGetCoordinatesLocal(dm, &coordinates);
    329:   DMGetCoordinateDim(dm, &dim);
    330:   VecGetLocalSize(coordinates, &N);
    331:   VecGetArrayRead(coordinates, &coords);
    332:   PetscGridHashCreate(comm, dim, coords, &lbox);
    333:   for (i = 0; i < N; i += dim) {PetscGridHashEnlarge(lbox, &coords[i]);}
    334:   VecRestoreArrayRead(coordinates, &coords);
    335:   PetscGridHashSetGrid(lbox, n, NULL);
    336: #if 0
    337:   /* Could define a custom reduction to merge these */
    338:   MPIU_Allreduce(lbox->lower, gbox->lower, 3, MPIU_REAL, MPI_MIN, comm);
    339:   MPIU_Allreduce(lbox->upper, gbox->upper, 3, MPIU_REAL, MPI_MAX, comm);
    340: #endif
    341:   /* Is there a reason to snap the local bounding box to a division of the global box? */
    342:   /* Should we compute all overlaps of local boxes? We could do this with a rendevouz scheme partitioning the global box */
    343:   /* Create label */
    344:   DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);
    345:   DMPlexGetHybridBounds(dm, &cMax, NULL, NULL, NULL);
    346:   if (cMax >= 0) cEnd = PetscMin(cEnd, cMax);
    347:   DMLabelCreate("cells", &lbox->cellsSparse);
    348:   DMLabelCreateIndex(lbox->cellsSparse, cStart, cEnd);
    349:   /* Compute boxes which overlap each cell: http://stackoverflow.com/questions/13790208/triangle-square-intersection-test-in-2d */
    350:   DMGetCoordinatesLocal(dm, &coordsLocal);
    351:   DMGetCoordinateSection(dm, &coordSection);
    352:   PetscCalloc2(16 * dim, &dboxes, 16, &boxes);
    353:   for (c = cStart; c < cEnd; ++c) {
    354:     const PetscReal *h       = lbox->h;
    355:     PetscScalar     *ccoords = NULL;
    356:     PetscInt         csize   = 0;
    357:     PetscScalar      point[3];
    358:     PetscInt         dlim[6], d, e, i, j, k;

    360:     /* Find boxes enclosing each vertex */
    361:     DMPlexVecGetClosure(dm, coordSection, coordsLocal, c, &csize, &ccoords);
    362:     PetscGridHashGetEnclosingBox(lbox, csize/dim, ccoords, dboxes, boxes);
    363:     /* Mark cells containing the vertices */
    364:     for (e = 0; e < csize/dim; ++e) {DMLabelSetValue(lbox->cellsSparse, c, boxes[e]);}
    365:     /* Get grid of boxes containing these */
    366:     for (d = 0;   d < dim; ++d) {dlim[d*2+0] = dlim[d*2+1] = dboxes[d];}
    367:     for (d = dim; d < 3;   ++d) {dlim[d*2+0] = dlim[d*2+1] = 0;}
    368:     for (e = 1; e < dim+1; ++e) {
    369:       for (d = 0; d < dim; ++d) {
    370:         dlim[d*2+0] = PetscMin(dlim[d*2+0], dboxes[e*dim+d]);
    371:         dlim[d*2+1] = PetscMax(dlim[d*2+1], dboxes[e*dim+d]);
    372:       }
    373:     }
    374:     /* Check for intersection of box with cell */
    375:     for (k = dlim[2*2+0], point[2] = lbox->lower[2] + k*h[2]; k <= dlim[2*2+1]; ++k, point[2] += h[2]) {
    376:       for (j = dlim[1*2+0], point[1] = lbox->lower[1] + j*h[1]; j <= dlim[1*2+1]; ++j, point[1] += h[1]) {
    377:         for (i = dlim[0*2+0], point[0] = lbox->lower[0] + i*h[0]; i <= dlim[0*2+1]; ++i, point[0] += h[0]) {
    378:           const PetscInt box = (k*lbox->n[1] + j)*lbox->n[0] + i;
    379:           PetscScalar    cpoint[3];
    380:           PetscInt       cell, edge, ii, jj, kk;

    382:           /* Check whether cell contains any vertex of these subboxes TODO vectorize this */
    383:           for (kk = 0, cpoint[2] = point[2]; kk < (dim > 2 ? 2 : 1); ++kk, cpoint[2] += h[2]) {
    384:             for (jj = 0, cpoint[1] = point[1]; jj < (dim > 1 ? 2 : 1); ++jj, cpoint[1] += h[1]) {
    385:               for (ii = 0, cpoint[0] = point[0]; ii < 2; ++ii, cpoint[0] += h[0]) {

    387:                 DMPlexLocatePoint_Internal(dm, dim, cpoint, c, &cell);
    388:                 if (cell >= 0) {DMLabelSetValue(lbox->cellsSparse, c, box); ii = jj = kk = 2;}
    389:               }
    390:             }
    391:           }
    392:           /* Check whether cell edge intersects any edge of these subboxes TODO vectorize this */
    393:           for (edge = 0; edge < dim+1; ++edge) {
    394:             PetscReal segA[6], segB[6];

    396:             for (d = 0; d < dim; ++d) {segA[d] = PetscRealPart(ccoords[edge*dim+d]); segA[dim+d] = PetscRealPart(ccoords[((edge+1)%(dim+1))*dim+d]);}
    397:             for (kk = 0; kk < (dim > 2 ? 2 : 1); ++kk) {
    398:               if (dim > 2) {segB[2]     = PetscRealPart(point[2]);
    399:                             segB[dim+2] = PetscRealPart(point[2]) + kk*h[2];}
    400:               for (jj = 0; jj < (dim > 1 ? 2 : 1); ++jj) {
    401:                 if (dim > 1) {segB[1]     = PetscRealPart(point[1]);
    402:                               segB[dim+1] = PetscRealPart(point[1]) + jj*h[1];}
    403:                 for (ii = 0; ii < 2; ++ii) {
    404:                   PetscBool intersects;

    406:                   segB[0]     = PetscRealPart(point[0]);
    407:                   segB[dim+0] = PetscRealPart(point[0]) + ii*h[0];
    408:                   DMPlexGetLineIntersection_2D_Internal(segA, segB, NULL, &intersects);
    409:                   if (intersects) {DMLabelSetValue(lbox->cellsSparse, c, box); edge = ii = jj = kk = dim+1;}
    410:                 }
    411:               }
    412:             }
    413:           }
    414:         }
    415:       }
    416:     }
    417:     DMPlexVecRestoreClosure(dm, coordSection, coordsLocal, c, NULL, &ccoords);
    418:   }
    419:   PetscFree2(dboxes, boxes);
    420:   DMLabelConvertToSection(lbox->cellsSparse, &lbox->cellSection, &lbox->cells);
    421:   DMLabelDestroy(&lbox->cellsSparse);
    422:   *localBox = lbox;
    423:   return(0);
    424: }

    428: PetscErrorCode DMLocatePoints_Plex(DM dm, Vec v, PetscSF cellSF)
    429: {
    430:   DM_Plex        *mesh = (DM_Plex *) dm->data;
    431:   PetscBool       hash = mesh->useHashLocation;
    432:   PetscInt        bs, numPoints, p, numFound, *found = NULL;
    433:   PetscInt        dim, cStart, cEnd, cMax, numCells, c;
    434:   const PetscInt *boxCells;
    435:   PetscSFNode    *cells;
    436:   PetscScalar    *a;
    437:   PetscMPIInt     result;
    438:   PetscErrorCode  ierr;

    441:   DMGetCoordinateDim(dm, &dim);
    442:   VecGetBlockSize(v, &bs);
    443:   MPI_Comm_compare(PetscObjectComm((PetscObject)cellSF),PETSC_COMM_SELF,&result);
    444:   if (result != MPI_IDENT && result != MPI_CONGRUENT) SETERRQ(PetscObjectComm((PetscObject)cellSF),PETSC_ERR_SUP, "Trying parallel point location: only local point location supported");
    445:   if (bs != dim) SETERRQ2(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "Block size for point vector %D must be the mesh coordinate dimension %D", bs, dim);
    446:   DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);
    447:   DMPlexGetHybridBounds(dm, &cMax, NULL, NULL, NULL);
    448:   if (cMax >= 0) cEnd = PetscMin(cEnd, cMax);
    449:   VecGetLocalSize(v, &numPoints);
    450:   VecGetArray(v, &a);
    451:   numPoints /= bs;
    452:   PetscMalloc1(numPoints, &cells);
    453:   if (hash) {
    454:     if (!mesh->lbox) {PetscInfo(dm, "Initializing grid hashing");DMPlexComputeGridHash_Internal(dm, &mesh->lbox);}
    455:     /* Designate the local box for each point */
    456:     /* Send points to correct process */
    457:     /* Search cells that lie in each subbox */
    458:     /*   Should we bin points before doing search? */
    459:     ISGetIndices(mesh->lbox->cells, &boxCells);
    460:   }
    461:   for (p = 0, numFound = 0; p < numPoints; ++p) {
    462:     const PetscScalar *point = &a[p*bs];
    463:     PetscInt           dbin[3], bin, cell = -1, cellOffset;

    465:     cells[p].rank  = -1;
    466:     cells[p].index = -1;
    467:     if (hash) {
    468:       PetscGridHashGetEnclosingBox(mesh->lbox, 1, point, dbin, &bin);
    469:       /* TODO Lay an interface over this so we can switch between Section (dense) and Label (sparse) */
    470:       PetscSectionGetDof(mesh->lbox->cellSection, bin, &numCells);
    471:       PetscSectionGetOffset(mesh->lbox->cellSection, bin, &cellOffset);
    472:       for (c = cellOffset; c < cellOffset + numCells; ++c) {
    473:         DMPlexLocatePoint_Internal(dm, dim, point, boxCells[c], &cell);
    474:         if (cell >= 0) {
    475:           cells[p].rank = 0;
    476:           cells[p].index = cell;
    477:           numFound++;
    478:           break;
    479:         }
    480:       }
    481:     } else {
    482:       for (c = cStart; c < cEnd; ++c) {
    483:         DMPlexLocatePoint_Internal(dm, dim, point, c, &cell);
    484:         if (cell >= 0) {
    485:           cells[p].rank = 0;
    486:           cells[p].index = cell;
    487:           numFound++;
    488:           break;
    489:         }
    490:       }
    491:     }
    492:   }
    493:   if (hash) {ISRestoreIndices(mesh->lbox->cells, &boxCells);}
    494:   /* Check for highest numbered proc that claims a point (do we care?) */
    495:   VecRestoreArray(v, &a);
    496:   if (numFound < numPoints) {
    497:     PetscMalloc1(numFound,&found);
    498:     for (p = 0, numFound = 0; p < numPoints; p++) {
    499:       if (cells[p].rank >= 0 && cells[p].index >= 0) {
    500:         if (numFound < p) {
    501:           cells[numFound] = cells[p];
    502:         }
    503:         found[numFound++] = p;
    504:       }
    505:     }
    506:   }
    507:   PetscSFSetGraph(cellSF, cEnd - cStart, numFound, found, PETSC_OWN_POINTER, cells, PETSC_OWN_POINTER);
    508:   return(0);
    509: }

    513: /*
    514:   DMPlexComputeProjection2Dto1D_Internal - Rewrite coordinates to be the 1D projection of the 2D
    515: */
    516: PetscErrorCode DMPlexComputeProjection2Dto1D_Internal(PetscScalar coords[], PetscReal R[])
    517: {
    518:   const PetscReal x = PetscRealPart(coords[2] - coords[0]);
    519:   const PetscReal y = PetscRealPart(coords[3] - coords[1]);
    520:   const PetscReal r = PetscSqrtReal(x*x + y*y), c = x/r, s = y/r;

    523:   R[0] = c; R[1] = -s;
    524:   R[2] = s; R[3] =  c;
    525:   coords[0] = 0.0;
    526:   coords[1] = r;
    527:   return(0);
    528: }

    532: /*
    533:   DMPlexComputeProjection3Dto1D_Internal - Rewrite coordinates to be the 1D projection of the 3D

    535:   This uses the basis completion described by Frisvad,

    537:   http://www.imm.dtu.dk/~jerf/papers/abstracts/onb.html
    538:   DOI:10.1080/2165347X.2012.689606
    539: */
    540: PetscErrorCode DMPlexComputeProjection3Dto1D_Internal(PetscScalar coords[], PetscReal R[])
    541: {
    542:   PetscReal      x    = PetscRealPart(coords[3] - coords[0]);
    543:   PetscReal      y    = PetscRealPart(coords[4] - coords[1]);
    544:   PetscReal      z    = PetscRealPart(coords[5] - coords[2]);
    545:   PetscReal      r    = PetscSqrtReal(x*x + y*y + z*z);
    546:   PetscReal      rinv = 1. / r;

    549:   x *= rinv; y *= rinv; z *= rinv;
    550:   if (x > 0.) {
    551:     PetscReal inv1pX   = 1./ (1. + x);

    553:     R[0] = x; R[1] = -y;              R[2] = -z;
    554:     R[3] = y; R[4] = 1. - y*y*inv1pX; R[5] =     -y*z*inv1pX;
    555:     R[6] = z; R[7] =     -y*z*inv1pX; R[8] = 1. - z*z*inv1pX;
    556:   }
    557:   else {
    558:     PetscReal inv1mX   = 1./ (1. - x);

    560:     R[0] = x; R[1] = z;               R[2] = y;
    561:     R[3] = y; R[4] =     -y*z*inv1mX; R[5] = 1. - y*y*inv1mX;
    562:     R[6] = z; R[7] = 1. - z*z*inv1mX; R[8] =     -y*z*inv1mX;
    563:   }
    564:   coords[0] = 0.0;
    565:   coords[1] = r;
    566:   return(0);
    567: }

    571: /*
    572:   DMPlexComputeProjection3Dto2D_Internal - Rewrite coordinates to be the 2D projection of the 3D
    573: */
    574: PetscErrorCode DMPlexComputeProjection3Dto2D_Internal(PetscInt coordSize, PetscScalar coords[], PetscReal R[])
    575: {
    576:   PetscReal      x1[3],  x2[3], n[3], norm;
    577:   PetscReal      x1p[3], x2p[3], xnp[3];
    578:   PetscReal      sqrtz, alpha;
    579:   const PetscInt dim = 3;
    580:   PetscInt       d, e, p;

    583:   /* 0) Calculate normal vector */
    584:   for (d = 0; d < dim; ++d) {
    585:     x1[d] = PetscRealPart(coords[1*dim+d] - coords[0*dim+d]);
    586:     x2[d] = PetscRealPart(coords[2*dim+d] - coords[0*dim+d]);
    587:   }
    588:   n[0] = x1[1]*x2[2] - x1[2]*x2[1];
    589:   n[1] = x1[2]*x2[0] - x1[0]*x2[2];
    590:   n[2] = x1[0]*x2[1] - x1[1]*x2[0];
    591:   norm = PetscSqrtReal(n[0]*n[0] + n[1]*n[1] + n[2]*n[2]);
    592:   n[0] /= norm;
    593:   n[1] /= norm;
    594:   n[2] /= norm;
    595:   /* 1) Take the normal vector and rotate until it is \hat z

    597:     Let the normal vector be <nx, ny, nz> and alpha = 1/sqrt(1 - nz^2), then

    599:     R = /  alpha nx nz  alpha ny nz -1/alpha \
    600:         | -alpha ny     alpha nx        0    |
    601:         \     nx            ny         nz    /

    603:     will rotate the normal vector to \hat z
    604:   */
    605:   sqrtz = PetscSqrtReal(1.0 - n[2]*n[2]);
    606:   /* Check for n = z */
    607:   if (sqrtz < 1.0e-10) {
    608:     const PetscInt s = PetscSign(n[2]);
    609:     /* If nz < 0, rotate 180 degrees around x-axis */
    610:     for (p = 3; p < coordSize/3; ++p) {
    611:       coords[p*2+0] = PetscRealPart(coords[p*dim+0] - coords[0*dim+0]);
    612:       coords[p*2+1] = (PetscRealPart(coords[p*dim+1] - coords[0*dim+1])) * s;
    613:     }
    614:     coords[0] = 0.0;
    615:     coords[1] = 0.0;
    616:     coords[2] = x1[0];
    617:     coords[3] = x1[1] * s;
    618:     coords[4] = x2[0];
    619:     coords[5] = x2[1] * s;
    620:     R[0] = 1.0;     R[1] = 0.0;     R[2] = 0.0;
    621:     R[3] = 0.0;     R[4] = 1.0 * s; R[5] = 0.0;
    622:     R[6] = 0.0;     R[7] = 0.0;     R[8] = 1.0 * s;
    623:     return(0);
    624:   }
    625:   alpha = 1.0/sqrtz;
    626:   R[0] =  alpha*n[0]*n[2]; R[1] = alpha*n[1]*n[2]; R[2] = -sqrtz;
    627:   R[3] = -alpha*n[1];      R[4] = alpha*n[0];      R[5] = 0.0;
    628:   R[6] =  n[0];            R[7] = n[1];            R[8] = n[2];
    629:   for (d = 0; d < dim; ++d) {
    630:     x1p[d] = 0.0;
    631:     x2p[d] = 0.0;
    632:     for (e = 0; e < dim; ++e) {
    633:       x1p[d] += R[d*dim+e]*x1[e];
    634:       x2p[d] += R[d*dim+e]*x2[e];
    635:     }
    636:   }
    637:   if (PetscAbsReal(x1p[2]) > 1.0e-9) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid rotation calculated");
    638:   if (PetscAbsReal(x2p[2]) > 1.0e-9) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid rotation calculated");
    639:   /* 2) Project to (x, y) */
    640:   for (p = 3; p < coordSize/3; ++p) {
    641:     for (d = 0; d < dim; ++d) {
    642:       xnp[d] = 0.0;
    643:       for (e = 0; e < dim; ++e) {
    644:         xnp[d] += R[d*dim+e]*PetscRealPart(coords[p*dim+e] - coords[0*dim+e]);
    645:       }
    646:       if (d < dim-1) coords[p*2+d] = xnp[d];
    647:     }
    648:   }
    649:   coords[0] = 0.0;
    650:   coords[1] = 0.0;
    651:   coords[2] = x1p[0];
    652:   coords[3] = x1p[1];
    653:   coords[4] = x2p[0];
    654:   coords[5] = x2p[1];
    655:   /* Output R^T which rotates \hat z to the input normal */
    656:   for (d = 0; d < dim; ++d) {
    657:     for (e = d+1; e < dim; ++e) {
    658:       PetscReal tmp;

    660:       tmp        = R[d*dim+e];
    661:       R[d*dim+e] = R[e*dim+d];
    662:       R[e*dim+d] = tmp;
    663:     }
    664:   }
    665:   return(0);
    666: }

    670: PETSC_UNUSED
    671: PETSC_STATIC_INLINE void Volume_Triangle_Internal(PetscReal *vol, PetscReal coords[])
    672: {
    673:   /* Signed volume is 1/2 the determinant

    675:    |  1  1  1 |
    676:    | x0 x1 x2 |
    677:    | y0 y1 y2 |

    679:      but if x0,y0 is the origin, we have

    681:    | x1 x2 |
    682:    | y1 y2 |
    683:   */
    684:   const PetscReal x1 = coords[2] - coords[0], y1 = coords[3] - coords[1];
    685:   const PetscReal x2 = coords[4] - coords[0], y2 = coords[5] - coords[1];
    686:   PetscReal       M[4], detM;
    687:   M[0] = x1; M[1] = x2;
    688:   M[2] = y1; M[3] = y2;
    689:   DMPlex_Det2D_Internal(&detM, M);
    690:   *vol = 0.5*detM;
    691:   (void)PetscLogFlops(5.0);
    692: }

    696: PETSC_STATIC_INLINE void Volume_Triangle_Origin_Internal(PetscReal *vol, PetscReal coords[])
    697: {
    698:   DMPlex_Det2D_Internal(vol, coords);
    699:   *vol *= 0.5;
    700: }

    704: PETSC_UNUSED
    705: PETSC_STATIC_INLINE void Volume_Tetrahedron_Internal(PetscReal *vol, PetscReal coords[])
    706: {
    707:   /* Signed volume is 1/6th of the determinant

    709:    |  1  1  1  1 |
    710:    | x0 x1 x2 x3 |
    711:    | y0 y1 y2 y3 |
    712:    | z0 z1 z2 z3 |

    714:      but if x0,y0,z0 is the origin, we have

    716:    | x1 x2 x3 |
    717:    | y1 y2 y3 |
    718:    | z1 z2 z3 |
    719:   */
    720:   const PetscReal x1 = coords[3] - coords[0], y1 = coords[4]  - coords[1], z1 = coords[5]  - coords[2];
    721:   const PetscReal x2 = coords[6] - coords[0], y2 = coords[7]  - coords[1], z2 = coords[8]  - coords[2];
    722:   const PetscReal x3 = coords[9] - coords[0], y3 = coords[10] - coords[1], z3 = coords[11] - coords[2];
    723:   PetscReal       M[9], detM;
    724:   M[0] = x1; M[1] = x2; M[2] = x3;
    725:   M[3] = y1; M[4] = y2; M[5] = y3;
    726:   M[6] = z1; M[7] = z2; M[8] = z3;
    727:   DMPlex_Det3D_Internal(&detM, M);
    728:   *vol = -0.16666666666666666666666*detM;
    729:   (void)PetscLogFlops(10.0);
    730: }

    734: PETSC_STATIC_INLINE void Volume_Tetrahedron_Origin_Internal(PetscReal *vol, PetscReal coords[])
    735: {
    736:   DMPlex_Det3D_Internal(vol, coords);
    737:   *vol *= -0.16666666666666666666666;
    738: }

    742: static PetscErrorCode DMPlexComputeLineGeometry_Internal(DM dm, PetscInt e, PetscReal v0[], PetscReal J[], PetscReal invJ[], PetscReal *detJ)
    743: {
    744:   PetscSection   coordSection;
    745:   Vec            coordinates;
    746:   PetscScalar   *coords = NULL;
    747:   PetscInt       numCoords, d;

    751:   DMGetCoordinatesLocal(dm, &coordinates);
    752:   DMGetCoordinateSection(dm, &coordSection);
    753:   DMPlexVecGetClosure(dm, coordSection, coordinates, e, &numCoords, &coords);
    754:   if (invJ && !J) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "In order to compute invJ, J must not be NULL");
    755:   *detJ = 0.0;
    756:   if (numCoords == 6) {
    757:     const PetscInt dim = 3;
    758:     PetscReal      R[9], J0;

    760:     if (v0)   {for (d = 0; d < dim; d++) v0[d] = PetscRealPart(coords[d]);}
    761:     DMPlexComputeProjection3Dto1D_Internal(coords, R);
    762:     if (J)    {
    763:       J0   = 0.5*PetscRealPart(coords[1]);
    764:       J[0] = R[0]*J0; J[1] = R[1]; J[2] = R[2];
    765:       J[3] = R[3]*J0; J[4] = R[4]; J[5] = R[5];
    766:       J[6] = R[6]*J0; J[7] = R[7]; J[8] = R[8];
    767:       DMPlex_Det3D_Internal(detJ, J);
    768:       if (invJ) {DMPlex_Invert2D_Internal(invJ, J, *detJ);}
    769:     }
    770:   } else if (numCoords == 4) {
    771:     const PetscInt dim = 2;
    772:     PetscReal      R[4], J0;

    774:     if (v0)   {for (d = 0; d < dim; d++) v0[d] = PetscRealPart(coords[d]);}
    775:     DMPlexComputeProjection2Dto1D_Internal(coords, R);
    776:     if (J)    {
    777:       J0   = 0.5*PetscRealPart(coords[1]);
    778:       J[0] = R[0]*J0; J[1] = R[1];
    779:       J[2] = R[2]*J0; J[3] = R[3];
    780:       DMPlex_Det2D_Internal(detJ, J);
    781:       if (invJ) {DMPlex_Invert2D_Internal(invJ, J, *detJ);}
    782:     }
    783:   } else if (numCoords == 2) {
    784:     const PetscInt dim = 1;

    786:     if (v0)   {for (d = 0; d < dim; d++) v0[d] = PetscRealPart(coords[d]);}
    787:     if (J)    {
    788:       J[0]  = 0.5*(PetscRealPart(coords[1]) - PetscRealPart(coords[0]));
    789:       *detJ = J[0];
    790:       PetscLogFlops(2.0);
    791:       if (invJ) {invJ[0] = 1.0/J[0]; PetscLogFlops(1.0);}
    792:     }
    793:   } else SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "The number of coordinates for this segment is %D != 2", numCoords);
    794:   DMPlexVecRestoreClosure(dm, coordSection, coordinates, e, &numCoords, &coords);
    795:   return(0);
    796: }

    800: static PetscErrorCode DMPlexComputeTriangleGeometry_Internal(DM dm, PetscInt e, PetscReal v0[], PetscReal J[], PetscReal invJ[], PetscReal *detJ)
    801: {
    802:   PetscSection   coordSection;
    803:   Vec            coordinates;
    804:   PetscScalar   *coords = NULL;
    805:   PetscInt       numCoords, d, f, g;

    809:   DMGetCoordinatesLocal(dm, &coordinates);
    810:   DMGetCoordinateSection(dm, &coordSection);
    811:   DMPlexVecGetClosure(dm, coordSection, coordinates, e, &numCoords, &coords);
    812:   *detJ = 0.0;
    813:   if (numCoords == 9) {
    814:     const PetscInt dim = 3;
    815:     PetscReal      R[9], J0[9] = {1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0};

    817:     if (v0)   {for (d = 0; d < dim; d++) v0[d] = PetscRealPart(coords[d]);}
    818:     DMPlexComputeProjection3Dto2D_Internal(numCoords, coords, R);
    819:     if (J)    {
    820:       const PetscInt pdim = 2;

    822:       for (d = 0; d < pdim; d++) {
    823:         for (f = 0; f < pdim; f++) {
    824:           J0[d*dim+f] = 0.5*(PetscRealPart(coords[(f+1)*pdim+d]) - PetscRealPart(coords[0*pdim+d]));
    825:         }
    826:       }
    827:       PetscLogFlops(8.0);
    828:       DMPlex_Det3D_Internal(detJ, J0);
    829:       for (d = 0; d < dim; d++) {
    830:         for (f = 0; f < dim; f++) {
    831:           J[d*dim+f] = 0.0;
    832:           for (g = 0; g < dim; g++) {
    833:             J[d*dim+f] += R[d*dim+g]*J0[g*dim+f];
    834:           }
    835:         }
    836:       }
    837:       PetscLogFlops(18.0);
    838:     }
    839:     if (invJ) {DMPlex_Invert3D_Internal(invJ, J, *detJ);}
    840:   } else if (numCoords == 6) {
    841:     const PetscInt dim = 2;

    843:     if (v0)   {for (d = 0; d < dim; d++) v0[d] = PetscRealPart(coords[d]);}
    844:     if (J)    {
    845:       for (d = 0; d < dim; d++) {
    846:         for (f = 0; f < dim; f++) {
    847:           J[d*dim+f] = 0.5*(PetscRealPart(coords[(f+1)*dim+d]) - PetscRealPart(coords[0*dim+d]));
    848:         }
    849:       }
    850:       PetscLogFlops(8.0);
    851:       DMPlex_Det2D_Internal(detJ, J);
    852:     }
    853:     if (invJ) {DMPlex_Invert2D_Internal(invJ, J, *detJ);}
    854:   } else SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "The number of coordinates for this triangle is %D != 6 or 9", numCoords);
    855:   DMPlexVecRestoreClosure(dm, coordSection, coordinates, e, &numCoords, &coords);
    856:   return(0);
    857: }

    861: static PetscErrorCode DMPlexComputeRectangleGeometry_Internal(DM dm, PetscInt e, PetscReal v0[], PetscReal J[], PetscReal invJ[], PetscReal *detJ)
    862: {
    863:   PetscSection   coordSection;
    864:   Vec            coordinates;
    865:   PetscScalar   *coords = NULL;
    866:   PetscInt       numCoords, d, f, g;

    870:   DMGetCoordinatesLocal(dm, &coordinates);
    871:   DMGetCoordinateSection(dm, &coordSection);
    872:   DMPlexVecGetClosure(dm, coordSection, coordinates, e, &numCoords, &coords);
    873:   *detJ = 0.0;
    874:   if (numCoords == 12) {
    875:     const PetscInt dim = 3;
    876:     PetscReal      R[9], J0[9] = {1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0};

    878:     if (v0)   {for (d = 0; d < dim; d++) v0[d] = PetscRealPart(coords[d]);}
    879:     DMPlexComputeProjection3Dto2D_Internal(numCoords, coords, R);
    880:     if (J)    {
    881:       const PetscInt pdim = 2;

    883:       for (d = 0; d < pdim; d++) {
    884:         J0[d*dim+0] = 0.5*(PetscRealPart(coords[1*pdim+d]) - PetscRealPart(coords[0*pdim+d]));
    885:         J0[d*dim+1] = 0.5*(PetscRealPart(coords[3*pdim+d]) - PetscRealPart(coords[0*pdim+d]));
    886:       }
    887:       PetscLogFlops(8.0);
    888:       DMPlex_Det3D_Internal(detJ, J0);
    889:       for (d = 0; d < dim; d++) {
    890:         for (f = 0; f < dim; f++) {
    891:           J[d*dim+f] = 0.0;
    892:           for (g = 0; g < dim; g++) {
    893:             J[d*dim+f] += R[d*dim+g]*J0[g*dim+f];
    894:           }
    895:         }
    896:       }
    897:       PetscLogFlops(18.0);
    898:     }
    899:     if (invJ) {DMPlex_Invert3D_Internal(invJ, J, *detJ);}
    900:   } else if ((numCoords == 8) || (numCoords == 16)) {
    901:     const PetscInt dim = 2;

    903:     if (v0)   {for (d = 0; d < dim; d++) v0[d] = PetscRealPart(coords[d]);}
    904:     if (J)    {
    905:       for (d = 0; d < dim; d++) {
    906:         J[d*dim+0] = 0.5*(PetscRealPart(coords[1*dim+d]) - PetscRealPart(coords[0*dim+d]));
    907:         J[d*dim+1] = 0.5*(PetscRealPart(coords[3*dim+d]) - PetscRealPart(coords[0*dim+d]));
    908:       }
    909:       PetscLogFlops(8.0);
    910:       DMPlex_Det2D_Internal(detJ, J);
    911:     }
    912:     if (invJ) {DMPlex_Invert2D_Internal(invJ, J, *detJ);}
    913:   } else SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "The number of coordinates for this quadrilateral is %D != 8 or 12", numCoords);
    914:   DMPlexVecRestoreClosure(dm, coordSection, coordinates, e, &numCoords, &coords);
    915:   return(0);
    916: }

    920: static PetscErrorCode DMPlexComputeTetrahedronGeometry_Internal(DM dm, PetscInt e, PetscReal v0[], PetscReal J[], PetscReal invJ[], PetscReal *detJ)
    921: {
    922:   PetscSection   coordSection;
    923:   Vec            coordinates;
    924:   PetscScalar   *coords = NULL;
    925:   const PetscInt dim = 3;
    926:   PetscInt       d;

    930:   DMGetCoordinatesLocal(dm, &coordinates);
    931:   DMGetCoordinateSection(dm, &coordSection);
    932:   DMPlexVecGetClosure(dm, coordSection, coordinates, e, NULL, &coords);
    933:   *detJ = 0.0;
    934:   if (v0)   {for (d = 0; d < dim; d++) v0[d] = PetscRealPart(coords[d]);}
    935:   if (J)    {
    936:     for (d = 0; d < dim; d++) {
    937:       /* I orient with outward face normals */
    938:       J[d*dim+0] = 0.5*(PetscRealPart(coords[2*dim+d]) - PetscRealPart(coords[0*dim+d]));
    939:       J[d*dim+1] = 0.5*(PetscRealPart(coords[1*dim+d]) - PetscRealPart(coords[0*dim+d]));
    940:       J[d*dim+2] = 0.5*(PetscRealPart(coords[3*dim+d]) - PetscRealPart(coords[0*dim+d]));
    941:     }
    942:     PetscLogFlops(18.0);
    943:     DMPlex_Det3D_Internal(detJ, J);
    944:   }
    945:   if (invJ) {DMPlex_Invert3D_Internal(invJ, J, *detJ);}
    946:   DMPlexVecRestoreClosure(dm, coordSection, coordinates, e, NULL, &coords);
    947:   return(0);
    948: }

    952: static PetscErrorCode DMPlexComputeHexahedronGeometry_Internal(DM dm, PetscInt e, PetscReal v0[], PetscReal J[], PetscReal invJ[], PetscReal *detJ)
    953: {
    954:   PetscSection   coordSection;
    955:   Vec            coordinates;
    956:   PetscScalar   *coords = NULL;
    957:   const PetscInt dim = 3;
    958:   PetscInt       d;

    962:   DMGetCoordinatesLocal(dm, &coordinates);
    963:   DMGetCoordinateSection(dm, &coordSection);
    964:   DMPlexVecGetClosure(dm, coordSection, coordinates, e, NULL, &coords);
    965:   *detJ = 0.0;
    966:   if (v0)   {for (d = 0; d < dim; d++) v0[d] = PetscRealPart(coords[d]);}
    967:   if (J)    {
    968:     for (d = 0; d < dim; d++) {
    969:       J[d*dim+0] = 0.5*(PetscRealPart(coords[3*dim+d]) - PetscRealPart(coords[0*dim+d]));
    970:       J[d*dim+1] = 0.5*(PetscRealPart(coords[1*dim+d]) - PetscRealPart(coords[0*dim+d]));
    971:       J[d*dim+2] = 0.5*(PetscRealPart(coords[4*dim+d]) - PetscRealPart(coords[0*dim+d]));
    972:     }
    973:     PetscLogFlops(18.0);
    974:     DMPlex_Det3D_Internal(detJ, J);
    975:   }
    976:   if (invJ) {DMPlex_Invert3D_Internal(invJ, J, *detJ);}
    977:   DMPlexVecRestoreClosure(dm, coordSection, coordinates, e, NULL, &coords);
    978:   return(0);
    979: }

    983: /*@C
    984:   DMPlexComputeCellGeometryAffineFEM - Assuming an affine map, compute the Jacobian, inverse Jacobian, and Jacobian determinant for a given cell

    986:   Collective on DM

    988:   Input Arguments:
    989: + dm   - the DM
    990: - cell - the cell

    992:   Output Arguments:
    993: + v0   - the translation part of this affine transform
    994: . J    - the Jacobian of the transform from the reference element
    995: . invJ - the inverse of the Jacobian
    996: - detJ - the Jacobian determinant

    998:   Level: advanced

    1000:   Fortran Notes:
    1001:   Since it returns arrays, this routine is only available in Fortran 90, and you must
    1002:   include petsc.h90 in your code.

    1004: .seealso: DMPlexComputeCellGeometryFEM(), DMGetCoordinateSection(), DMGetCoordinateVec()
    1005: @*/
    1006: PetscErrorCode DMPlexComputeCellGeometryAffineFEM(DM dm, PetscInt cell, PetscReal *v0, PetscReal *J, PetscReal *invJ, PetscReal *detJ)
    1007: {
    1008:   PetscInt       depth, dim, coneSize;

    1012:   DMPlexGetDepth(dm, &depth);
    1013:   DMPlexGetConeSize(dm, cell, &coneSize);
    1014:   if (depth == 1) {
    1015:     DMGetDimension(dm, &dim);
    1016:   } else {
    1017:     DMLabel depth;

    1019:     DMPlexGetDepthLabel(dm, &depth);
    1020:     DMLabelGetValue(depth, cell, &dim);
    1021:   }
    1022:   switch (dim) {
    1023:   case 1:
    1024:     DMPlexComputeLineGeometry_Internal(dm, cell, v0, J, invJ, detJ);
    1025:     break;
    1026:   case 2:
    1027:     switch (coneSize) {
    1028:     case 3:
    1029:       DMPlexComputeTriangleGeometry_Internal(dm, cell, v0, J, invJ, detJ);
    1030:       break;
    1031:     case 4:
    1032:       DMPlexComputeRectangleGeometry_Internal(dm, cell, v0, J, invJ, detJ);
    1033:       break;
    1034:     default:
    1035:       SETERRQ2(PetscObjectComm((PetscObject)dm), PETSC_ERR_SUP, "Unsupported number of faces %D in cell %D for element geometry computation", coneSize, cell);
    1036:     }
    1037:     break;
    1038:   case 3:
    1039:     switch (coneSize) {
    1040:     case 4:
    1041:       DMPlexComputeTetrahedronGeometry_Internal(dm, cell, v0, J, invJ, detJ);
    1042:       break;
    1043:     case 6: /* Faces */
    1044:     case 8: /* Vertices */
    1045:       DMPlexComputeHexahedronGeometry_Internal(dm, cell, v0, J, invJ, detJ);
    1046:       break;
    1047:     default:
    1048:         SETERRQ2(PetscObjectComm((PetscObject)dm), PETSC_ERR_SUP, "Unsupported number of faces %D in cell %D for element geometry computation", coneSize, cell);
    1049:     }
    1050:       break;
    1051:   default:
    1052:     SETERRQ1(PetscObjectComm((PetscObject)dm), PETSC_ERR_SUP, "Unsupported dimension %D for element geometry computation", dim);
    1053:   }
    1054:   return(0);
    1055: }

    1059: static PetscErrorCode DMPlexComputeIsoparametricGeometry_Internal(DM dm, PetscFE fe, PetscInt point, PetscReal v0[], PetscReal J[], PetscReal invJ[], PetscReal *detJ)
    1060: {
    1061:   PetscQuadrature  quad;
    1062:   PetscSection     coordSection;
    1063:   Vec              coordinates;
    1064:   PetscScalar     *coords = NULL;
    1065:   const PetscReal *quadPoints;
    1066:   PetscReal       *basisDer;
    1067:   PetscInt         dim, cdim, pdim, qdim, Nq, numCoords, d, q;
    1068:   PetscErrorCode   ierr;

    1071:   DMGetCoordinatesLocal(dm, &coordinates);
    1072:   DMGetCoordinateSection(dm, &coordSection);
    1073:   DMPlexVecGetClosure(dm, coordSection, coordinates, point, &numCoords, &coords);
    1074:   DMGetDimension(dm, &dim);
    1075:   DMGetCoordinateDim(dm, &cdim);
    1076:   PetscFEGetQuadrature(fe, &quad);
    1077:   PetscFEGetDimension(fe, &pdim);
    1078:   PetscQuadratureGetData(quad, &qdim, &Nq, &quadPoints, NULL);
    1079:   PetscFEGetDefaultTabulation(fe, NULL, &basisDer, NULL);
    1080:   *detJ = 0.0;
    1081:   if (qdim != dim) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_SIZ, "Point dimension %d != quadrature dimension %d", dim, qdim);
    1082:   if (numCoords != pdim*cdim) SETERRQ4(PETSC_COMM_SELF, PETSC_ERR_ARG_SIZ, "There are %d coordinates for point %d != %d*%d", numCoords, point, pdim, cdim);
    1083:   if (v0) {for (d = 0; d < cdim; d++) v0[d] = PetscRealPart(coords[d]);}
    1084:   if (J) {
    1085:     for (q = 0; q < Nq; ++q) {
    1086:       PetscInt i, j, k, c, r;

    1088:       /* J = dx_i/d\xi_j = sum[k=0,n-1] dN_k/d\xi_j * x_i(k) */
    1089:       for (k = 0; k < pdim; ++k)
    1090:         for (j = 0; j < dim; ++j)
    1091:           for (i = 0; i < cdim; ++i)
    1092:             J[(q*cdim + i)*dim + j] += basisDer[(q*pdim + k)*dim + j] * PetscRealPart(coords[k*cdim + i]);
    1093:       PetscLogFlops(2.0*pdim*dim*cdim);
    1094:       if (cdim > dim) {
    1095:         for (c = dim; c < cdim; ++c)
    1096:           for (r = 0; r < cdim; ++r)
    1097:             J[r*cdim+c] = r == c ? 1.0 : 0.0;
    1098:       }
    1099:       switch (cdim) {
    1100:       case 3:
    1101:         DMPlex_Det3D_Internal(detJ, J);
    1102:         if (invJ) {DMPlex_Invert3D_Internal(invJ, J, *detJ);}
    1103:         break;
    1104:       case 2:
    1105:         DMPlex_Det2D_Internal(detJ, J);
    1106:         if (invJ) {DMPlex_Invert2D_Internal(invJ, J, *detJ);}
    1107:         break;
    1108:       case 1:
    1109:         *detJ = J[0];
    1110:         if (invJ) invJ[0] = 1.0/J[0];
    1111:       }
    1112:     }
    1113:   }
    1114:   DMPlexVecRestoreClosure(dm, coordSection, coordinates, point, &numCoords, &coords);
    1115:   return(0);
    1116: }

    1120: /*@C
    1121:   DMPlexComputeCellGeometryFEM - Compute the Jacobian, inverse Jacobian, and Jacobian determinant at each quadrature point in the given cell

    1123:   Collective on DM

    1125:   Input Arguments:
    1126: + dm   - the DM
    1127: . cell - the cell
    1128: - fe   - the finite element containing the quadrature

    1130:   Output Arguments:
    1131: + v0   - the translation part of this transform
    1132: . J    - the Jacobian of the transform from the reference element at each quadrature point
    1133: . invJ - the inverse of the Jacobian at each quadrature point
    1134: - detJ - the Jacobian determinant at each quadrature point

    1136:   Level: advanced

    1138:   Fortran Notes:
    1139:   Since it returns arrays, this routine is only available in Fortran 90, and you must
    1140:   include petsc.h90 in your code.

    1142: .seealso: DMGetCoordinateSection(), DMGetCoordinateVec()
    1143: @*/
    1144: PetscErrorCode DMPlexComputeCellGeometryFEM(DM dm, PetscInt cell, PetscFE fe, PetscReal *v0, PetscReal *J, PetscReal *invJ, PetscReal *detJ)
    1145: {

    1149:   if (!fe) {DMPlexComputeCellGeometryAffineFEM(dm, cell, v0, J, invJ, detJ);}
    1150:   else     {DMPlexComputeIsoparametricGeometry_Internal(dm, fe, cell, v0, J, invJ, detJ);}
    1151:   return(0);
    1152: }

    1156: static PetscErrorCode DMPlexComputeGeometryFVM_1D_Internal(DM dm, PetscInt dim, PetscInt cell, PetscReal *vol, PetscReal centroid[], PetscReal normal[])
    1157: {
    1158:   PetscSection   coordSection;
    1159:   Vec            coordinates;
    1160:   PetscScalar   *coords = NULL;
    1161:   PetscScalar    tmp[2];
    1162:   PetscInt       coordSize;

    1166:   DMGetCoordinatesLocal(dm, &coordinates);
    1167:   DMGetCoordinateSection(dm, &coordSection);
    1168:   DMPlexVecGetClosure(dm, coordSection, coordinates, cell, &coordSize, &coords);
    1169:   if (dim != 2) SETERRQ(PetscObjectComm((PetscObject)dm), PETSC_ERR_SUP, "We only support 2D edges right now");
    1170:   DMLocalizeCoordinate_Internal(dm, dim, coords, &coords[dim], tmp);
    1171:   if (centroid) {
    1172:     centroid[0] = 0.5*PetscRealPart(coords[0] + tmp[0]);
    1173:     centroid[1] = 0.5*PetscRealPart(coords[1] + tmp[1]);
    1174:   }
    1175:   if (normal) {
    1176:     PetscReal norm;

    1178:     normal[0]  = -PetscRealPart(coords[1] - tmp[1]);
    1179:     normal[1]  =  PetscRealPart(coords[0] - tmp[0]);
    1180:     norm       = PetscSqrtReal(normal[0]*normal[0] + normal[1]*normal[1]);
    1181:     normal[0] /= norm;
    1182:     normal[1] /= norm;
    1183:   }
    1184:   if (vol) {
    1185:     *vol = PetscSqrtReal(PetscSqr(PetscRealPart(coords[0] - tmp[0])) + PetscSqr(PetscRealPart(coords[1] - tmp[1])));
    1186:   }
    1187:   DMPlexVecRestoreClosure(dm, coordSection, coordinates, cell, &coordSize, &coords);
    1188:   return(0);
    1189: }

    1193: /* Centroid_i = (\sum_n A_n Cn_i ) / A */
    1194: static PetscErrorCode DMPlexComputeGeometryFVM_2D_Internal(DM dm, PetscInt dim, PetscInt cell, PetscReal *vol, PetscReal centroid[], PetscReal normal[])
    1195: {
    1196:   PetscSection   coordSection;
    1197:   Vec            coordinates;
    1198:   PetscScalar   *coords = NULL;
    1199:   PetscReal      vsum = 0.0, csum[3] = {0.0, 0.0, 0.0}, vtmp, ctmp[4], v0[3], R[9];
    1200:   PetscInt       tdim = 2, coordSize, numCorners, p, d, e;

    1204:   DMGetCoordinatesLocal(dm, &coordinates);
    1205:   DMPlexGetConeSize(dm, cell, &numCorners);
    1206:   DMGetCoordinateSection(dm, &coordSection);
    1207:   DMPlexVecGetClosure(dm, coordSection, coordinates, cell, &coordSize, &coords);
    1208:   DMGetCoordinateDim(dm, &dim);
    1209:   if (dim > 2 && centroid) {
    1210:     v0[0] = PetscRealPart(coords[0]);
    1211:     v0[1] = PetscRealPart(coords[1]);
    1212:     v0[2] = PetscRealPart(coords[2]);
    1213:   }
    1214:   if (normal) {
    1215:     if (dim > 2) {
    1216:       const PetscReal x0 = PetscRealPart(coords[dim+0] - coords[0]), x1 = PetscRealPart(coords[dim*2+0] - coords[0]);
    1217:       const PetscReal y0 = PetscRealPart(coords[dim+1] - coords[1]), y1 = PetscRealPart(coords[dim*2+1] - coords[1]);
    1218:       const PetscReal z0 = PetscRealPart(coords[dim+2] - coords[2]), z1 = PetscRealPart(coords[dim*2+2] - coords[2]);
    1219:       PetscReal       norm;

    1221:       normal[0] = y0*z1 - z0*y1;
    1222:       normal[1] = z0*x1 - x0*z1;
    1223:       normal[2] = x0*y1 - y0*x1;
    1224:       norm = PetscSqrtReal(normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2]);
    1225:       normal[0] /= norm;
    1226:       normal[1] /= norm;
    1227:       normal[2] /= norm;
    1228:     } else {
    1229:       for (d = 0; d < dim; ++d) normal[d] = 0.0;
    1230:     }
    1231:   }
    1232:   if (dim == 3) {DMPlexComputeProjection3Dto2D_Internal(coordSize, coords, R);}
    1233:   for (p = 0; p < numCorners; ++p) {
    1234:     /* Need to do this copy to get types right */
    1235:     for (d = 0; d < tdim; ++d) {
    1236:       ctmp[d]      = PetscRealPart(coords[p*tdim+d]);
    1237:       ctmp[tdim+d] = PetscRealPart(coords[((p+1)%numCorners)*tdim+d]);
    1238:     }
    1239:     Volume_Triangle_Origin_Internal(&vtmp, ctmp);
    1240:     vsum += vtmp;
    1241:     for (d = 0; d < tdim; ++d) {
    1242:       csum[d] += (ctmp[d] + ctmp[tdim+d])*vtmp;
    1243:     }
    1244:   }
    1245:   for (d = 0; d < tdim; ++d) {
    1246:     csum[d] /= (tdim+1)*vsum;
    1247:   }
    1248:   DMPlexVecRestoreClosure(dm, coordSection, coordinates, cell, &coordSize, &coords);
    1249:   if (vol) *vol = PetscAbsReal(vsum);
    1250:   if (centroid) {
    1251:     if (dim > 2) {
    1252:       for (d = 0; d < dim; ++d) {
    1253:         centroid[d] = v0[d];
    1254:         for (e = 0; e < dim; ++e) {
    1255:           centroid[d] += R[d*dim+e]*csum[e];
    1256:         }
    1257:       }
    1258:     } else for (d = 0; d < dim; ++d) centroid[d] = csum[d];
    1259:   }
    1260:   return(0);
    1261: }

    1265: /* Centroid_i = (\sum_n V_n Cn_i ) / V */
    1266: static PetscErrorCode DMPlexComputeGeometryFVM_3D_Internal(DM dm, PetscInt dim, PetscInt cell, PetscReal *vol, PetscReal centroid[], PetscReal normal[])
    1267: {
    1268:   PetscSection    coordSection;
    1269:   Vec             coordinates;
    1270:   PetscScalar    *coords = NULL;
    1271:   PetscReal       vsum = 0.0, vtmp, coordsTmp[3*3];
    1272:   const PetscInt *faces, *facesO;
    1273:   PetscInt        numFaces, f, coordSize, numCorners, p, d;
    1274:   PetscErrorCode  ierr;

    1277:   if (PetscUnlikely(dim > 3)) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"No support for dim %D > 3",dim);
    1278:   DMGetCoordinatesLocal(dm, &coordinates);
    1279:   DMGetCoordinateSection(dm, &coordSection);

    1281:   if (centroid) for (d = 0; d < dim; ++d) centroid[d] = 0.0;
    1282:   DMPlexGetConeSize(dm, cell, &numFaces);
    1283:   DMPlexGetCone(dm, cell, &faces);
    1284:   DMPlexGetConeOrientation(dm, cell, &facesO);
    1285:   for (f = 0; f < numFaces; ++f) {
    1286:     DMPlexVecGetClosure(dm, coordSection, coordinates, faces[f], &coordSize, &coords);
    1287:     numCorners = coordSize/dim;
    1288:     switch (numCorners) {
    1289:     case 3:
    1290:       for (d = 0; d < dim; ++d) {
    1291:         coordsTmp[0*dim+d] = PetscRealPart(coords[0*dim+d]);
    1292:         coordsTmp[1*dim+d] = PetscRealPart(coords[1*dim+d]);
    1293:         coordsTmp[2*dim+d] = PetscRealPart(coords[2*dim+d]);
    1294:       }
    1295:       Volume_Tetrahedron_Origin_Internal(&vtmp, coordsTmp);
    1296:       if (facesO[f] < 0) vtmp = -vtmp;
    1297:       vsum += vtmp;
    1298:       if (centroid) {           /* Centroid of OABC = (a+b+c)/4 */
    1299:         for (d = 0; d < dim; ++d) {
    1300:           for (p = 0; p < 3; ++p) centroid[d] += coordsTmp[p*dim+d]*vtmp;
    1301:         }
    1302:       }
    1303:       break;
    1304:     case 4:
    1305:       /* DO FOR PYRAMID */
    1306:       /* First tet */
    1307:       for (d = 0; d < dim; ++d) {
    1308:         coordsTmp[0*dim+d] = PetscRealPart(coords[0*dim+d]);
    1309:         coordsTmp[1*dim+d] = PetscRealPart(coords[1*dim+d]);
    1310:         coordsTmp[2*dim+d] = PetscRealPart(coords[3*dim+d]);
    1311:       }
    1312:       Volume_Tetrahedron_Origin_Internal(&vtmp, coordsTmp);
    1313:       if (facesO[f] < 0) vtmp = -vtmp;
    1314:       vsum += vtmp;
    1315:       if (centroid) {
    1316:         for (d = 0; d < dim; ++d) {
    1317:           for (p = 0; p < 3; ++p) centroid[d] += coordsTmp[p*dim+d]*vtmp;
    1318:         }
    1319:       }
    1320:       /* Second tet */
    1321:       for (d = 0; d < dim; ++d) {
    1322:         coordsTmp[0*dim+d] = PetscRealPart(coords[1*dim+d]);
    1323:         coordsTmp[1*dim+d] = PetscRealPart(coords[2*dim+d]);
    1324:         coordsTmp[2*dim+d] = PetscRealPart(coords[3*dim+d]);
    1325:       }
    1326:       Volume_Tetrahedron_Origin_Internal(&vtmp, coordsTmp);
    1327:       if (facesO[f] < 0) vtmp = -vtmp;
    1328:       vsum += vtmp;
    1329:       if (centroid) {
    1330:         for (d = 0; d < dim; ++d) {
    1331:           for (p = 0; p < 3; ++p) centroid[d] += coordsTmp[p*dim+d]*vtmp;
    1332:         }
    1333:       }
    1334:       break;
    1335:     default:
    1336:       SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Cannot handle faces with %D vertices", numCorners);
    1337:     }
    1338:     DMPlexVecRestoreClosure(dm, coordSection, coordinates, faces[f], &coordSize, &coords);
    1339:   }
    1340:   if (vol)     *vol = PetscAbsReal(vsum);
    1341:   if (normal)   for (d = 0; d < dim; ++d) normal[d]    = 0.0;
    1342:   if (centroid) for (d = 0; d < dim; ++d) centroid[d] /= (vsum*4);
    1343:   return(0);
    1344: }

    1348: /*@C
    1349:   DMPlexComputeCellGeometryFVM - Compute the volume for a given cell

    1351:   Collective on DM

    1353:   Input Arguments:
    1354: + dm   - the DM
    1355: - cell - the cell

    1357:   Output Arguments:
    1358: + volume   - the cell volume
    1359: . centroid - the cell centroid
    1360: - normal - the cell normal, if appropriate

    1362:   Level: advanced

    1364:   Fortran Notes:
    1365:   Since it returns arrays, this routine is only available in Fortran 90, and you must
    1366:   include petsc.h90 in your code.

    1368: .seealso: DMGetCoordinateSection(), DMGetCoordinateVec()
    1369: @*/
    1370: PetscErrorCode DMPlexComputeCellGeometryFVM(DM dm, PetscInt cell, PetscReal *vol, PetscReal centroid[], PetscReal normal[])
    1371: {
    1372:   PetscInt       depth, dim;

    1376:   DMPlexGetDepth(dm, &depth);
    1377:   DMGetDimension(dm, &dim);
    1378:   if (depth != dim) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Mesh must be interpolated");
    1379:   /* We need to keep a pointer to the depth label */
    1380:   DMGetLabelValue(dm, "depth", cell, &depth);
    1381:   /* Cone size is now the number of faces */
    1382:   switch (depth) {
    1383:   case 1:
    1384:     DMPlexComputeGeometryFVM_1D_Internal(dm, dim, cell, vol, centroid, normal);
    1385:     break;
    1386:   case 2:
    1387:     DMPlexComputeGeometryFVM_2D_Internal(dm, dim, cell, vol, centroid, normal);
    1388:     break;
    1389:   case 3:
    1390:     DMPlexComputeGeometryFVM_3D_Internal(dm, dim, cell, vol, centroid, normal);
    1391:     break;
    1392:   default:
    1393:     SETERRQ1(PetscObjectComm((PetscObject)dm), PETSC_ERR_SUP, "Unsupported dimension %D for element geometry computation", dim);
    1394:   }
    1395:   return(0);
    1396: }

    1400: /* This should also take a PetscFE argument I think */
    1401: PetscErrorCode DMPlexComputeGeometryFEM(DM dm, Vec *cellgeom)
    1402: {
    1403:   DM             dmCell;
    1404:   Vec            coordinates;
    1405:   PetscSection   coordSection, sectionCell;
    1406:   PetscScalar   *cgeom;
    1407:   PetscInt       cStart, cEnd, cMax, c;

    1411:   DMClone(dm, &dmCell);
    1412:   DMGetCoordinateSection(dm, &coordSection);
    1413:   DMGetCoordinatesLocal(dm, &coordinates);
    1414:   DMSetCoordinateSection(dmCell, PETSC_DETERMINE, coordSection);
    1415:   DMSetCoordinatesLocal(dmCell, coordinates);
    1416:   PetscSectionCreate(PetscObjectComm((PetscObject) dm), &sectionCell);
    1417:   DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);
    1418:   DMPlexGetHybridBounds(dm, &cMax, NULL, NULL, NULL);
    1419:   cEnd = cMax < 0 ? cEnd : cMax;
    1420:   PetscSectionSetChart(sectionCell, cStart, cEnd);
    1421:   /* TODO This needs to be multiplied by Nq for non-affine */
    1422:   for (c = cStart; c < cEnd; ++c) {PetscSectionSetDof(sectionCell, c, (PetscInt) PetscCeilReal(((PetscReal) sizeof(PetscFECellGeom))/sizeof(PetscScalar)));}
    1423:   PetscSectionSetUp(sectionCell);
    1424:   DMSetDefaultSection(dmCell, sectionCell);
    1425:   PetscSectionDestroy(&sectionCell);
    1426:   DMCreateLocalVector(dmCell, cellgeom);
    1427:   VecGetArray(*cellgeom, &cgeom);
    1428:   for (c = cStart; c < cEnd; ++c) {
    1429:     PetscFECellGeom *cg;

    1431:     DMPlexPointLocalRef(dmCell, c, cgeom, &cg);
    1432:     PetscMemzero(cg, sizeof(*cg));
    1433:     DMPlexComputeCellGeometryFEM(dmCell, c, NULL, cg->v0, cg->J, cg->invJ, &cg->detJ);
    1434:     if (cg->detJ <= 0.0) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Invalid determinant %g for element %d", cg->detJ, c);
    1435:   }
    1436:   VecRestoreArray(*cellgeom, &cgeom);
    1437:   DMDestroy(&dmCell);
    1438:   return(0);
    1439: }

    1443: /*@
    1444:   DMPlexComputeGeometryFVM - Computes the cell and face geometry for a finite volume method

    1446:   Input Parameter:
    1447: . dm - The DM

    1449:   Output Parameters:
    1450: + cellgeom - A Vec of PetscFVCellGeom data
    1451: . facegeom - A Vec of PetscFVFaceGeom data

    1453:   Level: developer

    1455: .seealso: PetscFVFaceGeom, PetscFVCellGeom, DMPlexComputeGeometryFEM()
    1456: @*/
    1457: PetscErrorCode DMPlexComputeGeometryFVM(DM dm, Vec *cellgeom, Vec *facegeom)
    1458: {
    1459:   DM             dmFace, dmCell;
    1460:   DMLabel        ghostLabel;
    1461:   PetscSection   sectionFace, sectionCell;
    1462:   PetscSection   coordSection;
    1463:   Vec            coordinates;
    1464:   PetscScalar   *fgeom, *cgeom;
    1465:   PetscReal      minradius, gminradius;
    1466:   PetscInt       dim, cStart, cEnd, cEndInterior, c, fStart, fEnd, f;

    1470:   DMGetDimension(dm, &dim);
    1471:   DMGetCoordinateSection(dm, &coordSection);
    1472:   DMGetCoordinatesLocal(dm, &coordinates);
    1473:   /* Make cell centroids and volumes */
    1474:   DMClone(dm, &dmCell);
    1475:   DMSetCoordinateSection(dmCell, PETSC_DETERMINE, coordSection);
    1476:   DMSetCoordinatesLocal(dmCell, coordinates);
    1477:   PetscSectionCreate(PetscObjectComm((PetscObject) dm), &sectionCell);
    1478:   DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);
    1479:   DMPlexGetHybridBounds(dm, &cEndInterior, NULL, NULL, NULL);
    1480:   PetscSectionSetChart(sectionCell, cStart, cEnd);
    1481:   for (c = cStart; c < cEnd; ++c) {PetscSectionSetDof(sectionCell, c, (PetscInt) PetscCeilReal(((PetscReal) sizeof(PetscFVCellGeom))/sizeof(PetscScalar)));}
    1482:   PetscSectionSetUp(sectionCell);
    1483:   DMSetDefaultSection(dmCell, sectionCell);
    1484:   PetscSectionDestroy(&sectionCell);
    1485:   DMCreateLocalVector(dmCell, cellgeom);
    1486:   if (cEndInterior < 0) {
    1487:     cEndInterior = cEnd;
    1488:   }
    1489:   VecGetArray(*cellgeom, &cgeom);
    1490:   for (c = cStart; c < cEndInterior; ++c) {
    1491:     PetscFVCellGeom *cg;

    1493:     DMPlexPointLocalRef(dmCell, c, cgeom, &cg);
    1494:     PetscMemzero(cg, sizeof(*cg));
    1495:     DMPlexComputeCellGeometryFVM(dmCell, c, &cg->volume, cg->centroid, NULL);
    1496:   }
    1497:   /* Compute face normals and minimum cell radius */
    1498:   DMClone(dm, &dmFace);
    1499:   PetscSectionCreate(PetscObjectComm((PetscObject) dm), &sectionFace);
    1500:   DMPlexGetHeightStratum(dm, 1, &fStart, &fEnd);
    1501:   PetscSectionSetChart(sectionFace, fStart, fEnd);
    1502:   for (f = fStart; f < fEnd; ++f) {PetscSectionSetDof(sectionFace, f, (PetscInt) PetscCeilReal(((PetscReal) sizeof(PetscFVFaceGeom))/sizeof(PetscScalar)));}
    1503:   PetscSectionSetUp(sectionFace);
    1504:   DMSetDefaultSection(dmFace, sectionFace);
    1505:   PetscSectionDestroy(&sectionFace);
    1506:   DMCreateLocalVector(dmFace, facegeom);
    1507:   VecGetArray(*facegeom, &fgeom);
    1508:   DMGetLabel(dm, "ghost", &ghostLabel);
    1509:   minradius = PETSC_MAX_REAL;
    1510:   for (f = fStart; f < fEnd; ++f) {
    1511:     PetscFVFaceGeom *fg;
    1512:     PetscReal        area;
    1513:     PetscInt         ghost = -1, d, numChildren;

    1515:     if (ghostLabel) {DMLabelGetValue(ghostLabel, f, &ghost);}
    1516:     DMPlexGetTreeChildren(dm,f,&numChildren,NULL);
    1517:     if (ghost >= 0 || numChildren) continue;
    1518:     DMPlexPointLocalRef(dmFace, f, fgeom, &fg);
    1519:     DMPlexComputeCellGeometryFVM(dm, f, &area, fg->centroid, fg->normal);
    1520:     for (d = 0; d < dim; ++d) fg->normal[d] *= area;
    1521:     /* Flip face orientation if necessary to match ordering in support, and Update minimum radius */
    1522:     {
    1523:       PetscFVCellGeom *cL, *cR;
    1524:       PetscInt         ncells;
    1525:       const PetscInt  *cells;
    1526:       PetscReal       *lcentroid, *rcentroid;
    1527:       PetscReal        l[3], r[3], v[3];

    1529:       DMPlexGetSupport(dm, f, &cells);
    1530:       DMPlexGetSupportSize(dm, f, &ncells);
    1531:       DMPlexPointLocalRead(dmCell, cells[0], cgeom, &cL);
    1532:       lcentroid = cells[0] >= cEndInterior ? fg->centroid : cL->centroid;
    1533:       if (ncells > 1) {
    1534:         DMPlexPointLocalRead(dmCell, cells[1], cgeom, &cR);
    1535:         rcentroid = cells[1] >= cEndInterior ? fg->centroid : cR->centroid;
    1536:       }
    1537:       else {
    1538:         rcentroid = fg->centroid;
    1539:       }
    1540:       DMLocalizeCoordinateReal_Internal(dm, dim, fg->centroid, lcentroid, l);
    1541:       DMLocalizeCoordinateReal_Internal(dm, dim, fg->centroid, rcentroid, r);
    1542:       DMPlex_WaxpyD_Internal(dim, -1, l, r, v);
    1543:       if (DMPlex_DotRealD_Internal(dim, fg->normal, v) < 0) {
    1544:         for (d = 0; d < dim; ++d) fg->normal[d] = -fg->normal[d];
    1545:       }
    1546:       if (DMPlex_DotRealD_Internal(dim, fg->normal, v) <= 0) {
    1547:         if (dim == 2) SETERRQ5(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Direction for face %d could not be fixed, normal (%g,%g) v (%g,%g)", f, (double) fg->normal[0], (double) fg->normal[1], (double) v[0], (double) v[1]);
    1548:         if (dim == 3) SETERRQ7(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Direction for face %d could not be fixed, normal (%g,%g,%g) v (%g,%g,%g)", f, (double) fg->normal[0], (double) fg->normal[1], (double) fg->normal[2], (double) v[0], (double) v[1], (double) v[2]);
    1549:         SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Direction for face %d could not be fixed", f);
    1550:       }
    1551:       if (cells[0] < cEndInterior) {
    1552:         DMPlex_WaxpyD_Internal(dim, -1, fg->centroid, cL->centroid, v);
    1553:         minradius = PetscMin(minradius, DMPlex_NormD_Internal(dim, v));
    1554:       }
    1555:       if (ncells > 1 && cells[1] < cEndInterior) {
    1556:         DMPlex_WaxpyD_Internal(dim, -1, fg->centroid, cR->centroid, v);
    1557:         minradius = PetscMin(minradius, DMPlex_NormD_Internal(dim, v));
    1558:       }
    1559:     }
    1560:   }
    1561:   MPIU_Allreduce(&minradius, &gminradius, 1, MPIU_REAL, MPIU_MIN, PetscObjectComm((PetscObject)dm));
    1562:   DMPlexSetMinRadius(dm, gminradius);
    1563:   /* Compute centroids of ghost cells */
    1564:   for (c = cEndInterior; c < cEnd; ++c) {
    1565:     PetscFVFaceGeom *fg;
    1566:     const PetscInt  *cone,    *support;
    1567:     PetscInt         coneSize, supportSize, s;

    1569:     DMPlexGetConeSize(dmCell, c, &coneSize);
    1570:     if (coneSize != 1) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Ghost cell %d has cone size %d != 1", c, coneSize);
    1571:     DMPlexGetCone(dmCell, c, &cone);
    1572:     DMPlexGetSupportSize(dmCell, cone[0], &supportSize);
    1573:     if (supportSize != 2) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Face %d has support size %d != 2", cone[0], supportSize);
    1574:     DMPlexGetSupport(dmCell, cone[0], &support);
    1575:     DMPlexPointLocalRef(dmFace, cone[0], fgeom, &fg);
    1576:     for (s = 0; s < 2; ++s) {
    1577:       /* Reflect ghost centroid across plane of face */
    1578:       if (support[s] == c) {
    1579:         PetscFVCellGeom       *ci;
    1580:         PetscFVCellGeom       *cg;
    1581:         PetscReal              c2f[3], a;

    1583:         DMPlexPointLocalRead(dmCell, support[(s+1)%2], cgeom, &ci);
    1584:         DMPlex_WaxpyD_Internal(dim, -1, ci->centroid, fg->centroid, c2f); /* cell to face centroid */
    1585:         a    = DMPlex_DotRealD_Internal(dim, c2f, fg->normal)/DMPlex_DotRealD_Internal(dim, fg->normal, fg->normal);
    1586:         DMPlexPointLocalRef(dmCell, support[s], cgeom, &cg);
    1587:         DMPlex_WaxpyD_Internal(dim, 2*a, fg->normal, ci->centroid, cg->centroid);
    1588:         cg->volume = ci->volume;
    1589:       }
    1590:     }
    1591:   }
    1592:   VecRestoreArray(*facegeom, &fgeom);
    1593:   VecRestoreArray(*cellgeom, &cgeom);
    1594:   DMDestroy(&dmCell);
    1595:   DMDestroy(&dmFace);
    1596:   return(0);
    1597: }

    1601: /*@C
    1602:   DMPlexGetMinRadius - Returns the minimum distance from any cell centroid to a face

    1604:   Not collective

    1606:   Input Argument:
    1607: . dm - the DM

    1609:   Output Argument:
    1610: . minradius - the minium cell radius

    1612:   Level: developer

    1614: .seealso: DMGetCoordinates()
    1615: @*/
    1616: PetscErrorCode DMPlexGetMinRadius(DM dm, PetscReal *minradius)
    1617: {
    1621:   *minradius = ((DM_Plex*) dm->data)->minradius;
    1622:   return(0);
    1623: }

    1627: /*@C
    1628:   DMPlexSetMinRadius - Sets the minimum distance from the cell centroid to a face

    1630:   Logically collective

    1632:   Input Arguments:
    1633: + dm - the DM
    1634: - minradius - the minium cell radius

    1636:   Level: developer

    1638: .seealso: DMSetCoordinates()
    1639: @*/
    1640: PetscErrorCode DMPlexSetMinRadius(DM dm, PetscReal minradius)
    1641: {
    1644:   ((DM_Plex*) dm->data)->minradius = minradius;
    1645:   return(0);
    1646: }

    1650: static PetscErrorCode BuildGradientReconstruction_Internal(DM dm, PetscFV fvm, DM dmFace, PetscScalar *fgeom, DM dmCell, PetscScalar *cgeom)
    1651: {
    1652:   DMLabel        ghostLabel;
    1653:   PetscScalar   *dx, *grad, **gref;
    1654:   PetscInt       dim, cStart, cEnd, c, cEndInterior, maxNumFaces;

    1658:   DMGetDimension(dm, &dim);
    1659:   DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);
    1660:   DMPlexGetHybridBounds(dm, &cEndInterior, NULL, NULL, NULL);
    1661:   DMPlexGetMaxSizes(dm, &maxNumFaces, NULL);
    1662:   PetscFVLeastSquaresSetMaxFaces(fvm, maxNumFaces);
    1663:   DMGetLabel(dm, "ghost", &ghostLabel);
    1664:   PetscMalloc3(maxNumFaces*dim, &dx, maxNumFaces*dim, &grad, maxNumFaces, &gref);
    1665:   for (c = cStart; c < cEndInterior; c++) {
    1666:     const PetscInt        *faces;
    1667:     PetscInt               numFaces, usedFaces, f, d;
    1668:     PetscFVCellGeom        *cg;
    1669:     PetscBool              boundary;
    1670:     PetscInt               ghost;

    1672:     DMPlexPointLocalRead(dmCell, c, cgeom, &cg);
    1673:     DMPlexGetConeSize(dm, c, &numFaces);
    1674:     DMPlexGetCone(dm, c, &faces);
    1675:     if (numFaces < dim) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_INCOMP,"Cell %D has only %D faces, not enough for gradient reconstruction", c, numFaces);
    1676:     for (f = 0, usedFaces = 0; f < numFaces; ++f) {
    1677:       PetscFVCellGeom       *cg1;
    1678:       PetscFVFaceGeom       *fg;
    1679:       const PetscInt        *fcells;
    1680:       PetscInt               ncell, side;

    1682:       DMLabelGetValue(ghostLabel, faces[f], &ghost);
    1683:       DMIsBoundaryPoint(dm, faces[f], &boundary);
    1684:       if ((ghost >= 0) || boundary) continue;
    1685:       DMPlexGetSupport(dm, faces[f], &fcells);
    1686:       side  = (c != fcells[0]); /* c is on left=0 or right=1 of face */
    1687:       ncell = fcells[!side];    /* the neighbor */
    1688:       DMPlexPointLocalRef(dmFace, faces[f], fgeom, &fg);
    1689:       DMPlexPointLocalRead(dmCell, ncell, cgeom, &cg1);
    1690:       for (d = 0; d < dim; ++d) dx[usedFaces*dim+d] = cg1->centroid[d] - cg->centroid[d];
    1691:       gref[usedFaces++] = fg->grad[side];  /* Gradient reconstruction term will go here */
    1692:     }
    1693:     if (!usedFaces) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_USER, "Mesh contains isolated cell (no neighbors). Is it intentional?");
    1694:     PetscFVComputeGradient(fvm, usedFaces, dx, grad);
    1695:     for (f = 0, usedFaces = 0; f < numFaces; ++f) {
    1696:       DMLabelGetValue(ghostLabel, faces[f], &ghost);
    1697:       DMIsBoundaryPoint(dm, faces[f], &boundary);
    1698:       if ((ghost >= 0) || boundary) continue;
    1699:       for (d = 0; d < dim; ++d) gref[usedFaces][d] = grad[usedFaces*dim+d];
    1700:       ++usedFaces;
    1701:     }
    1702:   }
    1703:   PetscFree3(dx, grad, gref);
    1704:   return(0);
    1705: }

    1709: static PetscErrorCode BuildGradientReconstruction_Internal_Tree(DM dm, PetscFV fvm, DM dmFace, PetscScalar *fgeom, DM dmCell, PetscScalar *cgeom)
    1710: {
    1711:   DMLabel        ghostLabel;
    1712:   PetscScalar   *dx, *grad, **gref;
    1713:   PetscInt       dim, cStart, cEnd, c, cEndInterior, fStart, fEnd, f, nStart, nEnd, maxNumFaces = 0;
    1714:   PetscSection   neighSec;
    1715:   PetscInt     (*neighbors)[2];
    1716:   PetscInt      *counter;

    1720:   DMGetDimension(dm, &dim);
    1721:   DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);
    1722:   DMPlexGetHybridBounds(dm, &cEndInterior, NULL, NULL, NULL);
    1723:   if (cEndInterior < 0) {
    1724:     cEndInterior = cEnd;
    1725:   }
    1726:   PetscSectionCreate(PetscObjectComm((PetscObject)dm),&neighSec);
    1727:   PetscSectionSetChart(neighSec,cStart,cEndInterior);
    1728:   DMPlexGetHeightStratum(dm, 1, &fStart, &fEnd);
    1729:   DMGetLabel(dm, "ghost", &ghostLabel);
    1730:   for (f = fStart; f < fEnd; f++) {
    1731:     const PetscInt        *fcells;
    1732:     PetscBool              boundary;
    1733:     PetscInt               ghost = -1;
    1734:     PetscInt               numChildren, numCells, c;

    1736:     if (ghostLabel) {DMLabelGetValue(ghostLabel, f, &ghost);}
    1737:     DMIsBoundaryPoint(dm, f, &boundary);
    1738:     DMPlexGetTreeChildren(dm, f, &numChildren, NULL);
    1739:     if ((ghost >= 0) || boundary || numChildren) continue;
    1740:     DMPlexGetSupportSize(dm, f, &numCells);
    1741:     if (numCells == 2) {
    1742:       DMPlexGetSupport(dm, f, &fcells);
    1743:       for (c = 0; c < 2; c++) {
    1744:         PetscInt cell = fcells[c];

    1746:         if (cell >= cStart && cell < cEndInterior) {
    1747:           PetscSectionAddDof(neighSec,cell,1);
    1748:         }
    1749:       }
    1750:     }
    1751:   }
    1752:   PetscSectionSetUp(neighSec);
    1753:   PetscSectionGetMaxDof(neighSec,&maxNumFaces);
    1754:   PetscFVLeastSquaresSetMaxFaces(fvm, maxNumFaces);
    1755:   nStart = 0;
    1756:   PetscSectionGetStorageSize(neighSec,&nEnd);
    1757:   PetscMalloc1((nEnd-nStart),&neighbors);
    1758:   PetscCalloc1((cEndInterior-cStart),&counter);
    1759:   for (f = fStart; f < fEnd; f++) {
    1760:     const PetscInt        *fcells;
    1761:     PetscBool              boundary;
    1762:     PetscInt               ghost = -1;
    1763:     PetscInt               numChildren, numCells, c;

    1765:     if (ghostLabel) {DMLabelGetValue(ghostLabel, f, &ghost);}
    1766:     DMIsBoundaryPoint(dm, f, &boundary);
    1767:     DMPlexGetTreeChildren(dm, f, &numChildren, NULL);
    1768:     if ((ghost >= 0) || boundary || numChildren) continue;
    1769:     DMPlexGetSupportSize(dm, f, &numCells);
    1770:     if (numCells == 2) {
    1771:       DMPlexGetSupport(dm, f, &fcells);
    1772:       for (c = 0; c < 2; c++) {
    1773:         PetscInt cell = fcells[c], off;

    1775:         if (cell >= cStart && cell < cEndInterior) {
    1776:           PetscSectionGetOffset(neighSec,cell,&off);
    1777:           off += counter[cell - cStart]++;
    1778:           neighbors[off][0] = f;
    1779:           neighbors[off][1] = fcells[1 - c];
    1780:         }
    1781:       }
    1782:     }
    1783:   }
    1784:   PetscFree(counter);
    1785:   PetscMalloc3(maxNumFaces*dim, &dx, maxNumFaces*dim, &grad, maxNumFaces, &gref);
    1786:   for (c = cStart; c < cEndInterior; c++) {
    1787:     PetscInt               numFaces, f, d, off, ghost = -1;
    1788:     PetscFVCellGeom        *cg;

    1790:     DMPlexPointLocalRead(dmCell, c, cgeom, &cg);
    1791:     PetscSectionGetDof(neighSec, c, &numFaces);
    1792:     PetscSectionGetOffset(neighSec, c, &off);
    1793:     if (ghostLabel) {DMLabelGetValue(ghostLabel, c, &ghost);}
    1794:     if (ghost < 0 && numFaces < dim) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_INCOMP,"Cell %D has only %D faces, not enough for gradient reconstruction", c, numFaces);
    1795:     for (f = 0; f < numFaces; ++f) {
    1796:       PetscFVCellGeom       *cg1;
    1797:       PetscFVFaceGeom       *fg;
    1798:       const PetscInt        *fcells;
    1799:       PetscInt               ncell, side, nface;

    1801:       nface = neighbors[off + f][0];
    1802:       ncell = neighbors[off + f][1];
    1803:       DMPlexGetSupport(dm,nface,&fcells);
    1804:       side  = (c != fcells[0]);
    1805:       DMPlexPointLocalRef(dmFace, nface, fgeom, &fg);
    1806:       DMPlexPointLocalRead(dmCell, ncell, cgeom, &cg1);
    1807:       for (d = 0; d < dim; ++d) dx[f*dim+d] = cg1->centroid[d] - cg->centroid[d];
    1808:       gref[f] = fg->grad[side];  /* Gradient reconstruction term will go here */
    1809:     }
    1810:     PetscFVComputeGradient(fvm, numFaces, dx, grad);
    1811:     for (f = 0; f < numFaces; ++f) {
    1812:       for (d = 0; d < dim; ++d) gref[f][d] = grad[f*dim+d];
    1813:     }
    1814:   }
    1815:   PetscFree3(dx, grad, gref);
    1816:   PetscSectionDestroy(&neighSec);
    1817:   PetscFree(neighbors);
    1818:   return(0);
    1819: }

    1823: /*@
    1824:   DMPlexComputeGradientFVM - Compute geometric factors for gradient reconstruction, which are stored in the geometry data, and compute layout for gradient data

    1826:   Collective on DM

    1828:   Input Arguments:
    1829: + dm  - The DM
    1830: . fvm - The PetscFV
    1831: . faceGeometry - The face geometry from DMPlexGetFaceGeometryFVM()
    1832: - cellGeometry - The face geometry from DMPlexGetCellGeometryFVM()

    1834:   Output Parameters:
    1835: + faceGeometry - The geometric factors for gradient calculation are inserted
    1836: - dmGrad - The DM describing the layout of gradient data

    1838:   Level: developer

    1840: .seealso: DMPlexGetFaceGeometryFVM(), DMPlexGetCellGeometryFVM()
    1841: @*/
    1842: PetscErrorCode DMPlexComputeGradientFVM(DM dm, PetscFV fvm, Vec faceGeometry, Vec cellGeometry, DM *dmGrad)
    1843: {
    1844:   DM             dmFace, dmCell;
    1845:   PetscScalar   *fgeom, *cgeom;
    1846:   PetscSection   sectionGrad, parentSection;
    1847:   PetscInt       dim, pdim, cStart, cEnd, cEndInterior, c;

    1851:   DMGetDimension(dm, &dim);
    1852:   PetscFVGetNumComponents(fvm, &pdim);
    1853:   DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);
    1854:   DMPlexGetHybridBounds(dm, &cEndInterior, NULL, NULL, NULL);
    1855:   /* Construct the interpolant corresponding to each face from the least-square solution over the cell neighborhood */
    1856:   VecGetDM(faceGeometry, &dmFace);
    1857:   VecGetDM(cellGeometry, &dmCell);
    1858:   VecGetArray(faceGeometry, &fgeom);
    1859:   VecGetArray(cellGeometry, &cgeom);
    1860:   DMPlexGetTree(dm,&parentSection,NULL,NULL,NULL,NULL);
    1861:   if (!parentSection) {
    1862:     BuildGradientReconstruction_Internal(dm, fvm, dmFace, fgeom, dmCell, cgeom);
    1863:   }
    1864:   else {
    1865:     BuildGradientReconstruction_Internal_Tree(dm, fvm, dmFace, fgeom, dmCell, cgeom);
    1866:   }
    1867:   VecRestoreArray(faceGeometry, &fgeom);
    1868:   VecRestoreArray(cellGeometry, &cgeom);
    1869:   /* Create storage for gradients */
    1870:   DMClone(dm, dmGrad);
    1871:   PetscSectionCreate(PetscObjectComm((PetscObject) dm), &sectionGrad);
    1872:   PetscSectionSetChart(sectionGrad, cStart, cEnd);
    1873:   for (c = cStart; c < cEnd; ++c) {PetscSectionSetDof(sectionGrad, c, pdim*dim);}
    1874:   PetscSectionSetUp(sectionGrad);
    1875:   DMSetDefaultSection(*dmGrad, sectionGrad);
    1876:   PetscSectionDestroy(&sectionGrad);
    1877:   return(0);
    1878: }