Actual source code: plexcreate.c

petsc-3.11.2 2019-05-18
Report Typos and Errors
  1: #define PETSCDM_DLL
  2:  #include <petsc/private/dmpleximpl.h>
  3:  #include <petsc/private/hashseti.h>
  4:  #include <petscsf.h>

  6: /*@
  7:   DMPlexCreateDoublet - Creates a mesh of two cells of the specified type, optionally with later refinement.

  9:   Collective on MPI_Comm

 11:   Input Parameters:
 12: + comm - The communicator for the DM object
 13: . dim - The spatial dimension
 14: . simplex - Flag for simplicial cells, otherwise they are tensor product cells
 15: . interpolate - Flag to create intermediate mesh pieces (edges, faces)
 16: . refinementUniform - Flag for uniform parallel refinement
 17: - refinementLimit - A nonzero number indicates the largest admissible volume for a refined cell

 19:   Output Parameter:
 20: . dm - The DM object

 22:   Level: beginner

 24: .keywords: DM, create
 25: .seealso: DMSetType(), DMCreate()
 26: @*/
 27: PetscErrorCode DMPlexCreateDoublet(MPI_Comm comm, PetscInt dim, PetscBool simplex, PetscBool interpolate, PetscBool refinementUniform, PetscReal refinementLimit, DM *newdm)
 28: {
 29:   DM             dm;
 30:   PetscInt       p;
 31:   PetscMPIInt    rank;

 35:   DMCreate(comm, &dm);
 36:   DMSetType(dm, DMPLEX);
 37:   DMSetDimension(dm, dim);
 38:   MPI_Comm_rank(comm, &rank);
 39:   switch (dim) {
 40:   case 2:
 41:     if (simplex) {PetscObjectSetName((PetscObject) dm, "triangular");}
 42:     else         {PetscObjectSetName((PetscObject) dm, "quadrilateral");}
 43:     break;
 44:   case 3:
 45:     if (simplex) {PetscObjectSetName((PetscObject) dm, "tetrahedral");}
 46:     else         {PetscObjectSetName((PetscObject) dm, "hexahedral");}
 47:     break;
 48:   default:
 49:     SETERRQ1(comm, PETSC_ERR_ARG_OUTOFRANGE, "Cannot make meshes for dimension %d", dim);
 50:   }
 51:   if (rank) {
 52:     PetscInt numPoints[2] = {0, 0};
 53:     DMPlexCreateFromDAG(dm, 1, numPoints, NULL, NULL, NULL, NULL);
 54:   } else {
 55:     switch (dim) {
 56:     case 2:
 57:       if (simplex) {
 58:         PetscInt    numPoints[2]        = {4, 2};
 59:         PetscInt    coneSize[6]         = {3, 3, 0, 0, 0, 0};
 60:         PetscInt    cones[6]            = {2, 3, 4,  5, 4, 3};
 61:         PetscInt    coneOrientations[6] = {0, 0, 0,  0, 0, 0};
 62:         PetscScalar vertexCoords[8]     = {-0.5, 0.5, 0.0, 0.0, 0.0, 1.0, 0.5, 0.5};
 63:         PetscInt    markerPoints[8]     = {2, 1, 3, 1, 4, 1, 5, 1};

 65:         DMPlexCreateFromDAG(dm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
 66:         for (p = 0; p < 4; ++p) {DMSetLabelValue(dm, "marker", markerPoints[p*2], markerPoints[p*2+1]);}
 67:       } else {
 68:         PetscInt    numPoints[2]        = {6, 2};
 69:         PetscInt    coneSize[8]         = {4, 4, 0, 0, 0, 0, 0, 0};
 70:         PetscInt    cones[8]            = {2, 3, 4, 5,  3, 6, 7, 4};
 71:         PetscInt    coneOrientations[8] = {0, 0, 0, 0,  0, 0, 0, 0};
 72:         PetscScalar vertexCoords[12]    = {-1.0, -0.5,  0.0, -0.5,  0.0, 0.5,  -1.0, 0.5,  1.0, -0.5,  1.0, 0.5};

 74:         DMPlexCreateFromDAG(dm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
 75:       }
 76:       break;
 77:     case 3:
 78:       if (simplex) {
 79:         PetscInt    numPoints[2]        = {5, 2};
 80:         PetscInt    coneSize[7]         = {4, 4, 0, 0, 0, 0, 0};
 81:         PetscInt    cones[8]            = {4, 3, 5, 2,  5, 3, 4, 6};
 82:         PetscInt    coneOrientations[8] = {0, 0, 0, 0,  0, 0, 0, 0};
 83:         PetscScalar vertexCoords[15]    = {-1.0, 0.0, 0.0,  0.0, -1.0, 0.0,  0.0, 0.0, 1.0,  0.0, 1.0, 0.0,  1.0, 0.0, 0.0};
 84:         PetscInt    markerPoints[10]    = {2, 1, 3, 1, 4, 1, 5, 1, 6, 1};

 86:         DMPlexCreateFromDAG(dm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
 87:         for (p = 0; p < 5; ++p) {DMSetLabelValue(dm, "marker", markerPoints[p*2], markerPoints[p*2+1]);}
 88:       } else {
 89:         PetscInt    numPoints[2]         = {12, 2};
 90:         PetscInt    coneSize[14]         = {8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 91:         PetscInt    cones[16]            = {2, 3, 4, 5, 6, 7, 8, 9,  5, 4, 10, 11, 7, 12, 13, 8};
 92:         PetscInt    coneOrientations[16] = {0, 0, 0, 0, 0, 0, 0, 0,  0, 0,  0,  0, 0,  0,  0, 0};
 93:         PetscScalar vertexCoords[36]     = {-1.0, -0.5, -0.5,  -1.0,  0.5, -0.5,  0.0,  0.5, -0.5,   0.0, -0.5, -0.5,
 94:                                             -1.0, -0.5,  0.5,   0.0, -0.5,  0.5,  0.0,  0.5,  0.5,  -1.0,  0.5,  0.5,
 95:                                              1.0,  0.5, -0.5,   1.0, -0.5, -0.5,  1.0, -0.5,  0.5,   1.0,  0.5,  0.5};

 97:         DMPlexCreateFromDAG(dm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
 98:       }
 99:       break;
100:     default:
101:       SETERRQ1(comm, PETSC_ERR_ARG_OUTOFRANGE, "Cannot make meshes for dimension %d", dim);
102:     }
103:   }
104:   *newdm = dm;
105:   if (refinementLimit > 0.0) {
106:     DM rdm;
107:     const char *name;

109:     DMPlexSetRefinementUniform(*newdm, PETSC_FALSE);
110:     DMPlexSetRefinementLimit(*newdm, refinementLimit);
111:     DMRefine(*newdm, comm, &rdm);
112:     PetscObjectGetName((PetscObject) *newdm, &name);
113:     PetscObjectSetName((PetscObject)    rdm,  name);
114:     DMDestroy(newdm);
115:     *newdm = rdm;
116:   }
117:   if (interpolate) {
118:     DM idm;

120:     DMPlexInterpolate(*newdm, &idm);
121:     DMDestroy(newdm);
122:     *newdm = idm;
123:   }
124:   {
125:     DM refinedMesh     = NULL;
126:     DM distributedMesh = NULL;

128:     /* Distribute mesh over processes */
129:     DMPlexDistribute(*newdm, 0, NULL, &distributedMesh);
130:     if (distributedMesh) {
131:       DMDestroy(newdm);
132:       *newdm = distributedMesh;
133:     }
134:     if (refinementUniform) {
135:       DMPlexSetRefinementUniform(*newdm, refinementUniform);
136:       DMRefine(*newdm, comm, &refinedMesh);
137:       if (refinedMesh) {
138:         DMDestroy(newdm);
139:         *newdm = refinedMesh;
140:       }
141:     }
142:   }
143:   return(0);
144: }

146: /*@
147:   DMPlexCreateSquareBoundary - Creates a 1D mesh the is the boundary of a square lattice.

149:   Collective on MPI_Comm

151:   Input Parameters:
152: + comm  - The communicator for the DM object
153: . lower - The lower left corner coordinates
154: . upper - The upper right corner coordinates
155: - edges - The number of cells in each direction

157:   Output Parameter:
158: . dm  - The DM object

160:   Note: Here is the numbering returned for 2 cells in each direction:
161: $ 18--5-17--4--16
162: $  |     |     |
163: $  6    10     3
164: $  |     |     |
165: $ 19-11-20--9--15
166: $  |     |     |
167: $  7     8     2
168: $  |     |     |
169: $ 12--0-13--1--14

171:   Level: beginner

173: .keywords: DM, create
174: .seealso: DMPlexCreateBoxMesh(), DMPlexCreateCubeBoundary(), DMSetType(), DMCreate()
175: @*/
176: PetscErrorCode DMPlexCreateSquareBoundary(DM dm, const PetscReal lower[], const PetscReal upper[], const PetscInt edges[])
177: {
178:   const PetscInt numVertices    = (edges[0]+1)*(edges[1]+1);
179:   const PetscInt numEdges       = edges[0]*(edges[1]+1) + (edges[0]+1)*edges[1];
180:   PetscInt       markerTop      = 1;
181:   PetscInt       markerBottom   = 1;
182:   PetscInt       markerRight    = 1;
183:   PetscInt       markerLeft     = 1;
184:   PetscBool      markerSeparate = PETSC_FALSE;
185:   Vec            coordinates;
186:   PetscSection   coordSection;
187:   PetscScalar    *coords;
188:   PetscInt       coordSize;
189:   PetscMPIInt    rank;
190:   PetscInt       v, vx, vy;

194:   PetscOptionsGetBool(((PetscObject) dm)->options,((PetscObject) dm)->prefix, "-dm_plex_separate_marker", &markerSeparate, NULL);
195:   if (markerSeparate) {
196:     markerTop    = 3;
197:     markerBottom = 1;
198:     markerRight  = 2;
199:     markerLeft   = 4;
200:   }
201:   MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank);
202:   if (!rank) {
203:     PetscInt e, ex, ey;

205:     DMPlexSetChart(dm, 0, numEdges+numVertices);
206:     for (e = 0; e < numEdges; ++e) {
207:       DMPlexSetConeSize(dm, e, 2);
208:     }
209:     DMSetUp(dm); /* Allocate space for cones */
210:     for (vx = 0; vx <= edges[0]; vx++) {
211:       for (ey = 0; ey < edges[1]; ey++) {
212:         PetscInt edge   = vx*edges[1] + ey + edges[0]*(edges[1]+1);
213:         PetscInt vertex = ey*(edges[0]+1) + vx + numEdges;
214:         PetscInt cone[2];

216:         cone[0] = vertex; cone[1] = vertex+edges[0]+1;
217:         DMPlexSetCone(dm, edge, cone);
218:         if (vx == edges[0]) {
219:           DMSetLabelValue(dm, "marker", edge,    markerRight);
220:           DMSetLabelValue(dm, "marker", cone[0], markerRight);
221:           if (ey == edges[1]-1) {
222:             DMSetLabelValue(dm, "marker", cone[1], markerRight);
223:             DMSetLabelValue(dm, "Face Sets", cone[1], markerRight);
224:           }
225:         } else if (vx == 0) {
226:           DMSetLabelValue(dm, "marker", edge,    markerLeft);
227:           DMSetLabelValue(dm, "marker", cone[0], markerLeft);
228:           if (ey == edges[1]-1) {
229:             DMSetLabelValue(dm, "marker", cone[1], markerLeft);
230:             DMSetLabelValue(dm, "Face Sets", cone[1], markerLeft);
231:           }
232:         }
233:       }
234:     }
235:     for (vy = 0; vy <= edges[1]; vy++) {
236:       for (ex = 0; ex < edges[0]; ex++) {
237:         PetscInt edge   = vy*edges[0]     + ex;
238:         PetscInt vertex = vy*(edges[0]+1) + ex + numEdges;
239:         PetscInt cone[2];

241:         cone[0] = vertex; cone[1] = vertex+1;
242:         DMPlexSetCone(dm, edge, cone);
243:         if (vy == edges[1]) {
244:           DMSetLabelValue(dm, "marker", edge,    markerTop);
245:           DMSetLabelValue(dm, "marker", cone[0], markerTop);
246:           if (ex == edges[0]-1) {
247:             DMSetLabelValue(dm, "marker", cone[1], markerTop);
248:             DMSetLabelValue(dm, "Face Sets", cone[1], markerTop);
249:           }
250:         } else if (vy == 0) {
251:           DMSetLabelValue(dm, "marker", edge,    markerBottom);
252:           DMSetLabelValue(dm, "marker", cone[0], markerBottom);
253:           if (ex == edges[0]-1) {
254:             DMSetLabelValue(dm, "marker", cone[1], markerBottom);
255:             DMSetLabelValue(dm, "Face Sets", cone[1], markerBottom);
256:           }
257:         }
258:       }
259:     }
260:   }
261:   DMPlexSymmetrize(dm);
262:   DMPlexStratify(dm);
263:   /* Build coordinates */
264:   DMSetCoordinateDim(dm, 2);
265:   DMGetCoordinateSection(dm, &coordSection);
266:   PetscSectionSetNumFields(coordSection, 1);
267:   PetscSectionSetChart(coordSection, numEdges, numEdges + numVertices);
268:   PetscSectionSetFieldComponents(coordSection, 0, 2);
269:   for (v = numEdges; v < numEdges+numVertices; ++v) {
270:     PetscSectionSetDof(coordSection, v, 2);
271:     PetscSectionSetFieldDof(coordSection, v, 0, 2);
272:   }
273:   PetscSectionSetUp(coordSection);
274:   PetscSectionGetStorageSize(coordSection, &coordSize);
275:   VecCreate(PETSC_COMM_SELF, &coordinates);
276:   PetscObjectSetName((PetscObject) coordinates, "coordinates");
277:   VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
278:   VecSetBlockSize(coordinates, 2);
279:   VecSetType(coordinates,VECSTANDARD);
280:   VecGetArray(coordinates, &coords);
281:   for (vy = 0; vy <= edges[1]; ++vy) {
282:     for (vx = 0; vx <= edges[0]; ++vx) {
283:       coords[(vy*(edges[0]+1)+vx)*2+0] = lower[0] + ((upper[0] - lower[0])/edges[0])*vx;
284:       coords[(vy*(edges[0]+1)+vx)*2+1] = lower[1] + ((upper[1] - lower[1])/edges[1])*vy;
285:     }
286:   }
287:   VecRestoreArray(coordinates, &coords);
288:   DMSetCoordinatesLocal(dm, coordinates);
289:   VecDestroy(&coordinates);
290:   return(0);
291: }

293: /*@
294:   DMPlexCreateCubeBoundary - Creates a 2D mesh that is the boundary of a cubic lattice.

296:   Collective on MPI_Comm

298:   Input Parameters:
299: + comm  - The communicator for the DM object
300: . lower - The lower left front corner coordinates
301: . upper - The upper right back corner coordinates
302: - edges - The number of cells in each direction

304:   Output Parameter:
305: . dm  - The DM object

307:   Level: beginner

309: .keywords: DM, create
310: .seealso: DMPlexCreateBoxMesh(), DMPlexCreateSquareBoundary(), DMSetType(), DMCreate()
311: @*/
312: PetscErrorCode DMPlexCreateCubeBoundary(DM dm, const PetscReal lower[], const PetscReal upper[], const PetscInt faces[])
313: {
314:   PetscInt       vertices[3], numVertices;
315:   PetscInt       numFaces    = 2*faces[0]*faces[1] + 2*faces[1]*faces[2] + 2*faces[0]*faces[2];
316:   Vec            coordinates;
317:   PetscSection   coordSection;
318:   PetscScalar    *coords;
319:   PetscInt       coordSize;
320:   PetscMPIInt    rank;
321:   PetscInt       v, vx, vy, vz;
322:   PetscInt       voffset, iface=0, cone[4];

326:   if ((faces[0] < 1) || (faces[1] < 1) || (faces[2] < 1)) SETERRQ(PetscObjectComm((PetscObject)dm), PETSC_ERR_SUP, "Must have at least 1 face per side");
327:   MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank);
328:   vertices[0] = faces[0]+1; vertices[1] = faces[1]+1; vertices[2] = faces[2]+1;
329:   numVertices = vertices[0]*vertices[1]*vertices[2];
330:   if (!rank) {
331:     PetscInt f;

333:     DMPlexSetChart(dm, 0, numFaces+numVertices);
334:     for (f = 0; f < numFaces; ++f) {
335:       DMPlexSetConeSize(dm, f, 4);
336:     }
337:     DMSetUp(dm); /* Allocate space for cones */

339:     /* Side 0 (Top) */
340:     for (vy = 0; vy < faces[1]; vy++) {
341:       for (vx = 0; vx < faces[0]; vx++) {
342:         voffset = numFaces + vertices[0]*vertices[1]*(vertices[2]-1) + vy*vertices[0] + vx;
343:         cone[0] = voffset; cone[1] = voffset+1; cone[2] = voffset+vertices[0]+1; cone[3] = voffset+vertices[0];
344:         DMPlexSetCone(dm, iface, cone);
345:         DMSetLabelValue(dm, "marker", iface, 1);
346:         DMSetLabelValue(dm, "marker", voffset+0, 1);
347:         DMSetLabelValue(dm, "marker", voffset+1, 1);
348:         DMSetLabelValue(dm, "marker", voffset+vertices[0]+0, 1);
349:         DMSetLabelValue(dm, "marker", voffset+vertices[0]+1, 1);
350:         iface++;
351:       }
352:     }

354:     /* Side 1 (Bottom) */
355:     for (vy = 0; vy < faces[1]; vy++) {
356:       for (vx = 0; vx < faces[0]; vx++) {
357:         voffset = numFaces + vy*(faces[0]+1) + vx;
358:         cone[0] = voffset+1; cone[1] = voffset; cone[2] = voffset+vertices[0]; cone[3] = voffset+vertices[0]+1;
359:         DMPlexSetCone(dm, iface, cone);
360:         DMSetLabelValue(dm, "marker", iface, 1);
361:         DMSetLabelValue(dm, "marker", voffset+0, 1);
362:         DMSetLabelValue(dm, "marker", voffset+1, 1);
363:         DMSetLabelValue(dm, "marker", voffset+vertices[0]+0, 1);
364:         DMSetLabelValue(dm, "marker", voffset+vertices[0]+1, 1);
365:         iface++;
366:       }
367:     }

369:     /* Side 2 (Front) */
370:     for (vz = 0; vz < faces[2]; vz++) {
371:       for (vx = 0; vx < faces[0]; vx++) {
372:         voffset = numFaces + vz*vertices[0]*vertices[1] + vx;
373:         cone[0] = voffset; cone[1] = voffset+1; cone[2] = voffset+vertices[0]*vertices[1]+1; cone[3] = voffset+vertices[0]*vertices[1];
374:         DMPlexSetCone(dm, iface, cone);
375:         DMSetLabelValue(dm, "marker", iface, 1);
376:         DMSetLabelValue(dm, "marker", voffset+0, 1);
377:         DMSetLabelValue(dm, "marker", voffset+1, 1);
378:         DMSetLabelValue(dm, "marker", voffset+vertices[0]*vertices[1]+0, 1);
379:         DMSetLabelValue(dm, "marker", voffset+vertices[0]*vertices[1]+1, 1);
380:         iface++;
381:       }
382:     }

384:     /* Side 3 (Back) */
385:     for (vz = 0; vz < faces[2]; vz++) {
386:       for (vx = 0; vx < faces[0]; vx++) {
387:         voffset = numFaces + vz*vertices[0]*vertices[1] + vertices[0]*(vertices[1]-1) + vx;
388:         cone[0] = voffset+vertices[0]*vertices[1]; cone[1] = voffset+vertices[0]*vertices[1]+1;
389:         cone[2] = voffset+1; cone[3] = voffset;
390:         DMPlexSetCone(dm, iface, cone);
391:         DMSetLabelValue(dm, "marker", iface, 1);
392:         DMSetLabelValue(dm, "marker", voffset+0, 1);
393:         DMSetLabelValue(dm, "marker", voffset+1, 1);
394:         DMSetLabelValue(dm, "marker", voffset+vertices[0]*vertices[1]+0, 1);
395:         DMSetLabelValue(dm, "marker", voffset+vertices[0]*vertices[1]+1, 1);
396:         iface++;
397:       }
398:     }

400:     /* Side 4 (Left) */
401:     for (vz = 0; vz < faces[2]; vz++) {
402:       for (vy = 0; vy < faces[1]; vy++) {
403:         voffset = numFaces + vz*vertices[0]*vertices[1] + vy*vertices[0];
404:         cone[0] = voffset; cone[1] = voffset+vertices[0]*vertices[1];
405:         cone[2] = voffset+vertices[0]*vertices[1]+vertices[0]; cone[3] = voffset+vertices[0];
406:         DMPlexSetCone(dm, iface, cone);
407:         DMSetLabelValue(dm, "marker", iface, 1);
408:         DMSetLabelValue(dm, "marker", voffset+0, 1);
409:         DMSetLabelValue(dm, "marker", voffset+vertices[0]+0, 1);
410:         DMSetLabelValue(dm, "marker", voffset+vertices[1]+0, 1);
411:         DMSetLabelValue(dm, "marker", voffset+vertices[0]*vertices[1]+vertices[0], 1);
412:         iface++;
413:       }
414:     }

416:     /* Side 5 (Right) */
417:     for (vz = 0; vz < faces[2]; vz++) {
418:       for (vy = 0; vy < faces[1]; vy++) {
419:         voffset = numFaces + vz*vertices[0]*vertices[1] + vy*vertices[0] + faces[0];
420:         cone[0] = voffset+vertices[0]*vertices[1]; cone[1] = voffset;
421:         cone[2] = voffset+vertices[0]; cone[3] = voffset+vertices[0]*vertices[1]+vertices[0];
422:         DMPlexSetCone(dm, iface, cone);
423:         DMSetLabelValue(dm, "marker", iface, 1);
424:         DMSetLabelValue(dm, "marker", voffset+0, 1);
425:         DMSetLabelValue(dm, "marker", voffset+vertices[0]+0, 1);
426:         DMSetLabelValue(dm, "marker", voffset+vertices[0]*vertices[1]+0, 1);
427:         DMSetLabelValue(dm, "marker", voffset+vertices[0]*vertices[1]+vertices[0], 1);
428:         iface++;
429:       }
430:     }
431:   }
432:   DMPlexSymmetrize(dm);
433:   DMPlexStratify(dm);
434:   /* Build coordinates */
435:   DMSetCoordinateDim(dm, 3);
436:   DMGetCoordinateSection(dm, &coordSection);
437:   PetscSectionSetChart(coordSection, numFaces, numFaces + numVertices);
438:   for (v = numFaces; v < numFaces+numVertices; ++v) {
439:     PetscSectionSetDof(coordSection, v, 3);
440:   }
441:   PetscSectionSetUp(coordSection);
442:   PetscSectionGetStorageSize(coordSection, &coordSize);
443:   VecCreate(PETSC_COMM_SELF, &coordinates);
444:   PetscObjectSetName((PetscObject) coordinates, "coordinates");
445:   VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
446:   VecSetBlockSize(coordinates, 3);
447:   VecSetType(coordinates,VECSTANDARD);
448:   VecGetArray(coordinates, &coords);
449:   for (vz = 0; vz <= faces[2]; ++vz) {
450:     for (vy = 0; vy <= faces[1]; ++vy) {
451:       for (vx = 0; vx <= faces[0]; ++vx) {
452:         coords[((vz*(faces[1]+1)+vy)*(faces[0]+1)+vx)*3+0] = lower[0] + ((upper[0] - lower[0])/faces[0])*vx;
453:         coords[((vz*(faces[1]+1)+vy)*(faces[0]+1)+vx)*3+1] = lower[1] + ((upper[1] - lower[1])/faces[1])*vy;
454:         coords[((vz*(faces[1]+1)+vy)*(faces[0]+1)+vx)*3+2] = lower[2] + ((upper[2] - lower[2])/faces[2])*vz;
455:       }
456:     }
457:   }
458:   VecRestoreArray(coordinates, &coords);
459:   DMSetCoordinatesLocal(dm, coordinates);
460:   VecDestroy(&coordinates);
461:   return(0);
462: }

464: static PetscErrorCode DMPlexCreateLineMesh_Internal(MPI_Comm comm,PetscInt segments,PetscReal lower,PetscReal upper,DMBoundaryType bd,DM *dm)
465: {
466:   PetscInt       i,fStart,fEnd,numCells = 0,numVerts = 0;
467:   PetscInt       numPoints[2],*coneSize,*cones,*coneOrientations;
468:   PetscScalar    *vertexCoords;
469:   PetscReal      L,maxCell;
470:   PetscBool      markerSeparate = PETSC_FALSE;
471:   PetscInt       markerLeft  = 1, faceMarkerLeft  = 1;
472:   PetscInt       markerRight = 1, faceMarkerRight = 2;
473:   PetscBool      wrap = (bd == DM_BOUNDARY_PERIODIC || bd == DM_BOUNDARY_TWIST) ? PETSC_TRUE : PETSC_FALSE;
474:   PetscMPIInt    rank;


480:   DMCreate(comm,dm);
481:   DMSetType(*dm,DMPLEX);
482:   DMSetDimension(*dm,1);
483:   DMCreateLabel(*dm,"marker");
484:   DMCreateLabel(*dm,"Face Sets");

486:   MPI_Comm_rank(comm,&rank);
487:   if (!rank) numCells = segments;
488:   if (!rank) numVerts = segments + (wrap ? 0 : 1);

490:   numPoints[0] = numVerts ; numPoints[1] = numCells;
491:   PetscMalloc4(numCells+numVerts,&coneSize,numCells*2,&cones,numCells+numVerts,&coneOrientations,numVerts,&vertexCoords);
492:   PetscMemzero(coneOrientations,(numCells+numVerts)*sizeof(PetscInt));
493:   for (i = 0; i < numCells; ++i) { coneSize[i] = 2; }
494:   for (i = 0; i < numVerts; ++i) { coneSize[numCells+i] = 0; }
495:   for (i = 0; i < numCells; ++i) { cones[2*i] = numCells + i%numVerts; cones[2*i+1] = numCells + (i+1)%numVerts; }
496:   for (i = 0; i < numVerts; ++i) { vertexCoords[i] = lower + (upper-lower)*((PetscReal)i/(PetscReal)numCells); }
497:   DMPlexCreateFromDAG(*dm,1,numPoints,coneSize,cones,coneOrientations,vertexCoords);
498:   PetscFree4(coneSize,cones,coneOrientations,vertexCoords);

500:   PetscOptionsGetBool(((PetscObject)*dm)->options,((PetscObject)*dm)->prefix,"-dm_plex_separate_marker",&markerSeparate,NULL);
501:   if (markerSeparate) { markerLeft = faceMarkerLeft; markerRight = faceMarkerRight;}
502:   if (!wrap && !rank) {
503:     DMPlexGetHeightStratum(*dm,1,&fStart,&fEnd);
504:     DMSetLabelValue(*dm,"marker",fStart,markerLeft);
505:     DMSetLabelValue(*dm,"marker",fEnd-1,markerRight);
506:     DMSetLabelValue(*dm,"Face Sets",fStart,faceMarkerLeft);
507:     DMSetLabelValue(*dm,"Face Sets",fEnd-1,faceMarkerRight);
508:   }
509:   if (wrap) {
510:     L       = upper - lower;
511:     maxCell = (PetscReal)1.1*(L/(PetscReal)PetscMax(1,segments));
512:     DMSetPeriodicity(*dm,PETSC_TRUE,&maxCell,&L,&bd);
513:   }
514:   return(0);
515: }

517: static PetscErrorCode DMPlexCreateBoxMesh_Simplex_Internal(MPI_Comm comm, PetscInt dim, const PetscInt faces[], const PetscReal lower[], const PetscReal upper[], const DMBoundaryType periodicity[], PetscBool interpolate, DM *dm)
518: {
519:   DM             boundary;
520:   PetscInt       i;

525:   for (i = 0; i < dim; ++i) if (periodicity[i] != DM_BOUNDARY_NONE) SETERRQ(comm, PETSC_ERR_SUP, "Periodicity is not supported for simplex meshes");
526:   DMCreate(comm, &boundary);
528:   DMSetType(boundary, DMPLEX);
529:   DMSetDimension(boundary, dim-1);
530:   DMSetCoordinateDim(boundary, dim);
531:   switch (dim) {
532:   case 2: DMPlexCreateSquareBoundary(boundary, lower, upper, faces);break;
533:   case 3: DMPlexCreateCubeBoundary(boundary, lower, upper, faces);break;
534:   default: SETERRQ1(comm, PETSC_ERR_SUP, "Dimension not supported: %d", dim);
535:   }
536:   DMPlexGenerate(boundary, NULL, interpolate, dm);
537:   DMDestroy(&boundary);
538:   return(0);
539: }

541: static PetscErrorCode DMPlexCreateCubeMesh_Internal(DM dm, const PetscReal lower[], const PetscReal upper[], const PetscInt edges[], DMBoundaryType bdX, DMBoundaryType bdY, DMBoundaryType bdZ)
542: {
543:   DMLabel        cutLabel = NULL;
544:   PetscInt       markerTop      = 1, faceMarkerTop      = 1;
545:   PetscInt       markerBottom   = 1, faceMarkerBottom   = 1;
546:   PetscInt       markerFront    = 1, faceMarkerFront    = 1;
547:   PetscInt       markerBack     = 1, faceMarkerBack     = 1;
548:   PetscInt       markerRight    = 1, faceMarkerRight    = 1;
549:   PetscInt       markerLeft     = 1, faceMarkerLeft     = 1;
550:   PetscInt       dim;
551:   PetscBool      markerSeparate = PETSC_FALSE, cutMarker = PETSC_FALSE;
552:   PetscMPIInt    rank;

556:   DMGetDimension(dm,&dim);
557:   MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank);
558:   DMCreateLabel(dm,"marker");
559:   DMCreateLabel(dm,"Face Sets");
560:   PetscOptionsGetBool(((PetscObject) dm)->options,((PetscObject) dm)->prefix, "-dm_plex_periodic_cut", &cutMarker, NULL);
561:   if (bdX == DM_BOUNDARY_PERIODIC || bdX == DM_BOUNDARY_TWIST ||
562:       bdY == DM_BOUNDARY_PERIODIC || bdY == DM_BOUNDARY_TWIST ||
563:       bdZ == DM_BOUNDARY_PERIODIC || bdZ == DM_BOUNDARY_TWIST) {

565:     if (cutMarker) {DMCreateLabel(dm, "periodic_cut"); DMGetLabel(dm, "periodic_cut", &cutLabel);}
566:   }
567:   switch (dim) {
568:   case 2:
569:     faceMarkerTop    = 3;
570:     faceMarkerBottom = 1;
571:     faceMarkerRight  = 2;
572:     faceMarkerLeft   = 4;
573:     break;
574:   case 3:
575:     faceMarkerBottom = 1;
576:     faceMarkerTop    = 2;
577:     faceMarkerFront  = 3;
578:     faceMarkerBack   = 4;
579:     faceMarkerRight  = 5;
580:     faceMarkerLeft   = 6;
581:     break;
582:   default:
583:     SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"Dimension %d not supported",dim);
584:     break;
585:   }
586:   PetscOptionsGetBool(((PetscObject) dm)->options,((PetscObject) dm)->prefix, "-dm_plex_separate_marker", &markerSeparate, NULL);
587:   if (markerSeparate) {
588:     markerBottom = faceMarkerBottom;
589:     markerTop    = faceMarkerTop;
590:     markerFront  = faceMarkerFront;
591:     markerBack   = faceMarkerBack;
592:     markerRight  = faceMarkerRight;
593:     markerLeft   = faceMarkerLeft;
594:   }
595:   {
596:     const PetscInt numXEdges    = !rank ? edges[0] : 0;
597:     const PetscInt numYEdges    = !rank ? edges[1] : 0;
598:     const PetscInt numZEdges    = !rank ? edges[2] : 0;
599:     const PetscInt numXVertices = !rank ? (bdX == DM_BOUNDARY_PERIODIC || bdX == DM_BOUNDARY_TWIST ? edges[0] : edges[0]+1) : 0;
600:     const PetscInt numYVertices = !rank ? (bdY == DM_BOUNDARY_PERIODIC || bdY == DM_BOUNDARY_TWIST ? edges[1] : edges[1]+1) : 0;
601:     const PetscInt numZVertices = !rank ? (bdZ == DM_BOUNDARY_PERIODIC || bdZ == DM_BOUNDARY_TWIST ? edges[2] : edges[2]+1) : 0;
602:     const PetscInt numCells     = numXEdges*numYEdges*numZEdges;
603:     const PetscInt numXFaces    = numYEdges*numZEdges;
604:     const PetscInt numYFaces    = numXEdges*numZEdges;
605:     const PetscInt numZFaces    = numXEdges*numYEdges;
606:     const PetscInt numTotXFaces = numXVertices*numXFaces;
607:     const PetscInt numTotYFaces = numYVertices*numYFaces;
608:     const PetscInt numTotZFaces = numZVertices*numZFaces;
609:     const PetscInt numFaces     = numTotXFaces + numTotYFaces + numTotZFaces;
610:     const PetscInt numTotXEdges = numXEdges*numYVertices*numZVertices;
611:     const PetscInt numTotYEdges = numYEdges*numXVertices*numZVertices;
612:     const PetscInt numTotZEdges = numZEdges*numXVertices*numYVertices;
613:     const PetscInt numVertices  = numXVertices*numYVertices*numZVertices;
614:     const PetscInt numEdges     = numTotXEdges + numTotYEdges + numTotZEdges;
615:     const PetscInt firstVertex  = (dim == 2) ? numFaces : numCells;
616:     const PetscInt firstXFace   = (dim == 2) ? 0 : numCells + numVertices;
617:     const PetscInt firstYFace   = firstXFace + numTotXFaces;
618:     const PetscInt firstZFace   = firstYFace + numTotYFaces;
619:     const PetscInt firstXEdge   = numCells + numFaces + numVertices;
620:     const PetscInt firstYEdge   = firstXEdge + numTotXEdges;
621:     const PetscInt firstZEdge   = firstYEdge + numTotYEdges;
622:     Vec            coordinates;
623:     PetscSection   coordSection;
624:     PetscScalar   *coords;
625:     PetscInt       coordSize;
626:     PetscInt       v, vx, vy, vz;
627:     PetscInt       c, f, fx, fy, fz, e, ex, ey, ez;

629:     DMPlexSetChart(dm, 0, numCells+numFaces+numEdges+numVertices);
630:     for (c = 0; c < numCells; c++) {
631:       DMPlexSetConeSize(dm, c, 6);
632:     }
633:     for (f = firstXFace; f < firstXFace+numFaces; ++f) {
634:       DMPlexSetConeSize(dm, f, 4);
635:     }
636:     for (e = firstXEdge; e < firstXEdge+numEdges; ++e) {
637:       DMPlexSetConeSize(dm, e, 2);
638:     }
639:     DMSetUp(dm); /* Allocate space for cones */
640:     /* Build cells */
641:     for (fz = 0; fz < numZEdges; ++fz) {
642:       for (fy = 0; fy < numYEdges; ++fy) {
643:         for (fx = 0; fx < numXEdges; ++fx) {
644:           PetscInt cell    = (fz*numYEdges + fy)*numXEdges + fx;
645:           PetscInt faceB   = firstZFace + (fy*numXEdges+fx)*numZVertices +   fz;
646:           PetscInt faceT   = firstZFace + (fy*numXEdges+fx)*numZVertices + ((fz+1)%numZVertices);
647:           PetscInt faceF   = firstYFace + (fz*numXEdges+fx)*numYVertices +   fy;
648:           PetscInt faceK   = firstYFace + (fz*numXEdges+fx)*numYVertices + ((fy+1)%numYVertices);
649:           PetscInt faceL   = firstXFace + (fz*numYEdges+fy)*numXVertices +   fx;
650:           PetscInt faceR   = firstXFace + (fz*numYEdges+fy)*numXVertices + ((fx+1)%numXVertices);
651:                             /* B,  T,  F,  K,  R,  L */
652:           PetscInt ornt[6] = {-4,  0,  0, -1,  0, -4}; /* ??? */
653:           PetscInt cone[6];

655:           /* no boundary twisting in 3D */
656:           cone[0] = faceB; cone[1] = faceT; cone[2] = faceF; cone[3] = faceK; cone[4] = faceR; cone[5] = faceL;
657:           DMPlexSetCone(dm, cell, cone);
658:           DMPlexSetConeOrientation(dm, cell, ornt);
659:           if (bdX != DM_BOUNDARY_NONE && fx == numXEdges-1 && cutLabel) {DMLabelSetValue(cutLabel, cell, 2);}
660:           if (bdY != DM_BOUNDARY_NONE && fy == numYEdges-1 && cutLabel) {DMLabelSetValue(cutLabel, cell, 2);}
661:           if (bdZ != DM_BOUNDARY_NONE && fz == numZEdges-1 && cutLabel) {DMLabelSetValue(cutLabel, cell, 2);}
662:         }
663:       }
664:     }
665:     /* Build x faces */
666:     for (fz = 0; fz < numZEdges; ++fz) {
667:       for (fy = 0; fy < numYEdges; ++fy) {
668:         for (fx = 0; fx < numXVertices; ++fx) {
669:           PetscInt face    = firstXFace + (fz*numYEdges+fy)*numXVertices + fx;
670:           PetscInt edgeL   = firstZEdge + (  fy*                 numXVertices+fx)*numZEdges + fz;
671:           PetscInt edgeR   = firstZEdge + (((fy+1)%numYVertices)*numXVertices+fx)*numZEdges + fz;
672:           PetscInt edgeB   = firstYEdge + (  fz*                 numXVertices+fx)*numYEdges + fy;
673:           PetscInt edgeT   = firstYEdge + (((fz+1)%numZVertices)*numXVertices+fx)*numYEdges + fy;
674:           PetscInt ornt[4] = {0, 0, -2, -2};
675:           PetscInt cone[4];

677:           if (dim == 3) {
678:             /* markers */
679:             if (bdX != DM_BOUNDARY_PERIODIC) {
680:               if (fx == numXVertices-1) {
681:                 DMSetLabelValue(dm, "Face Sets", face, faceMarkerRight);
682:                 DMSetLabelValue(dm, "marker", face, markerRight);
683:               }
684:               else if (fx == 0) {
685:                 DMSetLabelValue(dm, "Face Sets", face, faceMarkerLeft);
686:                 DMSetLabelValue(dm, "marker", face, markerLeft);
687:               }
688:             }
689:           }
690:           cone[0] = edgeB; cone[1] = edgeR; cone[2] = edgeT; cone[3] = edgeL;
691:           DMPlexSetCone(dm, face, cone);
692:           DMPlexSetConeOrientation(dm, face, ornt);
693:         }
694:       }
695:     }
696:     /* Build y faces */
697:     for (fz = 0; fz < numZEdges; ++fz) {
698:       for (fx = 0; fx < numXEdges; ++fx) {
699:         for (fy = 0; fy < numYVertices; ++fy) {
700:           PetscInt face    = firstYFace + (fz*numXEdges+fx)*numYVertices + fy;
701:           PetscInt edgeL   = firstZEdge + (fy*numXVertices+  fx                 )*numZEdges + fz;
702:           PetscInt edgeR   = firstZEdge + (fy*numXVertices+((fx+1)%numXVertices))*numZEdges + fz;
703:           PetscInt edgeB   = firstXEdge + (  fz                 *numYVertices+fy)*numXEdges + fx;
704:           PetscInt edgeT   = firstXEdge + (((fz+1)%numZVertices)*numYVertices+fy)*numXEdges + fx;
705:           PetscInt ornt[4] = {0, 0, -2, -2};
706:           PetscInt cone[4];

708:           if (dim == 3) {
709:             /* markers */
710:             if (bdY != DM_BOUNDARY_PERIODIC) {
711:               if (fy == numYVertices-1) {
712:                 DMSetLabelValue(dm, "Face Sets", face, faceMarkerBack);
713:                 DMSetLabelValue(dm, "marker", face, markerBack);
714:               }
715:               else if (fy == 0) {
716:                 DMSetLabelValue(dm, "Face Sets", face, faceMarkerFront);
717:                 DMSetLabelValue(dm, "marker", face, markerFront);
718:               }
719:             }
720:           }
721:           cone[0] = edgeB; cone[1] = edgeR; cone[2] = edgeT; cone[3] = edgeL;
722:           DMPlexSetCone(dm, face, cone);
723:           DMPlexSetConeOrientation(dm, face, ornt);
724:         }
725:       }
726:     }
727:     /* Build z faces */
728:     for (fy = 0; fy < numYEdges; ++fy) {
729:       for (fx = 0; fx < numXEdges; ++fx) {
730:         for (fz = 0; fz < numZVertices; fz++) {
731:           PetscInt face    = firstZFace + (fy*numXEdges+fx)*numZVertices + fz;
732:           PetscInt edgeL   = firstYEdge + (fz*numXVertices+  fx                 )*numYEdges + fy;
733:           PetscInt edgeR   = firstYEdge + (fz*numXVertices+((fx+1)%numXVertices))*numYEdges + fy;
734:           PetscInt edgeB   = firstXEdge + (fz*numYVertices+  fy                 )*numXEdges + fx;
735:           PetscInt edgeT   = firstXEdge + (fz*numYVertices+((fy+1)%numYVertices))*numXEdges + fx;
736:           PetscInt ornt[4] = {0, 0, -2, -2};
737:           PetscInt cone[4];

739:           if (dim == 2) {
740:             if (bdX == DM_BOUNDARY_TWIST && fx == numXEdges-1) {edgeR += numYEdges-1-2*fy; ornt[1] = -2;}
741:             if (bdY == DM_BOUNDARY_TWIST && fy == numYEdges-1) {edgeT += numXEdges-1-2*fx; ornt[2] =  0;}
742:             if (bdX != DM_BOUNDARY_NONE && fx == numXEdges-1 && cutLabel) {DMLabelSetValue(cutLabel, face, 2);}
743:             if (bdY != DM_BOUNDARY_NONE && fy == numYEdges-1 && cutLabel) {DMLabelSetValue(cutLabel, face, 2);}
744:           } else {
745:             /* markers */
746:             if (bdZ != DM_BOUNDARY_PERIODIC) {
747:               if (fz == numZVertices-1) {
748:                 DMSetLabelValue(dm, "Face Sets", face, faceMarkerTop);
749:                 DMSetLabelValue(dm, "marker", face, markerTop);
750:               }
751:               else if (fz == 0) {
752:                 DMSetLabelValue(dm, "Face Sets", face, faceMarkerBottom);
753:                 DMSetLabelValue(dm, "marker", face, markerBottom);
754:               }
755:             }
756:           }
757:           cone[0] = edgeB; cone[1] = edgeR; cone[2] = edgeT; cone[3] = edgeL;
758:           DMPlexSetCone(dm, face, cone);
759:           DMPlexSetConeOrientation(dm, face, ornt);
760:         }
761:       }
762:     }
763:     /* Build Z edges*/
764:     for (vy = 0; vy < numYVertices; vy++) {
765:       for (vx = 0; vx < numXVertices; vx++) {
766:         for (ez = 0; ez < numZEdges; ez++) {
767:           const PetscInt edge    = firstZEdge  + (vy*numXVertices+vx)*numZEdges + ez;
768:           const PetscInt vertexB = firstVertex + (  ez                 *numYVertices+vy)*numXVertices + vx;
769:           const PetscInt vertexT = firstVertex + (((ez+1)%numZVertices)*numYVertices+vy)*numXVertices + vx;
770:           PetscInt       cone[2];

772:           if (dim == 3) {
773:             if (bdX != DM_BOUNDARY_PERIODIC) {
774:               if (vx == numXVertices-1) {
775:                 DMSetLabelValue(dm, "marker", edge, markerRight);
776:               }
777:               else if (vx == 0) {
778:                 DMSetLabelValue(dm, "marker", edge, markerLeft);
779:               }
780:             }
781:             if (bdY != DM_BOUNDARY_PERIODIC) {
782:               if (vy == numYVertices-1) {
783:                 DMSetLabelValue(dm, "marker", edge, markerBack);
784:               }
785:               else if (vy == 0) {
786:                 DMSetLabelValue(dm, "marker", edge, markerFront);
787:               }
788:             }
789:           }
790:           cone[0] = vertexB; cone[1] = vertexT;
791:           DMPlexSetCone(dm, edge, cone);
792:         }
793:       }
794:     }
795:     /* Build Y edges*/
796:     for (vz = 0; vz < numZVertices; vz++) {
797:       for (vx = 0; vx < numXVertices; vx++) {
798:         for (ey = 0; ey < numYEdges; ey++) {
799:           const PetscInt nextv   = (dim == 2 && bdY == DM_BOUNDARY_TWIST && ey == numYEdges-1) ? (numXVertices-vx-1) : (vz*numYVertices+((ey+1)%numYVertices))*numXVertices + vx;
800:           const PetscInt edge    = firstYEdge  + (vz*numXVertices+vx)*numYEdges + ey;
801:           const PetscInt vertexF = firstVertex + (vz*numYVertices+ey)*numXVertices + vx;
802:           const PetscInt vertexK = firstVertex + nextv;
803:           PetscInt       cone[2];

805:           cone[0] = vertexF; cone[1] = vertexK;
806:           DMPlexSetCone(dm, edge, cone);
807:           if (dim == 2) {
808:             if ((bdX != DM_BOUNDARY_PERIODIC) && (bdX != DM_BOUNDARY_TWIST)) {
809:               if (vx == numXVertices-1) {
810:                 DMSetLabelValue(dm, "Face Sets", edge, faceMarkerRight);
811:                 DMSetLabelValue(dm, "marker", edge,    markerRight);
812:                 DMSetLabelValue(dm, "marker", cone[0], markerRight);
813:                 if (ey == numYEdges-1) {
814:                   DMSetLabelValue(dm, "marker", cone[1], markerRight);
815:                 }
816:               } else if (vx == 0) {
817:                 DMSetLabelValue(dm, "Face Sets", edge, faceMarkerLeft);
818:                 DMSetLabelValue(dm, "marker", edge,    markerLeft);
819:                 DMSetLabelValue(dm, "marker", cone[0], markerLeft);
820:                 if (ey == numYEdges-1) {
821:                   DMSetLabelValue(dm, "marker", cone[1], markerLeft);
822:                 }
823:               }
824:             } else {
825:               if (vx == 0 && cutLabel) {
826:                 DMLabelSetValue(cutLabel, edge,    1);
827:                 DMLabelSetValue(cutLabel, cone[0], 1);
828:                 if (ey == numYEdges-1) {
829:                   DMLabelSetValue(cutLabel, cone[1], 1);
830:                 }
831:               }
832:             }
833:           } else {
834:             if (bdX != DM_BOUNDARY_PERIODIC) {
835:               if (vx == numXVertices-1) {
836:                 DMSetLabelValue(dm, "marker", edge, markerRight);
837:               } else if (vx == 0) {
838:                 DMSetLabelValue(dm, "marker", edge, markerLeft);
839:               }
840:             }
841:             if (bdZ != DM_BOUNDARY_PERIODIC) {
842:               if (vz == numZVertices-1) {
843:                 DMSetLabelValue(dm, "marker", edge, markerTop);
844:               } else if (vz == 0) {
845:                 DMSetLabelValue(dm, "marker", edge, markerBottom);
846:               }
847:             }
848:           }
849:         }
850:       }
851:     }
852:     /* Build X edges*/
853:     for (vz = 0; vz < numZVertices; vz++) {
854:       for (vy = 0; vy < numYVertices; vy++) {
855:         for (ex = 0; ex < numXEdges; ex++) {
856:           const PetscInt nextv   = (dim == 2 && bdX == DM_BOUNDARY_TWIST && ex == numXEdges-1) ? (numYVertices-vy-1)*numXVertices : (vz*numYVertices+vy)*numXVertices + (ex+1)%numXVertices;
857:           const PetscInt edge    = firstXEdge  + (vz*numYVertices+vy)*numXEdges + ex;
858:           const PetscInt vertexL = firstVertex + (vz*numYVertices+vy)*numXVertices + ex;
859:           const PetscInt vertexR = firstVertex + nextv;
860:           PetscInt       cone[2];

862:           cone[0] = vertexL; cone[1] = vertexR;
863:           DMPlexSetCone(dm, edge, cone);
864:           if (dim == 2) {
865:             if ((bdY != DM_BOUNDARY_PERIODIC) && (bdY != DM_BOUNDARY_TWIST)) {
866:               if (vy == numYVertices-1) {
867:                 DMSetLabelValue(dm, "Face Sets", edge, faceMarkerTop);
868:                 DMSetLabelValue(dm, "marker", edge,    markerTop);
869:                 DMSetLabelValue(dm, "marker", cone[0], markerTop);
870:                 if (ex == numXEdges-1) {
871:                   DMSetLabelValue(dm, "marker", cone[1], markerTop);
872:                 }
873:               } else if (vy == 0) {
874:                 DMSetLabelValue(dm, "Face Sets", edge, faceMarkerBottom);
875:                 DMSetLabelValue(dm, "marker", edge,    markerBottom);
876:                 DMSetLabelValue(dm, "marker", cone[0], markerBottom);
877:                 if (ex == numXEdges-1) {
878:                   DMSetLabelValue(dm, "marker", cone[1], markerBottom);
879:                 }
880:               }
881:             } else {
882:               if (vy == 0 && cutLabel) {
883:                 DMLabelSetValue(cutLabel, edge,    1);
884:                 DMLabelSetValue(cutLabel, cone[0], 1);
885:                 if (ex == numXEdges-1) {
886:                   DMLabelSetValue(cutLabel, cone[1], 1);
887:                 }
888:               }
889:             }
890:           } else {
891:             if (bdY != DM_BOUNDARY_PERIODIC) {
892:               if (vy == numYVertices-1) {
893:                 DMSetLabelValue(dm, "marker", edge, markerBack);
894:               }
895:               else if (vy == 0) {
896:                 DMSetLabelValue(dm, "marker", edge, markerFront);
897:               }
898:             }
899:             if (bdZ != DM_BOUNDARY_PERIODIC) {
900:               if (vz == numZVertices-1) {
901:                 DMSetLabelValue(dm, "marker", edge, markerTop);
902:               }
903:               else if (vz == 0) {
904:                 DMSetLabelValue(dm, "marker", edge, markerBottom);
905:               }
906:             }
907:           }
908:         }
909:       }
910:     }
911:     DMPlexSymmetrize(dm);
912:     DMPlexStratify(dm);
913:     /* Build coordinates */
914:     DMGetCoordinateSection(dm, &coordSection);
915:     PetscSectionSetNumFields(coordSection, 1);
916:     PetscSectionSetFieldComponents(coordSection, 0, dim);
917:     PetscSectionSetChart(coordSection, firstVertex, firstVertex+numVertices);
918:     for (v = firstVertex; v < firstVertex+numVertices; ++v) {
919:       PetscSectionSetDof(coordSection, v, dim);
920:       PetscSectionSetFieldDof(coordSection, v, 0, dim);
921:     }
922:     PetscSectionSetUp(coordSection);
923:     PetscSectionGetStorageSize(coordSection, &coordSize);
924:     VecCreate(PETSC_COMM_SELF, &coordinates);
925:     PetscObjectSetName((PetscObject) coordinates, "coordinates");
926:     VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
927:     VecSetBlockSize(coordinates, dim);
928:     VecSetType(coordinates,VECSTANDARD);
929:     VecGetArray(coordinates, &coords);
930:     for (vz = 0; vz < numZVertices; ++vz) {
931:       for (vy = 0; vy < numYVertices; ++vy) {
932:         for (vx = 0; vx < numXVertices; ++vx) {
933:           coords[((vz*numYVertices+vy)*numXVertices+vx)*dim+0] = lower[0] + ((upper[0] - lower[0])/numXEdges)*vx;
934:           coords[((vz*numYVertices+vy)*numXVertices+vx)*dim+1] = lower[1] + ((upper[1] - lower[1])/numYEdges)*vy;
935:           if (dim == 3) {
936:             coords[((vz*numYVertices+vy)*numXVertices+vx)*dim+2] = lower[2] + ((upper[2] - lower[2])/numZEdges)*vz;
937:           }
938:         }
939:       }
940:     }
941:     VecRestoreArray(coordinates, &coords);
942:     DMSetCoordinatesLocal(dm, coordinates);
943:     VecDestroy(&coordinates);
944:   }
945:   return(0);
946: }

948: static PetscErrorCode DMPlexCreateBoxMesh_Tensor_Internal(MPI_Comm comm, PetscInt dim, const PetscInt faces[], const PetscReal lower[], const PetscReal upper[], const DMBoundaryType periodicity[], PetscBool interpolate, DM *dm)
949: {
950:   PetscInt       i;

955:   DMCreate(comm, dm);
957:   DMSetType(*dm, DMPLEX);
958:   DMSetDimension(*dm, dim);
959:   switch (dim) {
960:   case 2: {DMPlexCreateCubeMesh_Internal(*dm, lower, upper, faces, periodicity[0], periodicity[1], DM_BOUNDARY_NONE);break;}
961:   case 3: {DMPlexCreateCubeMesh_Internal(*dm, lower, upper, faces, periodicity[0], periodicity[1], periodicity[2]);break;}
962:   default: SETERRQ1(comm, PETSC_ERR_SUP, "Dimension not supported: %d", dim);
963:   }
964:   if (periodicity[0] == DM_BOUNDARY_PERIODIC || periodicity[0] == DM_BOUNDARY_TWIST ||
965:       periodicity[1] == DM_BOUNDARY_PERIODIC || periodicity[1] == DM_BOUNDARY_TWIST ||
966:       (dim > 2 && (periodicity[2] == DM_BOUNDARY_PERIODIC || periodicity[2] == DM_BOUNDARY_TWIST))) {
967:     PetscReal L[3];
968:     PetscReal maxCell[3];

970:     for (i = 0; i < dim; i++) {
971:       L[i]       = upper[i] - lower[i];
972:       maxCell[i] = 1.1 * (L[i] / PetscMax(1,faces[i]));
973:     }
974:     DMSetPeriodicity(*dm,PETSC_TRUE,maxCell,L,periodicity);
975:   }
976:   if (!interpolate) {
977:     DM udm;

979:     DMPlexUninterpolate(*dm, &udm);
980:     DMPlexCopyCoordinates(*dm, udm);
981:     DMDestroy(dm);
982:     *dm  = udm;
983:   }
984:   return(0);
985: }

987: /*@C
988:   DMPlexCreateBoxMesh - Creates a mesh on the tensor product of unit intervals (box) using simplices or tensor cells (hexahedra).

990:   Collective on MPI_Comm

992:   Input Parameters:
993: + comm        - The communicator for the DM object
994: . dim         - The spatial dimension
995: . simplex     - PETSC_TRUE for simplices, PETSC_FALSE for tensor cells
996: . faces       - Number of faces per dimension, or NULL for (1,) in 1D and (2, 2) in 2D and (1, 1, 1) in 3D
997: . lower       - The lower left corner, or NULL for (0, 0, 0)
998: . upper       - The upper right corner, or NULL for (1, 1, 1)
999: . periodicity - The boundary type for the X,Y,Z direction, or NULL for DM_BOUNDARY_NONE
1000: - interpolate - Flag to create intermediate mesh pieces (edges, faces)

1002:   Output Parameter:
1003: . dm  - The DM object

1005:   Options Database Keys:
1006: + -dm_plex_box_lower <x,y,z> - Specify lower-left-bottom coordinates for the box
1007: - -dm_plex_box_upper <x,y,z> - Specify upper-right-top coordinates for the box

1009:   Note: Here is the numbering returned for 2 faces in each direction for tensor cells:
1010: $ 10---17---11---18----12
1011: $  |         |         |
1012: $  |         |         |
1013: $ 20    2   22    3    24
1014: $  |         |         |
1015: $  |         |         |
1016: $  7---15----8---16----9
1017: $  |         |         |
1018: $  |         |         |
1019: $ 19    0   21    1   23
1020: $  |         |         |
1021: $  |         |         |
1022: $  4---13----5---14----6

1024: and for simplicial cells

1026: $ 14----8---15----9----16
1027: $  |\     5  |\      7 |
1028: $  | \       | \       |
1029: $ 13   2    14    3    15
1030: $  | 4   \   | 6   \   |
1031: $  |       \ |       \ |
1032: $ 11----6---12----7----13
1033: $  |\        |\        |
1034: $  | \    1  | \     3 |
1035: $ 10   0    11    1    12
1036: $  | 0   \   | 2   \   |
1037: $  |       \ |       \ |
1038: $  8----4----9----5----10

1040:   Level: beginner

1042: .keywords: DM, create
1043: .seealso: DMPlexCreateFromFile(), DMPlexCreateHexCylinderMesh(), DMSetType(), DMCreate()
1044: @*/
1045: PetscErrorCode DMPlexCreateBoxMesh(MPI_Comm comm, PetscInt dim, PetscBool simplex, const PetscInt faces[], const PetscReal lower[], const PetscReal upper[], const DMBoundaryType periodicity[], PetscBool interpolate, DM *dm)
1046: {
1047:   PetscInt       fac[3] = {0, 0, 0};
1048:   PetscReal      low[3] = {0, 0, 0};
1049:   PetscReal      upp[3] = {1, 1, 1};
1050:   DMBoundaryType bdt[3] = {DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE};
1051:   PetscInt       i, n;
1052:   PetscBool      flg;

1056:   for (i = 0; i < dim; ++i) fac[i] = faces ? faces[i] : (dim == 1 ? 1 : 4-dim);
1057:   if (lower) for (i = 0; i < dim; ++i) low[i] = lower[i];
1058:   if (upper) for (i = 0; i < dim; ++i) upp[i] = upper[i];
1059:   if (periodicity) for (i = 0; i < dim; ++i) bdt[i] = periodicity[i];
1060:   /* Allow bounds to be specified from the command line */
1061:   n    = 3;
1062:   PetscOptionsGetRealArray(NULL, NULL, "-dm_plex_box_lower", low, &n, &flg);
1063:   if (flg && (n != dim)) SETERRQ2(comm, PETSC_ERR_ARG_SIZ, "Lower box point had %D values, should have been %D", n, dim);
1064:   n    = 3;
1065:   PetscOptionsGetRealArray(NULL, NULL, "-dm_plex_box_upper", upp, &n, &flg);
1066:   if (flg && (n != dim)) SETERRQ2(comm, PETSC_ERR_ARG_SIZ, "Upper box point had %D values, should have been %D", n, dim);

1068:   if (dim == 1)      {DMPlexCreateLineMesh_Internal(comm, fac[0], low[0], upp[0], bdt[0], dm);}
1069:   else if (simplex)  {DMPlexCreateBoxMesh_Simplex_Internal(comm, dim, fac, low, upp, bdt, interpolate, dm);}
1070:   else               {DMPlexCreateBoxMesh_Tensor_Internal(comm, dim, fac, low, upp, bdt, interpolate, dm);}
1071:   return(0);
1072: }

1074: /*@
1075:   DMPlexCreateWedgeBoxMesh - Creates a 3-D mesh tesselating the (x,y) plane and extruding in the third direction using wedge cells.

1077:   Collective on MPI_Comm

1079:   Input Parameters:
1080: + comm        - The communicator for the DM object
1081: . faces       - Number of faces per dimension, or NULL for (1, 1, 1)
1082: . lower       - The lower left corner, or NULL for (0, 0, 0)
1083: . upper       - The upper right corner, or NULL for (1, 1, 1)
1084: . periodicity - The boundary type for the X,Y,Z direction, or NULL for DM_BOUNDARY_NONE
1085: . ordExt      - If PETSC_TRUE, orders the extruded cells in the height first. Otherwise, orders the cell on the layers first
1086: - interpolate - Flag to create intermediate mesh pieces (edges, faces)

1088:   Output Parameter:
1089: . dm  - The DM object

1091:   Level: beginner

1093: .keywords: DM, create
1094: .seealso: DMPlexCreateHexCylinderMesh(), DMPlexCreateWedgeCylinderMesh(), DMPlexExtrude(), DMPlexCreateBoxMesh(), DMSetType(), DMCreate()
1095: @*/
1096: PetscErrorCode DMPlexCreateWedgeBoxMesh(MPI_Comm comm, const PetscInt faces[], const PetscReal lower[], const PetscReal upper[], const DMBoundaryType periodicity[], PetscBool ordExt, PetscBool interpolate, DM *dm)
1097: {
1098:   DM             bdm, botdm;
1099:   PetscInt       i;
1100:   PetscInt       fac[3] = {0, 0, 0};
1101:   PetscReal      low[3] = {0, 0, 0};
1102:   PetscReal      upp[3] = {1, 1, 1};
1103:   DMBoundaryType bdt[3] = {DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE};

1107:   for (i = 0; i < 3; ++i) fac[i] = faces ? (faces[i] > 0 ? faces[i] : 1) : 1;
1108:   if (lower) for (i = 0; i < 3; ++i) low[i] = lower[i];
1109:   if (upper) for (i = 0; i < 3; ++i) upp[i] = upper[i];
1110:   if (periodicity) for (i = 0; i < 3; ++i) bdt[i] = periodicity[i];
1111:   for (i = 0; i < 3; ++i) if (bdt[i] != DM_BOUNDARY_NONE) SETERRQ(comm, PETSC_ERR_SUP, "Periodicity not yet supported");

1113:   DMCreate(comm, &bdm);
1114:   DMSetType(bdm, DMPLEX);
1115:   DMSetDimension(bdm, 1);
1116:   DMSetCoordinateDim(bdm, 2);
1117:   DMPlexCreateSquareBoundary(bdm, low, upp, fac);
1118:   DMPlexGenerate(bdm, NULL, PETSC_FALSE, &botdm);
1119:   DMDestroy(&bdm);
1120:   DMPlexExtrude(botdm, fac[2], upp[2] - low[2], ordExt, interpolate, dm);
1121:   if (low[2] != 0.0) {
1122:     Vec         v;
1123:     PetscScalar *x;
1124:     PetscInt    cDim, n;

1126:     DMGetCoordinatesLocal(*dm, &v);
1127:     VecGetBlockSize(v, &cDim);
1128:     VecGetLocalSize(v, &n);
1129:     VecGetArray(v, &x);
1130:     x   += cDim;
1131:     for (i=0; i<n; i+=cDim) x[i] += low[2];
1132:     VecRestoreArray(v,&x);
1133:     DMSetCoordinatesLocal(*dm, v);
1134:   }
1135:   DMDestroy(&botdm);
1136:   return(0);
1137: }

1139: /*@
1140:   DMPlexExtrude - Creates a (d+1)-D mesh by extruding a d-D mesh in the normal direction using prismatic cells.

1142:   Collective on idm

1144:   Input Parameters:
1145: + idm - The mesh to be extruted
1146: . layers - The number of layers
1147: . height - The height of the extruded layer
1148: . ordExt - If PETSC_TRUE, orders the extruded cells in the height first. Otherwise, orders the cell on the layers first
1149: - interpolate - Flag to create intermediate mesh pieces (edges, faces)

1151:   Output Parameter:
1152: . dm  - The DM object

1154:   Notes: The object created is an hybrid mesh, the vertex ordering in the cone of the cell is that of the prismatic cells

1156:   Level: advanced

1158: .keywords: DM, create
1159: .seealso: DMPlexCreateWedgeCylinderMesh(), DMPlexCreateWedgeBoxMesh(), DMPlexSetHybridBounds(), DMSetType(), DMCreate()
1160: @*/
1161: PetscErrorCode DMPlexExtrude(DM idm, PetscInt layers, PetscReal height, PetscBool ordExt, PetscBool interpolate, DM* dm)
1162: {
1163:   PetscScalar       *coordsB;
1164:   const PetscScalar *coordsA;
1165:   PetscReal         *normals = NULL;
1166:   Vec               coordinatesA, coordinatesB;
1167:   PetscSection      coordSectionA, coordSectionB;
1168:   PetscInt          dim, cDim, cDimB, c, l, v, coordSize, *newCone;
1169:   PetscInt          cStart, cEnd, vStart, vEnd, cellV, numCells, numVertices;
1170:   PetscErrorCode    ierr;

1177:   DMGetDimension(idm, &dim);
1178:   if (dim < 1 || dim > 3) SETERRQ1(PetscObjectComm((PetscObject)idm), PETSC_ERR_SUP, "Support for dimension %D not coded", dim);

1180:   DMPlexGetHeightStratum(idm, 0, &cStart, &cEnd);
1181:   DMPlexGetDepthStratum(idm, 0, &vStart, &vEnd);
1182:   numCells = (cEnd - cStart)*layers;
1183:   numVertices = (vEnd - vStart)*(layers+1);
1184:   DMCreate(PetscObjectComm((PetscObject)idm), dm);
1185:   DMSetType(*dm, DMPLEX);
1186:   DMSetDimension(*dm, dim+1);
1187:   DMPlexSetChart(*dm, 0, numCells+numVertices);
1188:   for (c = cStart, cellV = 0; c < cEnd; ++c) {
1189:     PetscInt *closure = NULL;
1190:     PetscInt closureSize, numCorners = 0;

1192:     DMPlexGetTransitiveClosure(idm, c, PETSC_TRUE, &closureSize, &closure);
1193:     for (v = 0; v < closureSize*2; v += 2) if ((closure[v] >= vStart) && (closure[v] < vEnd)) numCorners++;
1194:     DMPlexRestoreTransitiveClosure(idm, c, PETSC_TRUE, &closureSize, &closure);
1195:     for (l = 0; l < layers; ++l) {
1196:       DMPlexSetConeSize(*dm, ordExt ? layers*(c - cStart) + l : l*(cEnd - cStart) + c - cStart, 2*numCorners);
1197:     }
1198:     cellV = PetscMax(numCorners,cellV);
1199:   }
1200:   DMPlexSetHybridBounds(*dm, 0, PETSC_DETERMINE, PETSC_DETERMINE, PETSC_DETERMINE);
1201:   DMSetUp(*dm);

1203:   DMGetCoordinateDim(idm, &cDim);
1204:   if (dim != cDim) {
1205:     PetscCalloc1(cDim*(vEnd - vStart), &normals);
1206:   }
1207:   PetscMalloc1(3*cellV,&newCone);
1208:   for (c = cStart; c < cEnd; ++c) {
1209:     PetscInt *closure = NULL;
1210:     PetscInt closureSize, numCorners = 0, l;
1211:     PetscReal normal[3] = {0, 0, 0};

1213:     if (normals) {
1214:       DMPlexComputeCellGeometryFVM(idm, c, NULL, NULL, normal);
1215:     }
1216:     DMPlexGetTransitiveClosure(idm, c, PETSC_TRUE, &closureSize, &closure);
1217:     for (v = 0; v < closureSize*2; v += 2) {
1218:       if ((closure[v] >= vStart) && (closure[v] < vEnd)) {
1219:         PetscInt d;

1221:         newCone[numCorners++] = closure[v] - vStart;
1222:         if (normals) { for (d = 0; d < cDim; ++d) normals[cDim*(closure[v]-vStart)+d] += normal[d]; }
1223:       }
1224:     }
1225:     switch (numCorners) {
1226:     case 4: /* do nothing */
1227:     case 2: /* do nothing */
1228:       break;
1229:     case 3: /* from counter-clockwise to wedge ordering */
1230:       l = newCone[1];
1231:       newCone[1] = newCone[2];
1232:       newCone[2] = l;
1233:       break;
1234:     default: SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_SUP, "Unsupported number of corners: %D", numCorners);
1235:     }
1236:     DMPlexRestoreTransitiveClosure(idm, c, PETSC_TRUE, &closureSize, &closure);
1237:     for (l = 0; l < layers; ++l) {
1238:       PetscInt i;

1240:       for (i = 0; i < numCorners; ++i) {
1241:         newCone[  numCorners + i] = ordExt ? (layers+1)*newCone[i] + l     + numCells :     l*(vEnd - vStart) + newCone[i] + numCells;
1242:         newCone[2*numCorners + i] = ordExt ? (layers+1)*newCone[i] + l + 1 + numCells : (l+1)*(vEnd - vStart) + newCone[i] + numCells;
1243:       }
1244:       DMPlexSetCone(*dm, ordExt ? layers*(c - cStart) + l : l*(cEnd - cStart) + c - cStart, newCone + numCorners);
1245:     }
1246:   }
1247:   DMPlexSymmetrize(*dm);
1248:   DMPlexStratify(*dm);
1249:   PetscFree(newCone);

1251:   cDimB = cDim == dim ? cDim+1 : cDim;
1252:   DMGetCoordinateSection(*dm, &coordSectionB);
1253:   PetscSectionSetNumFields(coordSectionB, 1);
1254:   PetscSectionSetFieldComponents(coordSectionB, 0, cDimB);
1255:   PetscSectionSetChart(coordSectionB, numCells, numCells+numVertices);
1256:   for (v = numCells; v < numCells+numVertices; ++v) {
1257:     PetscSectionSetDof(coordSectionB, v, cDimB);
1258:     PetscSectionSetFieldDof(coordSectionB, v, 0, cDimB);
1259:   }
1260:   PetscSectionSetUp(coordSectionB);
1261:   PetscSectionGetStorageSize(coordSectionB, &coordSize);
1262:   VecCreate(PETSC_COMM_SELF, &coordinatesB);
1263:   PetscObjectSetName((PetscObject) coordinatesB, "coordinates");
1264:   VecSetSizes(coordinatesB, coordSize, PETSC_DETERMINE);
1265:   VecSetBlockSize(coordinatesB, cDimB);
1266:   VecSetType(coordinatesB,VECSTANDARD);

1268:   DMGetCoordinateSection(idm, &coordSectionA);
1269:   DMGetCoordinatesLocal(idm, &coordinatesA);
1270:   VecGetArray(coordinatesB, &coordsB);
1271:   VecGetArrayRead(coordinatesA, &coordsA);
1272:   for (v = vStart; v < vEnd; ++v) {
1273:     const PetscScalar *cptr;
1274:     PetscReal         ones2[2] = { 0., 1.}, ones3[3] = { 0., 0., 1.};
1275:     PetscReal         *normal, norm, h = height/layers;
1276:     PetscInt          offA, d, cDimA = cDim;

1278:     normal = normals ? normals + cDimB*(v - vStart) : (cDim > 1 ? ones3 : ones2);
1279:     if (normals) {
1280:       for (d = 0, norm = 0.0; d < cDimB; ++d) norm += normal[d]*normal[d];
1281:       for (d = 0; d < cDimB; ++d) normal[d] *= 1./PetscSqrtReal(norm);
1282:     }

1284:     PetscSectionGetOffset(coordSectionA, v, &offA);
1285:     cptr = coordsA + offA;
1286:     for (l = 0; l < layers+1; ++l) {
1287:       PetscInt offB, d, newV;

1289:       newV = ordExt ? (layers+1)*(v -vStart) + l + numCells : (vEnd -vStart)*l + (v -vStart) + numCells;
1290:       PetscSectionGetOffset(coordSectionB, newV, &offB);
1291:       for (d = 0; d < cDimA; ++d) { coordsB[offB+d]  = cptr[d]; }
1292:       for (d = 0; d < cDimB; ++d) { coordsB[offB+d] += l ? normal[d]*h : 0.0; }
1293:       cptr    = coordsB + offB;
1294:       cDimA   = cDimB;
1295:     }
1296:   }
1297:   VecRestoreArrayRead(coordinatesA, &coordsA);
1298:   VecRestoreArray(coordinatesB, &coordsB);
1299:   DMSetCoordinatesLocal(*dm, coordinatesB);
1300:   VecDestroy(&coordinatesB);
1301:   PetscFree(normals);
1302:   if (interpolate) {
1303:     DM idm;

1305:     DMPlexInterpolate(*dm, &idm);
1306:     DMPlexCopyCoordinates(*dm, idm);
1307:     DMDestroy(dm);
1308:     *dm  = idm;
1309:   }
1310:   return(0);
1311: }

1313: /*@C
1314:   DMPlexSetOptionsPrefix - Sets the prefix used for searching for all DM options in the database.

1316:   Logically Collective on DM

1318:   Input Parameters:
1319: + dm - the DM context
1320: - prefix - the prefix to prepend to all option names

1322:   Notes:
1323:   A hyphen (-) must NOT be given at the beginning of the prefix name.
1324:   The first character of all runtime options is AUTOMATICALLY the hyphen.

1326:   Level: advanced

1328: .seealso: SNESSetFromOptions()
1329: @*/
1330: PetscErrorCode DMPlexSetOptionsPrefix(DM dm, const char prefix[])
1331: {
1332:   DM_Plex       *mesh = (DM_Plex *) dm->data;

1337:   PetscObjectSetOptionsPrefix((PetscObject) dm, prefix);
1338:   PetscObjectSetOptionsPrefix((PetscObject) mesh->partitioner, prefix);
1339:   return(0);
1340: }

1342: /*@
1343:   DMPlexCreateHexCylinderMesh - Creates a mesh on the tensor product of the unit interval with the circle (cylinder) using hexahedra.

1345:   Collective on MPI_Comm

1347:   Input Parameters:
1348: + comm      - The communicator for the DM object
1349: . numRefine - The number of regular refinements to the basic 5 cell structure
1350: - periodicZ - The boundary type for the Z direction

1352:   Output Parameter:
1353: . dm  - The DM object

1355:   Note: Here is the output numbering looking from the bottom of the cylinder:
1356: $       17-----14
1357: $        |     |
1358: $        |  2  |
1359: $        |     |
1360: $ 17-----8-----7-----14
1361: $  |     |     |     |
1362: $  |  3  |  0  |  1  |
1363: $  |     |     |     |
1364: $ 19-----5-----6-----13
1365: $        |     |
1366: $        |  4  |
1367: $        |     |
1368: $       19-----13
1369: $
1370: $ and up through the top
1371: $
1372: $       18-----16
1373: $        |     |
1374: $        |  2  |
1375: $        |     |
1376: $ 18----10----11-----16
1377: $  |     |     |     |
1378: $  |  3  |  0  |  1  |
1379: $  |     |     |     |
1380: $ 20-----9----12-----15
1381: $        |     |
1382: $        |  4  |
1383: $        |     |
1384: $       20-----15

1386:   Level: beginner

1388: .keywords: DM, create
1389: .seealso: DMPlexCreateBoxMesh(), DMSetType(), DMCreate()
1390: @*/
1391: PetscErrorCode DMPlexCreateHexCylinderMesh(MPI_Comm comm, PetscInt numRefine, DMBoundaryType periodicZ, DM *dm)
1392: {
1393:   const PetscInt dim = 3;
1394:   PetscInt       numCells, numVertices, r;
1395:   PetscMPIInt    rank;

1400:   MPI_Comm_rank(comm, &rank);
1401:   if (numRefine < 0) SETERRQ1(comm, PETSC_ERR_ARG_OUTOFRANGE, "Number of refinements %D cannot be negative", numRefine);
1402:   DMCreate(comm, dm);
1403:   DMSetType(*dm, DMPLEX);
1404:   DMSetDimension(*dm, dim);
1405:   /* Create topology */
1406:   {
1407:     PetscInt cone[8], c;

1409:     numCells    = !rank ?  5 : 0;
1410:     numVertices = !rank ? 16 : 0;
1411:     if (periodicZ == DM_BOUNDARY_PERIODIC) {
1412:       numCells   *= 3;
1413:       numVertices = !rank ? 24 : 0;
1414:     }
1415:     DMPlexSetChart(*dm, 0, numCells+numVertices);
1416:     for (c = 0; c < numCells; c++) {DMPlexSetConeSize(*dm, c, 8);}
1417:     DMSetUp(*dm);
1418:     if (!rank) {
1419:       if (periodicZ == DM_BOUNDARY_PERIODIC) {
1420:         cone[0] = 15; cone[1] = 18; cone[2] = 17; cone[3] = 16;
1421:         cone[4] = 31; cone[5] = 32; cone[6] = 33; cone[7] = 34;
1422:         DMPlexSetCone(*dm, 0, cone);
1423:         cone[0] = 16; cone[1] = 17; cone[2] = 24; cone[3] = 23;
1424:         cone[4] = 32; cone[5] = 36; cone[6] = 37; cone[7] = 33; /* 22 25 26 21 */
1425:         DMPlexSetCone(*dm, 1, cone);
1426:         cone[0] = 18; cone[1] = 27; cone[2] = 24; cone[3] = 17;
1427:         cone[4] = 34; cone[5] = 33; cone[6] = 37; cone[7] = 38;
1428:         DMPlexSetCone(*dm, 2, cone);
1429:         cone[0] = 29; cone[1] = 27; cone[2] = 18; cone[3] = 15;
1430:         cone[4] = 35; cone[5] = 31; cone[6] = 34; cone[7] = 38;
1431:         DMPlexSetCone(*dm, 3, cone);
1432:         cone[0] = 29; cone[1] = 15; cone[2] = 16; cone[3] = 23;
1433:         cone[4] = 35; cone[5] = 36; cone[6] = 32; cone[7] = 31;
1434:         DMPlexSetCone(*dm, 4, cone);

1436:         cone[0] = 31; cone[1] = 34; cone[2] = 33; cone[3] = 32;
1437:         cone[4] = 19; cone[5] = 22; cone[6] = 21; cone[7] = 20;
1438:         DMPlexSetCone(*dm, 5, cone);
1439:         cone[0] = 32; cone[1] = 33; cone[2] = 37; cone[3] = 36;
1440:         cone[4] = 22; cone[5] = 25; cone[6] = 26; cone[7] = 21;
1441:         DMPlexSetCone(*dm, 6, cone);
1442:         cone[0] = 34; cone[1] = 38; cone[2] = 37; cone[3] = 33;
1443:         cone[4] = 20; cone[5] = 21; cone[6] = 26; cone[7] = 28;
1444:         DMPlexSetCone(*dm, 7, cone);
1445:         cone[0] = 35; cone[1] = 38; cone[2] = 34; cone[3] = 31;
1446:         cone[4] = 30; cone[5] = 19; cone[6] = 20; cone[7] = 28;
1447:         DMPlexSetCone(*dm, 8, cone);
1448:         cone[0] = 35; cone[1] = 31; cone[2] = 32; cone[3] = 36;
1449:         cone[4] = 30; cone[5] = 25; cone[6] = 22; cone[7] = 19;
1450:         DMPlexSetCone(*dm, 9, cone);

1452:         cone[0] = 19; cone[1] = 20; cone[2] = 21; cone[3] = 22;
1453:         cone[4] = 15; cone[5] = 16; cone[6] = 17; cone[7] = 18;
1454:         DMPlexSetCone(*dm, 10, cone);
1455:         cone[0] = 22; cone[1] = 21; cone[2] = 26; cone[3] = 25;
1456:         cone[4] = 16; cone[5] = 23; cone[6] = 24; cone[7] = 17;
1457:         DMPlexSetCone(*dm, 11, cone);
1458:         cone[0] = 20; cone[1] = 28; cone[2] = 26; cone[3] = 21;
1459:         cone[4] = 18; cone[5] = 17; cone[6] = 24; cone[7] = 27;
1460:         DMPlexSetCone(*dm, 12, cone);
1461:         cone[0] = 30; cone[1] = 28; cone[2] = 20; cone[3] = 19;
1462:         cone[4] = 29; cone[5] = 15; cone[6] = 18; cone[7] = 27;
1463:         DMPlexSetCone(*dm, 13, cone);
1464:         cone[0] = 30; cone[1] = 19; cone[2] = 22; cone[3] = 25;
1465:         cone[4] = 29; cone[5] = 23; cone[6] = 16; cone[7] = 15;
1466:         DMPlexSetCone(*dm, 14, cone);
1467:       } else {
1468:         cone[0] =  5; cone[1] =  8; cone[2] =  7; cone[3] =  6;
1469:         cone[4] =  9; cone[5] = 12; cone[6] = 11; cone[7] = 10;
1470:         DMPlexSetCone(*dm, 0, cone);
1471:         cone[0] =  6; cone[1] =  7; cone[2] = 14; cone[3] = 13;
1472:         cone[4] = 12; cone[5] = 15; cone[6] = 16; cone[7] = 11;
1473:         DMPlexSetCone(*dm, 1, cone);
1474:         cone[0] =  8; cone[1] = 17; cone[2] = 14; cone[3] =  7;
1475:         cone[4] = 10; cone[5] = 11; cone[6] = 16; cone[7] = 18;
1476:         DMPlexSetCone(*dm, 2, cone);
1477:         cone[0] = 19; cone[1] = 17; cone[2] =  8; cone[3] =  5;
1478:         cone[4] = 20; cone[5] =  9; cone[6] = 10; cone[7] = 18;
1479:         DMPlexSetCone(*dm, 3, cone);
1480:         cone[0] = 19; cone[1] =  5; cone[2] =  6; cone[3] = 13;
1481:         cone[4] = 20; cone[5] = 15; cone[6] = 12; cone[7] =  9;
1482:         DMPlexSetCone(*dm, 4, cone);
1483:       }
1484:     }
1485:     DMPlexSymmetrize(*dm);
1486:     DMPlexStratify(*dm);
1487:   }
1488:   /* Interpolate */
1489:   {
1490:     DM idm;

1492:     DMPlexInterpolate(*dm, &idm);
1493:     DMDestroy(dm);
1494:     *dm  = idm;
1495:   }
1496:   /* Create cube geometry */
1497:   {
1498:     Vec             coordinates;
1499:     PetscSection    coordSection;
1500:     PetscScalar    *coords;
1501:     PetscInt        coordSize, v;
1502:     const PetscReal dis = 1.0/PetscSqrtReal(2.0);
1503:     const PetscReal ds2 = dis/2.0;

1505:     /* Build coordinates */
1506:     DMGetCoordinateSection(*dm, &coordSection);
1507:     PetscSectionSetNumFields(coordSection, 1);
1508:     PetscSectionSetFieldComponents(coordSection, 0, dim);
1509:     PetscSectionSetChart(coordSection, numCells, numCells+numVertices);
1510:     for (v = numCells; v < numCells+numVertices; ++v) {
1511:       PetscSectionSetDof(coordSection, v, dim);
1512:       PetscSectionSetFieldDof(coordSection, v, 0, dim);
1513:     }
1514:     PetscSectionSetUp(coordSection);
1515:     PetscSectionGetStorageSize(coordSection, &coordSize);
1516:     VecCreate(PETSC_COMM_SELF, &coordinates);
1517:     PetscObjectSetName((PetscObject) coordinates, "coordinates");
1518:     VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
1519:     VecSetBlockSize(coordinates, dim);
1520:     VecSetType(coordinates,VECSTANDARD);
1521:     VecGetArray(coordinates, &coords);
1522:     if (!rank) {
1523:       coords[0*dim+0] = -ds2; coords[0*dim+1] = -ds2; coords[0*dim+2] = 0.0;
1524:       coords[1*dim+0] =  ds2; coords[1*dim+1] = -ds2; coords[1*dim+2] = 0.0;
1525:       coords[2*dim+0] =  ds2; coords[2*dim+1] =  ds2; coords[2*dim+2] = 0.0;
1526:       coords[3*dim+0] = -ds2; coords[3*dim+1] =  ds2; coords[3*dim+2] = 0.0;
1527:       coords[4*dim+0] = -ds2; coords[4*dim+1] = -ds2; coords[4*dim+2] = 1.0;
1528:       coords[5*dim+0] = -ds2; coords[5*dim+1] =  ds2; coords[5*dim+2] = 1.0;
1529:       coords[6*dim+0] =  ds2; coords[6*dim+1] =  ds2; coords[6*dim+2] = 1.0;
1530:       coords[7*dim+0] =  ds2; coords[7*dim+1] = -ds2; coords[7*dim+2] = 1.0;
1531:       coords[ 8*dim+0] =  dis; coords[ 8*dim+1] = -dis; coords[ 8*dim+2] = 0.0;
1532:       coords[ 9*dim+0] =  dis; coords[ 9*dim+1] =  dis; coords[ 9*dim+2] = 0.0;
1533:       coords[10*dim+0] =  dis; coords[10*dim+1] = -dis; coords[10*dim+2] = 1.0;
1534:       coords[11*dim+0] =  dis; coords[11*dim+1] =  dis; coords[11*dim+2] = 1.0;
1535:       coords[12*dim+0] = -dis; coords[12*dim+1] =  dis; coords[12*dim+2] = 0.0;
1536:       coords[13*dim+0] = -dis; coords[13*dim+1] =  dis; coords[13*dim+2] = 1.0;
1537:       coords[14*dim+0] = -dis; coords[14*dim+1] = -dis; coords[14*dim+2] = 0.0;
1538:       coords[15*dim+0] = -dis; coords[15*dim+1] = -dis; coords[15*dim+2] = 1.0;
1539:       if (periodicZ == DM_BOUNDARY_PERIODIC) {
1540:         /* 15 31 19 */ coords[16*dim+0] = -ds2; coords[16*dim+1] = -ds2; coords[16*dim+2] = 0.5;
1541:         /* 16 32 22 */ coords[17*dim+0] =  ds2; coords[17*dim+1] = -ds2; coords[17*dim+2] = 0.5;
1542:         /* 17 33 21 */ coords[18*dim+0] =  ds2; coords[18*dim+1] =  ds2; coords[18*dim+2] = 0.5;
1543:         /* 18 34 20 */ coords[19*dim+0] = -ds2; coords[19*dim+1] =  ds2; coords[19*dim+2] = 0.5;
1544:         /* 29 35 30 */ coords[20*dim+0] = -dis; coords[20*dim+1] = -dis; coords[20*dim+2] = 0.5;
1545:         /* 23 36 25 */ coords[21*dim+0] =  dis; coords[21*dim+1] = -dis; coords[21*dim+2] = 0.5;
1546:         /* 24 37 26 */ coords[22*dim+0] =  dis; coords[22*dim+1] =  dis; coords[22*dim+2] = 0.5;
1547:         /* 27 38 28 */ coords[23*dim+0] = -dis; coords[23*dim+1] =  dis; coords[23*dim+2] = 0.5;
1548:       }
1549:     }
1550:     VecRestoreArray(coordinates, &coords);
1551:     DMSetCoordinatesLocal(*dm, coordinates);
1552:     VecDestroy(&coordinates);
1553:   }
1554:   /* Create periodicity */
1555:   if (periodicZ == DM_BOUNDARY_PERIODIC || periodicZ == DM_BOUNDARY_TWIST) {
1556:     PetscReal      L[3];
1557:     PetscReal      maxCell[3];
1558:     DMBoundaryType bdType[3];
1559:     PetscReal      lower[3] = {0.0, 0.0, 0.0};
1560:     PetscReal      upper[3] = {1.0, 1.0, 1.5};
1561:     PetscInt       i, numZCells = 3;

1563:     bdType[0] = DM_BOUNDARY_NONE;
1564:     bdType[1] = DM_BOUNDARY_NONE;
1565:     bdType[2] = periodicZ;
1566:     for (i = 0; i < dim; i++) {
1567:       L[i]       = upper[i] - lower[i];
1568:       maxCell[i] = 1.1 * (L[i] / numZCells);
1569:     }
1570:     DMSetPeriodicity(*dm, PETSC_TRUE, maxCell, L, bdType);
1571:   }
1572:   /* Refine topology */
1573:   for (r = 0; r < numRefine; ++r) {
1574:     DM rdm = NULL;

1576:     DMRefine(*dm, comm, &rdm);
1577:     DMDestroy(dm);
1578:     *dm  = rdm;
1579:   }
1580:   /* Remap geometry to cylinder
1581:        Interior square: Linear interpolation is correct
1582:        The other cells all have vertices on rays from the origin. We want to uniformly expand the spacing
1583:        such that the last vertex is on the unit circle. So the closest and farthest vertices are at distance

1585:          phi     = arctan(y/x)
1586:          d_close = sqrt(1/8 + 1/4 sin^2(phi))
1587:          d_far   = sqrt(1/2 + sin^2(phi))

1589:        so we remap them using

1591:          x_new = x_close + (x - x_close) (1 - d_close) / (d_far - d_close)
1592:          y_new = y_close + (y - y_close) (1 - d_close) / (d_far - d_close)

1594:        If pi/4 < phi < 3pi/4 or -3pi/4 < phi < -pi/4, then we switch x and y.
1595:   */
1596:   {
1597:     Vec           coordinates;
1598:     PetscSection  coordSection;
1599:     PetscScalar  *coords;
1600:     PetscInt      vStart, vEnd, v;
1601:     const PetscReal dis = 1.0/PetscSqrtReal(2.0);
1602:     const PetscReal ds2 = 0.5*dis;

1604:     DMPlexGetDepthStratum(*dm, 0, &vStart, &vEnd);
1605:     DMGetCoordinateSection(*dm, &coordSection);
1606:     DMGetCoordinatesLocal(*dm, &coordinates);
1607:     VecGetArray(coordinates, &coords);
1608:     for (v = vStart; v < vEnd; ++v) {
1609:       PetscReal phi, sinp, cosp, dc, df, x, y, xc, yc;
1610:       PetscInt  off;

1612:       PetscSectionGetOffset(coordSection, v, &off);
1613:       if ((PetscAbsScalar(coords[off+0]) <= ds2) && (PetscAbsScalar(coords[off+1]) <= ds2)) continue;
1614:       x    = PetscRealPart(coords[off]);
1615:       y    = PetscRealPart(coords[off+1]);
1616:       phi  = PetscAtan2Real(y, x);
1617:       sinp = PetscSinReal(phi);
1618:       cosp = PetscCosReal(phi);
1619:       if ((PetscAbsReal(phi) > PETSC_PI/4.0) && (PetscAbsReal(phi) < 3.0*PETSC_PI/4.0)) {
1620:         dc = PetscAbsReal(ds2/sinp);
1621:         df = PetscAbsReal(dis/sinp);
1622:         xc = ds2*x/PetscAbsReal(y);
1623:         yc = ds2*PetscSignReal(y);
1624:       } else {
1625:         dc = PetscAbsReal(ds2/cosp);
1626:         df = PetscAbsReal(dis/cosp);
1627:         xc = ds2*PetscSignReal(x);
1628:         yc = ds2*y/PetscAbsReal(x);
1629:       }
1630:       coords[off+0] = xc + (coords[off+0] - xc)*(1.0 - dc)/(df - dc);
1631:       coords[off+1] = yc + (coords[off+1] - yc)*(1.0 - dc)/(df - dc);
1632:     }
1633:     VecRestoreArray(coordinates, &coords);
1634:     if (periodicZ == DM_BOUNDARY_PERIODIC || periodicZ == DM_BOUNDARY_TWIST) {
1635:       DMLocalizeCoordinates(*dm);
1636:     }
1637:   }
1638:   return(0);
1639: }

1641: /*@
1642:   DMPlexCreateWedgeCylinderMesh - Creates a mesh on the tensor product of the unit interval with the circle (cylinder) using wedges.

1644:   Collective on MPI_Comm

1646:   Input Parameters:
1647: + comm - The communicator for the DM object
1648: . n    - The number of wedges around the origin
1649: - interpolate - Create edges and faces

1651:   Output Parameter:
1652: . dm  - The DM object

1654:   Level: beginner

1656: .keywords: DM, create
1657: .seealso: DMPlexCreateHexCylinderMesh(), DMPlexCreateBoxMesh(), DMSetType(), DMCreate()
1658: @*/
1659: PetscErrorCode DMPlexCreateWedgeCylinderMesh(MPI_Comm comm, PetscInt n, PetscBool interpolate, DM *dm)
1660: {
1661:   const PetscInt dim = 3;
1662:   PetscInt       numCells, numVertices;
1663:   PetscMPIInt    rank;

1668:   MPI_Comm_rank(comm, &rank);
1669:   if (n < 0) SETERRQ1(comm, PETSC_ERR_ARG_OUTOFRANGE, "Number of wedges %D cannot be negative", n);
1670:   DMCreate(comm, dm);
1671:   DMSetType(*dm, DMPLEX);
1672:   DMSetDimension(*dm, dim);
1673:   /* Create topology */
1674:   {
1675:     PetscInt cone[6], c;

1677:     numCells    = !rank ?        n : 0;
1678:     numVertices = !rank ?  2*(n+1) : 0;
1679:     DMPlexSetChart(*dm, 0, numCells+numVertices);
1680:     DMPlexSetHybridBounds(*dm, 0, PETSC_DETERMINE, PETSC_DETERMINE, PETSC_DETERMINE);
1681:     for (c = 0; c < numCells; c++) {DMPlexSetConeSize(*dm, c, 6);}
1682:     DMSetUp(*dm);
1683:     for (c = 0; c < numCells; c++) {
1684:       cone[0] =  c+n*1; cone[1] = (c+1)%n+n*1; cone[2] = 0+3*n;
1685:       cone[3] =  c+n*2; cone[4] = (c+1)%n+n*2; cone[5] = 1+3*n;
1686:       DMPlexSetCone(*dm, c, cone);
1687:     }
1688:     DMPlexSymmetrize(*dm);
1689:     DMPlexStratify(*dm);
1690:   }
1691:   /* Interpolate */
1692:   if (interpolate) {
1693:     DM idm;

1695:     DMPlexInterpolate(*dm, &idm);
1696:     DMDestroy(dm);
1697:     *dm  = idm;
1698:   }
1699:   /* Create cylinder geometry */
1700:   {
1701:     Vec          coordinates;
1702:     PetscSection coordSection;
1703:     PetscScalar *coords;
1704:     PetscInt     coordSize, v, c;

1706:     /* Build coordinates */
1707:     DMGetCoordinateSection(*dm, &coordSection);
1708:     PetscSectionSetNumFields(coordSection, 1);
1709:     PetscSectionSetFieldComponents(coordSection, 0, dim);
1710:     PetscSectionSetChart(coordSection, numCells, numCells+numVertices);
1711:     for (v = numCells; v < numCells+numVertices; ++v) {
1712:       PetscSectionSetDof(coordSection, v, dim);
1713:       PetscSectionSetFieldDof(coordSection, v, 0, dim);
1714:     }
1715:     PetscSectionSetUp(coordSection);
1716:     PetscSectionGetStorageSize(coordSection, &coordSize);
1717:     VecCreate(PETSC_COMM_SELF, &coordinates);
1718:     PetscObjectSetName((PetscObject) coordinates, "coordinates");
1719:     VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
1720:     VecSetBlockSize(coordinates, dim);
1721:     VecSetType(coordinates,VECSTANDARD);
1722:     VecGetArray(coordinates, &coords);
1723:     for (c = 0; c < numCells; c++) {
1724:       coords[(c+0*n)*dim+0] = PetscCosReal(2.0*c*PETSC_PI/n); coords[(c+0*n)*dim+1] = PetscSinReal(2.0*c*PETSC_PI/n); coords[(c+0*n)*dim+2] = 1.0;
1725:       coords[(c+1*n)*dim+0] = PetscCosReal(2.0*c*PETSC_PI/n); coords[(c+1*n)*dim+1] = PetscSinReal(2.0*c*PETSC_PI/n); coords[(c+1*n)*dim+2] = 0.0;
1726:     }
1727:     if (!rank) {
1728:       coords[(2*n+0)*dim+0] = 0.0; coords[(2*n+0)*dim+1] = 0.0; coords[(2*n+0)*dim+2] = 1.0;
1729:       coords[(2*n+1)*dim+0] = 0.0; coords[(2*n+1)*dim+1] = 0.0; coords[(2*n+1)*dim+2] = 0.0;
1730:     }
1731:     VecRestoreArray(coordinates, &coords);
1732:     DMSetCoordinatesLocal(*dm, coordinates);
1733:     VecDestroy(&coordinates);
1734:   }
1735:   return(0);
1736: }

1738: PETSC_STATIC_INLINE PetscReal DiffNormReal(PetscInt dim, const PetscReal x[], const PetscReal y[])
1739: {
1740:   PetscReal prod = 0.0;
1741:   PetscInt  i;
1742:   for (i = 0; i < dim; ++i) prod += PetscSqr(x[i] - y[i]);
1743:   return PetscSqrtReal(prod);
1744: }
1745: PETSC_STATIC_INLINE PetscReal DotReal(PetscInt dim, const PetscReal x[], const PetscReal y[])
1746: {
1747:   PetscReal prod = 0.0;
1748:   PetscInt  i;
1749:   for (i = 0; i < dim; ++i) prod += x[i]*y[i];
1750:   return prod;
1751: }

1753: /*@
1754:   DMPlexCreateSphereMesh - Creates a mesh on the d-dimensional sphere, S^d.

1756:   Collective on MPI_Comm

1758:   Input Parameters:
1759: . comm  - The communicator for the DM object
1760: . dim   - The dimension
1761: - simplex - Use simplices, or tensor product cells

1763:   Output Parameter:
1764: . dm  - The DM object

1766:   Level: beginner

1768: .keywords: DM, create
1769: .seealso: DMPlexCreateBoxMesh(), DMSetType(), DMCreate()
1770: @*/
1771: PetscErrorCode DMPlexCreateSphereMesh(MPI_Comm comm, PetscInt dim, PetscBool simplex, DM *dm)
1772: {
1773:   const PetscInt  embedDim = dim+1;
1774:   PetscSection    coordSection;
1775:   Vec             coordinates;
1776:   PetscScalar    *coords;
1777:   PetscReal      *coordsIn;
1778:   PetscInt        numCells, numEdges, numVerts, firstVertex, v, firstEdge, coordSize, d, c, e;
1779:   PetscMPIInt     rank;
1780:   PetscErrorCode  ierr;

1784:   DMCreate(comm, dm);
1785:   DMSetType(*dm, DMPLEX);
1786:   DMSetDimension(*dm, dim);
1787:   DMSetCoordinateDim(*dm, dim+1);
1788:   MPI_Comm_rank(PetscObjectComm((PetscObject) *dm), &rank);
1789:   switch (dim) {
1790:   case 2:
1791:     if (simplex) {
1792:       DM              idm;
1793:       const PetscReal edgeLen     = 2.0/(1.0 + PETSC_PHI);
1794:       const PetscReal vertex[3]   = {0.0, 1.0/(1.0 + PETSC_PHI), PETSC_PHI/(1.0 + PETSC_PHI)};
1795:       const PetscInt  degree      = 5;
1796:       PetscInt        s[3]        = {1, 1, 1};
1797:       PetscInt        cone[3];
1798:       PetscInt       *graph, p, i, j, k;

1800:       numCells    = !rank ? 20 : 0;
1801:       numVerts    = !rank ? 12 : 0;
1802:       firstVertex = numCells;
1803:       /* Use icosahedron, which for a unit sphere has coordinates which are all cyclic permutations of

1805:            (0, \pm 1/\phi+1, \pm \phi/\phi+1)

1807:          where \phi^2 - \phi - 1 = 0, meaning \phi is the golden ratio \frac{1 + \sqrt{5}}{2}. The edge
1808:          length is then given by 2/\phi = 2 * 2.73606 = 5.47214.
1809:        */
1810:       /* Construct vertices */
1811:       PetscCalloc1(numVerts * embedDim, &coordsIn);
1812:       for (p = 0, i = 0; p < embedDim; ++p) {
1813:         for (s[1] = -1; s[1] < 2; s[1] += 2) {
1814:           for (s[2] = -1; s[2] < 2; s[2] += 2) {
1815:             for (d = 0; d < embedDim; ++d) coordsIn[i*embedDim+d] = s[(d+p)%embedDim]*vertex[(d+p)%embedDim];
1816:             ++i;
1817:           }
1818:         }
1819:       }
1820:       /* Construct graph */
1821:       PetscCalloc1(numVerts * numVerts, &graph);
1822:       for (i = 0; i < numVerts; ++i) {
1823:         for (j = 0, k = 0; j < numVerts; ++j) {
1824:           if (PetscAbsReal(DiffNormReal(embedDim, &coordsIn[i*embedDim], &coordsIn[j*embedDim]) - edgeLen) < PETSC_SMALL) {graph[i*numVerts+j] = 1; ++k;}
1825:         }
1826:         if (k != degree) SETERRQ3(comm, PETSC_ERR_PLIB, "Invalid icosahedron, vertex %D degree %D != %D", i, k, degree);
1827:       }
1828:       /* Build Topology */
1829:       DMPlexSetChart(*dm, 0, numCells+numVerts);
1830:       for (c = 0; c < numCells; c++) {
1831:         DMPlexSetConeSize(*dm, c, embedDim);
1832:       }
1833:       DMSetUp(*dm); /* Allocate space for cones */
1834:       /* Cells */
1835:       for (i = 0, c = 0; i < numVerts; ++i) {
1836:         for (j = 0; j < i; ++j) {
1837:           for (k = 0; k < j; ++k) {
1838:             if (graph[i*numVerts+j] && graph[j*numVerts+k] && graph[k*numVerts+i]) {
1839:               cone[0] = firstVertex+i; cone[1] = firstVertex+j; cone[2] = firstVertex+k;
1840:               /* Check orientation */
1841:               {
1842:                 const PetscInt epsilon[3][3][3] = {{{0, 0, 0}, {0, 0, 1}, {0, -1, 0}}, {{0, 0, -1}, {0, 0, 0}, {1, 0, 0}}, {{0, 1, 0}, {-1, 0, 0}, {0, 0, 0}}};
1843:                 PetscReal normal[3];
1844:                 PetscInt  e, f;

1846:                 for (d = 0; d < embedDim; ++d) {
1847:                   normal[d] = 0.0;
1848:                   for (e = 0; e < embedDim; ++e) {
1849:                     for (f = 0; f < embedDim; ++f) {
1850:                       normal[d] += epsilon[d][e][f]*(coordsIn[j*embedDim+e] - coordsIn[i*embedDim+e])*(coordsIn[k*embedDim+f] - coordsIn[i*embedDim+f]);
1851:                     }
1852:                   }
1853:                 }
1854:                 if (DotReal(embedDim, normal, &coordsIn[i*embedDim]) < 0) {PetscInt tmp = cone[1]; cone[1] = cone[2]; cone[2] = tmp;}
1855:               }
1856:               DMPlexSetCone(*dm, c++, cone);
1857:             }
1858:           }
1859:         }
1860:       }
1861:       DMPlexSymmetrize(*dm);
1862:       DMPlexStratify(*dm);
1863:       PetscFree(graph);
1864:       /* Interpolate mesh */
1865:       DMPlexInterpolate(*dm, &idm);
1866:       DMDestroy(dm);
1867:       *dm  = idm;
1868:     } else {
1869:       /*
1870:         12-21--13
1871:          |     |
1872:         25  4  24
1873:          |     |
1874:   12-25--9-16--8-24--13
1875:    |     |     |     |
1876:   23  5 17  0 15  3  22
1877:    |     |     |     |
1878:   10-20--6-14--7-19--11
1879:          |     |
1880:         20  1  19
1881:          |     |
1882:         10-18--11
1883:          |     |
1884:         23  2  22
1885:          |     |
1886:         12-21--13
1887:        */
1888:       const PetscReal dist = 1.0/PetscSqrtReal(3.0);
1889:       PetscInt        cone[4], ornt[4];

1891:       numCells    = !rank ?  6 : 0;
1892:       numEdges    = !rank ? 12 : 0;
1893:       numVerts    = !rank ?  8 : 0;
1894:       firstVertex = numCells;
1895:       firstEdge   = numCells + numVerts;
1896:       /* Build Topology */
1897:       DMPlexSetChart(*dm, 0, numCells+numEdges+numVerts);
1898:       for (c = 0; c < numCells; c++) {
1899:         DMPlexSetConeSize(*dm, c, 4);
1900:       }
1901:       for (e = firstEdge; e < firstEdge+numEdges; ++e) {
1902:         DMPlexSetConeSize(*dm, e, 2);
1903:       }
1904:       DMSetUp(*dm); /* Allocate space for cones */
1905:       /* Cell 0 */
1906:       cone[0] = 14; cone[1] = 15; cone[2] = 16; cone[3] = 17;
1907:       DMPlexSetCone(*dm, 0, cone);
1908:       ornt[0] = 0; ornt[1] = 0; ornt[2] = 0; ornt[3] = 0;
1909:       DMPlexSetConeOrientation(*dm, 0, ornt);
1910:       /* Cell 1 */
1911:       cone[0] = 18; cone[1] = 19; cone[2] = 14; cone[3] = 20;
1912:       DMPlexSetCone(*dm, 1, cone);
1913:       ornt[0] = 0; ornt[1] = 0; ornt[2] = -2; ornt[3] = 0;
1914:       DMPlexSetConeOrientation(*dm, 1, ornt);
1915:       /* Cell 2 */
1916:       cone[0] = 21; cone[1] = 22; cone[2] = 18; cone[3] = 23;
1917:       DMPlexSetCone(*dm, 2, cone);
1918:       ornt[0] = 0; ornt[1] = 0; ornt[2] = -2; ornt[3] = 0;
1919:       DMPlexSetConeOrientation(*dm, 2, ornt);
1920:       /* Cell 3 */
1921:       cone[0] = 19; cone[1] = 22; cone[2] = 24; cone[3] = 15;
1922:       DMPlexSetCone(*dm, 3, cone);
1923:       ornt[0] = -2; ornt[1] = -2; ornt[2] = 0; ornt[3] = -2;
1924:       DMPlexSetConeOrientation(*dm, 3, ornt);
1925:       /* Cell 4 */
1926:       cone[0] = 16; cone[1] = 24; cone[2] = 21; cone[3] = 25;
1927:       DMPlexSetCone(*dm, 4, cone);
1928:       ornt[0] = -2; ornt[1] = -2; ornt[2] = -2; ornt[3] = 0;
1929:       DMPlexSetConeOrientation(*dm, 4, ornt);
1930:       /* Cell 5 */
1931:       cone[0] = 20; cone[1] = 17; cone[2] = 25; cone[3] = 23;
1932:       DMPlexSetCone(*dm, 5, cone);
1933:       ornt[0] = -2; ornt[1] = -2; ornt[2] = -2; ornt[3] = -2;
1934:       DMPlexSetConeOrientation(*dm, 5, ornt);
1935:       /* Edges */
1936:       cone[0] =  6; cone[1] =  7;
1937:       DMPlexSetCone(*dm, 14, cone);
1938:       cone[0] =  7; cone[1] =  8;
1939:       DMPlexSetCone(*dm, 15, cone);
1940:       cone[0] =  8; cone[1] =  9;
1941:       DMPlexSetCone(*dm, 16, cone);
1942:       cone[0] =  9; cone[1] =  6;
1943:       DMPlexSetCone(*dm, 17, cone);
1944:       cone[0] = 10; cone[1] = 11;
1945:       DMPlexSetCone(*dm, 18, cone);
1946:       cone[0] = 11; cone[1] =  7;
1947:       DMPlexSetCone(*dm, 19, cone);
1948:       cone[0] =  6; cone[1] = 10;
1949:       DMPlexSetCone(*dm, 20, cone);
1950:       cone[0] = 12; cone[1] = 13;
1951:       DMPlexSetCone(*dm, 21, cone);
1952:       cone[0] = 13; cone[1] = 11;
1953:       DMPlexSetCone(*dm, 22, cone);
1954:       cone[0] = 10; cone[1] = 12;
1955:       DMPlexSetCone(*dm, 23, cone);
1956:       cone[0] = 13; cone[1] =  8;
1957:       DMPlexSetCone(*dm, 24, cone);
1958:       cone[0] = 12; cone[1] =  9;
1959:       DMPlexSetCone(*dm, 25, cone);
1960:       DMPlexSymmetrize(*dm);
1961:       DMPlexStratify(*dm);
1962:       /* Build coordinates */
1963:       PetscCalloc1(numVerts * embedDim, &coordsIn);
1964:       coordsIn[0*embedDim+0] = -dist; coordsIn[0*embedDim+1] =  dist; coordsIn[0*embedDim+2] = -dist;
1965:       coordsIn[1*embedDim+0] =  dist; coordsIn[1*embedDim+1] =  dist; coordsIn[1*embedDim+2] = -dist;
1966:       coordsIn[2*embedDim+0] =  dist; coordsIn[2*embedDim+1] = -dist; coordsIn[2*embedDim+2] = -dist;
1967:       coordsIn[3*embedDim+0] = -dist; coordsIn[3*embedDim+1] = -dist; coordsIn[3*embedDim+2] = -dist;
1968:       coordsIn[4*embedDim+0] = -dist; coordsIn[4*embedDim+1] =  dist; coordsIn[4*embedDim+2] =  dist;
1969:       coordsIn[5*embedDim+0] =  dist; coordsIn[5*embedDim+1] =  dist; coordsIn[5*embedDim+2] =  dist;
1970:       coordsIn[6*embedDim+0] = -dist; coordsIn[6*embedDim+1] = -dist; coordsIn[6*embedDim+2] =  dist;
1971:       coordsIn[7*embedDim+0] =  dist; coordsIn[7*embedDim+1] = -dist; coordsIn[7*embedDim+2] =  dist;
1972:     }
1973:     break;
1974:   case 3:
1975:     if (simplex) {
1976:       DM              idm;
1977:       const PetscReal edgeLen         = 1.0/PETSC_PHI;
1978:       const PetscReal vertexA[4]      = {0.5, 0.5, 0.5, 0.5};
1979:       const PetscReal vertexB[4]      = {1.0, 0.0, 0.0, 0.0};
1980:       const PetscReal vertexC[4]      = {0.5, 0.5*PETSC_PHI, 0.5/PETSC_PHI, 0.0};
1981:       const PetscInt  degree          = 12;
1982:       PetscInt        s[4]            = {1, 1, 1};
1983:       PetscInt        evenPerm[12][4] = {{0, 1, 2, 3}, {0, 2, 3, 1}, {0, 3, 1, 2}, {1, 0, 3, 2}, {1, 2, 0, 3}, {1, 3, 2, 0},
1984:                                          {2, 0, 1, 3}, {2, 1, 3, 0}, {2, 3, 0, 1}, {3, 0, 2, 1}, {3, 1, 0, 2}, {3, 2, 1, 0}};
1985:       PetscInt        cone[4];
1986:       PetscInt       *graph, p, i, j, k, l;

1988:       numCells    = !rank ? 600 : 0;
1989:       numVerts    = !rank ? 120 : 0;
1990:       firstVertex = numCells;
1991:       /* Use the 600-cell, which for a unit sphere has coordinates which are

1993:            1/2 (\pm 1, \pm 1,    \pm 1, \pm 1)                          16
1994:                (\pm 1,    0,       0,      0)  all cyclic permutations   8
1995:            1/2 (\pm 1, \pm phi, \pm 1/phi, 0)  all even permutations    96

1997:          where \phi^2 - \phi - 1 = 0, meaning \phi is the golden ratio \frac{1 + \sqrt{5}}{2}. The edge
1998:          length is then given by 1/\phi = 2.73606.

2000:          http://buzzard.pugetsound.edu/sage-practice/ch03s03.html
2001:          http://mathworld.wolfram.com/600-Cell.html
2002:        */
2003:       /* Construct vertices */
2004:       PetscCalloc1(numVerts * embedDim, &coordsIn);
2005:       i    = 0;
2006:       for (s[0] = -1; s[0] < 2; s[0] += 2) {
2007:         for (s[1] = -1; s[1] < 2; s[1] += 2) {
2008:           for (s[2] = -1; s[2] < 2; s[2] += 2) {
2009:             for (s[3] = -1; s[3] < 2; s[3] += 2) {
2010:               for (d = 0; d < embedDim; ++d) coordsIn[i*embedDim+d] = s[d]*vertexA[d];
2011:               ++i;
2012:             }
2013:           }
2014:         }
2015:       }
2016:       for (p = 0; p < embedDim; ++p) {
2017:         s[1] = s[2] = s[3] = 1;
2018:         for (s[0] = -1; s[0] < 2; s[0] += 2) {
2019:           for (d = 0; d < embedDim; ++d) coordsIn[i*embedDim+d] = s[(d+p)%embedDim]*vertexB[(d+p)%embedDim];
2020:           ++i;
2021:         }
2022:       }
2023:       for (p = 0; p < 12; ++p) {
2024:         s[3] = 1;
2025:         for (s[0] = -1; s[0] < 2; s[0] += 2) {
2026:           for (s[1] = -1; s[1] < 2; s[1] += 2) {
2027:             for (s[2] = -1; s[2] < 2; s[2] += 2) {
2028:               for (d = 0; d < embedDim; ++d) coordsIn[i*embedDim+d] = s[evenPerm[p][d]]*vertexC[evenPerm[p][d]];
2029:               ++i;
2030:             }
2031:           }
2032:         }
2033:       }
2034:       if (i != numVerts) SETERRQ2(comm, PETSC_ERR_PLIB, "Invalid 600-cell, vertices %D != %D", i, numVerts);
2035:       /* Construct graph */
2036:       PetscCalloc1(numVerts * numVerts, &graph);
2037:       for (i = 0; i < numVerts; ++i) {
2038:         for (j = 0, k = 0; j < numVerts; ++j) {
2039:           if (PetscAbsReal(DiffNormReal(embedDim, &coordsIn[i*embedDim], &coordsIn[j*embedDim]) - edgeLen) < PETSC_SMALL) {graph[i*numVerts+j] = 1; ++k;}
2040:         }
2041:         if (k != degree) SETERRQ3(comm, PETSC_ERR_PLIB, "Invalid 600-cell, vertex %D degree %D != %D", i, k, degree);
2042:       }
2043:       /* Build Topology */
2044:       DMPlexSetChart(*dm, 0, numCells+numVerts);
2045:       for (c = 0; c < numCells; c++) {
2046:         DMPlexSetConeSize(*dm, c, embedDim);
2047:       }
2048:       DMSetUp(*dm); /* Allocate space for cones */
2049:       /* Cells */
2050:       for (i = 0, c = 0; i < numVerts; ++i) {
2051:         for (j = 0; j < i; ++j) {
2052:           for (k = 0; k < j; ++k) {
2053:             for (l = 0; l < k; ++l) {
2054:               if (graph[i*numVerts+j] && graph[j*numVerts+k] && graph[k*numVerts+i] &&
2055:                   graph[l*numVerts+i] && graph[l*numVerts+j] && graph[l*numVerts+k]) {
2056:                 cone[0] = firstVertex+i; cone[1] = firstVertex+j; cone[2] = firstVertex+k; cone[3] = firstVertex+l;
2057:                 /* Check orientation: https://ef.gy/linear-algebra:normal-vectors-in-higher-dimensional-spaces */
2058:                 {
2059:                   const PetscInt epsilon[4][4][4][4] = {{{{0,  0,  0,  0}, { 0, 0,  0,  0}, { 0,  0, 0,  0}, { 0,  0,  0, 0}},
2060:                                                          {{0,  0,  0,  0}, { 0, 0,  0,  0}, { 0,  0, 0,  1}, { 0,  0, -1, 0}},
2061:                                                          {{0,  0,  0,  0}, { 0, 0,  0, -1}, { 0,  0, 0,  0}, { 0,  1,  0, 0}},
2062:                                                          {{0,  0,  0,  0}, { 0, 0,  1,  0}, { 0, -1, 0,  0}, { 0,  0,  0, 0}}},

2064:                                                         {{{0,  0,  0,  0}, { 0, 0,  0,  0}, { 0,  0, 0, -1}, { 0,  0,  1, 0}},
2065:                                                          {{0,  0,  0,  0}, { 0, 0,  0,  0}, { 0,  0, 0,  0}, { 0,  0,  0, 0}},
2066:                                                          {{0,  0,  0,  1}, { 0, 0,  0,  0}, { 0,  0, 0,  0}, {-1,  0,  0, 0}},
2067:                                                          {{0,  0, -1,  0}, { 0, 0,  0,  0}, { 1,  0, 0,  0}, { 0,  0,  0, 0}}},

2069:                                                         {{{0,  0,  0,  0}, { 0, 0,  0,  1}, { 0,  0, 0,  0}, { 0, -1,  0, 0}},
2070:                                                          {{0,  0,  0, -1}, { 0, 0,  0,  0}, { 0,  0, 0,  0}, { 1,  0,  0, 0}},
2071:                                                          {{0,  0,  0,  0}, { 0, 0,  0,  0}, { 0,  0, 0,  0}, { 0,  0,  0, 0}},
2072:                                                          {{0,  1,  0,  0}, {-1, 0,  0,  0}, { 0,  0, 0,  0}, { 0,  0,  0, 0}}},

2074:                                                         {{{0,  0,  0,  0}, { 0, 0, -1,  0}, { 0,  1, 0,  0}, { 0,  0,  0, 0}},
2075:                                                          {{0,  0,  1,  0}, { 0, 0,  0,  0}, {-1,  0, 0,  0}, { 0,  0,  0, 0}},
2076:                                                          {{0, -1,  0,  0}, { 1, 0,  0,  0}, { 0,  0, 0,  0}, { 0,  0,  0, 0}},
2077:                                                          {{0,  0,  0,  0}, { 0, 0,  0,  0}, { 0,  0, 0,  0}, { 0,  0,  0, 0}}}};
2078:                   PetscReal normal[4];
2079:                   PetscInt  e, f, g;

2081:                   for (d = 0; d < embedDim; ++d) {
2082:                     normal[d] = 0.0;
2083:                     for (e = 0; e < embedDim; ++e) {
2084:                       for (f = 0; f < embedDim; ++f) {
2085:                         for (g = 0; g < embedDim; ++g) {
2086:                           normal[d] += epsilon[d][e][f][g]*(coordsIn[j*embedDim+e] - coordsIn[i*embedDim+e])*(coordsIn[k*embedDim+f] - coordsIn[i*embedDim+f])*(coordsIn[l*embedDim+f] - coordsIn[i*embedDim+f]);
2087:                         }
2088:                       }
2089:                     }
2090:                   }
2091:                   if (DotReal(embedDim, normal, &coordsIn[i*embedDim]) < 0) {PetscInt tmp = cone[1]; cone[1] = cone[2]; cone[2] = tmp;}
2092:                 }
2093:                 DMPlexSetCone(*dm, c++, cone);
2094:               }
2095:             }
2096:           }
2097:         }
2098:       }
2099:       DMPlexSymmetrize(*dm);
2100:       DMPlexStratify(*dm);
2101:       PetscFree(graph);
2102:       /* Interpolate mesh */
2103:       DMPlexInterpolate(*dm, &idm);
2104:       DMDestroy(dm);
2105:       *dm  = idm;
2106:       break;
2107:     }
2108:   default: SETERRQ1(comm, PETSC_ERR_SUP, "Unsupported dimension for sphere: %D", dim);
2109:   }
2110:   /* Create coordinates */
2111:   DMGetCoordinateSection(*dm, &coordSection);
2112:   PetscSectionSetNumFields(coordSection, 1);
2113:   PetscSectionSetFieldComponents(coordSection, 0, embedDim);
2114:   PetscSectionSetChart(coordSection, firstVertex, firstVertex+numVerts);
2115:   for (v = firstVertex; v < firstVertex+numVerts; ++v) {
2116:     PetscSectionSetDof(coordSection, v, embedDim);
2117:     PetscSectionSetFieldDof(coordSection, v, 0, embedDim);
2118:   }
2119:   PetscSectionSetUp(coordSection);
2120:   PetscSectionGetStorageSize(coordSection, &coordSize);
2121:   VecCreate(PETSC_COMM_SELF, &coordinates);
2122:   VecSetBlockSize(coordinates, embedDim);
2123:   PetscObjectSetName((PetscObject) coordinates, "coordinates");
2124:   VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
2125:   VecSetType(coordinates,VECSTANDARD);
2126:   VecGetArray(coordinates, &coords);
2127:   for (v = 0; v < numVerts; ++v) for (d = 0; d < embedDim; ++d) {coords[v*embedDim+d] = coordsIn[v*embedDim+d];}
2128:   VecRestoreArray(coordinates, &coords);
2129:   DMSetCoordinatesLocal(*dm, coordinates);
2130:   VecDestroy(&coordinates);
2131:   PetscFree(coordsIn);
2132:   return(0);
2133: }

2135: /* External function declarations here */
2136: extern PetscErrorCode DMCreateInterpolation_Plex(DM dmCoarse, DM dmFine, Mat *interpolation, Vec *scaling);
2137: extern PetscErrorCode DMCreateInjection_Plex(DM dmCoarse, DM dmFine, Mat *mat);
2138: extern PetscErrorCode DMCreateMassMatrix_Plex(DM dmCoarse, DM dmFine, Mat *mat);
2139: extern PetscErrorCode DMCreateDefaultSection_Plex(DM dm);
2140: extern PetscErrorCode DMCreateDefaultConstraints_Plex(DM dm);
2141: extern PetscErrorCode DMCreateMatrix_Plex(DM dm,  Mat *J);
2142: extern PetscErrorCode DMCreateCoordinateDM_Plex(DM dm, DM *cdm);
2143: extern PetscErrorCode DMCreateCoordinateField_Plex(DM dm, DMField *field);
2144: PETSC_INTERN PetscErrorCode DMClone_Plex(DM dm, DM *newdm);
2145: extern PetscErrorCode DMSetUp_Plex(DM dm);
2146: extern PetscErrorCode DMDestroy_Plex(DM dm);
2147: extern PetscErrorCode DMView_Plex(DM dm, PetscViewer viewer);
2148: extern PetscErrorCode DMLoad_Plex(DM dm, PetscViewer viewer);
2149: extern PetscErrorCode DMCreateSubDM_Plex(DM dm, PetscInt numFields, const PetscInt fields[], IS *is, DM *subdm);
2150: extern PetscErrorCode DMCreateSuperDM_Plex(DM dms[], PetscInt len, IS **is, DM *superdm);
2151: static PetscErrorCode DMInitialize_Plex(DM dm);

2153: /* Replace dm with the contents of dmNew
2154:    - Share the DM_Plex structure
2155:    - Share the coordinates
2156:    - Share the SF
2157: */
2158: static PetscErrorCode DMPlexReplace_Static(DM dm, DM dmNew)
2159: {
2160:   PetscSF               sf;
2161:   DM                    coordDM, coarseDM;
2162:   Vec                   coords;
2163:   PetscBool             isper;
2164:   const PetscReal      *maxCell, *L;
2165:   const DMBoundaryType *bd;
2166:   PetscErrorCode        ierr;

2169:   DMGetPointSF(dmNew, &sf);
2170:   DMSetPointSF(dm, sf);
2171:   DMGetCoordinateDM(dmNew, &coordDM);
2172:   DMGetCoordinatesLocal(dmNew, &coords);
2173:   DMSetCoordinateDM(dm, coordDM);
2174:   DMSetCoordinatesLocal(dm, coords);
2175:   DMGetPeriodicity(dm, &isper, &maxCell, &L, &bd);
2176:   DMSetPeriodicity(dmNew, isper, maxCell, L, bd);
2177:   DMDestroy_Plex(dm);
2178:   DMInitialize_Plex(dm);
2179:   dm->data = dmNew->data;
2180:   ((DM_Plex *) dmNew->data)->refct++;
2181:   dmNew->labels->refct++;
2182:   if (!--(dm->labels->refct)) {
2183:     DMLabelLink next = dm->labels->next;

2185:     /* destroy the labels */
2186:     while (next) {
2187:       DMLabelLink tmp = next->next;

2189:       DMLabelDestroy(&next->label);
2190:       PetscFree(next);
2191:       next = tmp;
2192:     }
2193:     PetscFree(dm->labels);
2194:   }
2195:   dm->labels = dmNew->labels;
2196:   dm->depthLabel = dmNew->depthLabel;
2197:   DMGetCoarseDM(dmNew,&coarseDM);
2198:   DMSetCoarseDM(dm,coarseDM);
2199:   return(0);
2200: }

2202: /* Swap dm with the contents of dmNew
2203:    - Swap the DM_Plex structure
2204:    - Swap the coordinates
2205:    - Swap the point PetscSF
2206: */
2207: static PetscErrorCode DMPlexSwap_Static(DM dmA, DM dmB)
2208: {
2209:   DM              coordDMA, coordDMB;
2210:   Vec             coordsA,  coordsB;
2211:   PetscSF         sfA,      sfB;
2212:   void            *tmp;
2213:   DMLabelLinkList listTmp;
2214:   DMLabel         depthTmp;
2215:   PetscInt        tmpI;
2216:   PetscErrorCode  ierr;

2219:   DMGetPointSF(dmA, &sfA);
2220:   DMGetPointSF(dmB, &sfB);
2221:   PetscObjectReference((PetscObject) sfA);
2222:   DMSetPointSF(dmA, sfB);
2223:   DMSetPointSF(dmB, sfA);
2224:   PetscObjectDereference((PetscObject) sfA);

2226:   DMGetCoordinateDM(dmA, &coordDMA);
2227:   DMGetCoordinateDM(dmB, &coordDMB);
2228:   PetscObjectReference((PetscObject) coordDMA);
2229:   DMSetCoordinateDM(dmA, coordDMB);
2230:   DMSetCoordinateDM(dmB, coordDMA);
2231:   PetscObjectDereference((PetscObject) coordDMA);

2233:   DMGetCoordinatesLocal(dmA, &coordsA);
2234:   DMGetCoordinatesLocal(dmB, &coordsB);
2235:   PetscObjectReference((PetscObject) coordsA);
2236:   DMSetCoordinatesLocal(dmA, coordsB);
2237:   DMSetCoordinatesLocal(dmB, coordsA);
2238:   PetscObjectDereference((PetscObject) coordsA);

2240:   tmp       = dmA->data;
2241:   dmA->data = dmB->data;
2242:   dmB->data = tmp;
2243:   listTmp   = dmA->labels;
2244:   dmA->labels = dmB->labels;
2245:   dmB->labels = listTmp;
2246:   depthTmp  = dmA->depthLabel;
2247:   dmA->depthLabel = dmB->depthLabel;
2248:   dmB->depthLabel = depthTmp;
2249:   tmpI         = dmA->levelup;
2250:   dmA->levelup = dmB->levelup;
2251:   dmB->levelup = tmpI;
2252:   return(0);
2253: }

2255: static PetscErrorCode DMPlexIsSimplex_Static(DM dm, PetscBool *isSimplex)
2256: {
2257:   PetscInt       dim, cStart, coneSize;

2261:   DMGetDimension(dm, &dim);
2262:   DMPlexGetHeightStratum(dm, 0, &cStart, NULL);
2263:   DMPlexGetConeSize(dm, cStart, &coneSize);
2264:   *isSimplex = coneSize == dim+1 ? PETSC_TRUE : PETSC_FALSE;
2265:   return(0);
2266: }

2268: PetscErrorCode DMSetFromOptions_NonRefinement_Plex(PetscOptionItems *PetscOptionsObject,DM dm)
2269: {
2270:   DM_Plex       *mesh = (DM_Plex*) dm->data;

2274:   /* Handle viewing */
2275:   PetscOptionsBool("-dm_plex_print_set_values", "Output all set values info", "DMPlexMatSetClosure", PETSC_FALSE, &mesh->printSetValues, NULL);
2276:   PetscOptionsInt("-dm_plex_print_fem", "Debug output level all fem computations", "DMPlexSNESComputeResidualFEM", 0, &mesh->printFEM, NULL);
2277:   PetscOptionsReal("-dm_plex_print_tol", "Tolerance for FEM output", "DMPlexSNESComputeResidualFEM", mesh->printTol, &mesh->printTol, NULL);
2278:   PetscOptionsInt("-dm_plex_print_l2", "Debug output level all L2 diff computations", "DMComputeL2Diff", 0, &mesh->printL2, NULL);
2279:   /* Point Location */
2280:   PetscOptionsBool("-dm_plex_hash_location", "Use grid hashing for point location", "DMInterpolate", PETSC_FALSE, &mesh->useHashLocation, NULL);
2281:   /* Partitioning and distribution */
2282:   PetscOptionsBool("-dm_plex_partition_balance", "Attempt to evenly divide points on partition boundary between processes", "DMPlexSetPartitionBalance", PETSC_FALSE, &mesh->partitionBalance, NULL);
2283:   /* Generation and remeshing */
2284:   PetscOptionsBool("-dm_plex_remesh_bd", "Allow changes to the boundary on remeshing", "DMAdapt", PETSC_FALSE, &mesh->remeshBd, NULL);
2285:   /* Projection behavior */
2286:   PetscOptionsInt("-dm_plex_max_projection_height", "Maxmimum mesh point height used to project locally", "DMPlexSetMaxProjectionHeight", 0, &mesh->maxProjectionHeight, NULL);
2287:   PetscOptionsBool("-dm_plex_regular_refinement", "Use special nested projection algorithm for regular refinement", "DMPlexSetRegularRefinement", mesh->regularRefinement, &mesh->regularRefinement, NULL);
2288:   /* Checking structure */
2289:   {
2290:     const char *cellTypes[] = {"simplex", "tensor", "unknown", "DMPlexCellType", "DM_PLEX_CELLTYPE_", NULL};
2291:     PetscEnum   ct;
2292:     PetscBool   flg = PETSC_FALSE, flg2 = PETSC_FALSE;

2294:     PetscOptionsBool("-dm_plex_check_symmetry", "Check that the adjacency information in the mesh is symmetric", "DMPlexCheckSymmetry", PETSC_FALSE, &flg, &flg2);
2295:     if (flg && flg2) {DMPlexCheckSymmetry(dm);}
2296:     PetscOptionsEnum("-dm_plex_check_skeleton", "Check that each cell has the correct number of vertices", "DMPlexCheckSkeleton", cellTypes, (PetscEnum) 0, &ct, &flg);
2297:     if (flg) {
2298:       PetscBool isSimplex = ct ? PETSC_FALSE : PETSC_TRUE;

2300:       if (ct == (PetscEnum) DM_PLEX_CELLTYPE_UNKNOWN) {DMPlexIsSimplex_Static(dm, &isSimplex);}
2301:       DMPlexCheckSkeleton(dm, isSimplex, 0);
2302:     }
2303:     PetscOptionsEnum("-dm_plex_check_faces", "Check that the faces of each cell give a vertex order this is consistent with what we expect from the cell type", "DMPlexCheckFaces", cellTypes, (PetscEnum) 0, &ct, &flg);
2304:     if (flg) {
2305:       PetscBool isSimplex = ct ? PETSC_FALSE : PETSC_TRUE;

2307:       if (ct == (PetscEnum) DM_PLEX_CELLTYPE_UNKNOWN) {DMPlexIsSimplex_Static(dm, &isSimplex);}
2308:       DMPlexCheckFaces(dm, isSimplex, 0);
2309:     }
2310:     PetscOptionsBool("-dm_plex_check_geometry", "Check that cells have positive volume", "DMPlexCheckGeometry", PETSC_FALSE, &flg, &flg2);
2311:     if (flg && flg2) {DMPlexCheckGeometry(dm);}
2312:   }

2314:   PetscPartitionerSetFromOptions(mesh->partitioner);
2315:   return(0);
2316: }

2318: static PetscErrorCode DMSetFromOptions_Plex(PetscOptionItems *PetscOptionsObject,DM dm)
2319: {
2320:   PetscInt       refine = 0, coarsen = 0, r;
2321:   PetscBool      isHierarchy;

2326:   PetscOptionsHead(PetscOptionsObject,"DMPlex Options");
2327:   /* Handle DMPlex refinement */
2328:   PetscOptionsInt("-dm_refine", "The number of uniform refinements", "DMCreate", refine, &refine, NULL);
2329:   PetscOptionsInt("-dm_refine_hierarchy", "The number of uniform refinements", "DMCreate", refine, &refine, &isHierarchy);
2330:   if (refine) {DMPlexSetRefinementUniform(dm, PETSC_TRUE);}
2331:   if (refine && isHierarchy) {
2332:     DM *dms, coarseDM;

2334:     DMGetCoarseDM(dm, &coarseDM);
2335:     PetscObjectReference((PetscObject)coarseDM);
2336:     PetscMalloc1(refine,&dms);
2337:     DMRefineHierarchy(dm, refine, dms);
2338:     /* Total hack since we do not pass in a pointer */
2339:     DMPlexSwap_Static(dm, dms[refine-1]);
2340:     if (refine == 1) {
2341:       DMSetCoarseDM(dm, dms[0]);
2342:       DMPlexSetRegularRefinement(dm, PETSC_TRUE);
2343:     } else {
2344:       DMSetCoarseDM(dm, dms[refine-2]);
2345:       DMPlexSetRegularRefinement(dm, PETSC_TRUE);
2346:       DMSetCoarseDM(dms[0], dms[refine-1]);
2347:       DMPlexSetRegularRefinement(dms[0], PETSC_TRUE);
2348:     }
2349:     DMSetCoarseDM(dms[refine-1], coarseDM);
2350:     PetscObjectDereference((PetscObject)coarseDM);
2351:     /* Free DMs */
2352:     for (r = 0; r < refine; ++r) {
2353:       DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dms[r]);
2354:       DMDestroy(&dms[r]);
2355:     }
2356:     PetscFree(dms);
2357:   } else {
2358:     for (r = 0; r < refine; ++r) {
2359:       DM refinedMesh;

2361:       DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dm);
2362:       DMRefine(dm, PetscObjectComm((PetscObject) dm), &refinedMesh);
2363:       /* Total hack since we do not pass in a pointer */
2364:       DMPlexReplace_Static(dm, refinedMesh);
2365:       DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dm);
2366:       DMDestroy(&refinedMesh);
2367:     }
2368:   }
2369:   /* Handle DMPlex coarsening */
2370:   PetscOptionsInt("-dm_coarsen", "Coarsen the mesh", "DMCreate", coarsen, &coarsen, NULL);
2371:   PetscOptionsInt("-dm_coarsen_hierarchy", "The number of coarsenings", "DMCreate", coarsen, &coarsen, &isHierarchy);
2372:   if (coarsen && isHierarchy) {
2373:     DM *dms;

2375:     PetscMalloc1(coarsen, &dms);
2376:     DMCoarsenHierarchy(dm, coarsen, dms);
2377:     /* Free DMs */
2378:     for (r = 0; r < coarsen; ++r) {
2379:       DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dms[r]);
2380:       DMDestroy(&dms[r]);
2381:     }
2382:     PetscFree(dms);
2383:   } else {
2384:     for (r = 0; r < coarsen; ++r) {
2385:       DM coarseMesh;

2387:       DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dm);
2388:       DMCoarsen(dm, PetscObjectComm((PetscObject) dm), &coarseMesh);
2389:       /* Total hack since we do not pass in a pointer */
2390:       DMPlexReplace_Static(dm, coarseMesh);
2391:       DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dm);
2392:       DMDestroy(&coarseMesh);
2393:     }
2394:   }
2395:   /* Handle */
2396:   DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dm);
2397:   PetscOptionsTail();
2398:   return(0);
2399: }

2401: static PetscErrorCode DMCreateGlobalVector_Plex(DM dm,Vec *vec)
2402: {

2406:   DMCreateGlobalVector_Section_Private(dm,vec);
2407:   /* VecSetOperation(*vec, VECOP_DUPLICATE, (void(*)(void)) VecDuplicate_MPI_DM); */
2408:   VecSetOperation(*vec, VECOP_VIEW, (void (*)(void)) VecView_Plex);
2409:   VecSetOperation(*vec, VECOP_VIEWNATIVE, (void (*)(void)) VecView_Plex_Native);
2410:   VecSetOperation(*vec, VECOP_LOAD, (void (*)(void)) VecLoad_Plex);
2411:   VecSetOperation(*vec, VECOP_LOADNATIVE, (void (*)(void)) VecLoad_Plex_Native);
2412:   return(0);
2413: }

2415: static PetscErrorCode DMCreateLocalVector_Plex(DM dm,Vec *vec)
2416: {

2420:   DMCreateLocalVector_Section_Private(dm,vec);
2421:   VecSetOperation(*vec, VECOP_VIEW, (void (*)(void)) VecView_Plex_Local);
2422:   VecSetOperation(*vec, VECOP_LOAD, (void (*)(void)) VecLoad_Plex_Local);
2423:   return(0);
2424: }

2426: static PetscErrorCode DMGetDimPoints_Plex(DM dm, PetscInt dim, PetscInt *pStart, PetscInt *pEnd)
2427: {
2428:   PetscInt       depth, d;

2432:   DMPlexGetDepth(dm, &depth);
2433:   if (depth == 1) {
2434:     DMGetDimension(dm, &d);
2435:     if (dim == 0)      {DMPlexGetDepthStratum(dm, dim, pStart, pEnd);}
2436:     else if (dim == d) {DMPlexGetDepthStratum(dm, 1, pStart, pEnd);}
2437:     else               {*pStart = 0; *pEnd = 0;}
2438:   } else {
2439:     DMPlexGetDepthStratum(dm, dim, pStart, pEnd);
2440:   }
2441:   return(0);
2442: }

2444: static PetscErrorCode DMGetNeighors_Plex(DM dm, PetscInt *nranks, const PetscMPIInt *ranks[])
2445: {
2446:   PetscSF        sf;

2450:   DMGetPointSF(dm, &sf);
2451:   PetscSFGetRanks(sf, nranks, ranks, NULL, NULL, NULL);
2452:   return(0);
2453: }

2455: static PetscErrorCode DMHasCreateInjection_Plex(DM dm, PetscBool *flg)
2456: {
2460:   *flg = PETSC_TRUE;
2461:   return(0);
2462: }

2464: static PetscErrorCode DMInitialize_Plex(DM dm)
2465: {

2469:   dm->ops->view                            = DMView_Plex;
2470:   dm->ops->load                            = DMLoad_Plex;
2471:   dm->ops->setfromoptions                  = DMSetFromOptions_Plex;
2472:   dm->ops->clone                           = DMClone_Plex;
2473:   dm->ops->setup                           = DMSetUp_Plex;
2474:   dm->ops->createdefaultsection            = DMCreateDefaultSection_Plex;
2475:   dm->ops->createdefaultconstraints        = DMCreateDefaultConstraints_Plex;
2476:   dm->ops->createglobalvector              = DMCreateGlobalVector_Plex;
2477:   dm->ops->createlocalvector               = DMCreateLocalVector_Plex;
2478:   dm->ops->getlocaltoglobalmapping         = NULL;
2479:   dm->ops->createfieldis                   = NULL;
2480:   dm->ops->createcoordinatedm              = DMCreateCoordinateDM_Plex;
2481:   dm->ops->createcoordinatefield           = DMCreateCoordinateField_Plex;
2482:   dm->ops->getcoloring                     = NULL;
2483:   dm->ops->creatematrix                    = DMCreateMatrix_Plex;
2484:   dm->ops->createinterpolation             = DMCreateInterpolation_Plex;
2485:   dm->ops->createmassmatrix                = DMCreateMassMatrix_Plex;
2486:   dm->ops->getaggregates                   = NULL;
2487:   dm->ops->getinjection                    = DMCreateInjection_Plex;
2488:   dm->ops->hascreateinjection              = DMHasCreateInjection_Plex;
2489:   dm->ops->refine                          = DMRefine_Plex;
2490:   dm->ops->coarsen                         = DMCoarsen_Plex;
2491:   dm->ops->refinehierarchy                 = DMRefineHierarchy_Plex;
2492:   dm->ops->coarsenhierarchy                = DMCoarsenHierarchy_Plex;
2493:   dm->ops->adaptlabel                      = DMAdaptLabel_Plex;
2494:   dm->ops->adaptmetric                     = DMAdaptMetric_Plex;
2495:   dm->ops->globaltolocalbegin              = NULL;
2496:   dm->ops->globaltolocalend                = NULL;
2497:   dm->ops->localtoglobalbegin              = NULL;
2498:   dm->ops->localtoglobalend                = NULL;
2499:   dm->ops->destroy                         = DMDestroy_Plex;
2500:   dm->ops->createsubdm                     = DMCreateSubDM_Plex;
2501:   dm->ops->createsuperdm                   = DMCreateSuperDM_Plex;
2502:   dm->ops->getdimpoints                    = DMGetDimPoints_Plex;
2503:   dm->ops->locatepoints                    = DMLocatePoints_Plex;
2504:   dm->ops->projectfunctionlocal            = DMProjectFunctionLocal_Plex;
2505:   dm->ops->projectfunctionlabellocal       = DMProjectFunctionLabelLocal_Plex;
2506:   dm->ops->projectfieldlocal               = DMProjectFieldLocal_Plex;
2507:   dm->ops->projectfieldlabellocal          = DMProjectFieldLabelLocal_Plex;
2508:   dm->ops->computel2diff                   = DMComputeL2Diff_Plex;
2509:   dm->ops->computel2gradientdiff           = DMComputeL2GradientDiff_Plex;
2510:   dm->ops->computel2fielddiff              = DMComputeL2FieldDiff_Plex;
2511:   dm->ops->getneighbors                    = DMGetNeighors_Plex;
2512:   PetscObjectComposeFunction((PetscObject)dm,"DMPlexInsertBoundaryValues_C",DMPlexInsertBoundaryValues_Plex);
2513:   PetscObjectComposeFunction((PetscObject)dm,"DMSetUpGLVisViewer_C",DMSetUpGLVisViewer_Plex);
2514:   return(0);
2515: }

2517: PETSC_INTERN PetscErrorCode DMClone_Plex(DM dm, DM *newdm)
2518: {
2519:   DM_Plex        *mesh = (DM_Plex *) dm->data;

2523:   mesh->refct++;
2524:   (*newdm)->data = mesh;
2525:   PetscObjectChangeTypeName((PetscObject) *newdm, DMPLEX);
2526:   DMInitialize_Plex(*newdm);
2527:   return(0);
2528: }

2530: /*MC
2531:   DMPLEX = "plex" - A DM object that encapsulates an unstructured mesh, or CW Complex, which can be expressed using a Hasse Diagram.
2532:                     In the local representation, Vecs contain all unknowns in the interior and shared boundary. This is
2533:                     specified by a PetscSection object. Ownership in the global representation is determined by
2534:                     ownership of the underlying DMPlex points. This is specified by another PetscSection object.

2536:   Options Database Keys:
2537: + -dm_plex_hash_location             - Use grid hashing for point location
2538: . -dm_plex_partition_balance         - Attempt to evenly divide points on partition boundary between processes
2539: . -dm_plex_remesh_bd                 - Allow changes to the boundary on remeshing
2540: . -dm_plex_max_projection_height     - Maxmimum mesh point height used to project locally
2541: . -dm_plex_regular_refinement        - Use special nested projection algorithm for regular refinement
2542: . -dm_plex_check_symmetry            - Check that the adjacency information in the mesh is symmetric
2543: . -dm_plex_check_skeleton <celltype> - Check that each cell has the correct number of vertices
2544: . -dm_plex_check_faces <celltype>    - Check that the faces of each cell give a vertex order this is consistent with what we expect from the cell type
2545: . -dm_plex_check_geometry            - Check that cells have positive volume
2546: . -dm_view :mesh.tex:ascii_latex     - View the mesh in LaTeX/TikZ
2547: . -dm_plex_view_scale <num>          - Scale the TikZ
2548: - -dm_plex_print_fem <num>           - View FEM assembly information, such as element vectors and matrices


2551:   Level: intermediate

2553: .seealso: DMType, DMPlexCreate(), DMCreate(), DMSetType()
2554: M*/

2556: PETSC_EXTERN PetscErrorCode DMCreate_Plex(DM dm)
2557: {
2558:   DM_Plex        *mesh;
2559:   PetscInt       unit, d;

2564:   PetscNewLog(dm,&mesh);
2565:   dm->dim  = 0;
2566:   dm->data = mesh;

2568:   mesh->refct             = 1;
2569:   PetscSectionCreate(PetscObjectComm((PetscObject)dm), &mesh->coneSection);
2570:   mesh->maxConeSize       = 0;
2571:   mesh->cones             = NULL;
2572:   mesh->coneOrientations  = NULL;
2573:   PetscSectionCreate(PetscObjectComm((PetscObject)dm), &mesh->supportSection);
2574:   mesh->maxSupportSize    = 0;
2575:   mesh->supports          = NULL;
2576:   mesh->refinementUniform = PETSC_TRUE;
2577:   mesh->refinementLimit   = -1.0;

2579:   mesh->facesTmp = NULL;

2581:   mesh->tetgenOpts   = NULL;
2582:   mesh->triangleOpts = NULL;
2583:   PetscPartitionerCreate(PetscObjectComm((PetscObject)dm), &mesh->partitioner);
2584:   mesh->remeshBd     = PETSC_FALSE;

2586:   mesh->subpointMap = NULL;

2588:   for (unit = 0; unit < NUM_PETSC_UNITS; ++unit) mesh->scale[unit] = 1.0;

2590:   mesh->regularRefinement   = PETSC_FALSE;
2591:   mesh->depthState          = -1;
2592:   mesh->globalVertexNumbers = NULL;
2593:   mesh->globalCellNumbers   = NULL;
2594:   mesh->anchorSection       = NULL;
2595:   mesh->anchorIS            = NULL;
2596:   mesh->createanchors       = NULL;
2597:   mesh->computeanchormatrix = NULL;
2598:   mesh->parentSection       = NULL;
2599:   mesh->parents             = NULL;
2600:   mesh->childIDs            = NULL;
2601:   mesh->childSection        = NULL;
2602:   mesh->children            = NULL;
2603:   mesh->referenceTree       = NULL;
2604:   mesh->getchildsymmetry    = NULL;
2605:   for (d = 0; d < 8; ++d) mesh->hybridPointMax[d] = PETSC_DETERMINE;
2606:   mesh->vtkCellHeight       = 0;
2607:   mesh->useAnchors          = PETSC_FALSE;

2609:   mesh->maxProjectionHeight = 0;

2611:   mesh->printSetValues = PETSC_FALSE;
2612:   mesh->printFEM       = 0;
2613:   mesh->printTol       = 1.0e-10;

2615:   DMInitialize_Plex(dm);
2616:   return(0);
2617: }

2619: /*@
2620:   DMPlexCreate - Creates a DMPlex object, which encapsulates an unstructured mesh, or CW complex, which can be expressed using a Hasse Diagram.

2622:   Collective on MPI_Comm

2624:   Input Parameter:
2625: . comm - The communicator for the DMPlex object

2627:   Output Parameter:
2628: . mesh  - The DMPlex object

2630:   Level: beginner

2632: .keywords: DMPlex, create
2633: @*/
2634: PetscErrorCode DMPlexCreate(MPI_Comm comm, DM *mesh)
2635: {

2640:   DMCreate(comm, mesh);
2641:   DMSetType(*mesh, DMPLEX);
2642:   return(0);
2643: }

2645: /*
2646:   This takes as input the common mesh generator output, a list of the vertices for each cell, but vertex numbers are global and an SF is built for them
2647: */
2648: /* TODO: invertCells and spaceDim arguments could be added also to to DMPlexCreateFromCellListParallel(), DMPlexBuildFromCellList_Internal() and DMPlexCreateFromCellList() */
2649: PetscErrorCode DMPlexBuildFromCellList_Parallel_Internal(DM dm, PetscInt spaceDim, PetscInt numCells, PetscInt numVertices, PetscInt numCorners, const int cells[], PetscBool invertCells, PetscSF *sfVert)
2650: {
2651:   PetscSF         sfPoint;
2652:   PetscLayout     vLayout;
2653:   PetscHSetI      vhash;
2654:   PetscSFNode    *remoteVerticesAdj, *vertexLocal, *vertexOwner, *remoteVertex;
2655:   const PetscInt *vrange;
2656:   PetscInt        numVerticesAdj, off = 0, *verticesAdj, numVerticesGhost = 0, *localVertex, *cone, c, p, v, g;
2657:   PetscMPIInt     rank, size;
2658:   PetscErrorCode  ierr;

2661:   MPI_Comm_rank(PetscObjectComm((PetscObject) dm), &rank);
2662:   MPI_Comm_size(PetscObjectComm((PetscObject) dm), &size);
2663:   /* Partition vertices */
2664:   PetscLayoutCreate(PetscObjectComm((PetscObject) dm), &vLayout);
2665:   PetscLayoutSetLocalSize(vLayout, numVertices);
2666:   PetscLayoutSetBlockSize(vLayout, 1);
2667:   PetscLayoutSetUp(vLayout);
2668:   PetscLayoutGetRanges(vLayout, &vrange);
2669:   /* Count vertices and map them to procs */
2670:   PetscHSetICreate(&vhash);
2671:   for (c = 0; c < numCells; ++c) {
2672:     for (p = 0; p < numCorners; ++p) {
2673:       PetscHSetIAdd(vhash, cells[c*numCorners+p]);
2674:     }
2675:   }
2676:   PetscHSetIGetSize(vhash, &numVerticesAdj);
2677:   PetscMalloc1(numVerticesAdj, &verticesAdj);
2678:   PetscHSetIGetElems(vhash, &off, verticesAdj);
2679:   PetscHSetIDestroy(&vhash);
2680:   if (off != numVerticesAdj) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Invalid number of local vertices %D should be %D", off, numVerticesAdj);
2681:   PetscSortInt(numVerticesAdj, verticesAdj);
2682:   PetscMalloc1(numVerticesAdj, &remoteVerticesAdj);
2683:   for (v = 0; v < numVerticesAdj; ++v) {
2684:     const PetscInt gv = verticesAdj[v];
2685:     PetscInt       vrank;

2687:     PetscFindInt(gv, size+1, vrange, &vrank);
2688:     vrank = vrank < 0 ? -(vrank+2) : vrank;
2689:     remoteVerticesAdj[v].index = gv - vrange[vrank];
2690:     remoteVerticesAdj[v].rank  = vrank;
2691:   }
2692:   /* Create cones */
2693:   DMPlexSetChart(dm, 0, numCells+numVerticesAdj);
2694:   for (c = 0; c < numCells; ++c) {DMPlexSetConeSize(dm, c, numCorners);}
2695:   DMSetUp(dm);
2696:   DMGetWorkArray(dm, numCorners, MPIU_INT, &cone);
2697:   for (c = 0; c < numCells; ++c) {
2698:     for (p = 0; p < numCorners; ++p) {
2699:       const PetscInt gv = cells[c*numCorners+p];
2700:       PetscInt       lv;

2702:       PetscFindInt(gv, numVerticesAdj, verticesAdj, &lv);
2703:       if (lv < 0) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Could not find global vertex %D in local connectivity", gv);
2704:       cone[p] = lv+numCells;
2705:     }
2706:     if (invertCells) { DMPlexInvertCell_Internal(spaceDim, numCorners, cone); }
2707:     DMPlexSetCone(dm, c, cone);
2708:   }
2709:   DMRestoreWorkArray(dm, numCorners, MPIU_INT, &cone);
2710:   /* Create SF for vertices */
2711:   PetscSFCreate(PetscObjectComm((PetscObject)dm), sfVert);
2712:   PetscObjectSetName((PetscObject) *sfVert, "Vertex Ownership SF");
2713:   PetscSFSetFromOptions(*sfVert);
2714:   PetscSFSetGraph(*sfVert, numVertices, numVerticesAdj, NULL, PETSC_OWN_POINTER, remoteVerticesAdj, PETSC_OWN_POINTER);
2715:   PetscFree(verticesAdj);
2716:   /* Build pointSF */
2717:   PetscMalloc2(numVerticesAdj, &vertexLocal, numVertices, &vertexOwner);
2718:   for (v = 0; v < numVerticesAdj; ++v) {vertexLocal[v].index = v+numCells; vertexLocal[v].rank = rank;}
2719:   for (v = 0; v < numVertices;    ++v) {vertexOwner[v].index = -1;         vertexOwner[v].rank = -1;}
2720:   PetscSFReduceBegin(*sfVert, MPIU_2INT, vertexLocal, vertexOwner, MPI_MAXLOC);
2721:   PetscSFReduceEnd(*sfVert, MPIU_2INT, vertexLocal, vertexOwner, MPI_MAXLOC);
2722:   for (v = 0; v < numVertices;    ++v) if (vertexOwner[v].rank < 0) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Global vertex %d on rank %d was unclaimed", v + vrange[rank], rank);
2723:   PetscSFBcastBegin(*sfVert, MPIU_2INT, vertexOwner, vertexLocal);
2724:   PetscSFBcastEnd(*sfVert, MPIU_2INT, vertexOwner, vertexLocal);
2725:   for (v = 0; v < numVerticesAdj; ++v) if (vertexLocal[v].rank != rank) ++numVerticesGhost;
2726:   PetscMalloc1(numVerticesGhost, &localVertex);
2727:   PetscMalloc1(numVerticesGhost, &remoteVertex);
2728:   for (v = 0, g = 0; v < numVerticesAdj; ++v) {
2729:     if (vertexLocal[v].rank != rank) {
2730:       localVertex[g]        = v+numCells;
2731:       remoteVertex[g].index = vertexLocal[v].index;
2732:       remoteVertex[g].rank  = vertexLocal[v].rank;
2733:       ++g;
2734:     }
2735:   }
2736:   PetscFree2(vertexLocal, vertexOwner);
2737:   if (g != numVerticesGhost) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid number of vertex ghosts %D should be %D", g, numVerticesGhost);
2738:   DMGetPointSF(dm, &sfPoint);
2739:   PetscObjectSetName((PetscObject) sfPoint, "point SF");
2740:   PetscSFSetGraph(sfPoint, numCells+numVerticesAdj, numVerticesGhost, localVertex, PETSC_OWN_POINTER, remoteVertex, PETSC_OWN_POINTER);
2741:   PetscLayoutDestroy(&vLayout);
2742:   /* Fill in the rest of the topology structure */
2743:   DMPlexSymmetrize(dm);
2744:   DMPlexStratify(dm);
2745:   return(0);
2746: }

2748: /*
2749:   This takes as input the coordinates for each owned vertex
2750: */
2751: PetscErrorCode DMPlexBuildCoordinates_Parallel_Internal(DM dm, PetscInt spaceDim, PetscInt numCells, PetscInt numV, PetscSF sfVert, const PetscReal vertexCoords[])
2752: {
2753:   PetscSection   coordSection;
2754:   Vec            coordinates;
2755:   PetscScalar   *coords;
2756:   PetscInt       numVertices, numVerticesAdj, coordSize, v;

2760:   DMSetCoordinateDim(dm, spaceDim);
2761:   PetscSFGetGraph(sfVert, &numVertices, &numVerticesAdj, NULL, NULL);
2762:   DMGetCoordinateSection(dm, &coordSection);
2763:   PetscSectionSetNumFields(coordSection, 1);
2764:   PetscSectionSetFieldComponents(coordSection, 0, spaceDim);
2765:   PetscSectionSetChart(coordSection, numCells, numCells + numVerticesAdj);
2766:   for (v = numCells; v < numCells+numVerticesAdj; ++v) {
2767:     PetscSectionSetDof(coordSection, v, spaceDim);
2768:     PetscSectionSetFieldDof(coordSection, v, 0, spaceDim);
2769:   }
2770:   PetscSectionSetUp(coordSection);
2771:   PetscSectionGetStorageSize(coordSection, &coordSize);
2772:   VecCreate(PetscObjectComm((PetscObject)dm), &coordinates);
2773:   VecSetBlockSize(coordinates, spaceDim);
2774:   PetscObjectSetName((PetscObject) coordinates, "coordinates");
2775:   VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
2776:   VecSetType(coordinates,VECSTANDARD);
2777:   VecGetArray(coordinates, &coords);
2778:   {
2779:     MPI_Datatype coordtype;

2781:     /* Need a temp buffer for coords if we have complex/single */
2782:     MPI_Type_contiguous(spaceDim, MPIU_SCALAR, &coordtype);
2783:     MPI_Type_commit(&coordtype);
2784: #if defined(PETSC_USE_COMPLEX)
2785:     {
2786:     PetscScalar *svertexCoords;
2787:     PetscInt    i;
2788:     PetscMalloc1(numV*spaceDim,&svertexCoords);
2789:     for (i=0; i<numV*spaceDim; i++) svertexCoords[i] = vertexCoords[i];
2790:     PetscSFBcastBegin(sfVert, coordtype, svertexCoords, coords);
2791:     PetscSFBcastEnd(sfVert, coordtype, svertexCoords, coords);
2792:     PetscFree(svertexCoords);
2793:     }
2794: #else
2795:     PetscSFBcastBegin(sfVert, coordtype, vertexCoords, coords);
2796:     PetscSFBcastEnd(sfVert, coordtype, vertexCoords, coords);
2797: #endif
2798:     MPI_Type_free(&coordtype);
2799:   }
2800:   VecRestoreArray(coordinates, &coords);
2801:   DMSetCoordinatesLocal(dm, coordinates);
2802:   VecDestroy(&coordinates);
2803:   return(0);
2804: }

2806: /*@C
2807:   DMPlexCreateFromCellListParallel - This takes as input common mesh generator output, a list of the vertices for each cell, and produces a DM

2809:   Input Parameters:
2810: + comm - The communicator
2811: . dim - The topological dimension of the mesh
2812: . numCells - The number of cells owned by this process
2813: . numVertices - The number of vertices owned by this process
2814: . numCorners - The number of vertices for each cell
2815: . interpolate - Flag indicating that intermediate mesh entities (faces, edges) should be created automatically
2816: . cells - An array of numCells*numCorners numbers, the global vertex numbers for each cell
2817: . spaceDim - The spatial dimension used for coordinates
2818: - vertexCoords - An array of numVertices*spaceDim numbers, the coordinates of each vertex

2820:   Output Parameter:
2821: + dm - The DM
2822: - vertexSF - Optional, SF describing complete vertex ownership

2824:   Note: Two triangles sharing a face
2825: $
2826: $        2
2827: $      / | \
2828: $     /  |  \
2829: $    /   |   \
2830: $   0  0 | 1  3
2831: $    \   |   /
2832: $     \  |  /
2833: $      \ | /
2834: $        1
2835: would have input
2836: $  numCells = 2, numVertices = 4
2837: $  cells = [0 1 2  1 3 2]
2838: $
2839: which would result in the DMPlex
2840: $
2841: $        4
2842: $      / | \
2843: $     /  |  \
2844: $    /   |   \
2845: $   2  0 | 1  5
2846: $    \   |   /
2847: $     \  |  /
2848: $      \ | /
2849: $        3

2851:   Level: beginner

2853: .seealso: DMPlexCreateFromCellList(), DMPlexCreateFromDAG(), DMPlexCreate()
2854: @*/
2855: PetscErrorCode DMPlexCreateFromCellListParallel(MPI_Comm comm, PetscInt dim, PetscInt numCells, PetscInt numVertices, PetscInt numCorners, PetscBool interpolate, const int cells[], PetscInt spaceDim, const PetscReal vertexCoords[], PetscSF *vertexSF, DM *dm)
2856: {
2857:   PetscSF        sfVert;

2861:   DMCreate(comm, dm);
2862:   DMSetType(*dm, DMPLEX);
2865:   DMSetDimension(*dm, dim);
2866:   DMPlexBuildFromCellList_Parallel_Internal(*dm, spaceDim, numCells, numVertices, numCorners, cells, PETSC_FALSE, &sfVert);
2867:   if (interpolate) {
2868:     DM idm;

2870:     DMPlexInterpolate(*dm, &idm);
2871:     DMDestroy(dm);
2872:     *dm  = idm;
2873:   }
2874:   DMPlexBuildCoordinates_Parallel_Internal(*dm, spaceDim, numCells, numVertices, sfVert, vertexCoords);
2875:   if (vertexSF) *vertexSF = sfVert;
2876:   else {PetscSFDestroy(&sfVert);}
2877:   return(0);
2878: }

2880: /*
2881:   This takes as input the common mesh generator output, a list of the vertices for each cell
2882: */
2883: PetscErrorCode DMPlexBuildFromCellList_Internal(DM dm, PetscInt spaceDim, PetscInt numCells, PetscInt numVertices, PetscInt numCorners, const int cells[], PetscBool invertCells)
2884: {
2885:   PetscInt      *cone, c, p;

2889:   DMPlexSetChart(dm, 0, numCells+numVertices);
2890:   for (c = 0; c < numCells; ++c) {
2891:     DMPlexSetConeSize(dm, c, numCorners);
2892:   }
2893:   DMSetUp(dm);
2894:   DMGetWorkArray(dm, numCorners, MPIU_INT, &cone);
2895:   for (c = 0; c < numCells; ++c) {
2896:     for (p = 0; p < numCorners; ++p) {
2897:       cone[p] = cells[c*numCorners+p]+numCells;
2898:     }
2899:     if (invertCells) { DMPlexInvertCell_Internal(spaceDim, numCorners, cone); }
2900:     DMPlexSetCone(dm, c, cone);
2901:   }
2902:   DMRestoreWorkArray(dm, numCorners, MPIU_INT, &cone);
2903:   DMPlexSymmetrize(dm);
2904:   DMPlexStratify(dm);
2905:   return(0);
2906: }

2908: /*
2909:   This takes as input the coordinates for each vertex
2910: */
2911: PetscErrorCode DMPlexBuildCoordinates_Internal(DM dm, PetscInt spaceDim, PetscInt numCells, PetscInt numVertices, const double vertexCoords[])
2912: {
2913:   PetscSection   coordSection;
2914:   Vec            coordinates;
2915:   DM             cdm;
2916:   PetscScalar   *coords;
2917:   PetscInt       v, d;

2921:   DMSetCoordinateDim(dm, spaceDim);
2922:   DMGetCoordinateSection(dm, &coordSection);
2923:   PetscSectionSetNumFields(coordSection, 1);
2924:   PetscSectionSetFieldComponents(coordSection, 0, spaceDim);
2925:   PetscSectionSetChart(coordSection, numCells, numCells + numVertices);
2926:   for (v = numCells; v < numCells+numVertices; ++v) {
2927:     PetscSectionSetDof(coordSection, v, spaceDim);
2928:     PetscSectionSetFieldDof(coordSection, v, 0, spaceDim);
2929:   }
2930:   PetscSectionSetUp(coordSection);

2932:   DMGetCoordinateDM(dm, &cdm);
2933:   DMCreateLocalVector(cdm, &coordinates);
2934:   VecSetBlockSize(coordinates, spaceDim);
2935:   PetscObjectSetName((PetscObject) coordinates, "coordinates");
2936:   VecGetArray(coordinates, &coords);
2937:   for (v = 0; v < numVertices; ++v) {
2938:     for (d = 0; d < spaceDim; ++d) {
2939:       coords[v*spaceDim+d] = vertexCoords[v*spaceDim+d];
2940:     }
2941:   }
2942:   VecRestoreArray(coordinates, &coords);
2943:   DMSetCoordinatesLocal(dm, coordinates);
2944:   VecDestroy(&coordinates);
2945:   return(0);
2946: }

2948: /*@C
2949:   DMPlexCreateFromCellList - This takes as input common mesh generator output, a list of the vertices for each cell, and produces a DM

2951:   Input Parameters:
2952: + comm - The communicator
2953: . dim - The topological dimension of the mesh
2954: . numCells - The number of cells
2955: . numVertices - The number of vertices
2956: . numCorners - The number of vertices for each cell
2957: . interpolate - Flag indicating that intermediate mesh entities (faces, edges) should be created automatically
2958: . cells - An array of numCells*numCorners numbers, the vertices for each cell
2959: . spaceDim - The spatial dimension used for coordinates
2960: - vertexCoords - An array of numVertices*spaceDim numbers, the coordinates of each vertex

2962:   Output Parameter:
2963: . dm - The DM

2965:   Note: Two triangles sharing a face
2966: $
2967: $        2
2968: $      / | \
2969: $     /  |  \
2970: $    /   |   \
2971: $   0  0 | 1  3
2972: $    \   |   /
2973: $     \  |  /
2974: $      \ | /
2975: $        1
2976: would have input
2977: $  numCells = 2, numVertices = 4
2978: $  cells = [0 1 2  1 3 2]
2979: $
2980: which would result in the DMPlex
2981: $
2982: $        4
2983: $      / | \
2984: $     /  |  \
2985: $    /   |   \
2986: $   2  0 | 1  5
2987: $    \   |   /
2988: $     \  |  /
2989: $      \ | /
2990: $        3

2992:   Level: beginner

2994: .seealso: DMPlexCreateFromDAG(), DMPlexCreate()
2995: @*/
2996: PetscErrorCode DMPlexCreateFromCellList(MPI_Comm comm, PetscInt dim, PetscInt numCells, PetscInt numVertices, PetscInt numCorners, PetscBool interpolate, const int cells[], PetscInt spaceDim, const double vertexCoords[], DM *dm)
2997: {

3001:   DMCreate(comm, dm);
3002:   DMSetType(*dm, DMPLEX);
3003:   DMSetDimension(*dm, dim);
3004:   DMPlexBuildFromCellList_Internal(*dm, spaceDim, numCells, numVertices, numCorners, cells, PETSC_FALSE);
3005:   if (interpolate) {
3006:     DM idm;

3008:     DMPlexInterpolate(*dm, &idm);
3009:     DMDestroy(dm);
3010:     *dm  = idm;
3011:   }
3012:   DMPlexBuildCoordinates_Internal(*dm, spaceDim, numCells, numVertices, vertexCoords);
3013:   return(0);
3014: }

3016: /*@
3017:   DMPlexCreateFromDAG - This takes as input the adjacency-list representation of the Directed Acyclic Graph (Hasse Diagram) encoding a mesh, and produces a DM

3019:   Input Parameters:
3020: + dm - The empty DM object, usually from DMCreate() and DMSetDimension()
3021: . depth - The depth of the DAG
3022: . numPoints - Array of size depth + 1 containing the number of points at each depth
3023: . coneSize - The cone size of each point
3024: . cones - The concatenation of the cone points for each point, the cone list must be oriented correctly for each point
3025: . coneOrientations - The orientation of each cone point
3026: - vertexCoords - An array of numPoints[0]*spacedim numbers representing the coordinates of each vertex, with spacedim the value set via DMSetCoordinateDim()

3028:   Output Parameter:
3029: . dm - The DM

3031:   Note: Two triangles sharing a face would have input
3032: $  depth = 1, numPoints = [4 2], coneSize = [3 3 0 0 0 0]
3033: $  cones = [2 3 4  3 5 4], coneOrientations = [0 0 0  0 0 0]
3034: $ vertexCoords = [-1.0 0.0  0.0 -1.0  0.0 1.0  1.0 0.0]
3035: $
3036: which would result in the DMPlex
3037: $
3038: $        4
3039: $      / | \
3040: $     /  |  \
3041: $    /   |   \
3042: $   2  0 | 1  5
3043: $    \   |   /
3044: $     \  |  /
3045: $      \ | /
3046: $        3
3047: $
3048: $ Notice that all points are numbered consecutively, unlikely DMPlexCreateFromCellList()

3050:   Level: advanced

3052: .seealso: DMPlexCreateFromCellList(), DMPlexCreate()
3053: @*/
3054: PetscErrorCode DMPlexCreateFromDAG(DM dm, PetscInt depth, const PetscInt numPoints[], const PetscInt coneSize[], const PetscInt cones[], const PetscInt coneOrientations[], const PetscScalar vertexCoords[])
3055: {
3056:   Vec            coordinates;
3057:   PetscSection   coordSection;
3058:   PetscScalar    *coords;
3059:   PetscInt       coordSize, firstVertex = -1, pStart = 0, pEnd = 0, p, v, dim, dimEmbed, d, off;

3063:   DMGetDimension(dm, &dim);
3064:   DMGetCoordinateDim(dm, &dimEmbed);
3065:   if (dimEmbed < dim) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Embedding dimension %d cannot be less than intrinsic dimension %d",dimEmbed,dim);
3066:   for (d = 0; d <= depth; ++d) pEnd += numPoints[d];
3067:   DMPlexSetChart(dm, pStart, pEnd);
3068:   for (p = pStart; p < pEnd; ++p) {
3069:     DMPlexSetConeSize(dm, p, coneSize[p-pStart]);
3070:     if (firstVertex < 0 && !coneSize[p - pStart]) {
3071:       firstVertex = p - pStart;
3072:     }
3073:   }
3074:   if (firstVertex < 0 && numPoints[0]) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Expected %d vertices but could not find any", numPoints[0]);
3075:   DMSetUp(dm); /* Allocate space for cones */
3076:   for (p = pStart, off = 0; p < pEnd; off += coneSize[p-pStart], ++p) {
3077:     DMPlexSetCone(dm, p, &cones[off]);
3078:     DMPlexSetConeOrientation(dm, p, &coneOrientations[off]);
3079:   }
3080:   DMPlexSymmetrize(dm);
3081:   DMPlexStratify(dm);
3082:   /* Build coordinates */
3083:   DMGetCoordinateSection(dm, &coordSection);
3084:   PetscSectionSetNumFields(coordSection, 1);
3085:   PetscSectionSetFieldComponents(coordSection, 0, dimEmbed);
3086:   PetscSectionSetChart(coordSection, firstVertex, firstVertex+numPoints[0]);
3087:   for (v = firstVertex; v < firstVertex+numPoints[0]; ++v) {
3088:     PetscSectionSetDof(coordSection, v, dimEmbed);
3089:     PetscSectionSetFieldDof(coordSection, v, 0, dimEmbed);
3090:   }
3091:   PetscSectionSetUp(coordSection);
3092:   PetscSectionGetStorageSize(coordSection, &coordSize);
3093:   VecCreate(PETSC_COMM_SELF, &coordinates);
3094:   PetscObjectSetName((PetscObject) coordinates, "coordinates");
3095:   VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
3096:   VecSetBlockSize(coordinates, dimEmbed);
3097:   VecSetType(coordinates,VECSTANDARD);
3098:   VecGetArray(coordinates, &coords);
3099:   for (v = 0; v < numPoints[0]; ++v) {
3100:     PetscInt off;

3102:     PetscSectionGetOffset(coordSection, v+firstVertex, &off);
3103:     for (d = 0; d < dimEmbed; ++d) {
3104:       coords[off+d] = vertexCoords[v*dimEmbed+d];
3105:     }
3106:   }
3107:   VecRestoreArray(coordinates, &coords);
3108:   DMSetCoordinatesLocal(dm, coordinates);
3109:   VecDestroy(&coordinates);
3110:   return(0);
3111: }

3113: /*@C
3114:   DMPlexCreateCellVertexFromFile - Create a DMPlex mesh from a simple cell-vertex file.

3116: + comm        - The MPI communicator
3117: . filename    - Name of the .dat file
3118: - interpolate - Create faces and edges in the mesh

3120:   Output Parameter:
3121: . dm  - The DM object representing the mesh

3123:   Note: The format is the simplest possible:
3124: $ Ne
3125: $ v0 v1 ... vk
3126: $ Nv
3127: $ x y z marker

3129:   Level: beginner

3131: .seealso: DMPlexCreateFromFile(), DMPlexCreateMedFromFile(), DMPlexCreateGmsh(), DMPlexCreate()
3132: @*/
3133: PetscErrorCode DMPlexCreateCellVertexFromFile(MPI_Comm comm, const char filename[], PetscBool interpolate, DM *dm)
3134: {
3135:   DMLabel         marker;
3136:   PetscViewer     viewer;
3137:   Vec             coordinates;
3138:   PetscSection    coordSection;
3139:   PetscScalar    *coords;
3140:   char            line[PETSC_MAX_PATH_LEN];
3141:   PetscInt        dim = 3, cdim = 3, coordSize, v, c, d;
3142:   PetscMPIInt     rank;
3143:   int             snum, Nv, Nc;
3144:   PetscErrorCode  ierr;

3147:   MPI_Comm_rank(comm, &rank);
3148:   PetscViewerCreate(comm, &viewer);
3149:   PetscViewerSetType(viewer, PETSCVIEWERASCII);
3150:   PetscViewerFileSetMode(viewer, FILE_MODE_READ);
3151:   PetscViewerFileSetName(viewer, filename);
3152:   if (!rank) {
3153:     PetscViewerRead(viewer, line, 2, NULL, PETSC_STRING);
3154:     snum = sscanf(line, "%d %d", &Nc, &Nv);
3155:     if (snum != 2) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Unable to parse cell-vertex file: %s", line);
3156:   } else {
3157:     Nc = Nv = 0;
3158:   }
3159:   DMCreate(comm, dm);
3160:   DMSetType(*dm, DMPLEX);
3161:   DMPlexSetChart(*dm, 0, Nc+Nv);
3162:   DMSetDimension(*dm, dim);
3163:   DMSetCoordinateDim(*dm, cdim);
3164:   /* Read topology */
3165:   if (!rank) {
3166:     PetscInt cone[8], corners = 8;
3167:     int      vbuf[8], v;

3169:     for (c = 0; c < Nc; ++c) {DMPlexSetConeSize(*dm, c, corners);}
3170:     DMSetUp(*dm);
3171:     for (c = 0; c < Nc; ++c) {
3172:       PetscViewerRead(viewer, line, corners, NULL, PETSC_STRING);
3173:       snum = sscanf(line, "%d %d %d %d %d %d %d %d", &vbuf[0], &vbuf[1], &vbuf[2], &vbuf[3], &vbuf[4], &vbuf[5], &vbuf[6], &vbuf[7]);
3174:       if (snum != corners) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Unable to parse cell-vertex file: %s", line);
3175:       for (v = 0; v < corners; ++v) cone[v] = vbuf[v] + Nc;
3176:       /* Hexahedra are inverted */
3177:       {
3178:         PetscInt tmp = cone[1];
3179:         cone[1] = cone[3];
3180:         cone[3] = tmp;
3181:       }
3182:       DMPlexSetCone(*dm, c, cone);
3183:     }
3184:   }
3185:   DMPlexSymmetrize(*dm);
3186:   DMPlexStratify(*dm);
3187:   /* Read coordinates */
3188:   DMGetCoordinateSection(*dm, &coordSection);
3189:   PetscSectionSetNumFields(coordSection, 1);
3190:   PetscSectionSetFieldComponents(coordSection, 0, cdim);
3191:   PetscSectionSetChart(coordSection, Nc, Nc + Nv);
3192:   for (v = Nc; v < Nc+Nv; ++v) {
3193:     PetscSectionSetDof(coordSection, v, cdim);
3194:     PetscSectionSetFieldDof(coordSection, v, 0, cdim);
3195:   }
3196:   PetscSectionSetUp(coordSection);
3197:   PetscSectionGetStorageSize(coordSection, &coordSize);
3198:   VecCreate(PETSC_COMM_SELF, &coordinates);
3199:   PetscObjectSetName((PetscObject) coordinates, "coordinates");
3200:   VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
3201:   VecSetBlockSize(coordinates, cdim);
3202:   VecSetType(coordinates, VECSTANDARD);
3203:   VecGetArray(coordinates, &coords);
3204:   if (!rank) {
3205:     double x[3];
3206:     int    val;

3208:     DMCreateLabel(*dm, "marker");
3209:     DMGetLabel(*dm, "marker", &marker);
3210:     for (v = 0; v < Nv; ++v) {
3211:       PetscViewerRead(viewer, line, 4, NULL, PETSC_STRING);
3212:       snum = sscanf(line, "%lg %lg %lg %d", &x[0], &x[1], &x[2], &val);
3213:       if (snum != 4) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Unable to parse cell-vertex file: %s", line);
3214:       for (d = 0; d < cdim; ++d) coords[v*cdim+d] = x[d];
3215:       if (val) {DMLabelSetValue(marker, v+Nc, val);}
3216:     }
3217:   }
3218:   VecRestoreArray(coordinates, &coords);
3219:   DMSetCoordinatesLocal(*dm, coordinates);
3220:   VecDestroy(&coordinates);
3221:   PetscViewerDestroy(&viewer);
3222:   if (interpolate) {
3223:     DM      idm;
3224:     DMLabel bdlabel;

3226:     DMPlexInterpolate(*dm, &idm);
3227:     DMDestroy(dm);
3228:     *dm  = idm;

3230:     DMGetLabel(*dm, "marker", &bdlabel);
3231:     DMPlexMarkBoundaryFaces(*dm, PETSC_DETERMINE, bdlabel);
3232:     DMPlexLabelComplete(*dm, bdlabel);
3233:   }
3234:   return(0);
3235: }

3237: /*@C
3238:   DMPlexCreateFromFile - This takes a filename and produces a DM

3240:   Input Parameters:
3241: + comm - The communicator
3242: . filename - A file name
3243: - interpolate - Flag to create intermediate mesh pieces (edges, faces)

3245:   Output Parameter:
3246: . dm - The DM

3248:   Options Database Keys:
3249: . -dm_plex_create_from_hdf5_xdmf - use the PETSC_VIEWER_HDF5_XDMF format for reading HDF5 

3251:   Level: beginner

3253: .seealso: DMPlexCreateFromDAG(), DMPlexCreateFromCellList(), DMPlexCreate()
3254: @*/
3255: PetscErrorCode DMPlexCreateFromFile(MPI_Comm comm, const char filename[], PetscBool interpolate, DM *dm)
3256: {
3257:   const char    *extGmsh    = ".msh";
3258:   const char    *extGmsh2   = ".msh2";
3259:   const char    *extGmsh4   = ".msh4";
3260:   const char    *extCGNS    = ".cgns";
3261:   const char    *extExodus  = ".exo";
3262:   const char    *extGenesis = ".gen";
3263:   const char    *extFluent  = ".cas";
3264:   const char    *extHDF5    = ".h5";
3265:   const char    *extMed     = ".med";
3266:   const char    *extPLY     = ".ply";
3267:   const char    *extCV      = ".dat";
3268:   size_t         len;
3269:   PetscBool      isGmsh, isGmsh2, isGmsh4, isCGNS, isExodus, isGenesis, isFluent, isHDF5, isMed, isPLY, isCV;
3270:   PetscMPIInt    rank;

3276:   MPI_Comm_rank(comm, &rank);
3277:   PetscStrlen(filename, &len);
3278:   if (!len) SETERRQ(comm, PETSC_ERR_ARG_WRONG, "Filename must be a valid path");
3279:   PetscStrncmp(&filename[PetscMax(0,len-4)], extGmsh,    4, &isGmsh);
3280:   PetscStrncmp(&filename[PetscMax(0,len-5)], extGmsh2,   5, &isGmsh2);
3281:   PetscStrncmp(&filename[PetscMax(0,len-5)], extGmsh4,   5, &isGmsh4);
3282:   PetscStrncmp(&filename[PetscMax(0,len-5)], extCGNS,    5, &isCGNS);
3283:   PetscStrncmp(&filename[PetscMax(0,len-4)], extExodus,  4, &isExodus);
3284:   PetscStrncmp(&filename[PetscMax(0,len-4)], extGenesis, 4, &isGenesis);
3285:   PetscStrncmp(&filename[PetscMax(0,len-4)], extFluent,  4, &isFluent);
3286:   PetscStrncmp(&filename[PetscMax(0,len-3)], extHDF5,    3, &isHDF5);
3287:   PetscStrncmp(&filename[PetscMax(0,len-4)], extMed,     4, &isMed);
3288:   PetscStrncmp(&filename[PetscMax(0,len-4)], extPLY,     4, &isPLY);
3289:   PetscStrncmp(&filename[PetscMax(0,len-4)], extCV,      4, &isCV);
3290:   if (isGmsh || isGmsh2 || isGmsh4) {
3291:     DMPlexCreateGmshFromFile(comm, filename, interpolate, dm);
3292:   } else if (isCGNS) {
3293:     DMPlexCreateCGNSFromFile(comm, filename, interpolate, dm);
3294:   } else if (isExodus || isGenesis) {
3295:     DMPlexCreateExodusFromFile(comm, filename, interpolate, dm);
3296:   } else if (isFluent) {
3297:     DMPlexCreateFluentFromFile(comm, filename, interpolate, dm);
3298:   } else if (isHDF5) {
3299:     PetscBool      load_hdf5_xdmf = PETSC_FALSE;
3300:     PetscViewer viewer;

3302:     /* PETSC_VIEWER_HDF5_XDMF is used if the filename ends with .xdmf.h5, or if -dm_plex_create_from_hdf5_xdmf option is present */
3303:     PetscStrncmp(&filename[PetscMax(0,len-8)], ".xdmf",  5, &load_hdf5_xdmf);
3304:     PetscOptionsGetBool(NULL, NULL, "-dm_plex_create_from_hdf5_xdmf", &load_hdf5_xdmf, NULL);
3305:     PetscViewerCreate(comm, &viewer);
3306:     PetscViewerSetType(viewer, PETSCVIEWERHDF5);
3307:     PetscViewerFileSetMode(viewer, FILE_MODE_READ);
3308:     PetscViewerFileSetName(viewer, filename);
3309:     DMCreate(comm, dm);
3310:     DMSetType(*dm, DMPLEX);
3311:     if (load_hdf5_xdmf) {PetscViewerPushFormat(viewer, PETSC_VIEWER_HDF5_XDMF);}
3312:     DMLoad(*dm, viewer);
3313:     if (load_hdf5_xdmf) {PetscViewerPopFormat(viewer);}
3314:     PetscViewerDestroy(&viewer);

3316:     if (interpolate) {
3317:       DM idm;

3319:       DMPlexInterpolate(*dm, &idm);
3320:       DMDestroy(dm);
3321:       *dm  = idm;
3322:     }
3323:   } else if (isMed) {
3324:     DMPlexCreateMedFromFile(comm, filename, interpolate, dm);
3325:   } else if (isPLY) {
3326:     DMPlexCreatePLYFromFile(comm, filename, interpolate, dm);
3327:   } else if (isCV) {
3328:     DMPlexCreateCellVertexFromFile(comm, filename, interpolate, dm);
3329:   } else SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Cannot load file %s: unrecognized extension", filename);
3330:   return(0);
3331: }

3333: /*@
3334:   DMPlexCreateReferenceCell - Create a DMPLEX with the appropriate FEM reference cell

3336:   Collective on comm

3338:   Input Parameters:
3339: + comm    - The communicator
3340: . dim     - The spatial dimension
3341: - simplex - Flag for simplex, otherwise use a tensor-product cell

3343:   Output Parameter:
3344: . refdm - The reference cell

3346:   Level: intermediate

3348: .keywords: reference cell
3349: .seealso:
3350: @*/
3351: PetscErrorCode DMPlexCreateReferenceCell(MPI_Comm comm, PetscInt dim, PetscBool simplex, DM *refdm)
3352: {
3353:   DM             rdm;
3354:   Vec            coords;

3358:   DMCreate(comm, &rdm);
3359:   DMSetType(rdm, DMPLEX);
3360:   DMSetDimension(rdm, dim);
3361:   switch (dim) {
3362:   case 0:
3363:   {
3364:     PetscInt    numPoints[1]        = {1};
3365:     PetscInt    coneSize[1]         = {0};
3366:     PetscInt    cones[1]            = {0};
3367:     PetscInt    coneOrientations[1] = {0};
3368:     PetscScalar vertexCoords[1]     = {0.0};

3370:     DMPlexCreateFromDAG(rdm, 0, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3371:   }
3372:   break;
3373:   case 1:
3374:   {
3375:     PetscInt    numPoints[2]        = {2, 1};
3376:     PetscInt    coneSize[3]         = {2, 0, 0};
3377:     PetscInt    cones[2]            = {1, 2};
3378:     PetscInt    coneOrientations[2] = {0, 0};
3379:     PetscScalar vertexCoords[2]     = {-1.0,  1.0};

3381:     DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3382:   }
3383:   break;
3384:   case 2:
3385:     if (simplex) {
3386:       PetscInt    numPoints[2]        = {3, 1};
3387:       PetscInt    coneSize[4]         = {3, 0, 0, 0};
3388:       PetscInt    cones[3]            = {1, 2, 3};
3389:       PetscInt    coneOrientations[3] = {0, 0, 0};
3390:       PetscScalar vertexCoords[6]     = {-1.0, -1.0,  1.0, -1.0,  -1.0, 1.0};

3392:       DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3393:     } else {
3394:       PetscInt    numPoints[2]        = {4, 1};
3395:       PetscInt    coneSize[5]         = {4, 0, 0, 0, 0};
3396:       PetscInt    cones[4]            = {1, 2, 3, 4};
3397:       PetscInt    coneOrientations[4] = {0, 0, 0, 0};
3398:       PetscScalar vertexCoords[8]     = {-1.0, -1.0,  1.0, -1.0,  1.0, 1.0,  -1.0, 1.0};

3400:       DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3401:     }
3402:   break;
3403:   case 3:
3404:     if (simplex) {
3405:       PetscInt    numPoints[2]        = {4, 1};
3406:       PetscInt    coneSize[5]         = {4, 0, 0, 0, 0};
3407:       PetscInt    cones[4]            = {1, 3, 2, 4};
3408:       PetscInt    coneOrientations[4] = {0, 0, 0, 0};
3409:       PetscScalar vertexCoords[12]    = {-1.0, -1.0, -1.0,  1.0, -1.0, -1.0,  -1.0, 1.0, -1.0,  -1.0, -1.0, 1.0};

3411:       DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3412:     } else {
3413:       PetscInt    numPoints[2]        = {8, 1};
3414:       PetscInt    coneSize[9]         = {8, 0, 0, 0, 0, 0, 0, 0, 0};
3415:       PetscInt    cones[8]            = {1, 4, 3, 2, 5, 6, 7, 8};
3416:       PetscInt    coneOrientations[8] = {0, 0, 0, 0, 0, 0, 0, 0};
3417:       PetscScalar vertexCoords[24]    = {-1.0, -1.0, -1.0,  1.0, -1.0, -1.0,  1.0, 1.0, -1.0,  -1.0, 1.0, -1.0,
3418:                                          -1.0, -1.0,  1.0,  1.0, -1.0,  1.0,  1.0, 1.0,  1.0,  -1.0, 1.0,  1.0};

3420:       DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3421:     }
3422:   break;
3423:   default:
3424:     SETERRQ1(comm, PETSC_ERR_ARG_WRONG, "Cannot create reference cell for dimension %d", dim);
3425:   }
3426:   DMPlexInterpolate(rdm, refdm);
3427:   if (rdm->coordinateDM) {
3428:     DM           ncdm;
3429:     PetscSection cs;
3430:     PetscInt     pEnd = -1;

3432:     DMGetSection(rdm->coordinateDM, &cs);
3433:     if (cs) {PetscSectionGetChart(cs, NULL, &pEnd);}
3434:     if (pEnd >= 0) {
3435:       DMClone(rdm->coordinateDM, &ncdm);
3436:       DMCopyDisc(rdm->coordinateDM, ncdm);
3437:       DMSetSection(ncdm, cs);
3438:       DMSetCoordinateDM(*refdm, ncdm);
3439:       DMDestroy(&ncdm);
3440:     }
3441:   }
3442:   DMGetCoordinatesLocal(rdm, &coords);
3443:   if (coords) {
3444:     DMSetCoordinatesLocal(*refdm, coords);
3445:   } else {
3446:     DMGetCoordinates(rdm, &coords);
3447:     if (coords) {DMSetCoordinates(*refdm, coords);}
3448:   }
3449:   DMDestroy(&rdm);
3450:   return(0);
3451: }