Actual source code: plexcreate.c
1: #define PETSCDM_DLL
2: #include <petsc/private/dmpleximpl.h>
3: #include <petsc/private/hashseti.h>
4: #include <petscsf.h>
6: PetscLogEvent DMPLEX_CreateFromFile, DMPLEX_BuildFromCellList, DMPLEX_BuildCoordinatesFromCellList;
8: /*@
9: DMPlexCreateDoublet - Creates a mesh of two cells of the specified type, optionally with later refinement.
11: Collective
13: Input Parameters:
14: + comm - The communicator for the DM object
15: . dim - The spatial dimension
16: . simplex - Flag for simplicial cells, otherwise they are tensor product cells
17: . interpolate - Flag to create intermediate mesh pieces (edges, faces)
18: - refinementLimit - A nonzero number indicates the largest admissible volume for a refined cell
20: Output Parameter:
21: . dm - The DM object
23: Level: beginner
25: .seealso: DMSetType(), DMCreate()
26: @*/
27: PetscErrorCode DMPlexCreateDoublet(MPI_Comm comm, PetscInt dim, PetscBool simplex, PetscBool interpolate, PetscReal refinementLimit, DM *newdm)
28: {
29: DM dm;
30: PetscMPIInt rank;
34: DMCreate(comm, &dm);
35: DMSetType(dm, DMPLEX);
36: DMSetDimension(dm, dim);
37: MPI_Comm_rank(comm, &rank);
38: switch (dim) {
39: case 2:
40: if (simplex) {PetscObjectSetName((PetscObject) dm, "triangular");}
41: else {PetscObjectSetName((PetscObject) dm, "quadrilateral");}
42: break;
43: case 3:
44: if (simplex) {PetscObjectSetName((PetscObject) dm, "tetrahedral");}
45: else {PetscObjectSetName((PetscObject) dm, "hexahedral");}
46: break;
47: default:
48: SETERRQ1(comm, PETSC_ERR_ARG_OUTOFRANGE, "Cannot make meshes for dimension %D", dim);
49: }
50: if (rank) {
51: PetscInt numPoints[2] = {0, 0};
52: DMPlexCreateFromDAG(dm, 1, numPoints, NULL, NULL, NULL, NULL);
53: } else {
54: switch (dim) {
55: case 2:
56: if (simplex) {
57: PetscInt numPoints[2] = {4, 2};
58: PetscInt coneSize[6] = {3, 3, 0, 0, 0, 0};
59: PetscInt cones[6] = {2, 3, 4, 5, 4, 3};
60: PetscInt coneOrientations[6] = {0, 0, 0, 0, 0, 0};
61: PetscScalar vertexCoords[8] = {-0.5, 0.5, 0.0, 0.0, 0.0, 1.0, 0.5, 0.5};
63: DMPlexCreateFromDAG(dm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
64: } else {
65: PetscInt numPoints[2] = {6, 2};
66: PetscInt coneSize[8] = {4, 4, 0, 0, 0, 0, 0, 0};
67: PetscInt cones[8] = {2, 3, 4, 5, 3, 6, 7, 4};
68: PetscInt coneOrientations[8] = {0, 0, 0, 0, 0, 0, 0, 0};
69: 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};
71: DMPlexCreateFromDAG(dm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
72: }
73: break;
74: case 3:
75: if (simplex) {
76: PetscInt numPoints[2] = {5, 2};
77: PetscInt coneSize[7] = {4, 4, 0, 0, 0, 0, 0};
78: PetscInt cones[8] = {4, 3, 5, 2, 5, 3, 4, 6};
79: PetscInt coneOrientations[8] = {0, 0, 0, 0, 0, 0, 0, 0};
80: 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};
82: DMPlexCreateFromDAG(dm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
83: } else {
84: PetscInt numPoints[2] = {12, 2};
85: PetscInt coneSize[14] = {8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
86: PetscInt cones[16] = {2, 3, 4, 5, 6, 7, 8, 9, 5, 4, 10, 11, 7, 12, 13, 8};
87: PetscInt coneOrientations[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
88: 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,
89: -1.0, -0.5, 0.5, 0.0, -0.5, 0.5, 0.0, 0.5, 0.5, -1.0, 0.5, 0.5,
90: 1.0, 0.5, -0.5, 1.0, -0.5, -0.5, 1.0, -0.5, 0.5, 1.0, 0.5, 0.5};
92: DMPlexCreateFromDAG(dm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
93: }
94: break;
95: default:
96: SETERRQ1(comm, PETSC_ERR_ARG_OUTOFRANGE, "Cannot make meshes for dimension %D", dim);
97: }
98: }
99: *newdm = dm;
100: if (refinementLimit > 0.0) {
101: DM rdm;
102: const char *name;
104: DMPlexSetRefinementUniform(*newdm, PETSC_FALSE);
105: DMPlexSetRefinementLimit(*newdm, refinementLimit);
106: DMRefine(*newdm, comm, &rdm);
107: PetscObjectGetName((PetscObject) *newdm, &name);
108: PetscObjectSetName((PetscObject) rdm, name);
109: DMDestroy(newdm);
110: *newdm = rdm;
111: }
112: if (interpolate) {
113: DM idm;
115: DMPlexInterpolate(*newdm, &idm);
116: DMDestroy(newdm);
117: *newdm = idm;
118: }
119: return(0);
120: }
122: /*@
123: DMPlexCreateSquareBoundary - Creates a 1D mesh the is the boundary of a square lattice.
125: Collective
127: Input Parameters:
128: + comm - The communicator for the DM object
129: . lower - The lower left corner coordinates
130: . upper - The upper right corner coordinates
131: - edges - The number of cells in each direction
133: Output Parameter:
134: . dm - The DM object
136: Note: Here is the numbering returned for 2 cells in each direction:
137: $ 18--5-17--4--16
138: $ | | |
139: $ 6 10 3
140: $ | | |
141: $ 19-11-20--9--15
142: $ | | |
143: $ 7 8 2
144: $ | | |
145: $ 12--0-13--1--14
147: Level: beginner
149: .seealso: DMPlexCreateBoxMesh(), DMPlexCreateCubeBoundary(), DMSetType(), DMCreate()
150: @*/
151: PetscErrorCode DMPlexCreateSquareBoundary(DM dm, const PetscReal lower[], const PetscReal upper[], const PetscInt edges[])
152: {
153: const PetscInt numVertices = (edges[0]+1)*(edges[1]+1);
154: const PetscInt numEdges = edges[0]*(edges[1]+1) + (edges[0]+1)*edges[1];
155: PetscInt markerTop = 1;
156: PetscInt markerBottom = 1;
157: PetscInt markerRight = 1;
158: PetscInt markerLeft = 1;
159: PetscBool markerSeparate = PETSC_FALSE;
160: Vec coordinates;
161: PetscSection coordSection;
162: PetscScalar *coords;
163: PetscInt coordSize;
164: PetscMPIInt rank;
165: PetscInt v, vx, vy;
169: PetscOptionsGetBool(((PetscObject) dm)->options,((PetscObject) dm)->prefix, "-dm_plex_separate_marker", &markerSeparate, NULL);
170: if (markerSeparate) {
171: markerTop = 3;
172: markerBottom = 1;
173: markerRight = 2;
174: markerLeft = 4;
175: }
176: MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank);
177: if (!rank) {
178: PetscInt e, ex, ey;
180: DMPlexSetChart(dm, 0, numEdges+numVertices);
181: for (e = 0; e < numEdges; ++e) {
182: DMPlexSetConeSize(dm, e, 2);
183: }
184: DMSetUp(dm); /* Allocate space for cones */
185: for (vx = 0; vx <= edges[0]; vx++) {
186: for (ey = 0; ey < edges[1]; ey++) {
187: PetscInt edge = vx*edges[1] + ey + edges[0]*(edges[1]+1);
188: PetscInt vertex = ey*(edges[0]+1) + vx + numEdges;
189: PetscInt cone[2];
191: cone[0] = vertex; cone[1] = vertex+edges[0]+1;
192: DMPlexSetCone(dm, edge, cone);
193: if (vx == edges[0]) {
194: DMSetLabelValue(dm, "marker", edge, markerRight);
195: DMSetLabelValue(dm, "marker", cone[0], markerRight);
196: if (ey == edges[1]-1) {
197: DMSetLabelValue(dm, "marker", cone[1], markerRight);
198: DMSetLabelValue(dm, "Face Sets", cone[1], markerRight);
199: }
200: } else if (vx == 0) {
201: DMSetLabelValue(dm, "marker", edge, markerLeft);
202: DMSetLabelValue(dm, "marker", cone[0], markerLeft);
203: if (ey == edges[1]-1) {
204: DMSetLabelValue(dm, "marker", cone[1], markerLeft);
205: DMSetLabelValue(dm, "Face Sets", cone[1], markerLeft);
206: }
207: }
208: }
209: }
210: for (vy = 0; vy <= edges[1]; vy++) {
211: for (ex = 0; ex < edges[0]; ex++) {
212: PetscInt edge = vy*edges[0] + ex;
213: PetscInt vertex = vy*(edges[0]+1) + ex + numEdges;
214: PetscInt cone[2];
216: cone[0] = vertex; cone[1] = vertex+1;
217: DMPlexSetCone(dm, edge, cone);
218: if (vy == edges[1]) {
219: DMSetLabelValue(dm, "marker", edge, markerTop);
220: DMSetLabelValue(dm, "marker", cone[0], markerTop);
221: if (ex == edges[0]-1) {
222: DMSetLabelValue(dm, "marker", cone[1], markerTop);
223: DMSetLabelValue(dm, "Face Sets", cone[1], markerTop);
224: }
225: } else if (vy == 0) {
226: DMSetLabelValue(dm, "marker", edge, markerBottom);
227: DMSetLabelValue(dm, "marker", cone[0], markerBottom);
228: if (ex == edges[0]-1) {
229: DMSetLabelValue(dm, "marker", cone[1], markerBottom);
230: DMSetLabelValue(dm, "Face Sets", cone[1], markerBottom);
231: }
232: }
233: }
234: }
235: }
236: DMPlexSymmetrize(dm);
237: DMPlexStratify(dm);
238: /* Build coordinates */
239: DMSetCoordinateDim(dm, 2);
240: DMGetCoordinateSection(dm, &coordSection);
241: PetscSectionSetNumFields(coordSection, 1);
242: PetscSectionSetChart(coordSection, numEdges, numEdges + numVertices);
243: PetscSectionSetFieldComponents(coordSection, 0, 2);
244: for (v = numEdges; v < numEdges+numVertices; ++v) {
245: PetscSectionSetDof(coordSection, v, 2);
246: PetscSectionSetFieldDof(coordSection, v, 0, 2);
247: }
248: PetscSectionSetUp(coordSection);
249: PetscSectionGetStorageSize(coordSection, &coordSize);
250: VecCreate(PETSC_COMM_SELF, &coordinates);
251: PetscObjectSetName((PetscObject) coordinates, "coordinates");
252: VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
253: VecSetBlockSize(coordinates, 2);
254: VecSetType(coordinates,VECSTANDARD);
255: VecGetArray(coordinates, &coords);
256: for (vy = 0; vy <= edges[1]; ++vy) {
257: for (vx = 0; vx <= edges[0]; ++vx) {
258: coords[(vy*(edges[0]+1)+vx)*2+0] = lower[0] + ((upper[0] - lower[0])/edges[0])*vx;
259: coords[(vy*(edges[0]+1)+vx)*2+1] = lower[1] + ((upper[1] - lower[1])/edges[1])*vy;
260: }
261: }
262: VecRestoreArray(coordinates, &coords);
263: DMSetCoordinatesLocal(dm, coordinates);
264: VecDestroy(&coordinates);
265: return(0);
266: }
268: /*@
269: DMPlexCreateCubeBoundary - Creates a 2D mesh that is the boundary of a cubic lattice.
271: Collective
273: Input Parameters:
274: + comm - The communicator for the DM object
275: . lower - The lower left front corner coordinates
276: . upper - The upper right back corner coordinates
277: - faces - The number of faces in each direction (the same as the number of cells)
279: Output Parameter:
280: . dm - The DM object
282: Level: beginner
284: .seealso: DMPlexCreateBoxMesh(), DMPlexCreateSquareBoundary(), DMSetType(), DMCreate()
285: @*/
286: PetscErrorCode DMPlexCreateCubeBoundary(DM dm, const PetscReal lower[], const PetscReal upper[], const PetscInt faces[])
287: {
288: PetscInt vertices[3], numVertices;
289: PetscInt numFaces = 2*faces[0]*faces[1] + 2*faces[1]*faces[2] + 2*faces[0]*faces[2];
290: Vec coordinates;
291: PetscSection coordSection;
292: PetscScalar *coords;
293: PetscInt coordSize;
294: PetscMPIInt rank;
295: PetscInt v, vx, vy, vz;
296: PetscInt voffset, iface=0, cone[4];
300: 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");
301: MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank);
302: vertices[0] = faces[0]+1; vertices[1] = faces[1]+1; vertices[2] = faces[2]+1;
303: numVertices = vertices[0]*vertices[1]*vertices[2];
304: if (!rank) {
305: PetscInt f;
307: DMPlexSetChart(dm, 0, numFaces+numVertices);
308: for (f = 0; f < numFaces; ++f) {
309: DMPlexSetConeSize(dm, f, 4);
310: }
311: DMSetUp(dm); /* Allocate space for cones */
313: /* Side 0 (Top) */
314: for (vy = 0; vy < faces[1]; vy++) {
315: for (vx = 0; vx < faces[0]; vx++) {
316: voffset = numFaces + vertices[0]*vertices[1]*(vertices[2]-1) + vy*vertices[0] + vx;
317: cone[0] = voffset; cone[1] = voffset+1; cone[2] = voffset+vertices[0]+1; cone[3] = voffset+vertices[0];
318: DMPlexSetCone(dm, iface, cone);
319: DMSetLabelValue(dm, "marker", iface, 1);
320: DMSetLabelValue(dm, "marker", voffset+0, 1);
321: DMSetLabelValue(dm, "marker", voffset+1, 1);
322: DMSetLabelValue(dm, "marker", voffset+vertices[0]+0, 1);
323: DMSetLabelValue(dm, "marker", voffset+vertices[0]+1, 1);
324: iface++;
325: }
326: }
328: /* Side 1 (Bottom) */
329: for (vy = 0; vy < faces[1]; vy++) {
330: for (vx = 0; vx < faces[0]; vx++) {
331: voffset = numFaces + vy*(faces[0]+1) + vx;
332: cone[0] = voffset+1; cone[1] = voffset; cone[2] = voffset+vertices[0]; cone[3] = voffset+vertices[0]+1;
333: DMPlexSetCone(dm, iface, cone);
334: DMSetLabelValue(dm, "marker", iface, 1);
335: DMSetLabelValue(dm, "marker", voffset+0, 1);
336: DMSetLabelValue(dm, "marker", voffset+1, 1);
337: DMSetLabelValue(dm, "marker", voffset+vertices[0]+0, 1);
338: DMSetLabelValue(dm, "marker", voffset+vertices[0]+1, 1);
339: iface++;
340: }
341: }
343: /* Side 2 (Front) */
344: for (vz = 0; vz < faces[2]; vz++) {
345: for (vx = 0; vx < faces[0]; vx++) {
346: voffset = numFaces + vz*vertices[0]*vertices[1] + vx;
347: cone[0] = voffset; cone[1] = voffset+1; cone[2] = voffset+vertices[0]*vertices[1]+1; cone[3] = voffset+vertices[0]*vertices[1];
348: DMPlexSetCone(dm, iface, cone);
349: DMSetLabelValue(dm, "marker", iface, 1);
350: DMSetLabelValue(dm, "marker", voffset+0, 1);
351: DMSetLabelValue(dm, "marker", voffset+1, 1);
352: DMSetLabelValue(dm, "marker", voffset+vertices[0]*vertices[1]+0, 1);
353: DMSetLabelValue(dm, "marker", voffset+vertices[0]*vertices[1]+1, 1);
354: iface++;
355: }
356: }
358: /* Side 3 (Back) */
359: for (vz = 0; vz < faces[2]; vz++) {
360: for (vx = 0; vx < faces[0]; vx++) {
361: voffset = numFaces + vz*vertices[0]*vertices[1] + vertices[0]*(vertices[1]-1) + vx;
362: cone[0] = voffset+vertices[0]*vertices[1]; cone[1] = voffset+vertices[0]*vertices[1]+1;
363: cone[2] = voffset+1; cone[3] = voffset;
364: DMPlexSetCone(dm, iface, cone);
365: DMSetLabelValue(dm, "marker", iface, 1);
366: DMSetLabelValue(dm, "marker", voffset+0, 1);
367: DMSetLabelValue(dm, "marker", voffset+1, 1);
368: DMSetLabelValue(dm, "marker", voffset+vertices[0]*vertices[1]+0, 1);
369: DMSetLabelValue(dm, "marker", voffset+vertices[0]*vertices[1]+1, 1);
370: iface++;
371: }
372: }
374: /* Side 4 (Left) */
375: for (vz = 0; vz < faces[2]; vz++) {
376: for (vy = 0; vy < faces[1]; vy++) {
377: voffset = numFaces + vz*vertices[0]*vertices[1] + vy*vertices[0];
378: cone[0] = voffset; cone[1] = voffset+vertices[0]*vertices[1];
379: cone[2] = voffset+vertices[0]*vertices[1]+vertices[0]; cone[3] = voffset+vertices[0];
380: DMPlexSetCone(dm, iface, cone);
381: DMSetLabelValue(dm, "marker", iface, 1);
382: DMSetLabelValue(dm, "marker", voffset+0, 1);
383: DMSetLabelValue(dm, "marker", voffset+vertices[0]+0, 1);
384: DMSetLabelValue(dm, "marker", voffset+vertices[1]+0, 1);
385: DMSetLabelValue(dm, "marker", voffset+vertices[0]*vertices[1]+vertices[0], 1);
386: iface++;
387: }
388: }
390: /* Side 5 (Right) */
391: for (vz = 0; vz < faces[2]; vz++) {
392: for (vy = 0; vy < faces[1]; vy++) {
393: voffset = numFaces + vz*vertices[0]*vertices[1] + vy*vertices[0] + faces[0];
394: cone[0] = voffset+vertices[0]*vertices[1]; cone[1] = voffset;
395: cone[2] = voffset+vertices[0]; cone[3] = voffset+vertices[0]*vertices[1]+vertices[0];
396: DMPlexSetCone(dm, iface, cone);
397: DMSetLabelValue(dm, "marker", iface, 1);
398: DMSetLabelValue(dm, "marker", voffset+0, 1);
399: DMSetLabelValue(dm, "marker", voffset+vertices[0]+0, 1);
400: DMSetLabelValue(dm, "marker", voffset+vertices[0]*vertices[1]+0, 1);
401: DMSetLabelValue(dm, "marker", voffset+vertices[0]*vertices[1]+vertices[0], 1);
402: iface++;
403: }
404: }
405: }
406: DMPlexSymmetrize(dm);
407: DMPlexStratify(dm);
408: /* Build coordinates */
409: DMSetCoordinateDim(dm, 3);
410: DMGetCoordinateSection(dm, &coordSection);
411: PetscSectionSetChart(coordSection, numFaces, numFaces + numVertices);
412: for (v = numFaces; v < numFaces+numVertices; ++v) {
413: PetscSectionSetDof(coordSection, v, 3);
414: }
415: PetscSectionSetUp(coordSection);
416: PetscSectionGetStorageSize(coordSection, &coordSize);
417: VecCreate(PETSC_COMM_SELF, &coordinates);
418: PetscObjectSetName((PetscObject) coordinates, "coordinates");
419: VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
420: VecSetBlockSize(coordinates, 3);
421: VecSetType(coordinates,VECSTANDARD);
422: VecGetArray(coordinates, &coords);
423: for (vz = 0; vz <= faces[2]; ++vz) {
424: for (vy = 0; vy <= faces[1]; ++vy) {
425: for (vx = 0; vx <= faces[0]; ++vx) {
426: coords[((vz*(faces[1]+1)+vy)*(faces[0]+1)+vx)*3+0] = lower[0] + ((upper[0] - lower[0])/faces[0])*vx;
427: coords[((vz*(faces[1]+1)+vy)*(faces[0]+1)+vx)*3+1] = lower[1] + ((upper[1] - lower[1])/faces[1])*vy;
428: coords[((vz*(faces[1]+1)+vy)*(faces[0]+1)+vx)*3+2] = lower[2] + ((upper[2] - lower[2])/faces[2])*vz;
429: }
430: }
431: }
432: VecRestoreArray(coordinates, &coords);
433: DMSetCoordinatesLocal(dm, coordinates);
434: VecDestroy(&coordinates);
435: return(0);
436: }
438: static PetscErrorCode DMPlexCreateLineMesh_Internal(MPI_Comm comm,PetscInt segments,PetscReal lower,PetscReal upper,DMBoundaryType bd,DM *dm)
439: {
440: PetscInt i,fStart,fEnd,numCells = 0,numVerts = 0;
441: PetscInt numPoints[2],*coneSize,*cones,*coneOrientations;
442: PetscScalar *vertexCoords;
443: PetscReal L,maxCell;
444: PetscBool markerSeparate = PETSC_FALSE;
445: PetscInt markerLeft = 1, faceMarkerLeft = 1;
446: PetscInt markerRight = 1, faceMarkerRight = 2;
447: PetscBool wrap = (bd == DM_BOUNDARY_PERIODIC || bd == DM_BOUNDARY_TWIST) ? PETSC_TRUE : PETSC_FALSE;
448: PetscMPIInt rank;
454: DMCreate(comm,dm);
455: DMSetType(*dm,DMPLEX);
456: DMSetDimension(*dm,1);
457: DMCreateLabel(*dm,"marker");
458: DMCreateLabel(*dm,"Face Sets");
460: MPI_Comm_rank(comm,&rank);
461: if (!rank) numCells = segments;
462: if (!rank) numVerts = segments + (wrap ? 0 : 1);
464: numPoints[0] = numVerts ; numPoints[1] = numCells;
465: PetscMalloc4(numCells+numVerts,&coneSize,numCells*2,&cones,numCells+numVerts,&coneOrientations,numVerts,&vertexCoords);
466: PetscArrayzero(coneOrientations,numCells+numVerts);
467: for (i = 0; i < numCells; ++i) { coneSize[i] = 2; }
468: for (i = 0; i < numVerts; ++i) { coneSize[numCells+i] = 0; }
469: for (i = 0; i < numCells; ++i) { cones[2*i] = numCells + i%numVerts; cones[2*i+1] = numCells + (i+1)%numVerts; }
470: for (i = 0; i < numVerts; ++i) { vertexCoords[i] = lower + (upper-lower)*((PetscReal)i/(PetscReal)numCells); }
471: DMPlexCreateFromDAG(*dm,1,numPoints,coneSize,cones,coneOrientations,vertexCoords);
472: PetscFree4(coneSize,cones,coneOrientations,vertexCoords);
474: PetscOptionsGetBool(((PetscObject)*dm)->options,((PetscObject)*dm)->prefix,"-dm_plex_separate_marker",&markerSeparate,NULL);
475: if (markerSeparate) { markerLeft = faceMarkerLeft; markerRight = faceMarkerRight;}
476: if (!wrap && !rank) {
477: DMPlexGetHeightStratum(*dm,1,&fStart,&fEnd);
478: DMSetLabelValue(*dm,"marker",fStart,markerLeft);
479: DMSetLabelValue(*dm,"marker",fEnd-1,markerRight);
480: DMSetLabelValue(*dm,"Face Sets",fStart,faceMarkerLeft);
481: DMSetLabelValue(*dm,"Face Sets",fEnd-1,faceMarkerRight);
482: }
483: if (wrap) {
484: L = upper - lower;
485: maxCell = (PetscReal)1.1*(L/(PetscReal)PetscMax(1,segments));
486: DMSetPeriodicity(*dm,PETSC_TRUE,&maxCell,&L,&bd);
487: }
488: DMPlexSetRefinementUniform(*dm, PETSC_TRUE);
489: return(0);
490: }
492: 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)
493: {
494: DM boundary;
495: PetscInt i;
500: for (i = 0; i < dim; ++i) if (periodicity[i] != DM_BOUNDARY_NONE) SETERRQ(comm, PETSC_ERR_SUP, "Periodicity is not supported for simplex meshes");
501: DMCreate(comm, &boundary);
503: DMSetType(boundary, DMPLEX);
504: DMSetDimension(boundary, dim-1);
505: DMSetCoordinateDim(boundary, dim);
506: switch (dim) {
507: case 2: DMPlexCreateSquareBoundary(boundary, lower, upper, faces);break;
508: case 3: DMPlexCreateCubeBoundary(boundary, lower, upper, faces);break;
509: default: SETERRQ1(comm, PETSC_ERR_SUP, "Dimension not supported: %D", dim);
510: }
511: DMPlexGenerate(boundary, NULL, interpolate, dm);
512: DMDestroy(&boundary);
513: return(0);
514: }
516: static PetscErrorCode DMPlexCreateCubeMesh_Internal(DM dm, const PetscReal lower[], const PetscReal upper[], const PetscInt edges[], DMBoundaryType bdX, DMBoundaryType bdY, DMBoundaryType bdZ)
517: {
518: DMLabel cutLabel = NULL;
519: PetscInt markerTop = 1, faceMarkerTop = 1;
520: PetscInt markerBottom = 1, faceMarkerBottom = 1;
521: PetscInt markerFront = 1, faceMarkerFront = 1;
522: PetscInt markerBack = 1, faceMarkerBack = 1;
523: PetscInt markerRight = 1, faceMarkerRight = 1;
524: PetscInt markerLeft = 1, faceMarkerLeft = 1;
525: PetscInt dim;
526: PetscBool markerSeparate = PETSC_FALSE, cutMarker = PETSC_FALSE;
527: PetscMPIInt rank;
531: DMGetDimension(dm,&dim);
532: MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank);
533: DMCreateLabel(dm,"marker");
534: DMCreateLabel(dm,"Face Sets");
535: PetscOptionsGetBool(((PetscObject) dm)->options,((PetscObject) dm)->prefix, "-dm_plex_periodic_cut", &cutMarker, NULL);
536: if (bdX == DM_BOUNDARY_PERIODIC || bdX == DM_BOUNDARY_TWIST ||
537: bdY == DM_BOUNDARY_PERIODIC || bdY == DM_BOUNDARY_TWIST ||
538: bdZ == DM_BOUNDARY_PERIODIC || bdZ == DM_BOUNDARY_TWIST) {
540: if (cutMarker) {DMCreateLabel(dm, "periodic_cut"); DMGetLabel(dm, "periodic_cut", &cutLabel);}
541: }
542: switch (dim) {
543: case 2:
544: faceMarkerTop = 3;
545: faceMarkerBottom = 1;
546: faceMarkerRight = 2;
547: faceMarkerLeft = 4;
548: break;
549: case 3:
550: faceMarkerBottom = 1;
551: faceMarkerTop = 2;
552: faceMarkerFront = 3;
553: faceMarkerBack = 4;
554: faceMarkerRight = 5;
555: faceMarkerLeft = 6;
556: break;
557: default:
558: SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"Dimension %D not supported",dim);
559: }
560: PetscOptionsGetBool(((PetscObject) dm)->options,((PetscObject) dm)->prefix, "-dm_plex_separate_marker", &markerSeparate, NULL);
561: if (markerSeparate) {
562: markerBottom = faceMarkerBottom;
563: markerTop = faceMarkerTop;
564: markerFront = faceMarkerFront;
565: markerBack = faceMarkerBack;
566: markerRight = faceMarkerRight;
567: markerLeft = faceMarkerLeft;
568: }
569: {
570: const PetscInt numXEdges = !rank ? edges[0] : 0;
571: const PetscInt numYEdges = !rank ? edges[1] : 0;
572: const PetscInt numZEdges = !rank ? edges[2] : 0;
573: const PetscInt numXVertices = !rank ? (bdX == DM_BOUNDARY_PERIODIC || bdX == DM_BOUNDARY_TWIST ? edges[0] : edges[0]+1) : 0;
574: const PetscInt numYVertices = !rank ? (bdY == DM_BOUNDARY_PERIODIC || bdY == DM_BOUNDARY_TWIST ? edges[1] : edges[1]+1) : 0;
575: const PetscInt numZVertices = !rank ? (bdZ == DM_BOUNDARY_PERIODIC || bdZ == DM_BOUNDARY_TWIST ? edges[2] : edges[2]+1) : 0;
576: const PetscInt numCells = numXEdges*numYEdges*numZEdges;
577: const PetscInt numXFaces = numYEdges*numZEdges;
578: const PetscInt numYFaces = numXEdges*numZEdges;
579: const PetscInt numZFaces = numXEdges*numYEdges;
580: const PetscInt numTotXFaces = numXVertices*numXFaces;
581: const PetscInt numTotYFaces = numYVertices*numYFaces;
582: const PetscInt numTotZFaces = numZVertices*numZFaces;
583: const PetscInt numFaces = numTotXFaces + numTotYFaces + numTotZFaces;
584: const PetscInt numTotXEdges = numXEdges*numYVertices*numZVertices;
585: const PetscInt numTotYEdges = numYEdges*numXVertices*numZVertices;
586: const PetscInt numTotZEdges = numZEdges*numXVertices*numYVertices;
587: const PetscInt numVertices = numXVertices*numYVertices*numZVertices;
588: const PetscInt numEdges = numTotXEdges + numTotYEdges + numTotZEdges;
589: const PetscInt firstVertex = (dim == 2) ? numFaces : numCells;
590: const PetscInt firstXFace = (dim == 2) ? 0 : numCells + numVertices;
591: const PetscInt firstYFace = firstXFace + numTotXFaces;
592: const PetscInt firstZFace = firstYFace + numTotYFaces;
593: const PetscInt firstXEdge = numCells + numFaces + numVertices;
594: const PetscInt firstYEdge = firstXEdge + numTotXEdges;
595: const PetscInt firstZEdge = firstYEdge + numTotYEdges;
596: Vec coordinates;
597: PetscSection coordSection;
598: PetscScalar *coords;
599: PetscInt coordSize;
600: PetscInt v, vx, vy, vz;
601: PetscInt c, f, fx, fy, fz, e, ex, ey, ez;
603: DMPlexSetChart(dm, 0, numCells+numFaces+numEdges+numVertices);
604: for (c = 0; c < numCells; c++) {
605: DMPlexSetConeSize(dm, c, 6);
606: }
607: for (f = firstXFace; f < firstXFace+numFaces; ++f) {
608: DMPlexSetConeSize(dm, f, 4);
609: }
610: for (e = firstXEdge; e < firstXEdge+numEdges; ++e) {
611: DMPlexSetConeSize(dm, e, 2);
612: }
613: DMSetUp(dm); /* Allocate space for cones */
614: /* Build cells */
615: for (fz = 0; fz < numZEdges; ++fz) {
616: for (fy = 0; fy < numYEdges; ++fy) {
617: for (fx = 0; fx < numXEdges; ++fx) {
618: PetscInt cell = (fz*numYEdges + fy)*numXEdges + fx;
619: PetscInt faceB = firstZFace + (fy*numXEdges+fx)*numZVertices + fz;
620: PetscInt faceT = firstZFace + (fy*numXEdges+fx)*numZVertices + ((fz+1)%numZVertices);
621: PetscInt faceF = firstYFace + (fz*numXEdges+fx)*numYVertices + fy;
622: PetscInt faceK = firstYFace + (fz*numXEdges+fx)*numYVertices + ((fy+1)%numYVertices);
623: PetscInt faceL = firstXFace + (fz*numYEdges+fy)*numXVertices + fx;
624: PetscInt faceR = firstXFace + (fz*numYEdges+fy)*numXVertices + ((fx+1)%numXVertices);
625: /* B, T, F, K, R, L */
626: PetscInt ornt[6] = {-4, 0, 0, -1, 0, -4}; /* ??? */
627: PetscInt cone[6];
629: /* no boundary twisting in 3D */
630: cone[0] = faceB; cone[1] = faceT; cone[2] = faceF; cone[3] = faceK; cone[4] = faceR; cone[5] = faceL;
631: DMPlexSetCone(dm, cell, cone);
632: DMPlexSetConeOrientation(dm, cell, ornt);
633: if (bdX != DM_BOUNDARY_NONE && fx == numXEdges-1 && cutLabel) {DMLabelSetValue(cutLabel, cell, 2);}
634: if (bdY != DM_BOUNDARY_NONE && fy == numYEdges-1 && cutLabel) {DMLabelSetValue(cutLabel, cell, 2);}
635: if (bdZ != DM_BOUNDARY_NONE && fz == numZEdges-1 && cutLabel) {DMLabelSetValue(cutLabel, cell, 2);}
636: }
637: }
638: }
639: /* Build x faces */
640: for (fz = 0; fz < numZEdges; ++fz) {
641: for (fy = 0; fy < numYEdges; ++fy) {
642: for (fx = 0; fx < numXVertices; ++fx) {
643: PetscInt face = firstXFace + (fz*numYEdges+fy) *numXVertices+fx;
644: PetscInt edgeL = firstZEdge + (fy *numXVertices+fx)*numZEdges + fz;
645: PetscInt edgeR = firstZEdge + (((fy+1)%numYVertices)*numXVertices+fx)*numZEdges + fz;
646: PetscInt edgeB = firstYEdge + (fz *numXVertices+fx)*numYEdges + fy;
647: PetscInt edgeT = firstYEdge + (((fz+1)%numZVertices)*numXVertices+fx)*numYEdges + fy;
648: PetscInt ornt[4] = {0, 0, -2, -2};
649: PetscInt cone[4];
651: if (dim == 3) {
652: /* markers */
653: if (bdX != DM_BOUNDARY_PERIODIC) {
654: if (fx == numXVertices-1) {
655: DMSetLabelValue(dm, "Face Sets", face, faceMarkerRight);
656: DMSetLabelValue(dm, "marker", face, markerRight);
657: }
658: else if (fx == 0) {
659: DMSetLabelValue(dm, "Face Sets", face, faceMarkerLeft);
660: DMSetLabelValue(dm, "marker", face, markerLeft);
661: }
662: }
663: }
664: cone[0] = edgeB; cone[1] = edgeR; cone[2] = edgeT; cone[3] = edgeL;
665: DMPlexSetCone(dm, face, cone);
666: DMPlexSetConeOrientation(dm, face, ornt);
667: }
668: }
669: }
670: /* Build y faces */
671: for (fz = 0; fz < numZEdges; ++fz) {
672: for (fx = 0; fx < numXEdges; ++fx) {
673: for (fy = 0; fy < numYVertices; ++fy) {
674: PetscInt face = firstYFace + (fz*numXEdges+fx)*numYVertices + fy;
675: PetscInt edgeL = firstZEdge + (fy*numXVertices+ fx)*numZEdges + fz;
676: PetscInt edgeR = firstZEdge + (fy*numXVertices+((fx+1)%numXVertices))*numZEdges + fz;
677: PetscInt edgeB = firstXEdge + (fz *numYVertices+fy)*numXEdges + fx;
678: PetscInt edgeT = firstXEdge + (((fz+1)%numZVertices)*numYVertices+fy)*numXEdges + fx;
679: PetscInt ornt[4] = {0, 0, -2, -2};
680: PetscInt cone[4];
682: if (dim == 3) {
683: /* markers */
684: if (bdY != DM_BOUNDARY_PERIODIC) {
685: if (fy == numYVertices-1) {
686: DMSetLabelValue(dm, "Face Sets", face, faceMarkerBack);
687: DMSetLabelValue(dm, "marker", face, markerBack);
688: }
689: else if (fy == 0) {
690: DMSetLabelValue(dm, "Face Sets", face, faceMarkerFront);
691: DMSetLabelValue(dm, "marker", face, markerFront);
692: }
693: }
694: }
695: cone[0] = edgeB; cone[1] = edgeR; cone[2] = edgeT; cone[3] = edgeL;
696: DMPlexSetCone(dm, face, cone);
697: DMPlexSetConeOrientation(dm, face, ornt);
698: }
699: }
700: }
701: /* Build z faces */
702: for (fy = 0; fy < numYEdges; ++fy) {
703: for (fx = 0; fx < numXEdges; ++fx) {
704: for (fz = 0; fz < numZVertices; fz++) {
705: PetscInt face = firstZFace + (fy*numXEdges+fx)*numZVertices + fz;
706: PetscInt edgeL = firstYEdge + (fz*numXVertices+ fx)*numYEdges + fy;
707: PetscInt edgeR = firstYEdge + (fz*numXVertices+((fx+1)%numXVertices))*numYEdges + fy;
708: PetscInt edgeB = firstXEdge + (fz*numYVertices+ fy)*numXEdges + fx;
709: PetscInt edgeT = firstXEdge + (fz*numYVertices+((fy+1)%numYVertices))*numXEdges + fx;
710: PetscInt ornt[4] = {0, 0, -2, -2};
711: PetscInt cone[4];
713: if (dim == 2) {
714: if (bdX == DM_BOUNDARY_TWIST && fx == numXEdges-1) {edgeR += numYEdges-1-2*fy; ornt[1] = -2;}
715: if (bdY == DM_BOUNDARY_TWIST && fy == numYEdges-1) {edgeT += numXEdges-1-2*fx; ornt[2] = 0;}
716: if (bdX != DM_BOUNDARY_NONE && fx == numXEdges-1 && cutLabel) {DMLabelSetValue(cutLabel, face, 2);}
717: if (bdY != DM_BOUNDARY_NONE && fy == numYEdges-1 && cutLabel) {DMLabelSetValue(cutLabel, face, 2);}
718: } else {
719: /* markers */
720: if (bdZ != DM_BOUNDARY_PERIODIC) {
721: if (fz == numZVertices-1) {
722: DMSetLabelValue(dm, "Face Sets", face, faceMarkerTop);
723: DMSetLabelValue(dm, "marker", face, markerTop);
724: }
725: else if (fz == 0) {
726: DMSetLabelValue(dm, "Face Sets", face, faceMarkerBottom);
727: DMSetLabelValue(dm, "marker", face, markerBottom);
728: }
729: }
730: }
731: cone[0] = edgeB; cone[1] = edgeR; cone[2] = edgeT; cone[3] = edgeL;
732: DMPlexSetCone(dm, face, cone);
733: DMPlexSetConeOrientation(dm, face, ornt);
734: }
735: }
736: }
737: /* Build Z edges*/
738: for (vy = 0; vy < numYVertices; vy++) {
739: for (vx = 0; vx < numXVertices; vx++) {
740: for (ez = 0; ez < numZEdges; ez++) {
741: const PetscInt edge = firstZEdge + (vy*numXVertices+vx)*numZEdges + ez;
742: const PetscInt vertexB = firstVertex + (ez *numYVertices+vy)*numXVertices + vx;
743: const PetscInt vertexT = firstVertex + (((ez+1)%numZVertices)*numYVertices+vy)*numXVertices + vx;
744: PetscInt cone[2];
746: if (dim == 3) {
747: if (bdX != DM_BOUNDARY_PERIODIC) {
748: if (vx == numXVertices-1) {
749: DMSetLabelValue(dm, "marker", edge, markerRight);
750: }
751: else if (vx == 0) {
752: DMSetLabelValue(dm, "marker", edge, markerLeft);
753: }
754: }
755: if (bdY != DM_BOUNDARY_PERIODIC) {
756: if (vy == numYVertices-1) {
757: DMSetLabelValue(dm, "marker", edge, markerBack);
758: }
759: else if (vy == 0) {
760: DMSetLabelValue(dm, "marker", edge, markerFront);
761: }
762: }
763: }
764: cone[0] = vertexB; cone[1] = vertexT;
765: DMPlexSetCone(dm, edge, cone);
766: }
767: }
768: }
769: /* Build Y edges*/
770: for (vz = 0; vz < numZVertices; vz++) {
771: for (vx = 0; vx < numXVertices; vx++) {
772: for (ey = 0; ey < numYEdges; ey++) {
773: const PetscInt nextv = (dim == 2 && bdY == DM_BOUNDARY_TWIST && ey == numYEdges-1) ? (numXVertices-vx-1) : (vz*numYVertices+((ey+1)%numYVertices))*numXVertices + vx;
774: const PetscInt edge = firstYEdge + (vz*numXVertices+vx)*numYEdges + ey;
775: const PetscInt vertexF = firstVertex + (vz*numYVertices+ey)*numXVertices + vx;
776: const PetscInt vertexK = firstVertex + nextv;
777: PetscInt cone[2];
779: cone[0] = vertexF; cone[1] = vertexK;
780: DMPlexSetCone(dm, edge, cone);
781: if (dim == 2) {
782: if ((bdX != DM_BOUNDARY_PERIODIC) && (bdX != DM_BOUNDARY_TWIST)) {
783: if (vx == numXVertices-1) {
784: DMSetLabelValue(dm, "Face Sets", edge, faceMarkerRight);
785: DMSetLabelValue(dm, "marker", edge, markerRight);
786: DMSetLabelValue(dm, "marker", cone[0], markerRight);
787: if (ey == numYEdges-1) {
788: DMSetLabelValue(dm, "marker", cone[1], markerRight);
789: }
790: } else if (vx == 0) {
791: DMSetLabelValue(dm, "Face Sets", edge, faceMarkerLeft);
792: DMSetLabelValue(dm, "marker", edge, markerLeft);
793: DMSetLabelValue(dm, "marker", cone[0], markerLeft);
794: if (ey == numYEdges-1) {
795: DMSetLabelValue(dm, "marker", cone[1], markerLeft);
796: }
797: }
798: } else {
799: if (vx == 0 && cutLabel) {
800: DMLabelSetValue(cutLabel, edge, 1);
801: DMLabelSetValue(cutLabel, cone[0], 1);
802: if (ey == numYEdges-1) {
803: DMLabelSetValue(cutLabel, cone[1], 1);
804: }
805: }
806: }
807: } else {
808: if (bdX != DM_BOUNDARY_PERIODIC) {
809: if (vx == numXVertices-1) {
810: DMSetLabelValue(dm, "marker", edge, markerRight);
811: } else if (vx == 0) {
812: DMSetLabelValue(dm, "marker", edge, markerLeft);
813: }
814: }
815: if (bdZ != DM_BOUNDARY_PERIODIC) {
816: if (vz == numZVertices-1) {
817: DMSetLabelValue(dm, "marker", edge, markerTop);
818: } else if (vz == 0) {
819: DMSetLabelValue(dm, "marker", edge, markerBottom);
820: }
821: }
822: }
823: }
824: }
825: }
826: /* Build X edges*/
827: for (vz = 0; vz < numZVertices; vz++) {
828: for (vy = 0; vy < numYVertices; vy++) {
829: for (ex = 0; ex < numXEdges; ex++) {
830: const PetscInt nextv = (dim == 2 && bdX == DM_BOUNDARY_TWIST && ex == numXEdges-1) ? (numYVertices-vy-1)*numXVertices : (vz*numYVertices+vy)*numXVertices + (ex+1)%numXVertices;
831: const PetscInt edge = firstXEdge + (vz*numYVertices+vy)*numXEdges + ex;
832: const PetscInt vertexL = firstVertex + (vz*numYVertices+vy)*numXVertices + ex;
833: const PetscInt vertexR = firstVertex + nextv;
834: PetscInt cone[2];
836: cone[0] = vertexL; cone[1] = vertexR;
837: DMPlexSetCone(dm, edge, cone);
838: if (dim == 2) {
839: if ((bdY != DM_BOUNDARY_PERIODIC) && (bdY != DM_BOUNDARY_TWIST)) {
840: if (vy == numYVertices-1) {
841: DMSetLabelValue(dm, "Face Sets", edge, faceMarkerTop);
842: DMSetLabelValue(dm, "marker", edge, markerTop);
843: DMSetLabelValue(dm, "marker", cone[0], markerTop);
844: if (ex == numXEdges-1) {
845: DMSetLabelValue(dm, "marker", cone[1], markerTop);
846: }
847: } else if (vy == 0) {
848: DMSetLabelValue(dm, "Face Sets", edge, faceMarkerBottom);
849: DMSetLabelValue(dm, "marker", edge, markerBottom);
850: DMSetLabelValue(dm, "marker", cone[0], markerBottom);
851: if (ex == numXEdges-1) {
852: DMSetLabelValue(dm, "marker", cone[1], markerBottom);
853: }
854: }
855: } else {
856: if (vy == 0 && cutLabel) {
857: DMLabelSetValue(cutLabel, edge, 1);
858: DMLabelSetValue(cutLabel, cone[0], 1);
859: if (ex == numXEdges-1) {
860: DMLabelSetValue(cutLabel, cone[1], 1);
861: }
862: }
863: }
864: } else {
865: if (bdY != DM_BOUNDARY_PERIODIC) {
866: if (vy == numYVertices-1) {
867: DMSetLabelValue(dm, "marker", edge, markerBack);
868: }
869: else if (vy == 0) {
870: DMSetLabelValue(dm, "marker", edge, markerFront);
871: }
872: }
873: if (bdZ != DM_BOUNDARY_PERIODIC) {
874: if (vz == numZVertices-1) {
875: DMSetLabelValue(dm, "marker", edge, markerTop);
876: }
877: else if (vz == 0) {
878: DMSetLabelValue(dm, "marker", edge, markerBottom);
879: }
880: }
881: }
882: }
883: }
884: }
885: DMPlexSymmetrize(dm);
886: DMPlexStratify(dm);
887: /* Build coordinates */
888: DMGetCoordinateSection(dm, &coordSection);
889: PetscSectionSetNumFields(coordSection, 1);
890: PetscSectionSetFieldComponents(coordSection, 0, dim);
891: PetscSectionSetChart(coordSection, firstVertex, firstVertex+numVertices);
892: for (v = firstVertex; v < firstVertex+numVertices; ++v) {
893: PetscSectionSetDof(coordSection, v, dim);
894: PetscSectionSetFieldDof(coordSection, v, 0, dim);
895: }
896: PetscSectionSetUp(coordSection);
897: PetscSectionGetStorageSize(coordSection, &coordSize);
898: VecCreate(PETSC_COMM_SELF, &coordinates);
899: PetscObjectSetName((PetscObject) coordinates, "coordinates");
900: VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
901: VecSetBlockSize(coordinates, dim);
902: VecSetType(coordinates,VECSTANDARD);
903: VecGetArray(coordinates, &coords);
904: for (vz = 0; vz < numZVertices; ++vz) {
905: for (vy = 0; vy < numYVertices; ++vy) {
906: for (vx = 0; vx < numXVertices; ++vx) {
907: coords[((vz*numYVertices+vy)*numXVertices+vx)*dim+0] = lower[0] + ((upper[0] - lower[0])/numXEdges)*vx;
908: coords[((vz*numYVertices+vy)*numXVertices+vx)*dim+1] = lower[1] + ((upper[1] - lower[1])/numYEdges)*vy;
909: if (dim == 3) {
910: coords[((vz*numYVertices+vy)*numXVertices+vx)*dim+2] = lower[2] + ((upper[2] - lower[2])/numZEdges)*vz;
911: }
912: }
913: }
914: }
915: VecRestoreArray(coordinates, &coords);
916: DMSetCoordinatesLocal(dm, coordinates);
917: VecDestroy(&coordinates);
918: }
919: return(0);
920: }
922: 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)
923: {
924: PetscInt i;
929: DMCreate(comm, dm);
931: DMSetType(*dm, DMPLEX);
932: DMSetDimension(*dm, dim);
933: switch (dim) {
934: case 2: {DMPlexCreateCubeMesh_Internal(*dm, lower, upper, faces, periodicity[0], periodicity[1], DM_BOUNDARY_NONE);break;}
935: case 3: {DMPlexCreateCubeMesh_Internal(*dm, lower, upper, faces, periodicity[0], periodicity[1], periodicity[2]);break;}
936: default: SETERRQ1(comm, PETSC_ERR_SUP, "Dimension not supported: %D", dim);
937: }
938: if (periodicity[0] == DM_BOUNDARY_PERIODIC || periodicity[0] == DM_BOUNDARY_TWIST ||
939: periodicity[1] == DM_BOUNDARY_PERIODIC || periodicity[1] == DM_BOUNDARY_TWIST ||
940: (dim > 2 && (periodicity[2] == DM_BOUNDARY_PERIODIC || periodicity[2] == DM_BOUNDARY_TWIST))) {
941: PetscReal L[3];
942: PetscReal maxCell[3];
944: for (i = 0; i < dim; i++) {
945: L[i] = upper[i] - lower[i];
946: maxCell[i] = 1.1 * (L[i] / PetscMax(1,faces[i]));
947: }
948: DMSetPeriodicity(*dm,PETSC_TRUE,maxCell,L,periodicity);
949: }
950: if (!interpolate) {
951: DM udm;
953: DMPlexUninterpolate(*dm, &udm);
954: DMPlexCopyCoordinates(*dm, udm);
955: DMDestroy(dm);
956: *dm = udm;
957: }
958: DMPlexSetRefinementUniform(*dm, PETSC_TRUE);
959: return(0);
960: }
962: /*@C
963: DMPlexCreateBoxMesh - Creates a mesh on the tensor product of unit intervals (box) using simplices or tensor cells (hexahedra).
965: Collective
967: Input Parameters:
968: + comm - The communicator for the DM object
969: . dim - The spatial dimension
970: . simplex - PETSC_TRUE for simplices, PETSC_FALSE for tensor cells
971: . faces - Number of faces per dimension, or NULL for (1,) in 1D and (2, 2) in 2D and (1, 1, 1) in 3D
972: . lower - The lower left corner, or NULL for (0, 0, 0)
973: . upper - The upper right corner, or NULL for (1, 1, 1)
974: . periodicity - The boundary type for the X,Y,Z direction, or NULL for DM_BOUNDARY_NONE
975: - interpolate - Flag to create intermediate mesh pieces (edges, faces)
977: Output Parameter:
978: . dm - The DM object
980: Options Database Keys:
981: These options override the hard-wired input values.
982: + -dm_plex_box_dim <dim> - Set the topological dimension
983: . -dm_plex_box_simplex <bool> - PETSC_TRUE for simplex elements, PETSC_FALSE for tensor elements
984: . -dm_plex_box_lower <x,y,z> - Specify lower-left-bottom coordinates for the box
985: . -dm_plex_box_upper <x,y,z> - Specify upper-right-top coordinates for the box
986: . -dm_plex_box_faces <m,n,p> - Number of faces in each linear direction
987: . -dm_plex_box_bd <bx,by,bz> - Specify the DMBoundaryType for each direction
988: - -dm_plex_box_interpolate <bool> - PETSC_TRUE turns on topological interpolation (creating edges and faces)
990: Notes:
991: The options database keys above take lists of length d in d dimensions.
993: Here is the numbering returned for 2 faces in each direction for tensor cells:
994: $ 10---17---11---18----12
995: $ | | |
996: $ | | |
997: $ 20 2 22 3 24
998: $ | | |
999: $ | | |
1000: $ 7---15----8---16----9
1001: $ | | |
1002: $ | | |
1003: $ 19 0 21 1 23
1004: $ | | |
1005: $ | | |
1006: $ 4---13----5---14----6
1008: and for simplicial cells
1010: $ 14----8---15----9----16
1011: $ |\ 5 |\ 7 |
1012: $ | \ | \ |
1013: $ 13 2 14 3 15
1014: $ | 4 \ | 6 \ |
1015: $ | \ | \ |
1016: $ 11----6---12----7----13
1017: $ |\ |\ |
1018: $ | \ 1 | \ 3 |
1019: $ 10 0 11 1 12
1020: $ | 0 \ | 2 \ |
1021: $ | \ | \ |
1022: $ 8----4----9----5----10
1024: Level: beginner
1026: .seealso: DMPlexCreateFromFile(), DMPlexCreateHexCylinderMesh(), DMSetType(), DMCreate()
1027: @*/
1028: 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)
1029: {
1030: PetscInt fac[3] = {0, 0, 0};
1031: PetscReal low[3] = {0, 0, 0};
1032: PetscReal upp[3] = {1, 1, 1};
1033: DMBoundaryType bdt[3] = {DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE};
1034: PetscInt i, n;
1035: PetscBool flg;
1039: PetscOptionsGetInt(NULL, NULL, "-dm_plex_box_dim", &dim, &flg);
1040: if ((dim < 0) || (dim > 3)) SETERRQ1(comm, PETSC_ERR_ARG_OUTOFRANGE, "Dimension %D should be in [1, 3]", dim);
1041: PetscOptionsGetBool(NULL, NULL, "-dm_plex_box_simplex", &simplex, &flg);
1042: n = dim;
1043: PetscOptionsGetIntArray(NULL, NULL, "-dm_plex_box_faces", fac, &n, &flg);
1044: for (i = 0; i < dim; ++i) fac[i] = faces ? faces[i] : (flg && i < n ? fac[i] : (dim == 1 ? 1 : 4-dim));
1045: if (lower) for (i = 0; i < dim; ++i) low[i] = lower[i];
1046: if (upper) for (i = 0; i < dim; ++i) upp[i] = upper[i];
1047: if (periodicity) for (i = 0; i < dim; ++i) bdt[i] = periodicity[i];
1048: /* Allow bounds to be specified from the command line */
1049: n = 3;
1050: PetscOptionsGetRealArray(NULL, NULL, "-dm_plex_box_lower", low, &n, &flg);
1051: if (flg && (n != dim)) SETERRQ2(comm, PETSC_ERR_ARG_SIZ, "Lower box point had %D values, should have been %D", n, dim);
1052: n = 3;
1053: PetscOptionsGetRealArray(NULL, NULL, "-dm_plex_box_upper", upp, &n, &flg);
1054: if (flg && (n != dim)) SETERRQ2(comm, PETSC_ERR_ARG_SIZ, "Upper box point had %D values, should have been %D", n, dim);
1055: n = 3;
1056: PetscOptionsGetEnumArray(NULL, NULL, "-dm_plex_box_bd", DMBoundaryTypes, (PetscEnum *) bdt, &n, &flg);
1057: if (flg && (n != dim)) SETERRQ2(comm, PETSC_ERR_ARG_SIZ, "Box boundary types had %D values, should have been %D", n, dim);
1058: PetscOptionsGetBool(NULL, NULL, "-dm_plex_box_interpolate", &interpolate, &flg);
1060: if (dim == 1) {DMPlexCreateLineMesh_Internal(comm, fac[0], low[0], upp[0], bdt[0], dm);}
1061: else if (simplex) {DMPlexCreateBoxMesh_Simplex_Internal(comm, dim, fac, low, upp, bdt, interpolate, dm);}
1062: else {DMPlexCreateBoxMesh_Tensor_Internal(comm, dim, fac, low, upp, bdt, interpolate, dm);}
1063: return(0);
1064: }
1066: /*@
1067: DMPlexCreateWedgeBoxMesh - Creates a 3-D mesh tesselating the (x,y) plane and extruding in the third direction using wedge cells.
1069: Collective
1071: Input Parameters:
1072: + comm - The communicator for the DM object
1073: . faces - Number of faces per dimension, or NULL for (1, 1, 1)
1074: . lower - The lower left corner, or NULL for (0, 0, 0)
1075: . upper - The upper right corner, or NULL for (1, 1, 1)
1076: . periodicity - The boundary type for the X,Y,Z direction, or NULL for DM_BOUNDARY_NONE
1077: . orderHeight - If PETSC_TRUE, orders the extruded cells in the height first. Otherwise, orders the cell on the layers first
1078: - interpolate - Flag to create intermediate mesh pieces (edges, faces)
1080: Output Parameter:
1081: . dm - The DM object
1083: Level: beginner
1085: .seealso: DMPlexCreateHexCylinderMesh(), DMPlexCreateWedgeCylinderMesh(), DMPlexExtrude(), DMPlexCreateBoxMesh(), DMSetType(), DMCreate()
1086: @*/
1087: PetscErrorCode DMPlexCreateWedgeBoxMesh(MPI_Comm comm, const PetscInt faces[], const PetscReal lower[], const PetscReal upper[], const DMBoundaryType periodicity[], PetscBool orderHeight, PetscBool interpolate, DM *dm)
1088: {
1089: DM bdm, botdm;
1090: PetscInt i;
1091: PetscInt fac[3] = {0, 0, 0};
1092: PetscReal low[3] = {0, 0, 0};
1093: PetscReal upp[3] = {1, 1, 1};
1094: DMBoundaryType bdt[3] = {DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE};
1098: for (i = 0; i < 3; ++i) fac[i] = faces ? (faces[i] > 0 ? faces[i] : 1) : 1;
1099: if (lower) for (i = 0; i < 3; ++i) low[i] = lower[i];
1100: if (upper) for (i = 0; i < 3; ++i) upp[i] = upper[i];
1101: if (periodicity) for (i = 0; i < 3; ++i) bdt[i] = periodicity[i];
1102: for (i = 0; i < 3; ++i) if (bdt[i] != DM_BOUNDARY_NONE) SETERRQ(comm, PETSC_ERR_SUP, "Periodicity not yet supported");
1104: DMCreate(comm, &bdm);
1105: DMSetType(bdm, DMPLEX);
1106: DMSetDimension(bdm, 1);
1107: DMSetCoordinateDim(bdm, 2);
1108: DMPlexCreateSquareBoundary(bdm, low, upp, fac);
1109: DMPlexGenerate(bdm, NULL, PETSC_FALSE, &botdm);
1110: DMDestroy(&bdm);
1111: DMPlexExtrude(botdm, fac[2], upp[2] - low[2], orderHeight, NULL, interpolate, dm);
1112: if (low[2] != 0.0) {
1113: Vec v;
1114: PetscScalar *x;
1115: PetscInt cDim, n;
1117: DMGetCoordinatesLocal(*dm, &v);
1118: VecGetBlockSize(v, &cDim);
1119: VecGetLocalSize(v, &n);
1120: VecGetArray(v, &x);
1121: x += cDim;
1122: for (i=0; i<n; i+=cDim) x[i] += low[2];
1123: VecRestoreArray(v,&x);
1124: DMSetCoordinatesLocal(*dm, v);
1125: }
1126: DMDestroy(&botdm);
1127: return(0);
1128: }
1130: /*@C
1131: DMPlexExtrude - Creates a (d+1)-D mesh by extruding a d-D mesh in the normal direction using prismatic cells.
1133: Collective on idm
1135: Input Parameters:
1136: + idm - The mesh to be extruded
1137: . layers - The number of layers, or PETSC_DETERMINE to use the default
1138: . height - The total height of the extrusion, or PETSC_DETERMINE to use the default
1139: . orderHeight - If PETSC_TRUE, orders the extruded cells in the height first. Otherwise, orders the cell on the layers first
1140: . extNormal - The normal direction in which the mesh should be extruded, or NULL to extrude using the surface normal
1141: - interpolate - Flag to create intermediate mesh pieces (edges, faces)
1143: Output Parameter:
1144: . dm - The DM object
1146: Notes:
1147: The mesh created has prismatic cells, and the vertex ordering in the cone of the cell is that of the tensor prismatic cells. Not currently supported in Fortran.
1149: Options Database Keys:
1150: + -dm_plex_extrude_layers <k> - Sets the number of layers k
1151: . -dm_plex_extrude_height <h> - Sets the total height of the extrusion
1152: . -dm_plex_extrude_heights <h0,h1,...> - Sets the height of each layer
1153: . -dm_plex_extrude_order_height - If true, order cells by height first
1154: - -dm_plex_extrude_normal <n0,...,nd> - Sets the normal vector along which to extrude
1156: Level: advanced
1158: .seealso: DMPlexCreateWedgeCylinderMesh(), DMPlexCreateWedgeBoxMesh(), DMSetType(), DMCreate()
1159: @*/
1160: PetscErrorCode DMPlexExtrude(DM idm, PetscInt layers, PetscReal height, PetscBool orderHeight, const PetscReal extNormal[], PetscBool interpolate, DM* dm)
1161: {
1162: PetscScalar *coordsB;
1163: const PetscScalar *coordsA;
1164: PetscReal *normals = NULL, *heights = NULL;
1165: PetscReal clNormal[3];
1166: Vec coordinatesA, coordinatesB;
1167: PetscSection coordSectionA, coordSectionB;
1168: PetscInt dim, cDim, cDimB, c, l, v, coordSize, *newCone, nl;
1169: PetscInt cStart, cEnd, vStart, vEnd, cellV, numCells, numVertices;
1170: const char *prefix;
1171: PetscBool haveCLNormal, flg;
1172: PetscErrorCode ierr;
1179: DMGetDimension(idm, &dim);
1180: DMGetCoordinateDim(idm, &cDim);
1181: cDimB = cDim == dim ? cDim+1 : cDim;
1182: if (dim < 1 || dim > 3) SETERRQ1(PetscObjectComm((PetscObject)idm), PETSC_ERR_SUP, "Support for dimension %D not coded", dim);
1184: PetscObjectGetOptionsPrefix((PetscObject) idm, &prefix);
1185: if (layers < 0) layers = 1;
1186: PetscOptionsGetInt(NULL, prefix, "-dm_plex_extrude_layers", &layers, NULL);
1187: if (layers <= 0) SETERRQ1(PetscObjectComm((PetscObject) idm), PETSC_ERR_ARG_OUTOFRANGE, "Number of layers %D must be positive", layers);
1188: if (height < 0.) height = 1.;
1189: PetscOptionsGetReal(NULL, prefix, "-dm_plex_extrude_height", &height, NULL);
1190: if (height <= 0.) SETERRQ1(PetscObjectComm((PetscObject) idm), PETSC_ERR_ARG_OUTOFRANGE, "Height of layers %g must be positive", (double) height);
1191: PetscMalloc1(layers, &heights);
1192: nl = layers;
1193: PetscOptionsGetRealArray(NULL, prefix, "-dm_plex_extrude_heights", heights, &nl, &flg);
1194: if (flg) {
1195: if (!nl) SETERRQ(PetscObjectComm((PetscObject) idm), PETSC_ERR_ARG_OUTOFRANGE, "Must give at least one height for -dm_plex_extrude_heights");
1196: for (l = nl; l < layers; ++l) heights[l] = heights[l-1];
1197: for (l = 0; l < layers; ++l) if (heights[l] <= 0.) SETERRQ2(PetscObjectComm((PetscObject) idm), PETSC_ERR_ARG_OUTOFRANGE, "Height %g of layers %D must be positive", (double) heights[l], l);
1198: } else {
1199: for (l = 0; l < layers; ++l) heights[l] = height/layers;
1200: }
1201: PetscOptionsGetBool(NULL, prefix, "-dm_plex_extrude_order_height", &orderHeight, NULL);
1202: c = 3;
1203: PetscOptionsGetRealArray(NULL, prefix, "-dm_plex_extrude_normal", clNormal, &c, &haveCLNormal);
1204: if (haveCLNormal && c != cDimB) SETERRQ2(PetscObjectComm((PetscObject)idm), PETSC_ERR_ARG_SIZ, "Input normal has size %D != %D extruded coordinate dimension", c, cDimB);
1206: DMPlexGetHeightStratum(idm, 0, &cStart, &cEnd);
1207: DMPlexGetDepthStratum(idm, 0, &vStart, &vEnd);
1208: numCells = (cEnd - cStart)*layers;
1209: numVertices = (vEnd - vStart)*(layers+1);
1210: DMCreate(PetscObjectComm((PetscObject)idm), dm);
1211: DMSetType(*dm, DMPLEX);
1212: DMSetDimension(*dm, dim+1);
1213: DMPlexSetChart(*dm, 0, numCells+numVertices);
1214: /* Must create the celltype label here so that we do not automatically try to compute the types */
1215: DMCreateLabel(*dm, "celltype");
1216: for (c = cStart, cellV = 0; c < cEnd; ++c) {
1217: DMPolytopeType ct, nct;
1218: PetscInt *closure = NULL;
1219: PetscInt closureSize, numCorners = 0;
1221: DMPlexGetCellType(idm, c, &ct);
1222: switch (ct) {
1223: case DM_POLYTOPE_SEGMENT: nct = DM_POLYTOPE_SEG_PRISM_TENSOR;break;
1224: case DM_POLYTOPE_TRIANGLE: nct = DM_POLYTOPE_TRI_PRISM_TENSOR;break;
1225: case DM_POLYTOPE_QUADRILATERAL: nct = DM_POLYTOPE_QUAD_PRISM_TENSOR;break;
1226: default: nct = DM_POLYTOPE_UNKNOWN;
1227: }
1228: DMPlexGetTransitiveClosure(idm, c, PETSC_TRUE, &closureSize, &closure);
1229: for (v = 0; v < closureSize*2; v += 2) if ((closure[v] >= vStart) && (closure[v] < vEnd)) numCorners++;
1230: DMPlexRestoreTransitiveClosure(idm, c, PETSC_TRUE, &closureSize, &closure);
1231: for (l = 0; l < layers; ++l) {
1232: const PetscInt cell = orderHeight ? layers*(c - cStart) + l : l*(cEnd - cStart) + c - cStart;
1234: DMPlexSetConeSize(*dm, cell, 2*numCorners);
1235: DMPlexSetCellType(*dm, cell, nct);
1236: }
1237: cellV = PetscMax(numCorners,cellV);
1238: }
1239: DMSetUp(*dm);
1241: if (dim != cDim && !(extNormal || haveCLNormal)) {PetscCalloc1(cDim*(vEnd - vStart), &normals);}
1242: PetscMalloc1(3*cellV,&newCone);
1243: for (c = cStart; c < cEnd; ++c) {
1244: PetscInt *closure = NULL;
1245: PetscInt closureSize, numCorners = 0, l;
1246: PetscReal normal[3] = {0, 0, 0};
1248: if (normals) {DMPlexComputeCellGeometryFVM(idm, c, NULL, NULL, normal);}
1249: DMPlexGetTransitiveClosure(idm, c, PETSC_TRUE, &closureSize, &closure);
1250: for (v = 0; v < closureSize*2; v += 2) {
1251: if ((closure[v] >= vStart) && (closure[v] < vEnd)) {
1252: PetscInt d;
1254: newCone[numCorners++] = closure[v] - vStart;
1255: if (normals) {for (d = 0; d < cDim; ++d) normals[cDim*(closure[v]-vStart)+d] += normal[d];}
1256: }
1257: }
1258: DMPlexRestoreTransitiveClosure(idm, c, PETSC_TRUE, &closureSize, &closure);
1259: for (l = 0; l < layers; ++l) {
1260: PetscInt i;
1262: for (i = 0; i < numCorners; ++i) {
1263: newCone[ numCorners + i] = orderHeight ? (layers+1)*newCone[i] + l + numCells : l*(vEnd - vStart) + newCone[i] + numCells;
1264: newCone[2*numCorners + i] = orderHeight ? (layers+1)*newCone[i] + l + 1 + numCells : (l+1)*(vEnd - vStart) + newCone[i] + numCells;
1265: }
1266: DMPlexSetCone(*dm, orderHeight ? layers*(c - cStart) + l : l*(cEnd - cStart) + c - cStart, newCone + numCorners);
1267: }
1268: }
1269: DMPlexSymmetrize(*dm);
1270: DMPlexStratify(*dm);
1271: PetscFree(newCone);
1273: DMGetCoordinateSection(*dm, &coordSectionB);
1274: PetscSectionSetNumFields(coordSectionB, 1);
1275: PetscSectionSetFieldComponents(coordSectionB, 0, cDimB);
1276: PetscSectionSetChart(coordSectionB, numCells, numCells+numVertices);
1277: for (v = numCells; v < numCells+numVertices; ++v) {
1278: PetscSectionSetDof(coordSectionB, v, cDimB);
1279: PetscSectionSetFieldDof(coordSectionB, v, 0, cDimB);
1280: DMPlexSetCellType(*dm, v, DM_POLYTOPE_POINT);
1281: }
1282: PetscSectionSetUp(coordSectionB);
1283: PetscSectionGetStorageSize(coordSectionB, &coordSize);
1284: VecCreate(PETSC_COMM_SELF, &coordinatesB);
1285: PetscObjectSetName((PetscObject) coordinatesB, "coordinates");
1286: VecSetSizes(coordinatesB, coordSize, PETSC_DETERMINE);
1287: VecSetBlockSize(coordinatesB, cDimB);
1288: VecSetType(coordinatesB,VECSTANDARD);
1290: DMGetCoordinateSection(idm, &coordSectionA);
1291: DMGetCoordinatesLocal(idm, &coordinatesA);
1292: VecGetArray(coordinatesB, &coordsB);
1293: VecGetArrayRead(coordinatesA, &coordsA);
1294: for (v = vStart; v < vEnd; ++v) {
1295: const PetscScalar *cptr;
1296: PetscReal ones2[2] = { 0., 1.}, ones3[3] = { 0., 0., 1.};
1297: PetscReal normal[3];
1298: PetscReal norm;
1299: PetscInt offA, d, cDimA = cDim;
1301: if (normals) {for (d = 0; d < cDimB; ++d) normal[d] = normals[cDimB*(v - vStart)+d];}
1302: else if (haveCLNormal) {for (d = 0; d < cDimB; ++d) normal[d] = clNormal[d];}
1303: else if (extNormal) {for (d = 0; d < cDimB; ++d) normal[d] = extNormal[d];}
1304: else if (cDimB == 2) {for (d = 0; d < cDimB; ++d) normal[d] = ones2[d];}
1305: else if (cDimB == 3) {for (d = 0; d < cDimB; ++d) normal[d] = ones3[d];}
1306: else SETERRQ(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Unable to determine normal for extrusion");
1307: for (d = 0, norm = 0.0; d < cDimB; ++d) norm += normal[d]*normal[d];
1308: for (d = 0; d < cDimB; ++d) normal[d] *= 1./PetscSqrtReal(norm);
1310: PetscSectionGetOffset(coordSectionA, v, &offA);
1311: cptr = coordsA + offA;
1312: for (l = 0; l <= layers; ++l) {
1313: PetscInt offB, d, newV;
1315: newV = orderHeight ? (layers+1)*(v -vStart) + l + numCells : (vEnd -vStart)*l + (v -vStart) + numCells;
1316: PetscSectionGetOffset(coordSectionB, newV, &offB);
1317: for (d = 0; d < cDimA; ++d) { coordsB[offB+d] = cptr[d]; }
1318: for (d = 0; d < cDimB; ++d) { coordsB[offB+d] += l ? normal[d]*heights[l-1] : 0.0; }
1319: cptr = coordsB + offB;
1320: cDimA = cDimB;
1321: }
1322: }
1323: VecRestoreArrayRead(coordinatesA, &coordsA);
1324: VecRestoreArray(coordinatesB, &coordsB);
1325: DMSetCoordinatesLocal(*dm, coordinatesB);
1326: VecDestroy(&coordinatesB);
1327: PetscFree(normals);
1328: PetscFree(heights);
1329: if (interpolate) {
1330: DM idm;
1332: DMPlexInterpolate(*dm, &idm);
1333: DMPlexCopyCoordinates(*dm, idm);
1334: DMDestroy(dm);
1335: *dm = idm;
1336: }
1337: return(0);
1338: }
1340: /*@C
1341: DMPlexSetOptionsPrefix - Sets the prefix used for searching for all DM options in the database.
1343: Logically Collective on dm
1345: Input Parameters:
1346: + dm - the DM context
1347: - prefix - the prefix to prepend to all option names
1349: Notes:
1350: A hyphen (-) must NOT be given at the beginning of the prefix name.
1351: The first character of all runtime options is AUTOMATICALLY the hyphen.
1353: Level: advanced
1355: .seealso: SNESSetFromOptions()
1356: @*/
1357: PetscErrorCode DMPlexSetOptionsPrefix(DM dm, const char prefix[])
1358: {
1359: DM_Plex *mesh = (DM_Plex *) dm->data;
1364: PetscObjectSetOptionsPrefix((PetscObject) dm, prefix);
1365: PetscObjectSetOptionsPrefix((PetscObject) mesh->partitioner, prefix);
1366: return(0);
1367: }
1369: /*@
1370: DMPlexCreateHexCylinderMesh - Creates a mesh on the tensor product of the unit interval with the circle (cylinder) using hexahedra.
1372: Collective
1374: Input Parameters:
1375: + comm - The communicator for the DM object
1376: . numRefine - The number of regular refinements to the basic 5 cell structure
1377: - periodicZ - The boundary type for the Z direction
1379: Output Parameter:
1380: . dm - The DM object
1382: Options Database Keys:
1383: These options override the hard-wired input values.
1384: + -dm_plex_hex_cyl_refine <r> - Refine the sylinder r times
1385: - -dm_plex_hex_cyl_bd <bz> - Specify the DMBoundaryType in the z-direction
1387: Note:
1388: Here is the output numbering looking from the bottom of the cylinder:
1389: $ 17-----14
1390: $ | |
1391: $ | 2 |
1392: $ | |
1393: $ 17-----8-----7-----14
1394: $ | | | |
1395: $ | 3 | 0 | 1 |
1396: $ | | | |
1397: $ 19-----5-----6-----13
1398: $ | |
1399: $ | 4 |
1400: $ | |
1401: $ 19-----13
1402: $
1403: $ and up through the top
1404: $
1405: $ 18-----16
1406: $ | |
1407: $ | 2 |
1408: $ | |
1409: $ 18----10----11-----16
1410: $ | | | |
1411: $ | 3 | 0 | 1 |
1412: $ | | | |
1413: $ 20-----9----12-----15
1414: $ | |
1415: $ | 4 |
1416: $ | |
1417: $ 20-----15
1419: Level: beginner
1421: .seealso: DMPlexCreateBoxMesh(), DMSetType(), DMCreate()
1422: @*/
1423: PetscErrorCode DMPlexCreateHexCylinderMesh(MPI_Comm comm, PetscInt numRefine, DMBoundaryType periodicZ, DM *dm)
1424: {
1425: const PetscInt dim = 3;
1426: PetscInt numCells, numVertices, r;
1427: PetscMPIInt rank;
1432: MPI_Comm_rank(comm, &rank);
1433: PetscOptionsGetInt(NULL, NULL, "-dm_plex_hex_cyl_refine", &numRefine, NULL);
1434: if (numRefine < 0) SETERRQ1(comm, PETSC_ERR_ARG_OUTOFRANGE, "Number of refinements %D cannot be negative", numRefine);
1435: PetscOptionsGetEnum(NULL, NULL, "-dm_plex_box_bd", DMBoundaryTypes, (PetscEnum *) &periodicZ, NULL);
1436: DMCreate(comm, dm);
1437: DMSetType(*dm, DMPLEX);
1438: DMSetDimension(*dm, dim);
1439: /* Create topology */
1440: {
1441: PetscInt cone[8], c;
1443: numCells = !rank ? 5 : 0;
1444: numVertices = !rank ? 16 : 0;
1445: if (periodicZ == DM_BOUNDARY_PERIODIC) {
1446: numCells *= 3;
1447: numVertices = !rank ? 24 : 0;
1448: }
1449: DMPlexSetChart(*dm, 0, numCells+numVertices);
1450: for (c = 0; c < numCells; c++) {DMPlexSetConeSize(*dm, c, 8);}
1451: DMSetUp(*dm);
1452: if (!rank) {
1453: if (periodicZ == DM_BOUNDARY_PERIODIC) {
1454: cone[0] = 15; cone[1] = 18; cone[2] = 17; cone[3] = 16;
1455: cone[4] = 31; cone[5] = 32; cone[6] = 33; cone[7] = 34;
1456: DMPlexSetCone(*dm, 0, cone);
1457: cone[0] = 16; cone[1] = 17; cone[2] = 24; cone[3] = 23;
1458: cone[4] = 32; cone[5] = 36; cone[6] = 37; cone[7] = 33; /* 22 25 26 21 */
1459: DMPlexSetCone(*dm, 1, cone);
1460: cone[0] = 18; cone[1] = 27; cone[2] = 24; cone[3] = 17;
1461: cone[4] = 34; cone[5] = 33; cone[6] = 37; cone[7] = 38;
1462: DMPlexSetCone(*dm, 2, cone);
1463: cone[0] = 29; cone[1] = 27; cone[2] = 18; cone[3] = 15;
1464: cone[4] = 35; cone[5] = 31; cone[6] = 34; cone[7] = 38;
1465: DMPlexSetCone(*dm, 3, cone);
1466: cone[0] = 29; cone[1] = 15; cone[2] = 16; cone[3] = 23;
1467: cone[4] = 35; cone[5] = 36; cone[6] = 32; cone[7] = 31;
1468: DMPlexSetCone(*dm, 4, cone);
1470: cone[0] = 31; cone[1] = 34; cone[2] = 33; cone[3] = 32;
1471: cone[4] = 19; cone[5] = 22; cone[6] = 21; cone[7] = 20;
1472: DMPlexSetCone(*dm, 5, cone);
1473: cone[0] = 32; cone[1] = 33; cone[2] = 37; cone[3] = 36;
1474: cone[4] = 22; cone[5] = 25; cone[6] = 26; cone[7] = 21;
1475: DMPlexSetCone(*dm, 6, cone);
1476: cone[0] = 34; cone[1] = 38; cone[2] = 37; cone[3] = 33;
1477: cone[4] = 20; cone[5] = 21; cone[6] = 26; cone[7] = 28;
1478: DMPlexSetCone(*dm, 7, cone);
1479: cone[0] = 35; cone[1] = 38; cone[2] = 34; cone[3] = 31;
1480: cone[4] = 30; cone[5] = 19; cone[6] = 20; cone[7] = 28;
1481: DMPlexSetCone(*dm, 8, cone);
1482: cone[0] = 35; cone[1] = 31; cone[2] = 32; cone[3] = 36;
1483: cone[4] = 30; cone[5] = 25; cone[6] = 22; cone[7] = 19;
1484: DMPlexSetCone(*dm, 9, cone);
1486: cone[0] = 19; cone[1] = 20; cone[2] = 21; cone[3] = 22;
1487: cone[4] = 15; cone[5] = 16; cone[6] = 17; cone[7] = 18;
1488: DMPlexSetCone(*dm, 10, cone);
1489: cone[0] = 22; cone[1] = 21; cone[2] = 26; cone[3] = 25;
1490: cone[4] = 16; cone[5] = 23; cone[6] = 24; cone[7] = 17;
1491: DMPlexSetCone(*dm, 11, cone);
1492: cone[0] = 20; cone[1] = 28; cone[2] = 26; cone[3] = 21;
1493: cone[4] = 18; cone[5] = 17; cone[6] = 24; cone[7] = 27;
1494: DMPlexSetCone(*dm, 12, cone);
1495: cone[0] = 30; cone[1] = 28; cone[2] = 20; cone[3] = 19;
1496: cone[4] = 29; cone[5] = 15; cone[6] = 18; cone[7] = 27;
1497: DMPlexSetCone(*dm, 13, cone);
1498: cone[0] = 30; cone[1] = 19; cone[2] = 22; cone[3] = 25;
1499: cone[4] = 29; cone[5] = 23; cone[6] = 16; cone[7] = 15;
1500: DMPlexSetCone(*dm, 14, cone);
1501: } else {
1502: cone[0] = 5; cone[1] = 8; cone[2] = 7; cone[3] = 6;
1503: cone[4] = 9; cone[5] = 12; cone[6] = 11; cone[7] = 10;
1504: DMPlexSetCone(*dm, 0, cone);
1505: cone[0] = 6; cone[1] = 7; cone[2] = 14; cone[3] = 13;
1506: cone[4] = 12; cone[5] = 15; cone[6] = 16; cone[7] = 11;
1507: DMPlexSetCone(*dm, 1, cone);
1508: cone[0] = 8; cone[1] = 17; cone[2] = 14; cone[3] = 7;
1509: cone[4] = 10; cone[5] = 11; cone[6] = 16; cone[7] = 18;
1510: DMPlexSetCone(*dm, 2, cone);
1511: cone[0] = 19; cone[1] = 17; cone[2] = 8; cone[3] = 5;
1512: cone[4] = 20; cone[5] = 9; cone[6] = 10; cone[7] = 18;
1513: DMPlexSetCone(*dm, 3, cone);
1514: cone[0] = 19; cone[1] = 5; cone[2] = 6; cone[3] = 13;
1515: cone[4] = 20; cone[5] = 15; cone[6] = 12; cone[7] = 9;
1516: DMPlexSetCone(*dm, 4, cone);
1517: }
1518: }
1519: DMPlexSymmetrize(*dm);
1520: DMPlexStratify(*dm);
1521: }
1522: /* Interpolate */
1523: {
1524: DM idm;
1526: DMPlexInterpolate(*dm, &idm);
1527: DMDestroy(dm);
1528: *dm = idm;
1529: }
1530: /* Create cube geometry */
1531: {
1532: Vec coordinates;
1533: PetscSection coordSection;
1534: PetscScalar *coords;
1535: PetscInt coordSize, v;
1536: const PetscReal dis = 1.0/PetscSqrtReal(2.0);
1537: const PetscReal ds2 = dis/2.0;
1539: /* Build coordinates */
1540: DMGetCoordinateSection(*dm, &coordSection);
1541: PetscSectionSetNumFields(coordSection, 1);
1542: PetscSectionSetFieldComponents(coordSection, 0, dim);
1543: PetscSectionSetChart(coordSection, numCells, numCells+numVertices);
1544: for (v = numCells; v < numCells+numVertices; ++v) {
1545: PetscSectionSetDof(coordSection, v, dim);
1546: PetscSectionSetFieldDof(coordSection, v, 0, dim);
1547: }
1548: PetscSectionSetUp(coordSection);
1549: PetscSectionGetStorageSize(coordSection, &coordSize);
1550: VecCreate(PETSC_COMM_SELF, &coordinates);
1551: PetscObjectSetName((PetscObject) coordinates, "coordinates");
1552: VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
1553: VecSetBlockSize(coordinates, dim);
1554: VecSetType(coordinates,VECSTANDARD);
1555: VecGetArray(coordinates, &coords);
1556: if (!rank) {
1557: coords[0*dim+0] = -ds2; coords[0*dim+1] = -ds2; coords[0*dim+2] = 0.0;
1558: coords[1*dim+0] = ds2; coords[1*dim+1] = -ds2; coords[1*dim+2] = 0.0;
1559: coords[2*dim+0] = ds2; coords[2*dim+1] = ds2; coords[2*dim+2] = 0.0;
1560: coords[3*dim+0] = -ds2; coords[3*dim+1] = ds2; coords[3*dim+2] = 0.0;
1561: coords[4*dim+0] = -ds2; coords[4*dim+1] = -ds2; coords[4*dim+2] = 1.0;
1562: coords[5*dim+0] = -ds2; coords[5*dim+1] = ds2; coords[5*dim+2] = 1.0;
1563: coords[6*dim+0] = ds2; coords[6*dim+1] = ds2; coords[6*dim+2] = 1.0;
1564: coords[7*dim+0] = ds2; coords[7*dim+1] = -ds2; coords[7*dim+2] = 1.0;
1565: coords[ 8*dim+0] = dis; coords[ 8*dim+1] = -dis; coords[ 8*dim+2] = 0.0;
1566: coords[ 9*dim+0] = dis; coords[ 9*dim+1] = dis; coords[ 9*dim+2] = 0.0;
1567: coords[10*dim+0] = dis; coords[10*dim+1] = -dis; coords[10*dim+2] = 1.0;
1568: coords[11*dim+0] = dis; coords[11*dim+1] = dis; coords[11*dim+2] = 1.0;
1569: coords[12*dim+0] = -dis; coords[12*dim+1] = dis; coords[12*dim+2] = 0.0;
1570: coords[13*dim+0] = -dis; coords[13*dim+1] = dis; coords[13*dim+2] = 1.0;
1571: coords[14*dim+0] = -dis; coords[14*dim+1] = -dis; coords[14*dim+2] = 0.0;
1572: coords[15*dim+0] = -dis; coords[15*dim+1] = -dis; coords[15*dim+2] = 1.0;
1573: if (periodicZ == DM_BOUNDARY_PERIODIC) {
1574: /* 15 31 19 */ coords[16*dim+0] = -ds2; coords[16*dim+1] = -ds2; coords[16*dim+2] = 0.5;
1575: /* 16 32 22 */ coords[17*dim+0] = ds2; coords[17*dim+1] = -ds2; coords[17*dim+2] = 0.5;
1576: /* 17 33 21 */ coords[18*dim+0] = ds2; coords[18*dim+1] = ds2; coords[18*dim+2] = 0.5;
1577: /* 18 34 20 */ coords[19*dim+0] = -ds2; coords[19*dim+1] = ds2; coords[19*dim+2] = 0.5;
1578: /* 29 35 30 */ coords[20*dim+0] = -dis; coords[20*dim+1] = -dis; coords[20*dim+2] = 0.5;
1579: /* 23 36 25 */ coords[21*dim+0] = dis; coords[21*dim+1] = -dis; coords[21*dim+2] = 0.5;
1580: /* 24 37 26 */ coords[22*dim+0] = dis; coords[22*dim+1] = dis; coords[22*dim+2] = 0.5;
1581: /* 27 38 28 */ coords[23*dim+0] = -dis; coords[23*dim+1] = dis; coords[23*dim+2] = 0.5;
1582: }
1583: }
1584: VecRestoreArray(coordinates, &coords);
1585: DMSetCoordinatesLocal(*dm, coordinates);
1586: VecDestroy(&coordinates);
1587: }
1588: /* Create periodicity */
1589: if (periodicZ == DM_BOUNDARY_PERIODIC || periodicZ == DM_BOUNDARY_TWIST) {
1590: PetscReal L[3];
1591: PetscReal maxCell[3];
1592: DMBoundaryType bdType[3];
1593: PetscReal lower[3] = {0.0, 0.0, 0.0};
1594: PetscReal upper[3] = {1.0, 1.0, 1.5};
1595: PetscInt i, numZCells = 3;
1597: bdType[0] = DM_BOUNDARY_NONE;
1598: bdType[1] = DM_BOUNDARY_NONE;
1599: bdType[2] = periodicZ;
1600: for (i = 0; i < dim; i++) {
1601: L[i] = upper[i] - lower[i];
1602: maxCell[i] = 1.1 * (L[i] / numZCells);
1603: }
1604: DMSetPeriodicity(*dm, PETSC_TRUE, maxCell, L, bdType);
1605: }
1606: /* Refine topology */
1607: for (r = 0; r < numRefine; ++r) {
1608: DM rdm = NULL;
1610: DMRefine(*dm, comm, &rdm);
1611: DMDestroy(dm);
1612: *dm = rdm;
1613: }
1614: /* Remap geometry to cylinder
1615: Interior square: Linear interpolation is correct
1616: The other cells all have vertices on rays from the origin. We want to uniformly expand the spacing
1617: such that the last vertex is on the unit circle. So the closest and farthest vertices are at distance
1619: phi = arctan(y/x)
1620: d_close = sqrt(1/8 + 1/4 sin^2(phi))
1621: d_far = sqrt(1/2 + sin^2(phi))
1623: so we remap them using
1625: x_new = x_close + (x - x_close) (1 - d_close) / (d_far - d_close)
1626: y_new = y_close + (y - y_close) (1 - d_close) / (d_far - d_close)
1628: If pi/4 < phi < 3pi/4 or -3pi/4 < phi < -pi/4, then we switch x and y.
1629: */
1630: {
1631: Vec coordinates;
1632: PetscSection coordSection;
1633: PetscScalar *coords;
1634: PetscInt vStart, vEnd, v;
1635: const PetscReal dis = 1.0/PetscSqrtReal(2.0);
1636: const PetscReal ds2 = 0.5*dis;
1638: DMPlexGetDepthStratum(*dm, 0, &vStart, &vEnd);
1639: DMGetCoordinateSection(*dm, &coordSection);
1640: DMGetCoordinatesLocal(*dm, &coordinates);
1641: VecGetArray(coordinates, &coords);
1642: for (v = vStart; v < vEnd; ++v) {
1643: PetscReal phi, sinp, cosp, dc, df, x, y, xc, yc;
1644: PetscInt off;
1646: PetscSectionGetOffset(coordSection, v, &off);
1647: if ((PetscAbsScalar(coords[off+0]) <= ds2) && (PetscAbsScalar(coords[off+1]) <= ds2)) continue;
1648: x = PetscRealPart(coords[off]);
1649: y = PetscRealPart(coords[off+1]);
1650: phi = PetscAtan2Real(y, x);
1651: sinp = PetscSinReal(phi);
1652: cosp = PetscCosReal(phi);
1653: if ((PetscAbsReal(phi) > PETSC_PI/4.0) && (PetscAbsReal(phi) < 3.0*PETSC_PI/4.0)) {
1654: dc = PetscAbsReal(ds2/sinp);
1655: df = PetscAbsReal(dis/sinp);
1656: xc = ds2*x/PetscAbsReal(y);
1657: yc = ds2*PetscSignReal(y);
1658: } else {
1659: dc = PetscAbsReal(ds2/cosp);
1660: df = PetscAbsReal(dis/cosp);
1661: xc = ds2*PetscSignReal(x);
1662: yc = ds2*y/PetscAbsReal(x);
1663: }
1664: coords[off+0] = xc + (coords[off+0] - xc)*(1.0 - dc)/(df - dc);
1665: coords[off+1] = yc + (coords[off+1] - yc)*(1.0 - dc)/(df - dc);
1666: }
1667: VecRestoreArray(coordinates, &coords);
1668: if (periodicZ == DM_BOUNDARY_PERIODIC || periodicZ == DM_BOUNDARY_TWIST) {
1669: DMLocalizeCoordinates(*dm);
1670: }
1671: }
1672: return(0);
1673: }
1675: /*@
1676: DMPlexCreateWedgeCylinderMesh - Creates a mesh on the tensor product of the unit interval with the circle (cylinder) using wedges.
1678: Collective
1680: Input Parameters:
1681: + comm - The communicator for the DM object
1682: . n - The number of wedges around the origin
1683: - interpolate - Create edges and faces
1685: Output Parameter:
1686: . dm - The DM object
1688: Level: beginner
1690: .seealso: DMPlexCreateHexCylinderMesh(), DMPlexCreateBoxMesh(), DMSetType(), DMCreate()
1691: @*/
1692: PetscErrorCode DMPlexCreateWedgeCylinderMesh(MPI_Comm comm, PetscInt n, PetscBool interpolate, DM *dm)
1693: {
1694: const PetscInt dim = 3;
1695: PetscInt numCells, numVertices, v;
1696: PetscMPIInt rank;
1701: MPI_Comm_rank(comm, &rank);
1702: if (n < 0) SETERRQ1(comm, PETSC_ERR_ARG_OUTOFRANGE, "Number of wedges %D cannot be negative", n);
1703: DMCreate(comm, dm);
1704: DMSetType(*dm, DMPLEX);
1705: DMSetDimension(*dm, dim);
1706: /* Must create the celltype label here so that we do not automatically try to compute the types */
1707: DMCreateLabel(*dm, "celltype");
1708: /* Create topology */
1709: {
1710: PetscInt cone[6], c;
1712: numCells = !rank ? n : 0;
1713: numVertices = !rank ? 2*(n+1) : 0;
1714: DMPlexSetChart(*dm, 0, numCells+numVertices);
1715: for (c = 0; c < numCells; c++) {DMPlexSetConeSize(*dm, c, 6);}
1716: DMSetUp(*dm);
1717: for (c = 0; c < numCells; c++) {
1718: cone[0] = c+n*1; cone[1] = (c+1)%n+n*1; cone[2] = 0+3*n;
1719: cone[3] = c+n*2; cone[4] = (c+1)%n+n*2; cone[5] = 1+3*n;
1720: DMPlexSetCone(*dm, c, cone);
1721: DMPlexSetCellType(*dm, c, DM_POLYTOPE_TRI_PRISM_TENSOR);
1722: }
1723: DMPlexSymmetrize(*dm);
1724: DMPlexStratify(*dm);
1725: }
1726: for (v = numCells; v < numCells+numVertices; ++v) {
1727: DMPlexSetCellType(*dm, v, DM_POLYTOPE_POINT);
1728: }
1729: /* Interpolate */
1730: if (interpolate) {
1731: DM idm;
1733: DMPlexInterpolate(*dm, &idm);
1734: DMDestroy(dm);
1735: *dm = idm;
1736: }
1737: /* Create cylinder geometry */
1738: {
1739: Vec coordinates;
1740: PetscSection coordSection;
1741: PetscScalar *coords;
1742: PetscInt coordSize, c;
1744: /* Build coordinates */
1745: DMGetCoordinateSection(*dm, &coordSection);
1746: PetscSectionSetNumFields(coordSection, 1);
1747: PetscSectionSetFieldComponents(coordSection, 0, dim);
1748: PetscSectionSetChart(coordSection, numCells, numCells+numVertices);
1749: for (v = numCells; v < numCells+numVertices; ++v) {
1750: PetscSectionSetDof(coordSection, v, dim);
1751: PetscSectionSetFieldDof(coordSection, v, 0, dim);
1752: }
1753: PetscSectionSetUp(coordSection);
1754: PetscSectionGetStorageSize(coordSection, &coordSize);
1755: VecCreate(PETSC_COMM_SELF, &coordinates);
1756: PetscObjectSetName((PetscObject) coordinates, "coordinates");
1757: VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
1758: VecSetBlockSize(coordinates, dim);
1759: VecSetType(coordinates,VECSTANDARD);
1760: VecGetArray(coordinates, &coords);
1761: for (c = 0; c < numCells; c++) {
1762: 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;
1763: 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;
1764: }
1765: if (!rank) {
1766: coords[(2*n+0)*dim+0] = 0.0; coords[(2*n+0)*dim+1] = 0.0; coords[(2*n+0)*dim+2] = 1.0;
1767: coords[(2*n+1)*dim+0] = 0.0; coords[(2*n+1)*dim+1] = 0.0; coords[(2*n+1)*dim+2] = 0.0;
1768: }
1769: VecRestoreArray(coordinates, &coords);
1770: DMSetCoordinatesLocal(*dm, coordinates);
1771: VecDestroy(&coordinates);
1772: }
1773: return(0);
1774: }
1776: PETSC_STATIC_INLINE PetscReal DiffNormReal(PetscInt dim, const PetscReal x[], const PetscReal y[])
1777: {
1778: PetscReal prod = 0.0;
1779: PetscInt i;
1780: for (i = 0; i < dim; ++i) prod += PetscSqr(x[i] - y[i]);
1781: return PetscSqrtReal(prod);
1782: }
1783: PETSC_STATIC_INLINE PetscReal DotReal(PetscInt dim, const PetscReal x[], const PetscReal y[])
1784: {
1785: PetscReal prod = 0.0;
1786: PetscInt i;
1787: for (i = 0; i < dim; ++i) prod += x[i]*y[i];
1788: return prod;
1789: }
1791: /* The first constant is the sphere radius */
1792: static void snapToSphere(PetscInt dim, PetscInt Nf, PetscInt NfAux,
1793: const PetscInt uOff[], const PetscInt uOff_x[], const PetscScalar u[], const PetscScalar u_t[], const PetscScalar u_x[],
1794: const PetscInt aOff[], const PetscInt aOff_x[], const PetscScalar a[], const PetscScalar a_t[], const PetscScalar a_x[],
1795: PetscReal t, const PetscReal x[], PetscInt numConstants, const PetscScalar constants[], PetscScalar f0[])
1796: {
1797: PetscReal r = PetscRealPart(constants[0]);
1798: PetscReal norm2 = 0.0, fac;
1799: PetscInt n = uOff[1] - uOff[0], d;
1801: for (d = 0; d < n; ++d) norm2 += PetscSqr(PetscRealPart(u[d]));
1802: fac = r/PetscSqrtReal(norm2);
1803: for (d = 0; d < n; ++d) f0[d] = u[d]*fac;
1804: }
1806: /*@
1807: DMPlexCreateSphereMesh - Creates a mesh on the d-dimensional sphere, S^d.
1809: Collective
1811: Input Parameters:
1812: + comm - The communicator for the DM object
1813: . dim - The dimension
1814: . simplex - Use simplices, or tensor product cells
1815: - R - The radius
1817: Output Parameter:
1818: . dm - The DM object
1820: Level: beginner
1822: .seealso: DMPlexCreateBallMesh(), DMPlexCreateBoxMesh(), DMSetType(), DMCreate()
1823: @*/
1824: PetscErrorCode DMPlexCreateSphereMesh(MPI_Comm comm, PetscInt dim, PetscBool simplex, PetscReal R, DM *dm)
1825: {
1826: const PetscInt embedDim = dim+1;
1827: PetscSection coordSection;
1828: Vec coordinates;
1829: PetscScalar *coords;
1830: PetscReal *coordsIn;
1831: PetscInt numCells, numEdges, numVerts, firstVertex, v, firstEdge, coordSize, d, c, e;
1832: PetscMPIInt rank;
1833: PetscErrorCode ierr;
1837: DMCreate(comm, dm);
1838: DMSetType(*dm, DMPLEX);
1839: DMSetDimension(*dm, dim);
1840: DMSetCoordinateDim(*dm, dim+1);
1841: MPI_Comm_rank(PetscObjectComm((PetscObject) *dm), &rank);
1842: switch (dim) {
1843: case 2:
1844: if (simplex) {
1845: DM idm;
1846: const PetscReal radius = PetscSqrtReal(1 + PETSC_PHI*PETSC_PHI)/(1.0 + PETSC_PHI);
1847: const PetscReal edgeLen = 2.0/(1.0 + PETSC_PHI) * (R/radius);
1848: const PetscInt degree = 5;
1849: PetscReal vertex[3] = {0.0, 1.0/(1.0 + PETSC_PHI), PETSC_PHI/(1.0 + PETSC_PHI)};
1850: PetscInt s[3] = {1, 1, 1};
1851: PetscInt cone[3];
1852: PetscInt *graph, p, i, j, k;
1854: vertex[0] *= R/radius; vertex[1] *= R/radius; vertex[2] *= R/radius;
1855: numCells = !rank ? 20 : 0;
1856: numVerts = !rank ? 12 : 0;
1857: firstVertex = numCells;
1858: /* Use icosahedron, which for a R-sphere has coordinates which are all cyclic permutations of
1860: (0, \pm 1/\phi+1, \pm \phi/\phi+1)
1862: where \phi^2 - \phi - 1 = 0, meaning \phi is the golden ratio \frac{1 + \sqrt{5}}{2}. The edge
1863: length is then given by 2/(1+\phi) = 2 * 0.38197 = 0.76393.
1864: */
1865: /* Construct vertices */
1866: PetscCalloc1(numVerts * embedDim, &coordsIn);
1867: if (!rank) {
1868: for (p = 0, i = 0; p < embedDim; ++p) {
1869: for (s[1] = -1; s[1] < 2; s[1] += 2) {
1870: for (s[2] = -1; s[2] < 2; s[2] += 2) {
1871: for (d = 0; d < embedDim; ++d) coordsIn[i*embedDim+d] = s[(d+p)%embedDim]*vertex[(d+p)%embedDim];
1872: ++i;
1873: }
1874: }
1875: }
1876: }
1877: /* Construct graph */
1878: PetscCalloc1(numVerts * numVerts, &graph);
1879: for (i = 0; i < numVerts; ++i) {
1880: for (j = 0, k = 0; j < numVerts; ++j) {
1881: if (PetscAbsReal(DiffNormReal(embedDim, &coordsIn[i*embedDim], &coordsIn[j*embedDim]) - edgeLen) < PETSC_SMALL) {graph[i*numVerts+j] = 1; ++k;}
1882: }
1883: if (k != degree) SETERRQ3(comm, PETSC_ERR_PLIB, "Invalid icosahedron, vertex %D degree %D != %D", i, k, degree);
1884: }
1885: /* Build Topology */
1886: DMPlexSetChart(*dm, 0, numCells+numVerts);
1887: for (c = 0; c < numCells; c++) {
1888: DMPlexSetConeSize(*dm, c, embedDim);
1889: }
1890: DMSetUp(*dm); /* Allocate space for cones */
1891: /* Cells */
1892: for (i = 0, c = 0; i < numVerts; ++i) {
1893: for (j = 0; j < i; ++j) {
1894: for (k = 0; k < j; ++k) {
1895: if (graph[i*numVerts+j] && graph[j*numVerts+k] && graph[k*numVerts+i]) {
1896: cone[0] = firstVertex+i; cone[1] = firstVertex+j; cone[2] = firstVertex+k;
1897: /* Check orientation */
1898: {
1899: 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}}};
1900: PetscReal normal[3];
1901: PetscInt e, f;
1903: for (d = 0; d < embedDim; ++d) {
1904: normal[d] = 0.0;
1905: for (e = 0; e < embedDim; ++e) {
1906: for (f = 0; f < embedDim; ++f) {
1907: normal[d] += epsilon[d][e][f]*(coordsIn[j*embedDim+e] - coordsIn[i*embedDim+e])*(coordsIn[k*embedDim+f] - coordsIn[i*embedDim+f]);
1908: }
1909: }
1910: }
1911: if (DotReal(embedDim, normal, &coordsIn[i*embedDim]) < 0) {PetscInt tmp = cone[1]; cone[1] = cone[2]; cone[2] = tmp;}
1912: }
1913: DMPlexSetCone(*dm, c++, cone);
1914: }
1915: }
1916: }
1917: }
1918: DMPlexSymmetrize(*dm);
1919: DMPlexStratify(*dm);
1920: PetscFree(graph);
1921: /* Interpolate mesh */
1922: DMPlexInterpolate(*dm, &idm);
1923: DMDestroy(dm);
1924: *dm = idm;
1925: } else {
1926: /*
1927: 12-21--13
1928: | |
1929: 25 4 24
1930: | |
1931: 12-25--9-16--8-24--13
1932: | | | |
1933: 23 5 17 0 15 3 22
1934: | | | |
1935: 10-20--6-14--7-19--11
1936: | |
1937: 20 1 19
1938: | |
1939: 10-18--11
1940: | |
1941: 23 2 22
1942: | |
1943: 12-21--13
1944: */
1945: PetscInt cone[4], ornt[4];
1947: numCells = !rank ? 6 : 0;
1948: numEdges = !rank ? 12 : 0;
1949: numVerts = !rank ? 8 : 0;
1950: firstVertex = numCells;
1951: firstEdge = numCells + numVerts;
1952: /* Build Topology */
1953: DMPlexSetChart(*dm, 0, numCells+numEdges+numVerts);
1954: for (c = 0; c < numCells; c++) {
1955: DMPlexSetConeSize(*dm, c, 4);
1956: }
1957: for (e = firstEdge; e < firstEdge+numEdges; ++e) {
1958: DMPlexSetConeSize(*dm, e, 2);
1959: }
1960: DMSetUp(*dm); /* Allocate space for cones */
1961: if (!rank) {
1962: /* Cell 0 */
1963: cone[0] = 14; cone[1] = 15; cone[2] = 16; cone[3] = 17;
1964: DMPlexSetCone(*dm, 0, cone);
1965: ornt[0] = 0; ornt[1] = 0; ornt[2] = 0; ornt[3] = 0;
1966: DMPlexSetConeOrientation(*dm, 0, ornt);
1967: /* Cell 1 */
1968: cone[0] = 18; cone[1] = 19; cone[2] = 14; cone[3] = 20;
1969: DMPlexSetCone(*dm, 1, cone);
1970: ornt[0] = 0; ornt[1] = 0; ornt[2] = -2; ornt[3] = 0;
1971: DMPlexSetConeOrientation(*dm, 1, ornt);
1972: /* Cell 2 */
1973: cone[0] = 21; cone[1] = 22; cone[2] = 18; cone[3] = 23;
1974: DMPlexSetCone(*dm, 2, cone);
1975: ornt[0] = 0; ornt[1] = 0; ornt[2] = -2; ornt[3] = 0;
1976: DMPlexSetConeOrientation(*dm, 2, ornt);
1977: /* Cell 3 */
1978: cone[0] = 19; cone[1] = 22; cone[2] = 24; cone[3] = 15;
1979: DMPlexSetCone(*dm, 3, cone);
1980: ornt[0] = -2; ornt[1] = -2; ornt[2] = 0; ornt[3] = -2;
1981: DMPlexSetConeOrientation(*dm, 3, ornt);
1982: /* Cell 4 */
1983: cone[0] = 16; cone[1] = 24; cone[2] = 21; cone[3] = 25;
1984: DMPlexSetCone(*dm, 4, cone);
1985: ornt[0] = -2; ornt[1] = -2; ornt[2] = -2; ornt[3] = 0;
1986: DMPlexSetConeOrientation(*dm, 4, ornt);
1987: /* Cell 5 */
1988: cone[0] = 20; cone[1] = 17; cone[2] = 25; cone[3] = 23;
1989: DMPlexSetCone(*dm, 5, cone);
1990: ornt[0] = -2; ornt[1] = -2; ornt[2] = -2; ornt[3] = -2;
1991: DMPlexSetConeOrientation(*dm, 5, ornt);
1992: /* Edges */
1993: cone[0] = 6; cone[1] = 7;
1994: DMPlexSetCone(*dm, 14, cone);
1995: cone[0] = 7; cone[1] = 8;
1996: DMPlexSetCone(*dm, 15, cone);
1997: cone[0] = 8; cone[1] = 9;
1998: DMPlexSetCone(*dm, 16, cone);
1999: cone[0] = 9; cone[1] = 6;
2000: DMPlexSetCone(*dm, 17, cone);
2001: cone[0] = 10; cone[1] = 11;
2002: DMPlexSetCone(*dm, 18, cone);
2003: cone[0] = 11; cone[1] = 7;
2004: DMPlexSetCone(*dm, 19, cone);
2005: cone[0] = 6; cone[1] = 10;
2006: DMPlexSetCone(*dm, 20, cone);
2007: cone[0] = 12; cone[1] = 13;
2008: DMPlexSetCone(*dm, 21, cone);
2009: cone[0] = 13; cone[1] = 11;
2010: DMPlexSetCone(*dm, 22, cone);
2011: cone[0] = 10; cone[1] = 12;
2012: DMPlexSetCone(*dm, 23, cone);
2013: cone[0] = 13; cone[1] = 8;
2014: DMPlexSetCone(*dm, 24, cone);
2015: cone[0] = 12; cone[1] = 9;
2016: DMPlexSetCone(*dm, 25, cone);
2017: }
2018: DMPlexSymmetrize(*dm);
2019: DMPlexStratify(*dm);
2020: /* Build coordinates */
2021: PetscCalloc1(numVerts * embedDim, &coordsIn);
2022: if (!rank) {
2023: coordsIn[0*embedDim+0] = -R; coordsIn[0*embedDim+1] = R; coordsIn[0*embedDim+2] = -R;
2024: coordsIn[1*embedDim+0] = R; coordsIn[1*embedDim+1] = R; coordsIn[1*embedDim+2] = -R;
2025: coordsIn[2*embedDim+0] = R; coordsIn[2*embedDim+1] = -R; coordsIn[2*embedDim+2] = -R;
2026: coordsIn[3*embedDim+0] = -R; coordsIn[3*embedDim+1] = -R; coordsIn[3*embedDim+2] = -R;
2027: coordsIn[4*embedDim+0] = -R; coordsIn[4*embedDim+1] = R; coordsIn[4*embedDim+2] = R;
2028: coordsIn[5*embedDim+0] = R; coordsIn[5*embedDim+1] = R; coordsIn[5*embedDim+2] = R;
2029: coordsIn[6*embedDim+0] = -R; coordsIn[6*embedDim+1] = -R; coordsIn[6*embedDim+2] = R;
2030: coordsIn[7*embedDim+0] = R; coordsIn[7*embedDim+1] = -R; coordsIn[7*embedDim+2] = R;
2031: }
2032: }
2033: break;
2034: case 3:
2035: if (simplex) {
2036: DM idm;
2037: const PetscReal edgeLen = 1.0/PETSC_PHI;
2038: PetscReal vertexA[4] = {0.5, 0.5, 0.5, 0.5};
2039: PetscReal vertexB[4] = {1.0, 0.0, 0.0, 0.0};
2040: PetscReal vertexC[4] = {0.5, 0.5*PETSC_PHI, 0.5/PETSC_PHI, 0.0};
2041: const PetscInt degree = 12;
2042: PetscInt s[4] = {1, 1, 1};
2043: 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},
2044: {2, 0, 1, 3}, {2, 1, 3, 0}, {2, 3, 0, 1}, {3, 0, 2, 1}, {3, 1, 0, 2}, {3, 2, 1, 0}};
2045: PetscInt cone[4];
2046: PetscInt *graph, p, i, j, k, l;
2048: vertexA[0] *= R; vertexA[1] *= R; vertexA[2] *= R; vertexA[3] *= R;
2049: vertexB[0] *= R; vertexB[1] *= R; vertexB[2] *= R; vertexB[3] *= R;
2050: vertexC[0] *= R; vertexC[1] *= R; vertexC[2] *= R; vertexC[3] *= R;
2051: numCells = !rank ? 600 : 0;
2052: numVerts = !rank ? 120 : 0;
2053: firstVertex = numCells;
2054: /* Use the 600-cell, which for a unit sphere has coordinates which are
2056: 1/2 (\pm 1, \pm 1, \pm 1, \pm 1) 16
2057: (\pm 1, 0, 0, 0) all cyclic permutations 8
2058: 1/2 (\pm 1, \pm phi, \pm 1/phi, 0) all even permutations 96
2060: where \phi^2 - \phi - 1 = 0, meaning \phi is the golden ratio \frac{1 + \sqrt{5}}{2}. The edge
2061: length is then given by 1/\phi = 0.61803.
2063: http://buzzard.pugetsound.edu/sage-practice/ch03s03.html
2064: http://mathworld.wolfram.com/600-Cell.html
2065: */
2066: /* Construct vertices */
2067: PetscCalloc1(numVerts * embedDim, &coordsIn);
2068: i = 0;
2069: if (!rank) {
2070: for (s[0] = -1; s[0] < 2; s[0] += 2) {
2071: for (s[1] = -1; s[1] < 2; s[1] += 2) {
2072: for (s[2] = -1; s[2] < 2; s[2] += 2) {
2073: for (s[3] = -1; s[3] < 2; s[3] += 2) {
2074: for (d = 0; d < embedDim; ++d) coordsIn[i*embedDim+d] = s[d]*vertexA[d];
2075: ++i;
2076: }
2077: }
2078: }
2079: }
2080: for (p = 0; p < embedDim; ++p) {
2081: s[1] = s[2] = s[3] = 1;
2082: for (s[0] = -1; s[0] < 2; s[0] += 2) {
2083: for (d = 0; d < embedDim; ++d) coordsIn[i*embedDim+d] = s[(d+p)%embedDim]*vertexB[(d+p)%embedDim];
2084: ++i;
2085: }
2086: }
2087: for (p = 0; p < 12; ++p) {
2088: s[3] = 1;
2089: for (s[0] = -1; s[0] < 2; s[0] += 2) {
2090: for (s[1] = -1; s[1] < 2; s[1] += 2) {
2091: for (s[2] = -1; s[2] < 2; s[2] += 2) {
2092: for (d = 0; d < embedDim; ++d) coordsIn[i*embedDim+d] = s[evenPerm[p][d]]*vertexC[evenPerm[p][d]];
2093: ++i;
2094: }
2095: }
2096: }
2097: }
2098: }
2099: if (i != numVerts) SETERRQ2(comm, PETSC_ERR_PLIB, "Invalid 600-cell, vertices %D != %D", i, numVerts);
2100: /* Construct graph */
2101: PetscCalloc1(numVerts * numVerts, &graph);
2102: for (i = 0; i < numVerts; ++i) {
2103: for (j = 0, k = 0; j < numVerts; ++j) {
2104: if (PetscAbsReal(DiffNormReal(embedDim, &coordsIn[i*embedDim], &coordsIn[j*embedDim]) - edgeLen) < PETSC_SMALL) {graph[i*numVerts+j] = 1; ++k;}
2105: }
2106: if (k != degree) SETERRQ3(comm, PETSC_ERR_PLIB, "Invalid 600-cell, vertex %D degree %D != %D", i, k, degree);
2107: }
2108: /* Build Topology */
2109: DMPlexSetChart(*dm, 0, numCells+numVerts);
2110: for (c = 0; c < numCells; c++) {
2111: DMPlexSetConeSize(*dm, c, embedDim);
2112: }
2113: DMSetUp(*dm); /* Allocate space for cones */
2114: /* Cells */
2115: if (!rank) {
2116: for (i = 0, c = 0; i < numVerts; ++i) {
2117: for (j = 0; j < i; ++j) {
2118: for (k = 0; k < j; ++k) {
2119: for (l = 0; l < k; ++l) {
2120: if (graph[i*numVerts+j] && graph[j*numVerts+k] && graph[k*numVerts+i] &&
2121: graph[l*numVerts+i] && graph[l*numVerts+j] && graph[l*numVerts+k]) {
2122: cone[0] = firstVertex+i; cone[1] = firstVertex+j; cone[2] = firstVertex+k; cone[3] = firstVertex+l;
2123: /* Check orientation: https://ef.gy/linear-algebra:normal-vectors-in-higher-dimensional-spaces */
2124: {
2125: const PetscInt epsilon[4][4][4][4] = {{{{0, 0, 0, 0}, { 0, 0, 0, 0}, { 0, 0, 0, 0}, { 0, 0, 0, 0}},
2126: {{0, 0, 0, 0}, { 0, 0, 0, 0}, { 0, 0, 0, 1}, { 0, 0, -1, 0}},
2127: {{0, 0, 0, 0}, { 0, 0, 0, -1}, { 0, 0, 0, 0}, { 0, 1, 0, 0}},
2128: {{0, 0, 0, 0}, { 0, 0, 1, 0}, { 0, -1, 0, 0}, { 0, 0, 0, 0}}},
2130: {{{0, 0, 0, 0}, { 0, 0, 0, 0}, { 0, 0, 0, -1}, { 0, 0, 1, 0}},
2131: {{0, 0, 0, 0}, { 0, 0, 0, 0}, { 0, 0, 0, 0}, { 0, 0, 0, 0}},
2132: {{0, 0, 0, 1}, { 0, 0, 0, 0}, { 0, 0, 0, 0}, {-1, 0, 0, 0}},
2133: {{0, 0, -1, 0}, { 0, 0, 0, 0}, { 1, 0, 0, 0}, { 0, 0, 0, 0}}},
2135: {{{0, 0, 0, 0}, { 0, 0, 0, 1}, { 0, 0, 0, 0}, { 0, -1, 0, 0}},
2136: {{0, 0, 0, -1}, { 0, 0, 0, 0}, { 0, 0, 0, 0}, { 1, 0, 0, 0}},
2137: {{0, 0, 0, 0}, { 0, 0, 0, 0}, { 0, 0, 0, 0}, { 0, 0, 0, 0}},
2138: {{0, 1, 0, 0}, {-1, 0, 0, 0}, { 0, 0, 0, 0}, { 0, 0, 0, 0}}},
2140: {{{0, 0, 0, 0}, { 0, 0, -1, 0}, { 0, 1, 0, 0}, { 0, 0, 0, 0}},
2141: {{0, 0, 1, 0}, { 0, 0, 0, 0}, {-1, 0, 0, 0}, { 0, 0, 0, 0}},
2142: {{0, -1, 0, 0}, { 1, 0, 0, 0}, { 0, 0, 0, 0}, { 0, 0, 0, 0}},
2143: {{0, 0, 0, 0}, { 0, 0, 0, 0}, { 0, 0, 0, 0}, { 0, 0, 0, 0}}}};
2144: PetscReal normal[4];
2145: PetscInt e, f, g;
2147: for (d = 0; d < embedDim; ++d) {
2148: normal[d] = 0.0;
2149: for (e = 0; e < embedDim; ++e) {
2150: for (f = 0; f < embedDim; ++f) {
2151: for (g = 0; g < embedDim; ++g) {
2152: 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]);
2153: }
2154: }
2155: }
2156: }
2157: if (DotReal(embedDim, normal, &coordsIn[i*embedDim]) < 0) {PetscInt tmp = cone[1]; cone[1] = cone[2]; cone[2] = tmp;}
2158: }
2159: DMPlexSetCone(*dm, c++, cone);
2160: }
2161: }
2162: }
2163: }
2164: }
2165: }
2166: DMPlexSymmetrize(*dm);
2167: DMPlexStratify(*dm);
2168: PetscFree(graph);
2169: /* Interpolate mesh */
2170: DMPlexInterpolate(*dm, &idm);
2171: DMDestroy(dm);
2172: *dm = idm;
2173: break;
2174: }
2175: default: SETERRQ1(comm, PETSC_ERR_SUP, "Unsupported dimension for sphere: %D", dim);
2176: }
2177: /* Create coordinates */
2178: DMGetCoordinateSection(*dm, &coordSection);
2179: PetscSectionSetNumFields(coordSection, 1);
2180: PetscSectionSetFieldComponents(coordSection, 0, embedDim);
2181: PetscSectionSetChart(coordSection, firstVertex, firstVertex+numVerts);
2182: for (v = firstVertex; v < firstVertex+numVerts; ++v) {
2183: PetscSectionSetDof(coordSection, v, embedDim);
2184: PetscSectionSetFieldDof(coordSection, v, 0, embedDim);
2185: }
2186: PetscSectionSetUp(coordSection);
2187: PetscSectionGetStorageSize(coordSection, &coordSize);
2188: VecCreate(PETSC_COMM_SELF, &coordinates);
2189: VecSetBlockSize(coordinates, embedDim);
2190: PetscObjectSetName((PetscObject) coordinates, "coordinates");
2191: VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
2192: VecSetType(coordinates,VECSTANDARD);
2193: VecGetArray(coordinates, &coords);
2194: for (v = 0; v < numVerts; ++v) for (d = 0; d < embedDim; ++d) {coords[v*embedDim+d] = coordsIn[v*embedDim+d];}
2195: VecRestoreArray(coordinates, &coords);
2196: DMSetCoordinatesLocal(*dm, coordinates);
2197: VecDestroy(&coordinates);
2198: PetscFree(coordsIn);
2199: /* Create coordinate function space */
2200: {
2201: DM cdm;
2202: PetscDS cds;
2203: PetscFE fe;
2204: PetscScalar radius = R;
2205: PetscInt dT, dE;
2207: DMGetCoordinateDM(*dm, &cdm);
2208: DMGetDimension(*dm, &dT);
2209: DMGetCoordinateDim(*dm, &dE);
2210: PetscFECreateLagrange(PETSC_COMM_SELF, dT, dE, simplex, 1, -1, &fe);
2211: DMSetField(cdm, 0, NULL, (PetscObject) fe);
2212: PetscFEDestroy(&fe);
2213: DMCreateDS(cdm);
2215: DMGetDS(cdm, &cds);
2216: PetscDSSetConstants(cds, 1, &radius);
2217: }
2218: ((DM_Plex *) (*dm)->data)->coordFunc = snapToSphere;
2219: return(0);
2220: }
2222: /*@
2223: DMPlexCreateBallMesh - Creates a simplex mesh on the d-dimensional ball, B^d.
2225: Collective
2227: Input Parameters:
2228: + comm - The communicator for the DM object
2229: . dim - The dimension
2230: - R - The radius
2232: Output Parameter:
2233: . dm - The DM object
2235: Options Database Keys:
2236: - bd_dm_refine - This will refine the surface mesh preserving the sphere geometry
2238: Level: beginner
2240: .seealso: DMPlexCreateSphereMesh(), DMPlexCreateBoxMesh(), DMSetType(), DMCreate()
2241: @*/
2242: PetscErrorCode DMPlexCreateBallMesh(MPI_Comm comm, PetscInt dim, PetscReal R, DM *dm)
2243: {
2244: DM sdm;
2245: DMLabel bdlabel;
2249: DMPlexCreateSphereMesh(comm, dim-1, PETSC_TRUE, R, &sdm);
2250: PetscObjectSetOptionsPrefix((PetscObject) sdm, "bd_");
2251: DMSetFromOptions(sdm);
2252: DMPlexGenerate(sdm, NULL, PETSC_TRUE, dm);
2253: DMDestroy(&sdm);
2254: DMCreateLabel(*dm, "marker");
2255: DMGetLabel(*dm, "marker", &bdlabel);
2256: DMPlexMarkBoundaryFaces(*dm, PETSC_DETERMINE, bdlabel);
2257: DMPlexLabelComplete(*dm, bdlabel);
2258: return(0);
2259: }
2261: /* External function declarations here */
2262: extern PetscErrorCode DMCreateInterpolation_Plex(DM dmCoarse, DM dmFine, Mat *interpolation, Vec *scaling);
2263: extern PetscErrorCode DMCreateInjection_Plex(DM dmCoarse, DM dmFine, Mat *mat);
2264: extern PetscErrorCode DMCreateMassMatrix_Plex(DM dmCoarse, DM dmFine, Mat *mat);
2265: extern PetscErrorCode DMCreateLocalSection_Plex(DM dm);
2266: extern PetscErrorCode DMCreateDefaultConstraints_Plex(DM dm);
2267: extern PetscErrorCode DMCreateMatrix_Plex(DM dm, Mat *J);
2268: extern PetscErrorCode DMCreateCoordinateDM_Plex(DM dm, DM *cdm);
2269: extern PetscErrorCode DMCreateCoordinateField_Plex(DM dm, DMField *field);
2270: PETSC_INTERN PetscErrorCode DMClone_Plex(DM dm, DM *newdm);
2271: extern PetscErrorCode DMSetUp_Plex(DM dm);
2272: extern PetscErrorCode DMDestroy_Plex(DM dm);
2273: extern PetscErrorCode DMView_Plex(DM dm, PetscViewer viewer);
2274: extern PetscErrorCode DMLoad_Plex(DM dm, PetscViewer viewer);
2275: extern PetscErrorCode DMCreateSubDM_Plex(DM dm, PetscInt numFields, const PetscInt fields[], IS *is, DM *subdm);
2276: extern PetscErrorCode DMCreateSuperDM_Plex(DM dms[], PetscInt len, IS **is, DM *superdm);
2277: static PetscErrorCode DMInitialize_Plex(DM dm);
2279: /* Replace dm with the contents of dmNew
2280: - Share the DM_Plex structure
2281: - Share the coordinates
2282: - Share the SF
2283: */
2284: static PetscErrorCode DMPlexReplace_Static(DM dm, DM dmNew)
2285: {
2286: PetscSF sf;
2287: DM coordDM, coarseDM;
2288: Vec coords;
2289: PetscBool isper;
2290: const PetscReal *maxCell, *L;
2291: const DMBoundaryType *bd;
2292: PetscErrorCode ierr;
2295: DMGetPointSF(dmNew, &sf);
2296: DMSetPointSF(dm, sf);
2297: DMGetCoordinateDM(dmNew, &coordDM);
2298: DMGetCoordinatesLocal(dmNew, &coords);
2299: DMSetCoordinateDM(dm, coordDM);
2300: DMSetCoordinatesLocal(dm, coords);
2301: /* Do not want to create the coordinate field if it does not already exist, so do not call DMGetCoordinateField() */
2302: DMFieldDestroy(&dm->coordinateField);
2303: dm->coordinateField = dmNew->coordinateField;
2304: DMGetPeriodicity(dmNew, &isper, &maxCell, &L, &bd);
2305: DMSetPeriodicity(dm, isper, maxCell, L, bd);
2306: DMDestroy_Plex(dm);
2307: DMInitialize_Plex(dm);
2308: dm->data = dmNew->data;
2309: ((DM_Plex *) dmNew->data)->refct++;
2310: DMDestroyLabelLinkList_Internal(dm);
2311: DMCopyLabels(dmNew, dm, PETSC_OWN_POINTER, PETSC_TRUE);
2312: DMGetCoarseDM(dmNew,&coarseDM);
2313: DMSetCoarseDM(dm,coarseDM);
2314: return(0);
2315: }
2317: /* Swap dm with the contents of dmNew
2318: - Swap the DM_Plex structure
2319: - Swap the coordinates
2320: - Swap the point PetscSF
2321: */
2322: static PetscErrorCode DMPlexSwap_Static(DM dmA, DM dmB)
2323: {
2324: DM coordDMA, coordDMB;
2325: Vec coordsA, coordsB;
2326: PetscSF sfA, sfB;
2327: DMField fieldTmp;
2328: void *tmp;
2329: DMLabelLink listTmp;
2330: DMLabel depthTmp;
2331: PetscInt tmpI;
2332: PetscErrorCode ierr;
2335: DMGetPointSF(dmA, &sfA);
2336: DMGetPointSF(dmB, &sfB);
2337: PetscObjectReference((PetscObject) sfA);
2338: DMSetPointSF(dmA, sfB);
2339: DMSetPointSF(dmB, sfA);
2340: PetscObjectDereference((PetscObject) sfA);
2342: DMGetCoordinateDM(dmA, &coordDMA);
2343: DMGetCoordinateDM(dmB, &coordDMB);
2344: PetscObjectReference((PetscObject) coordDMA);
2345: DMSetCoordinateDM(dmA, coordDMB);
2346: DMSetCoordinateDM(dmB, coordDMA);
2347: PetscObjectDereference((PetscObject) coordDMA);
2349: DMGetCoordinatesLocal(dmA, &coordsA);
2350: DMGetCoordinatesLocal(dmB, &coordsB);
2351: PetscObjectReference((PetscObject) coordsA);
2352: DMSetCoordinatesLocal(dmA, coordsB);
2353: DMSetCoordinatesLocal(dmB, coordsA);
2354: PetscObjectDereference((PetscObject) coordsA);
2356: fieldTmp = dmA->coordinateField;
2357: dmA->coordinateField = dmB->coordinateField;
2358: dmB->coordinateField = fieldTmp;
2359: tmp = dmA->data;
2360: dmA->data = dmB->data;
2361: dmB->data = tmp;
2362: listTmp = dmA->labels;
2363: dmA->labels = dmB->labels;
2364: dmB->labels = listTmp;
2365: depthTmp = dmA->depthLabel;
2366: dmA->depthLabel = dmB->depthLabel;
2367: dmB->depthLabel = depthTmp;
2368: depthTmp = dmA->celltypeLabel;
2369: dmA->celltypeLabel = dmB->celltypeLabel;
2370: dmB->celltypeLabel = depthTmp;
2371: tmpI = dmA->levelup;
2372: dmA->levelup = dmB->levelup;
2373: dmB->levelup = tmpI;
2374: return(0);
2375: }
2377: PetscErrorCode DMSetFromOptions_NonRefinement_Plex(PetscOptionItems *PetscOptionsObject,DM dm)
2378: {
2379: DM_Plex *mesh = (DM_Plex*) dm->data;
2380: PetscBool flg;
2384: /* Handle viewing */
2385: PetscOptionsBool("-dm_plex_print_set_values", "Output all set values info", "DMPlexMatSetClosure", PETSC_FALSE, &mesh->printSetValues, NULL);
2386: PetscOptionsBoundedInt("-dm_plex_print_fem", "Debug output level all fem computations", "DMPlexSNESComputeResidualFEM", 0, &mesh->printFEM, NULL,0);
2387: PetscOptionsReal("-dm_plex_print_tol", "Tolerance for FEM output", "DMPlexSNESComputeResidualFEM", mesh->printTol, &mesh->printTol, NULL);
2388: PetscOptionsBoundedInt("-dm_plex_print_l2", "Debug output level all L2 diff computations", "DMComputeL2Diff", 0, &mesh->printL2, NULL,0);
2389: DMMonitorSetFromOptions(dm, "-dm_plex_monitor_throughput", "Monitor the simulation throughput", "DMPlexMonitorThroughput", DMPlexMonitorThroughput, NULL, &flg);
2390: if (flg) {PetscLogDefaultBegin();}
2391: /* Point Location */
2392: PetscOptionsBool("-dm_plex_hash_location", "Use grid hashing for point location", "DMInterpolate", PETSC_FALSE, &mesh->useHashLocation, NULL);
2393: /* Partitioning and distribution */
2394: PetscOptionsBool("-dm_plex_partition_balance", "Attempt to evenly divide points on partition boundary between processes", "DMPlexSetPartitionBalance", PETSC_FALSE, &mesh->partitionBalance, NULL);
2395: /* Generation and remeshing */
2396: PetscOptionsBool("-dm_plex_remesh_bd", "Allow changes to the boundary on remeshing", "DMAdapt", PETSC_FALSE, &mesh->remeshBd, NULL);
2397: /* Projection behavior */
2398: PetscOptionsBoundedInt("-dm_plex_max_projection_height", "Maxmimum mesh point height used to project locally", "DMPlexSetMaxProjectionHeight", 0, &mesh->maxProjectionHeight, NULL,0);
2399: PetscOptionsBool("-dm_plex_regular_refinement", "Use special nested projection algorithm for regular refinement", "DMPlexSetRegularRefinement", mesh->regularRefinement, &mesh->regularRefinement, NULL);
2400: PetscOptionsEnum("-dm_plex_cell_refiner", "Strategy for cell refinment", "ex40.c", DMPlexCellRefinerTypes, (PetscEnum) mesh->cellRefiner, (PetscEnum *) &mesh->cellRefiner, NULL);
2401: /* Checking structure */
2402: {
2403: PetscBool flg = PETSC_FALSE, flg2 = PETSC_FALSE, all = PETSC_FALSE;
2405: PetscOptionsBool("-dm_plex_check_all", "Perform all checks", NULL, PETSC_FALSE, &all, &flg2);
2406: PetscOptionsBool("-dm_plex_check_symmetry", "Check that the adjacency information in the mesh is symmetric", "DMPlexCheckSymmetry", PETSC_FALSE, &flg, &flg2);
2407: if (all || (flg && flg2)) {DMPlexCheckSymmetry(dm);}
2408: PetscOptionsBool("-dm_plex_check_skeleton", "Check that each cell has the correct number of vertices (only for homogeneous simplex or tensor meshes)", "DMPlexCheckSkeleton", PETSC_FALSE, &flg, &flg2);
2409: if (all || (flg && flg2)) {DMPlexCheckSkeleton(dm, 0);}
2410: PetscOptionsBool("-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", PETSC_FALSE, &flg, &flg2);
2411: if (all || (flg && flg2)) {DMPlexCheckFaces(dm, 0);}
2412: PetscOptionsBool("-dm_plex_check_geometry", "Check that cells have positive volume", "DMPlexCheckGeometry", PETSC_FALSE, &flg, &flg2);
2413: if (all || (flg && flg2)) {DMPlexCheckGeometry(dm);}
2414: PetscOptionsBool("-dm_plex_check_pointsf", "Check some necessary conditions for PointSF", "DMPlexCheckPointSF", PETSC_FALSE, &flg, &flg2);
2415: if (all || (flg && flg2)) {DMPlexCheckPointSF(dm);}
2416: PetscOptionsBool("-dm_plex_check_interface_cones", "Check points on inter-partition interfaces have conforming order of cone points", "DMPlexCheckInterfaceCones", PETSC_FALSE, &flg, &flg2);
2417: if (all || (flg && flg2)) {DMPlexCheckInterfaceCones(dm);}
2418: PetscOptionsBool("-dm_plex_check_cell_shape", "Check cell shape", "DMPlexCheckCellShape", PETSC_FALSE, &flg, &flg2);
2419: if (flg && flg2) {DMPlexCheckCellShape(dm, PETSC_TRUE, PETSC_DETERMINE);}
2420: }
2422: PetscPartitionerSetFromOptions(mesh->partitioner);
2423: return(0);
2424: }
2426: static PetscErrorCode DMSetFromOptions_Plex(PetscOptionItems *PetscOptionsObject,DM dm)
2427: {
2428: PetscReal volume = -1.0;
2429: PetscInt prerefine = 0, refine = 0, r, coarsen = 0, overlap = 0;
2430: PetscBool uniformOrig, uniform = PETSC_TRUE, distribute = PETSC_FALSE, isHierarchy, flg;
2435: PetscOptionsHead(PetscOptionsObject,"DMPlex Options");
2436: /* Handle DMPlex refinement before distribution */
2437: DMPlexGetRefinementUniform(dm, &uniformOrig);
2438: PetscOptionsBool("-dm_refine_uniform_pre", "Flag for uniform refinement before distribution", "DMCreate", uniform, &uniform, &flg);
2439: if (flg) {DMPlexSetRefinementUniform(dm, uniform);}
2440: PetscOptionsReal("-dm_refine_volume_limit_pre", "The maximum cell volume after refinement before distribution", "DMCreate", volume, &volume, &flg);
2441: if (flg) {DMPlexSetRefinementLimit(dm, volume);}
2442: PetscOptionsBoundedInt("-dm_refine_pre", "The number of refinements before distribution", "DMCreate", prerefine, &prerefine, NULL,0);
2443: for (r = 0; r < prerefine; ++r) {
2444: DM rdm;
2445: PetscPointFunc coordFunc = ((DM_Plex*) dm->data)->coordFunc;
2447: DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dm);
2448: DMRefine(dm, PetscObjectComm((PetscObject) dm), &rdm);
2449: /* Total hack since we do not pass in a pointer */
2450: DMPlexReplace_Static(dm, rdm);
2451: DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dm);
2452: if (coordFunc) {
2453: DMPlexRemapGeometry(dm, 0.0, coordFunc);
2454: ((DM_Plex*) dm->data)->coordFunc = coordFunc;
2455: }
2456: DMDestroy(&rdm);
2457: }
2458: DMPlexSetRefinementUniform(dm, uniformOrig);
2459: /* Handle DMPlex distribution */
2460: PetscOptionsBool("-dm_distribute", "Flag to redistribute a mesh among processes", "DMCreate", distribute, &distribute, NULL);
2461: PetscOptionsBoundedInt("-dm_distribute_overlap", "The size of the overlap halo", "DMCreate", overlap, &overlap, NULL, 0);
2462: if (distribute) {
2463: DM pdm = NULL;
2464: PetscPartitioner part;
2466: DMPlexGetPartitioner(dm, &part);
2467: PetscPartitionerSetFromOptions(part);
2468: DMPlexDistribute(dm, overlap, NULL, &pdm);
2469: if (pdm) {
2470: DMPlexReplace_Static(dm, pdm);
2471: DMDestroy(&pdm);
2472: }
2473: }
2474: /* Handle DMPlex refinement */
2475: PetscOptionsBoundedInt("-dm_refine", "The number of uniform refinements", "DMCreate", refine, &refine, NULL,0);
2476: PetscOptionsBoundedInt("-dm_refine_hierarchy", "The number of uniform refinements", "DMCreate", refine, &refine, &isHierarchy,0);
2477: if (refine) {DMPlexSetRefinementUniform(dm, PETSC_TRUE);}
2478: if (refine && isHierarchy) {
2479: DM *dms, coarseDM;
2481: DMGetCoarseDM(dm, &coarseDM);
2482: PetscObjectReference((PetscObject)coarseDM);
2483: PetscMalloc1(refine,&dms);
2484: DMRefineHierarchy(dm, refine, dms);
2485: /* Total hack since we do not pass in a pointer */
2486: DMPlexSwap_Static(dm, dms[refine-1]);
2487: if (refine == 1) {
2488: DMSetCoarseDM(dm, dms[0]);
2489: DMPlexSetRegularRefinement(dm, PETSC_TRUE);
2490: } else {
2491: DMSetCoarseDM(dm, dms[refine-2]);
2492: DMPlexSetRegularRefinement(dm, PETSC_TRUE);
2493: DMSetCoarseDM(dms[0], dms[refine-1]);
2494: DMPlexSetRegularRefinement(dms[0], PETSC_TRUE);
2495: }
2496: DMSetCoarseDM(dms[refine-1], coarseDM);
2497: PetscObjectDereference((PetscObject)coarseDM);
2498: /* Free DMs */
2499: for (r = 0; r < refine; ++r) {
2500: DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dms[r]);
2501: DMDestroy(&dms[r]);
2502: }
2503: PetscFree(dms);
2504: } else {
2505: for (r = 0; r < refine; ++r) {
2506: DM refinedMesh;
2507: PetscPointFunc coordFunc = ((DM_Plex*) dm->data)->coordFunc;
2509: DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dm);
2510: DMRefine(dm, PetscObjectComm((PetscObject) dm), &refinedMesh);
2511: /* Total hack since we do not pass in a pointer */
2512: DMPlexReplace_Static(dm, refinedMesh);
2513: DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dm);
2514: if (coordFunc) {
2515: DMPlexRemapGeometry(dm, 0.0, coordFunc);
2516: ((DM_Plex*) dm->data)->coordFunc = coordFunc;
2517: }
2518: DMDestroy(&refinedMesh);
2519: }
2520: }
2521: /* Handle DMPlex coarsening */
2522: PetscOptionsBoundedInt("-dm_coarsen", "Coarsen the mesh", "DMCreate", coarsen, &coarsen, NULL,0);
2523: PetscOptionsBoundedInt("-dm_coarsen_hierarchy", "The number of coarsenings", "DMCreate", coarsen, &coarsen, &isHierarchy,0);
2524: if (coarsen && isHierarchy) {
2525: DM *dms;
2527: PetscMalloc1(coarsen, &dms);
2528: DMCoarsenHierarchy(dm, coarsen, dms);
2529: /* Free DMs */
2530: for (r = 0; r < coarsen; ++r) {
2531: DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dms[r]);
2532: DMDestroy(&dms[r]);
2533: }
2534: PetscFree(dms);
2535: } else {
2536: for (r = 0; r < coarsen; ++r) {
2537: DM coarseMesh;
2539: DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dm);
2540: DMCoarsen(dm, PetscObjectComm((PetscObject) dm), &coarseMesh);
2541: /* Total hack since we do not pass in a pointer */
2542: DMPlexReplace_Static(dm, coarseMesh);
2543: DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dm);
2544: DMDestroy(&coarseMesh);
2545: }
2546: }
2547: /* Handle */
2548: DMSetFromOptions_NonRefinement_Plex(PetscOptionsObject, dm);
2549: PetscOptionsTail();
2550: return(0);
2551: }
2553: static PetscErrorCode DMCreateGlobalVector_Plex(DM dm,Vec *vec)
2554: {
2558: DMCreateGlobalVector_Section_Private(dm,vec);
2559: /* VecSetOperation(*vec, VECOP_DUPLICATE, (void(*)(void)) VecDuplicate_MPI_DM); */
2560: VecSetOperation(*vec, VECOP_VIEW, (void (*)(void)) VecView_Plex);
2561: VecSetOperation(*vec, VECOP_VIEWNATIVE, (void (*)(void)) VecView_Plex_Native);
2562: VecSetOperation(*vec, VECOP_LOAD, (void (*)(void)) VecLoad_Plex);
2563: VecSetOperation(*vec, VECOP_LOADNATIVE, (void (*)(void)) VecLoad_Plex_Native);
2564: return(0);
2565: }
2567: static PetscErrorCode DMCreateLocalVector_Plex(DM dm,Vec *vec)
2568: {
2572: DMCreateLocalVector_Section_Private(dm,vec);
2573: VecSetOperation(*vec, VECOP_VIEW, (void (*)(void)) VecView_Plex_Local);
2574: VecSetOperation(*vec, VECOP_LOAD, (void (*)(void)) VecLoad_Plex_Local);
2575: return(0);
2576: }
2578: static PetscErrorCode DMGetDimPoints_Plex(DM dm, PetscInt dim, PetscInt *pStart, PetscInt *pEnd)
2579: {
2580: PetscInt depth, d;
2584: DMPlexGetDepth(dm, &depth);
2585: if (depth == 1) {
2586: DMGetDimension(dm, &d);
2587: if (dim == 0) {DMPlexGetDepthStratum(dm, dim, pStart, pEnd);}
2588: else if (dim == d) {DMPlexGetDepthStratum(dm, 1, pStart, pEnd);}
2589: else {*pStart = 0; *pEnd = 0;}
2590: } else {
2591: DMPlexGetDepthStratum(dm, dim, pStart, pEnd);
2592: }
2593: return(0);
2594: }
2596: static PetscErrorCode DMGetNeighbors_Plex(DM dm, PetscInt *nranks, const PetscMPIInt *ranks[])
2597: {
2598: PetscSF sf;
2599: PetscInt niranks, njranks, n;
2600: const PetscMPIInt *iranks, *jranks;
2601: DM_Plex *data = (DM_Plex*) dm->data;
2602: PetscErrorCode ierr;
2605: DMGetPointSF(dm, &sf);
2606: if (!data->neighbors) {
2607: PetscSFSetUp(sf);
2608: PetscSFGetRootRanks(sf, &njranks, &jranks, NULL, NULL, NULL);
2609: PetscSFGetLeafRanks(sf, &niranks, &iranks, NULL, NULL);
2610: PetscMalloc1(njranks + niranks + 1, &data->neighbors);
2611: PetscArraycpy(data->neighbors + 1, jranks, njranks);
2612: PetscArraycpy(data->neighbors + njranks + 1, iranks, niranks);
2613: n = njranks + niranks;
2614: PetscSortRemoveDupsMPIInt(&n, data->neighbors + 1);
2615: /* The following cast should never fail: can't have more neighbors than PETSC_MPI_INT_MAX */
2616: PetscMPIIntCast(n, data->neighbors);
2617: }
2618: if (nranks) *nranks = data->neighbors[0];
2619: if (ranks) {
2620: if (data->neighbors[0]) *ranks = data->neighbors + 1;
2621: else *ranks = NULL;
2622: }
2623: return(0);
2624: }
2626: PETSC_INTERN PetscErrorCode DMInterpolateSolution_Plex(DM, DM, Mat, Vec, Vec);
2628: static PetscErrorCode DMInitialize_Plex(DM dm)
2629: {
2633: dm->ops->view = DMView_Plex;
2634: dm->ops->load = DMLoad_Plex;
2635: dm->ops->setfromoptions = DMSetFromOptions_Plex;
2636: dm->ops->clone = DMClone_Plex;
2637: dm->ops->setup = DMSetUp_Plex;
2638: dm->ops->createlocalsection = DMCreateLocalSection_Plex;
2639: dm->ops->createdefaultconstraints = DMCreateDefaultConstraints_Plex;
2640: dm->ops->createglobalvector = DMCreateGlobalVector_Plex;
2641: dm->ops->createlocalvector = DMCreateLocalVector_Plex;
2642: dm->ops->getlocaltoglobalmapping = NULL;
2643: dm->ops->createfieldis = NULL;
2644: dm->ops->createcoordinatedm = DMCreateCoordinateDM_Plex;
2645: dm->ops->createcoordinatefield = DMCreateCoordinateField_Plex;
2646: dm->ops->getcoloring = NULL;
2647: dm->ops->creatematrix = DMCreateMatrix_Plex;
2648: dm->ops->createinterpolation = DMCreateInterpolation_Plex;
2649: dm->ops->createmassmatrix = DMCreateMassMatrix_Plex;
2650: dm->ops->createinjection = DMCreateInjection_Plex;
2651: dm->ops->refine = DMRefine_Plex;
2652: dm->ops->coarsen = DMCoarsen_Plex;
2653: dm->ops->refinehierarchy = DMRefineHierarchy_Plex;
2654: dm->ops->coarsenhierarchy = DMCoarsenHierarchy_Plex;
2655: dm->ops->adaptlabel = DMAdaptLabel_Plex;
2656: dm->ops->adaptmetric = DMAdaptMetric_Plex;
2657: dm->ops->globaltolocalbegin = NULL;
2658: dm->ops->globaltolocalend = NULL;
2659: dm->ops->localtoglobalbegin = NULL;
2660: dm->ops->localtoglobalend = NULL;
2661: dm->ops->destroy = DMDestroy_Plex;
2662: dm->ops->createsubdm = DMCreateSubDM_Plex;
2663: dm->ops->createsuperdm = DMCreateSuperDM_Plex;
2664: dm->ops->getdimpoints = DMGetDimPoints_Plex;
2665: dm->ops->locatepoints = DMLocatePoints_Plex;
2666: dm->ops->projectfunctionlocal = DMProjectFunctionLocal_Plex;
2667: dm->ops->projectfunctionlabellocal = DMProjectFunctionLabelLocal_Plex;
2668: dm->ops->projectfieldlocal = DMProjectFieldLocal_Plex;
2669: dm->ops->projectfieldlabellocal = DMProjectFieldLabelLocal_Plex;
2670: dm->ops->projectbdfieldlabellocal = DMProjectBdFieldLabelLocal_Plex;
2671: dm->ops->computel2diff = DMComputeL2Diff_Plex;
2672: dm->ops->computel2gradientdiff = DMComputeL2GradientDiff_Plex;
2673: dm->ops->computel2fielddiff = DMComputeL2FieldDiff_Plex;
2674: dm->ops->getneighbors = DMGetNeighbors_Plex;
2675: PetscObjectComposeFunction((PetscObject)dm,"DMPlexInsertBoundaryValues_C",DMPlexInsertBoundaryValues_Plex);
2676: PetscObjectComposeFunction((PetscObject)dm,"DMPlexInsertTimeDerviativeBoundaryValues_C",DMPlexInsertTimeDerivativeBoundaryValues_Plex);
2677: PetscObjectComposeFunction((PetscObject)dm,"DMSetUpGLVisViewer_C",DMSetUpGLVisViewer_Plex);
2678: PetscObjectComposeFunction((PetscObject)dm,"DMCreateNeumannOverlap_C",DMCreateNeumannOverlap_Plex);
2679: PetscObjectComposeFunction((PetscObject)dm,"DMPlexGetOverlap_C",DMPlexGetOverlap_Plex);
2680: PetscObjectComposeFunction((PetscObject)dm,"DMInterpolateSolution_C",DMInterpolateSolution_Plex);
2681: return(0);
2682: }
2684: PETSC_INTERN PetscErrorCode DMClone_Plex(DM dm, DM *newdm)
2685: {
2686: DM_Plex *mesh = (DM_Plex *) dm->data;
2690: mesh->refct++;
2691: (*newdm)->data = mesh;
2692: PetscObjectChangeTypeName((PetscObject) *newdm, DMPLEX);
2693: DMInitialize_Plex(*newdm);
2694: return(0);
2695: }
2697: /*MC
2698: DMPLEX = "plex" - A DM object that encapsulates an unstructured mesh, or CW Complex, which can be expressed using a Hasse Diagram.
2699: In the local representation, Vecs contain all unknowns in the interior and shared boundary. This is
2700: specified by a PetscSection object. Ownership in the global representation is determined by
2701: ownership of the underlying DMPlex points. This is specified by another PetscSection object.
2703: Options Database Keys:
2704: + -dm_refine_pre - Refine mesh before distribution
2705: + -dm_refine_uniform_pre - Choose uniform or generator-based refinement
2706: + -dm_refine_volume_limit_pre - Cell volume limit after pre-refinement using generator
2707: . -dm_distribute - Distribute mesh across processes
2708: . -dm_distribute_overlap - Number of cells to overlap for distribution
2709: . -dm_refine - Refine mesh after distribution
2710: . -dm_plex_hash_location - Use grid hashing for point location
2711: . -dm_plex_partition_balance - Attempt to evenly divide points on partition boundary between processes
2712: . -dm_plex_remesh_bd - Allow changes to the boundary on remeshing
2713: . -dm_plex_max_projection_height - Maxmimum mesh point height used to project locally
2714: . -dm_plex_regular_refinement - Use special nested projection algorithm for regular refinement
2715: . -dm_plex_check_all - Perform all shecks below
2716: . -dm_plex_check_symmetry - Check that the adjacency information in the mesh is symmetric
2717: . -dm_plex_check_skeleton <celltype> - Check that each cell has the correct number of vertices
2718: . -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
2719: . -dm_plex_check_geometry - Check that cells have positive volume
2720: . -dm_view :mesh.tex:ascii_latex - View the mesh in LaTeX/TikZ
2721: . -dm_plex_view_scale <num> - Scale the TikZ
2722: - -dm_plex_print_fem <num> - View FEM assembly information, such as element vectors and matrices
2725: Level: intermediate
2727: .seealso: DMType, DMPlexCreate(), DMCreate(), DMSetType()
2728: M*/
2730: PETSC_EXTERN PetscErrorCode DMCreate_Plex(DM dm)
2731: {
2732: DM_Plex *mesh;
2733: PetscInt unit;
2738: PetscNewLog(dm,&mesh);
2739: dm->dim = 0;
2740: dm->data = mesh;
2742: mesh->refct = 1;
2743: PetscSectionCreate(PetscObjectComm((PetscObject)dm), &mesh->coneSection);
2744: mesh->maxConeSize = 0;
2745: mesh->cones = NULL;
2746: mesh->coneOrientations = NULL;
2747: PetscSectionCreate(PetscObjectComm((PetscObject)dm), &mesh->supportSection);
2748: mesh->maxSupportSize = 0;
2749: mesh->supports = NULL;
2750: mesh->refinementUniform = PETSC_TRUE;
2751: mesh->refinementLimit = -1.0;
2752: mesh->interpolated = DMPLEX_INTERPOLATED_INVALID;
2753: mesh->interpolatedCollective = DMPLEX_INTERPOLATED_INVALID;
2755: mesh->facesTmp = NULL;
2757: mesh->tetgenOpts = NULL;
2758: mesh->triangleOpts = NULL;
2759: PetscPartitionerCreate(PetscObjectComm((PetscObject)dm), &mesh->partitioner);
2760: mesh->remeshBd = PETSC_FALSE;
2762: mesh->subpointMap = NULL;
2764: for (unit = 0; unit < NUM_PETSC_UNITS; ++unit) mesh->scale[unit] = 1.0;
2766: mesh->regularRefinement = PETSC_FALSE;
2767: mesh->depthState = -1;
2768: mesh->celltypeState = -1;
2769: mesh->globalVertexNumbers = NULL;
2770: mesh->globalCellNumbers = NULL;
2771: mesh->anchorSection = NULL;
2772: mesh->anchorIS = NULL;
2773: mesh->createanchors = NULL;
2774: mesh->computeanchormatrix = NULL;
2775: mesh->parentSection = NULL;
2776: mesh->parents = NULL;
2777: mesh->childIDs = NULL;
2778: mesh->childSection = NULL;
2779: mesh->children = NULL;
2780: mesh->referenceTree = NULL;
2781: mesh->getchildsymmetry = NULL;
2782: mesh->vtkCellHeight = 0;
2783: mesh->useAnchors = PETSC_FALSE;
2785: mesh->maxProjectionHeight = 0;
2787: mesh->neighbors = NULL;
2789: mesh->printSetValues = PETSC_FALSE;
2790: mesh->printFEM = 0;
2791: mesh->printTol = 1.0e-10;
2793: DMInitialize_Plex(dm);
2794: return(0);
2795: }
2797: /*@
2798: DMPlexCreate - Creates a DMPlex object, which encapsulates an unstructured mesh, or CW complex, which can be expressed using a Hasse Diagram.
2800: Collective
2802: Input Parameter:
2803: . comm - The communicator for the DMPlex object
2805: Output Parameter:
2806: . mesh - The DMPlex object
2808: Level: beginner
2810: @*/
2811: PetscErrorCode DMPlexCreate(MPI_Comm comm, DM *mesh)
2812: {
2817: DMCreate(comm, mesh);
2818: DMSetType(*mesh, DMPLEX);
2819: return(0);
2820: }
2822: /*@C
2823: DMPlexBuildFromCellListParallel - Build distributed DMPLEX topology from a list of vertices for each cell (common mesh generator output)
2825: Input Parameters:
2826: + dm - The DM
2827: . numCells - The number of cells owned by this process
2828: . numVertices - The number of vertices owned by this process, or PETSC_DECIDE
2829: . NVertices - The global number of vertices, or PETSC_DECIDE
2830: . numCorners - The number of vertices for each cell
2831: - cells - An array of numCells*numCorners numbers, the global vertex numbers for each cell
2833: Output Parameter:
2834: . vertexSF - (Optional) SF describing complete vertex ownership
2836: Notes:
2837: Two triangles sharing a face
2838: $
2839: $ 2
2840: $ / | \
2841: $ / | \
2842: $ / | \
2843: $ 0 0 | 1 3
2844: $ \ | /
2845: $ \ | /
2846: $ \ | /
2847: $ 1
2848: would have input
2849: $ numCells = 2, numVertices = 4
2850: $ cells = [0 1 2 1 3 2]
2851: $
2852: which would result in the DMPlex
2853: $
2854: $ 4
2855: $ / | \
2856: $ / | \
2857: $ / | \
2858: $ 2 0 | 1 5
2859: $ \ | /
2860: $ \ | /
2861: $ \ | /
2862: $ 3
2864: Vertices are implicitly numbered consecutively 0,...,NVertices.
2865: Each rank owns a chunk of numVertices consecutive vertices.
2866: If numVertices is PETSC_DECIDE, PETSc will distribute them as evenly as possible using PetscLayout.
2867: If both NVertices and numVertices are PETSC_DECIDE, NVertices is computed by PETSc as the maximum vertex index in cells + 1.
2868: If only NVertices is PETSC_DECIDE, it is computed as the sum of numVertices over all ranks.
2870: The cell distribution is arbitrary non-overlapping, independent of the vertex distribution.
2872: Not currently supported in Fortran.
2874: Level: advanced
2876: .seealso: DMPlexBuildFromCellList(), DMPlexCreateFromCellListParallelPetsc(), DMPlexBuildCoordinatesFromCellListParallel()
2877: @*/
2878: PetscErrorCode DMPlexBuildFromCellListParallel(DM dm, PetscInt numCells, PetscInt numVertices, PetscInt NVertices, PetscInt numCorners, const PetscInt cells[], PetscSF *vertexSF)
2879: {
2880: PetscSF sfPoint;
2881: PetscLayout layout;
2882: PetscInt numVerticesAdj, *verticesAdj, *cones, c, p, dim;
2883: PetscMPIInt rank, size;
2884: PetscErrorCode ierr;
2888: PetscLogEventBegin(DMPLEX_BuildFromCellList,dm,0,0,0);
2889: MPI_Comm_rank(PetscObjectComm((PetscObject) dm), &rank);
2890: MPI_Comm_size(PetscObjectComm((PetscObject) dm), &size);
2891: DMGetDimension(dm, &dim);
2892: /* Get/check global number of vertices */
2893: {
2894: PetscInt NVerticesInCells, i;
2895: const PetscInt len = numCells * numCorners;
2897: /* NVerticesInCells = max(cells) + 1 */
2898: NVerticesInCells = PETSC_MIN_INT;
2899: for (i=0; i<len; i++) if (cells[i] > NVerticesInCells) NVerticesInCells = cells[i];
2900: ++NVerticesInCells;
2901: MPI_Allreduce(MPI_IN_PLACE, &NVerticesInCells, 1, MPIU_INT, MPI_MAX, PetscObjectComm((PetscObject) dm));
2903: if (numVertices == PETSC_DECIDE && NVertices == PETSC_DECIDE) NVertices = NVerticesInCells;
2904: else if (NVertices != PETSC_DECIDE && NVertices < NVerticesInCells) SETERRQ2(PetscObjectComm((PetscObject) dm), PETSC_ERR_ARG_WRONG, "Specified global number of vertices %D must be greater than or equal to the number of vertices in cells %D",NVertices,NVerticesInCells);
2905: }
2906: /* Count locally unique vertices */
2907: {
2908: PetscHSetI vhash;
2909: PetscInt off = 0;
2911: PetscHSetICreate(&vhash);
2912: for (c = 0; c < numCells; ++c) {
2913: for (p = 0; p < numCorners; ++p) {
2914: PetscHSetIAdd(vhash, cells[c*numCorners+p]);
2915: }
2916: }
2917: PetscHSetIGetSize(vhash, &numVerticesAdj);
2918: PetscMalloc1(numVerticesAdj, &verticesAdj);
2919: PetscHSetIGetElems(vhash, &off, verticesAdj);
2920: PetscHSetIDestroy(&vhash);
2921: if (off != numVerticesAdj) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Invalid number of local vertices %D should be %D", off, numVerticesAdj);
2922: }
2923: PetscSortInt(numVerticesAdj, verticesAdj);
2924: /* Create cones */
2925: DMPlexSetChart(dm, 0, numCells+numVerticesAdj);
2926: for (c = 0; c < numCells; ++c) {DMPlexSetConeSize(dm, c, numCorners);}
2927: DMSetUp(dm);
2928: DMPlexGetCones(dm,&cones);
2929: for (c = 0; c < numCells; ++c) {
2930: for (p = 0; p < numCorners; ++p) {
2931: const PetscInt gv = cells[c*numCorners+p];
2932: PetscInt lv;
2934: /* Positions within verticesAdj form 0-based local vertex numbering;
2935: we need to shift it by numCells to get correct DAG points (cells go first) */
2936: PetscFindInt(gv, numVerticesAdj, verticesAdj, &lv);
2937: if (lv < 0) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Could not find global vertex %D in local connectivity", gv);
2938: cones[c*numCorners+p] = lv+numCells;
2939: }
2940: }
2941: /* Build point sf */
2942: PetscLayoutCreate(PetscObjectComm((PetscObject)dm), &layout);
2943: PetscLayoutSetSize(layout, NVertices);
2944: PetscLayoutSetLocalSize(layout, numVertices);
2945: PetscLayoutSetBlockSize(layout, 1);
2946: PetscSFCreateByMatchingIndices(layout, numVerticesAdj, verticesAdj, NULL, numCells, numVerticesAdj, verticesAdj, NULL, numCells, vertexSF, &sfPoint);
2947: PetscLayoutDestroy(&layout);
2948: PetscFree(verticesAdj);
2949: PetscObjectSetName((PetscObject) sfPoint, "point SF");
2950: if (dm->sf) {
2951: const char *prefix;
2953: PetscObjectGetOptionsPrefix((PetscObject)dm->sf, &prefix);
2954: PetscObjectSetOptionsPrefix((PetscObject)sfPoint, prefix);
2955: }
2956: DMSetPointSF(dm, sfPoint);
2957: PetscSFDestroy(&sfPoint);
2958: if (vertexSF) {PetscObjectSetName((PetscObject)(*vertexSF), "Vertex Ownership SF");}
2959: /* Fill in the rest of the topology structure */
2960: DMPlexSymmetrize(dm);
2961: DMPlexStratify(dm);
2962: PetscLogEventEnd(DMPLEX_BuildFromCellList,dm,0,0,0);
2963: return(0);
2964: }
2966: /*@C
2967: DMPlexBuildCoordinatesFromCellListParallel - Build DM coordinates from a list of coordinates for each owned vertex (common mesh generator output)
2969: Input Parameters:
2970: + dm - The DM
2971: . spaceDim - The spatial dimension used for coordinates
2972: . sfVert - SF describing complete vertex ownership
2973: - vertexCoords - An array of numVertices*spaceDim numbers, the coordinates of each vertex
2975: Level: advanced
2977: Notes:
2978: Not currently supported in Fortran.
2980: .seealso: DMPlexBuildCoordinatesFromCellList(), DMPlexCreateFromCellListParallelPetsc(), DMPlexBuildFromCellListParallel()
2981: @*/
2982: PetscErrorCode DMPlexBuildCoordinatesFromCellListParallel(DM dm, PetscInt spaceDim, PetscSF sfVert, const PetscReal vertexCoords[])
2983: {
2984: PetscSection coordSection;
2985: Vec coordinates;
2986: PetscScalar *coords;
2987: PetscInt numVertices, numVerticesAdj, coordSize, v, vStart, vEnd;
2991: PetscLogEventBegin(DMPLEX_BuildCoordinatesFromCellList,dm,0,0,0);
2992: DMPlexGetDepthStratum(dm, 0, &vStart, &vEnd);
2993: if (vStart < 0 || vEnd < 0) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "DM is not set up properly. DMPlexBuildFromCellList() should be called first.");
2994: DMSetCoordinateDim(dm, spaceDim);
2995: PetscSFGetGraph(sfVert, &numVertices, &numVerticesAdj, NULL, NULL);
2996: if (vEnd - vStart != numVerticesAdj) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Supplied sfVert has wrong number of leaves = %D != %D = vEnd - vStart",numVerticesAdj,vEnd - vStart);
2997: DMGetCoordinateSection(dm, &coordSection);
2998: PetscSectionSetNumFields(coordSection, 1);
2999: PetscSectionSetFieldComponents(coordSection, 0, spaceDim);
3000: PetscSectionSetChart(coordSection, vStart, vEnd);
3001: for (v = vStart; v < vEnd; ++v) {
3002: PetscSectionSetDof(coordSection, v, spaceDim);
3003: PetscSectionSetFieldDof(coordSection, v, 0, spaceDim);
3004: }
3005: PetscSectionSetUp(coordSection);
3006: PetscSectionGetStorageSize(coordSection, &coordSize);
3007: VecCreate(PetscObjectComm((PetscObject)dm), &coordinates);
3008: VecSetBlockSize(coordinates, spaceDim);
3009: PetscObjectSetName((PetscObject) coordinates, "coordinates");
3010: VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
3011: VecSetType(coordinates,VECSTANDARD);
3012: VecGetArray(coordinates, &coords);
3013: {
3014: MPI_Datatype coordtype;
3016: /* Need a temp buffer for coords if we have complex/single */
3017: MPI_Type_contiguous(spaceDim, MPIU_SCALAR, &coordtype);
3018: MPI_Type_commit(&coordtype);
3019: #if defined(PETSC_USE_COMPLEX)
3020: {
3021: PetscScalar *svertexCoords;
3022: PetscInt i;
3023: PetscMalloc1(numVertices*spaceDim,&svertexCoords);
3024: for (i=0; i<numVertices*spaceDim; i++) svertexCoords[i] = vertexCoords[i];
3025: PetscSFBcastBegin(sfVert, coordtype, svertexCoords, coords,MPI_REPLACE);
3026: PetscSFBcastEnd(sfVert, coordtype, svertexCoords, coords,MPI_REPLACE);
3027: PetscFree(svertexCoords);
3028: }
3029: #else
3030: PetscSFBcastBegin(sfVert, coordtype, vertexCoords, coords,MPI_REPLACE);
3031: PetscSFBcastEnd(sfVert, coordtype, vertexCoords, coords,MPI_REPLACE);
3032: #endif
3033: MPI_Type_free(&coordtype);
3034: }
3035: VecRestoreArray(coordinates, &coords);
3036: DMSetCoordinatesLocal(dm, coordinates);
3037: VecDestroy(&coordinates);
3038: PetscLogEventEnd(DMPLEX_BuildCoordinatesFromCellList,dm,0,0,0);
3039: return(0);
3040: }
3042: /*@
3043: DMPlexCreateFromCellListParallelPetsc - Create distributed DMPLEX from a list of vertices for each cell (common mesh generator output)
3045: Input Parameters:
3046: + comm - The communicator
3047: . dim - The topological dimension of the mesh
3048: . numCells - The number of cells owned by this process
3049: . numVertices - The number of vertices owned by this process, or PETSC_DECIDE
3050: . NVertices - The global number of vertices, or PETSC_DECIDE
3051: . numCorners - The number of vertices for each cell
3052: . interpolate - Flag indicating that intermediate mesh entities (faces, edges) should be created automatically
3053: . cells - An array of numCells*numCorners numbers, the global vertex numbers for each cell
3054: . spaceDim - The spatial dimension used for coordinates
3055: - vertexCoords - An array of numVertices*spaceDim numbers, the coordinates of each vertex
3057: Output Parameter:
3058: + dm - The DM
3059: - vertexSF - (Optional) SF describing complete vertex ownership
3061: Notes:
3062: This function is just a convenient sequence of DMCreate(), DMSetType(), DMSetDimension(),
3063: DMPlexBuildFromCellListParallel(), DMPlexInterpolate(), DMPlexBuildCoordinatesFromCellListParallel()
3065: See DMPlexBuildFromCellListParallel() for an example and details about the topology-related parameters.
3066: See DMPlexBuildCoordinatesFromCellListParallel() for details about the geometry-related parameters.
3068: Level: intermediate
3070: .seealso: DMPlexCreateFromCellListPetsc(), DMPlexBuildFromCellListParallel(), DMPlexBuildCoordinatesFromCellListParallel(), DMPlexCreateFromDAG(), DMPlexCreate()
3071: @*/
3072: PetscErrorCode DMPlexCreateFromCellListParallelPetsc(MPI_Comm comm, PetscInt dim, PetscInt numCells, PetscInt numVertices, PetscInt NVertices, PetscInt numCorners, PetscBool interpolate, const PetscInt cells[], PetscInt spaceDim, const PetscReal vertexCoords[], PetscSF *vertexSF, DM *dm)
3073: {
3074: PetscSF sfVert;
3078: DMCreate(comm, dm);
3079: DMSetType(*dm, DMPLEX);
3082: DMSetDimension(*dm, dim);
3083: DMPlexBuildFromCellListParallel(*dm, numCells, numVertices, NVertices, numCorners, cells, &sfVert);
3084: if (interpolate) {
3085: DM idm;
3087: DMPlexInterpolate(*dm, &idm);
3088: DMDestroy(dm);
3089: *dm = idm;
3090: }
3091: DMPlexBuildCoordinatesFromCellListParallel(*dm, spaceDim, sfVert, vertexCoords);
3092: if (vertexSF) *vertexSF = sfVert;
3093: else {PetscSFDestroy(&sfVert);}
3094: return(0);
3095: }
3098: /*@
3099: DMPlexCreateFromCellListParallel - Deprecated, use DMPlexCreateFromCellListParallelPetsc()
3101: Level: deprecated
3103: .seealso: DMPlexCreateFromCellListParallelPetsc()
3104: @*/
3105: 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)
3106: {
3108: PetscInt i;
3109: PetscInt *pintCells;
3112: if (sizeof(int) > sizeof(PetscInt)) SETERRQ2(comm, PETSC_ERR_ARG_SIZ, "Size of int %zd greater than size of PetscInt %zd. Reconfigure PETSc --with-64-bit-indices=1", sizeof(int), sizeof(PetscInt));
3113: if (sizeof(int) == sizeof(PetscInt)) {
3114: pintCells = (PetscInt *) cells;
3115: } else {
3116: PetscMalloc1(numCells*numCorners, &pintCells);
3117: for (i = 0; i < numCells*numCorners; i++) {
3118: pintCells[i] = (PetscInt) cells[i];
3119: }
3120: }
3121: DMPlexCreateFromCellListParallelPetsc(comm, dim, numCells, numVertices, PETSC_DECIDE, numCorners, interpolate, pintCells, spaceDim, vertexCoords, vertexSF, dm);
3122: if (sizeof(int) != sizeof(PetscInt)) {
3123: PetscFree(pintCells);
3124: }
3125: return(0);
3126: }
3128: /*@C
3129: DMPlexBuildFromCellList - Build DMPLEX topology from a list of vertices for each cell (common mesh generator output)
3131: Input Parameters:
3132: + dm - The DM
3133: . numCells - The number of cells owned by this process
3134: . numVertices - The number of vertices owned by this process, or PETSC_DECIDE
3135: . numCorners - The number of vertices for each cell
3136: - cells - An array of numCells*numCorners numbers, the global vertex numbers for each cell
3138: Level: advanced
3140: Notes:
3141: Two triangles sharing a face
3142: $
3143: $ 2
3144: $ / | \
3145: $ / | \
3146: $ / | \
3147: $ 0 0 | 1 3
3148: $ \ | /
3149: $ \ | /
3150: $ \ | /
3151: $ 1
3152: would have input
3153: $ numCells = 2, numVertices = 4
3154: $ cells = [0 1 2 1 3 2]
3155: $
3156: which would result in the DMPlex
3157: $
3158: $ 4
3159: $ / | \
3160: $ / | \
3161: $ / | \
3162: $ 2 0 | 1 5
3163: $ \ | /
3164: $ \ | /
3165: $ \ | /
3166: $ 3
3168: If numVertices is PETSC_DECIDE, it is computed by PETSc as the maximum vertex index in cells + 1.
3170: Not currently supported in Fortran.
3172: .seealso: DMPlexBuildFromCellListParallel(), DMPlexBuildCoordinatesFromCellList(), DMPlexCreateFromCellListPetsc()
3173: @*/
3174: PetscErrorCode DMPlexBuildFromCellList(DM dm, PetscInt numCells, PetscInt numVertices, PetscInt numCorners, const PetscInt cells[])
3175: {
3176: PetscInt *cones, c, p, dim;
3180: PetscLogEventBegin(DMPLEX_BuildFromCellList,dm,0,0,0);
3181: DMGetDimension(dm, &dim);
3182: /* Get/check global number of vertices */
3183: {
3184: PetscInt NVerticesInCells, i;
3185: const PetscInt len = numCells * numCorners;
3187: /* NVerticesInCells = max(cells) + 1 */
3188: NVerticesInCells = PETSC_MIN_INT;
3189: for (i=0; i<len; i++) if (cells[i] > NVerticesInCells) NVerticesInCells = cells[i];
3190: ++NVerticesInCells;
3192: if (numVertices == PETSC_DECIDE) numVertices = NVerticesInCells;
3193: else if (numVertices < NVerticesInCells) SETERRQ2(PetscObjectComm((PetscObject) dm), PETSC_ERR_ARG_WRONG, "Specified number of vertices %D must be greater than or equal to the number of vertices in cells %D",numVertices,NVerticesInCells);
3194: }
3195: DMPlexSetChart(dm, 0, numCells+numVertices);
3196: for (c = 0; c < numCells; ++c) {
3197: DMPlexSetConeSize(dm, c, numCorners);
3198: }
3199: DMSetUp(dm);
3200: DMPlexGetCones(dm,&cones);
3201: for (c = 0; c < numCells; ++c) {
3202: for (p = 0; p < numCorners; ++p) {
3203: cones[c*numCorners+p] = cells[c*numCorners+p]+numCells;
3204: }
3205: }
3206: DMPlexSymmetrize(dm);
3207: DMPlexStratify(dm);
3208: PetscLogEventEnd(DMPLEX_BuildFromCellList,dm,0,0,0);
3209: return(0);
3210: }
3212: /*@C
3213: DMPlexBuildCoordinatesFromCellList - Build DM coordinates from a list of coordinates for each owned vertex (common mesh generator output)
3215: Input Parameters:
3216: + dm - The DM
3217: . spaceDim - The spatial dimension used for coordinates
3218: - vertexCoords - An array of numVertices*spaceDim numbers, the coordinates of each vertex
3220: Level: advanced
3222: Notes:
3223: Not currently supported in Fortran.
3225: .seealso: DMPlexBuildCoordinatesFromCellListParallel(), DMPlexCreateFromCellListPetsc(), DMPlexBuildFromCellList()
3226: @*/
3227: PetscErrorCode DMPlexBuildCoordinatesFromCellList(DM dm, PetscInt spaceDim, const PetscReal vertexCoords[])
3228: {
3229: PetscSection coordSection;
3230: Vec coordinates;
3231: DM cdm;
3232: PetscScalar *coords;
3233: PetscInt v, vStart, vEnd, d;
3237: PetscLogEventBegin(DMPLEX_BuildCoordinatesFromCellList,dm,0,0,0);
3238: DMPlexGetDepthStratum(dm, 0, &vStart, &vEnd);
3239: if (vStart < 0 || vEnd < 0) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "DM is not set up properly. DMPlexBuildFromCellList() should be called first.");
3240: DMSetCoordinateDim(dm, spaceDim);
3241: DMGetCoordinateSection(dm, &coordSection);
3242: PetscSectionSetNumFields(coordSection, 1);
3243: PetscSectionSetFieldComponents(coordSection, 0, spaceDim);
3244: PetscSectionSetChart(coordSection, vStart, vEnd);
3245: for (v = vStart; v < vEnd; ++v) {
3246: PetscSectionSetDof(coordSection, v, spaceDim);
3247: PetscSectionSetFieldDof(coordSection, v, 0, spaceDim);
3248: }
3249: PetscSectionSetUp(coordSection);
3251: DMGetCoordinateDM(dm, &cdm);
3252: DMCreateLocalVector(cdm, &coordinates);
3253: VecSetBlockSize(coordinates, spaceDim);
3254: PetscObjectSetName((PetscObject) coordinates, "coordinates");
3255: VecGetArrayWrite(coordinates, &coords);
3256: for (v = 0; v < vEnd-vStart; ++v) {
3257: for (d = 0; d < spaceDim; ++d) {
3258: coords[v*spaceDim+d] = vertexCoords[v*spaceDim+d];
3259: }
3260: }
3261: VecRestoreArrayWrite(coordinates, &coords);
3262: DMSetCoordinatesLocal(dm, coordinates);
3263: VecDestroy(&coordinates);
3264: PetscLogEventEnd(DMPLEX_BuildCoordinatesFromCellList,dm,0,0,0);
3265: return(0);
3266: }
3268: /*@
3269: DMPlexCreateFromCellListPetsc - Create DMPLEX from a list of vertices for each cell (common mesh generator output)
3271: Input Parameters:
3272: + comm - The communicator
3273: . dim - The topological dimension of the mesh
3274: . numCells - The number of cells
3275: . numVertices - The number of vertices owned by this process, or PETSC_DECIDE
3276: . numCorners - The number of vertices for each cell
3277: . interpolate - Flag indicating that intermediate mesh entities (faces, edges) should be created automatically
3278: . cells - An array of numCells*numCorners numbers, the vertices for each cell
3279: . spaceDim - The spatial dimension used for coordinates
3280: - vertexCoords - An array of numVertices*spaceDim numbers, the coordinates of each vertex
3282: Output Parameter:
3283: . dm - The DM
3285: Notes:
3286: This function is just a convenient sequence of DMCreate(), DMSetType(), DMSetDimension(), DMPlexBuildFromCellList(),
3287: DMPlexInterpolate(), DMPlexBuildCoordinatesFromCellList()
3289: See DMPlexBuildFromCellList() for an example and details about the topology-related parameters.
3290: See DMPlexBuildCoordinatesFromCellList() for details about the geometry-related parameters.
3292: Level: intermediate
3294: .seealso: DMPlexCreateFromCellListParallelPetsc(), DMPlexBuildFromCellList(), DMPlexBuildCoordinatesFromCellList(), DMPlexCreateFromDAG(), DMPlexCreate()
3295: @*/
3296: PetscErrorCode DMPlexCreateFromCellListPetsc(MPI_Comm comm, PetscInt dim, PetscInt numCells, PetscInt numVertices, PetscInt numCorners, PetscBool interpolate, const PetscInt cells[], PetscInt spaceDim, const PetscReal vertexCoords[], DM *dm)
3297: {
3301: if (!dim) SETERRQ(comm, PETSC_ERR_ARG_OUTOFRANGE, "This is not appropriate for 0-dimensional meshes. Consider either creating the DM using DMPlexCreateFromDAG(), by hand, or using DMSwarm.");
3302: DMCreate(comm, dm);
3303: DMSetType(*dm, DMPLEX);
3304: DMSetDimension(*dm, dim);
3305: DMPlexBuildFromCellList(*dm, numCells, numVertices, numCorners, cells);
3306: if (interpolate) {
3307: DM idm;
3309: DMPlexInterpolate(*dm, &idm);
3310: DMDestroy(dm);
3311: *dm = idm;
3312: }
3313: DMPlexBuildCoordinatesFromCellList(*dm, spaceDim, vertexCoords);
3314: return(0);
3315: }
3317: /*@
3318: DMPlexCreateFromCellList - Deprecated, use DMPlexCreateFromCellListPetsc()
3320: Level: deprecated
3322: .seealso: DMPlexCreateFromCellListPetsc()
3323: @*/
3324: 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)
3325: {
3327: PetscInt i;
3328: PetscInt *pintCells;
3329: PetscReal *prealVC;
3332: if (sizeof(int) > sizeof(PetscInt)) SETERRQ2(comm, PETSC_ERR_ARG_SIZ, "Size of int %zd greater than size of PetscInt %zd. Reconfigure PETSc --with-64-bit-indices=1", sizeof(int), sizeof(PetscInt));
3333: if (sizeof(int) == sizeof(PetscInt)) {
3334: pintCells = (PetscInt *) cells;
3335: } else {
3336: PetscMalloc1(numCells*numCorners, &pintCells);
3337: for (i = 0; i < numCells*numCorners; i++) {
3338: pintCells[i] = (PetscInt) cells[i];
3339: }
3340: }
3341: if (sizeof(double) > sizeof(PetscReal)) SETERRQ2(comm, PETSC_ERR_ARG_SIZ, "Size of double %zd greater than size of PetscReal %zd. Reconfigure PETSc --with-precision=<higher precision>.", sizeof(double), sizeof(PetscReal));
3342: if (sizeof(double) == sizeof(PetscReal)) {
3343: prealVC = (PetscReal *) vertexCoords;
3344: } else {
3345: PetscMalloc1(numVertices*spaceDim, &prealVC);
3346: for (i = 0; i < numVertices*spaceDim; i++) {
3347: prealVC[i] = (PetscReal) vertexCoords[i];
3348: }
3349: }
3350: DMPlexCreateFromCellListPetsc(comm, dim, numCells, numVertices, numCorners, interpolate, pintCells, spaceDim, prealVC, dm);
3351: if (sizeof(int) != sizeof(PetscInt)) {
3352: PetscFree(pintCells);
3353: }
3354: if (sizeof(double) != sizeof(PetscReal)) {
3355: PetscFree(prealVC);
3356: }
3357: return(0);
3358: }
3360: /*@
3361: DMPlexCreateFromDAG - This takes as input the adjacency-list representation of the Directed Acyclic Graph (Hasse Diagram) encoding a mesh, and produces a DM
3363: Input Parameters:
3364: + dm - The empty DM object, usually from DMCreate() and DMSetDimension()
3365: . depth - The depth of the DAG
3366: . numPoints - Array of size depth + 1 containing the number of points at each depth
3367: . coneSize - The cone size of each point
3368: . cones - The concatenation of the cone points for each point, the cone list must be oriented correctly for each point
3369: . coneOrientations - The orientation of each cone point
3370: - vertexCoords - An array of numPoints[0]*spacedim numbers representing the coordinates of each vertex, with spacedim the value set via DMSetCoordinateDim()
3372: Output Parameter:
3373: . dm - The DM
3375: Note: Two triangles sharing a face would have input
3376: $ depth = 1, numPoints = [4 2], coneSize = [3 3 0 0 0 0]
3377: $ cones = [2 3 4 3 5 4], coneOrientations = [0 0 0 0 0 0]
3378: $ vertexCoords = [-1.0 0.0 0.0 -1.0 0.0 1.0 1.0 0.0]
3379: $
3380: which would result in the DMPlex
3381: $
3382: $ 4
3383: $ / | \
3384: $ / | \
3385: $ / | \
3386: $ 2 0 | 1 5
3387: $ \ | /
3388: $ \ | /
3389: $ \ | /
3390: $ 3
3391: $
3392: $ Notice that all points are numbered consecutively, unlike DMPlexCreateFromCellListPetsc()
3394: Level: advanced
3396: .seealso: DMPlexCreateFromCellListPetsc(), DMPlexCreate()
3397: @*/
3398: PetscErrorCode DMPlexCreateFromDAG(DM dm, PetscInt depth, const PetscInt numPoints[], const PetscInt coneSize[], const PetscInt cones[], const PetscInt coneOrientations[], const PetscScalar vertexCoords[])
3399: {
3400: Vec coordinates;
3401: PetscSection coordSection;
3402: PetscScalar *coords;
3403: PetscInt coordSize, firstVertex = -1, pStart = 0, pEnd = 0, p, v, dim, dimEmbed, d, off;
3407: DMGetDimension(dm, &dim);
3408: DMGetCoordinateDim(dm, &dimEmbed);
3409: if (dimEmbed < dim) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Embedding dimension %D cannot be less than intrinsic dimension %d",dimEmbed,dim);
3410: for (d = 0; d <= depth; ++d) pEnd += numPoints[d];
3411: DMPlexSetChart(dm, pStart, pEnd);
3412: for (p = pStart; p < pEnd; ++p) {
3413: DMPlexSetConeSize(dm, p, coneSize[p-pStart]);
3414: if (firstVertex < 0 && !coneSize[p - pStart]) {
3415: firstVertex = p - pStart;
3416: }
3417: }
3418: if (firstVertex < 0 && numPoints[0]) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Expected %D vertices but could not find any", numPoints[0]);
3419: DMSetUp(dm); /* Allocate space for cones */
3420: for (p = pStart, off = 0; p < pEnd; off += coneSize[p-pStart], ++p) {
3421: DMPlexSetCone(dm, p, &cones[off]);
3422: DMPlexSetConeOrientation(dm, p, &coneOrientations[off]);
3423: }
3424: DMPlexSymmetrize(dm);
3425: DMPlexStratify(dm);
3426: /* Build coordinates */
3427: DMGetCoordinateSection(dm, &coordSection);
3428: PetscSectionSetNumFields(coordSection, 1);
3429: PetscSectionSetFieldComponents(coordSection, 0, dimEmbed);
3430: PetscSectionSetChart(coordSection, firstVertex, firstVertex+numPoints[0]);
3431: for (v = firstVertex; v < firstVertex+numPoints[0]; ++v) {
3432: PetscSectionSetDof(coordSection, v, dimEmbed);
3433: PetscSectionSetFieldDof(coordSection, v, 0, dimEmbed);
3434: }
3435: PetscSectionSetUp(coordSection);
3436: PetscSectionGetStorageSize(coordSection, &coordSize);
3437: VecCreate(PETSC_COMM_SELF, &coordinates);
3438: PetscObjectSetName((PetscObject) coordinates, "coordinates");
3439: VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
3440: VecSetBlockSize(coordinates, dimEmbed);
3441: VecSetType(coordinates,VECSTANDARD);
3442: VecGetArray(coordinates, &coords);
3443: for (v = 0; v < numPoints[0]; ++v) {
3444: PetscInt off;
3446: PetscSectionGetOffset(coordSection, v+firstVertex, &off);
3447: for (d = 0; d < dimEmbed; ++d) {
3448: coords[off+d] = vertexCoords[v*dimEmbed+d];
3449: }
3450: }
3451: VecRestoreArray(coordinates, &coords);
3452: DMSetCoordinatesLocal(dm, coordinates);
3453: VecDestroy(&coordinates);
3454: return(0);
3455: }
3457: /*@C
3458: DMPlexCreateCellVertexFromFile - Create a DMPlex mesh from a simple cell-vertex file.
3460: + comm - The MPI communicator
3461: . filename - Name of the .dat file
3462: - interpolate - Create faces and edges in the mesh
3464: Output Parameter:
3465: . dm - The DM object representing the mesh
3467: Note: The format is the simplest possible:
3468: $ Ne
3469: $ v0 v1 ... vk
3470: $ Nv
3471: $ x y z marker
3473: Level: beginner
3475: .seealso: DMPlexCreateFromFile(), DMPlexCreateMedFromFile(), DMPlexCreateGmsh(), DMPlexCreate()
3476: @*/
3477: PetscErrorCode DMPlexCreateCellVertexFromFile(MPI_Comm comm, const char filename[], PetscBool interpolate, DM *dm)
3478: {
3479: DMLabel marker;
3480: PetscViewer viewer;
3481: Vec coordinates;
3482: PetscSection coordSection;
3483: PetscScalar *coords;
3484: char line[PETSC_MAX_PATH_LEN];
3485: PetscInt dim = 3, cdim = 3, coordSize, v, c, d;
3486: PetscMPIInt rank;
3487: int snum, Nv, Nc;
3488: PetscErrorCode ierr;
3491: MPI_Comm_rank(comm, &rank);
3492: PetscViewerCreate(comm, &viewer);
3493: PetscViewerSetType(viewer, PETSCVIEWERASCII);
3494: PetscViewerFileSetMode(viewer, FILE_MODE_READ);
3495: PetscViewerFileSetName(viewer, filename);
3496: if (!rank) {
3497: PetscViewerRead(viewer, line, 2, NULL, PETSC_STRING);
3498: snum = sscanf(line, "%d %d", &Nc, &Nv);
3499: if (snum != 2) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Unable to parse cell-vertex file: %s", line);
3500: } else {
3501: Nc = Nv = 0;
3502: }
3503: DMCreate(comm, dm);
3504: DMSetType(*dm, DMPLEX);
3505: DMPlexSetChart(*dm, 0, Nc+Nv);
3506: DMSetDimension(*dm, dim);
3507: DMSetCoordinateDim(*dm, cdim);
3508: /* Read topology */
3509: if (!rank) {
3510: PetscInt cone[8], corners = 8;
3511: int vbuf[8], v;
3513: for (c = 0; c < Nc; ++c) {DMPlexSetConeSize(*dm, c, corners);}
3514: DMSetUp(*dm);
3515: for (c = 0; c < Nc; ++c) {
3516: PetscViewerRead(viewer, line, corners, NULL, PETSC_STRING);
3517: 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]);
3518: if (snum != corners) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Unable to parse cell-vertex file: %s", line);
3519: for (v = 0; v < corners; ++v) cone[v] = vbuf[v] + Nc;
3520: /* Hexahedra are inverted */
3521: {
3522: PetscInt tmp = cone[1];
3523: cone[1] = cone[3];
3524: cone[3] = tmp;
3525: }
3526: DMPlexSetCone(*dm, c, cone);
3527: }
3528: }
3529: DMPlexSymmetrize(*dm);
3530: DMPlexStratify(*dm);
3531: /* Read coordinates */
3532: DMGetCoordinateSection(*dm, &coordSection);
3533: PetscSectionSetNumFields(coordSection, 1);
3534: PetscSectionSetFieldComponents(coordSection, 0, cdim);
3535: PetscSectionSetChart(coordSection, Nc, Nc + Nv);
3536: for (v = Nc; v < Nc+Nv; ++v) {
3537: PetscSectionSetDof(coordSection, v, cdim);
3538: PetscSectionSetFieldDof(coordSection, v, 0, cdim);
3539: }
3540: PetscSectionSetUp(coordSection);
3541: PetscSectionGetStorageSize(coordSection, &coordSize);
3542: VecCreate(PETSC_COMM_SELF, &coordinates);
3543: PetscObjectSetName((PetscObject) coordinates, "coordinates");
3544: VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);
3545: VecSetBlockSize(coordinates, cdim);
3546: VecSetType(coordinates, VECSTANDARD);
3547: VecGetArray(coordinates, &coords);
3548: if (!rank) {
3549: double x[3];
3550: int val;
3552: DMCreateLabel(*dm, "marker");
3553: DMGetLabel(*dm, "marker", &marker);
3554: for (v = 0; v < Nv; ++v) {
3555: PetscViewerRead(viewer, line, 4, NULL, PETSC_STRING);
3556: snum = sscanf(line, "%lg %lg %lg %d", &x[0], &x[1], &x[2], &val);
3557: if (snum != 4) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Unable to parse cell-vertex file: %s", line);
3558: for (d = 0; d < cdim; ++d) coords[v*cdim+d] = x[d];
3559: if (val) {DMLabelSetValue(marker, v+Nc, val);}
3560: }
3561: }
3562: VecRestoreArray(coordinates, &coords);
3563: DMSetCoordinatesLocal(*dm, coordinates);
3564: VecDestroy(&coordinates);
3565: PetscViewerDestroy(&viewer);
3566: if (interpolate) {
3567: DM idm;
3568: DMLabel bdlabel;
3570: DMPlexInterpolate(*dm, &idm);
3571: DMDestroy(dm);
3572: *dm = idm;
3574: DMGetLabel(*dm, "marker", &bdlabel);
3575: DMPlexMarkBoundaryFaces(*dm, PETSC_DETERMINE, bdlabel);
3576: DMPlexLabelComplete(*dm, bdlabel);
3577: }
3578: return(0);
3579: }
3581: /*@C
3582: DMPlexCreateFromFile - This takes a filename and produces a DM
3584: Input Parameters:
3585: + comm - The communicator
3586: . filename - A file name
3587: - interpolate - Flag to create intermediate mesh pieces (edges, faces)
3589: Output Parameter:
3590: . dm - The DM
3592: Options Database Keys:
3593: . -dm_plex_create_from_hdf5_xdmf - use the PETSC_VIEWER_HDF5_XDMF format for reading HDF5
3595: Use -dm_plex_create_ prefix to pass options to the internal PetscViewer, e.g.
3596: $ -dm_plex_create_viewer_hdf5_collective
3598: Level: beginner
3600: .seealso: DMPlexCreateFromDAG(), DMPlexCreateFromCellListPetsc(), DMPlexCreate()
3601: @*/
3602: PetscErrorCode DMPlexCreateFromFile(MPI_Comm comm, const char filename[], PetscBool interpolate, DM *dm)
3603: {
3604: const char *extGmsh = ".msh";
3605: const char *extGmsh2 = ".msh2";
3606: const char *extGmsh4 = ".msh4";
3607: const char *extCGNS = ".cgns";
3608: const char *extExodus = ".exo";
3609: const char *extGenesis = ".gen";
3610: const char *extFluent = ".cas";
3611: const char *extHDF5 = ".h5";
3612: const char *extMed = ".med";
3613: const char *extPLY = ".ply";
3614: const char *extEGADS = ".egadslite";
3615: const char *extCV = ".dat";
3616: size_t len;
3617: PetscBool isGmsh, isGmsh2, isGmsh4, isCGNS, isExodus, isGenesis, isFluent, isHDF5, isMed, isPLY, isEGADS, isCV;
3618: PetscMPIInt rank;
3624: DMInitializePackage();
3625: PetscLogEventBegin(DMPLEX_CreateFromFile,0,0,0,0);
3626: MPI_Comm_rank(comm, &rank);
3627: PetscStrlen(filename, &len);
3628: if (!len) SETERRQ(comm, PETSC_ERR_ARG_WRONG, "Filename must be a valid path");
3629: PetscStrncmp(&filename[PetscMax(0,len-4)], extGmsh, 4, &isGmsh);
3630: PetscStrncmp(&filename[PetscMax(0,len-5)], extGmsh2, 5, &isGmsh2);
3631: PetscStrncmp(&filename[PetscMax(0,len-5)], extGmsh4, 5, &isGmsh4);
3632: PetscStrncmp(&filename[PetscMax(0,len-5)], extCGNS, 5, &isCGNS);
3633: PetscStrncmp(&filename[PetscMax(0,len-4)], extExodus, 4, &isExodus);
3634: PetscStrncmp(&filename[PetscMax(0,len-4)], extGenesis, 4, &isGenesis);
3635: PetscStrncmp(&filename[PetscMax(0,len-4)], extFluent, 4, &isFluent);
3636: PetscStrncmp(&filename[PetscMax(0,len-3)], extHDF5, 3, &isHDF5);
3637: PetscStrncmp(&filename[PetscMax(0,len-4)], extMed, 4, &isMed);
3638: PetscStrncmp(&filename[PetscMax(0,len-4)], extPLY, 4, &isPLY);
3639: PetscStrncmp(&filename[PetscMax(0,len-10)], extEGADS, 9, &isEGADS);
3640: PetscStrncmp(&filename[PetscMax(0,len-4)], extCV, 4, &isCV);
3641: if (isGmsh || isGmsh2 || isGmsh4) {
3642: DMPlexCreateGmshFromFile(comm, filename, interpolate, dm);
3643: } else if (isCGNS) {
3644: DMPlexCreateCGNSFromFile(comm, filename, interpolate, dm);
3645: } else if (isExodus || isGenesis) {
3646: DMPlexCreateExodusFromFile(comm, filename, interpolate, dm);
3647: } else if (isFluent) {
3648: DMPlexCreateFluentFromFile(comm, filename, interpolate, dm);
3649: } else if (isHDF5) {
3650: PetscBool load_hdf5_xdmf = PETSC_FALSE;
3651: PetscViewer viewer;
3653: /* PETSC_VIEWER_HDF5_XDMF is used if the filename ends with .xdmf.h5, or if -dm_plex_create_from_hdf5_xdmf option is present */
3654: PetscStrncmp(&filename[PetscMax(0,len-8)], ".xdmf", 5, &load_hdf5_xdmf);
3655: PetscOptionsGetBool(NULL, NULL, "-dm_plex_create_from_hdf5_xdmf", &load_hdf5_xdmf, NULL);
3656: PetscViewerCreate(comm, &viewer);
3657: PetscViewerSetType(viewer, PETSCVIEWERHDF5);
3658: PetscViewerSetOptionsPrefix(viewer, "dm_plex_create_");
3659: PetscViewerSetFromOptions(viewer);
3660: PetscViewerFileSetMode(viewer, FILE_MODE_READ);
3661: PetscViewerFileSetName(viewer, filename);
3662: DMCreate(comm, dm);
3663: DMSetType(*dm, DMPLEX);
3664: if (load_hdf5_xdmf) {PetscViewerPushFormat(viewer, PETSC_VIEWER_HDF5_XDMF);}
3665: DMLoad(*dm, viewer);
3666: if (load_hdf5_xdmf) {PetscViewerPopFormat(viewer);}
3667: PetscViewerDestroy(&viewer);
3669: if (interpolate) {
3670: DM idm;
3672: DMPlexInterpolate(*dm, &idm);
3673: DMDestroy(dm);
3674: *dm = idm;
3675: }
3676: } else if (isMed) {
3677: DMPlexCreateMedFromFile(comm, filename, interpolate, dm);
3678: } else if (isPLY) {
3679: DMPlexCreatePLYFromFile(comm, filename, interpolate, dm);
3680: } else if (isEGADS) {
3681: DMPlexCreateEGADSFromFile(comm, filename, dm);
3682: if (!interpolate) {
3683: DM udm;
3685: DMPlexUninterpolate(*dm, &udm);
3686: DMDestroy(dm);
3687: *dm = udm;
3688: }
3689: } else if (isCV) {
3690: DMPlexCreateCellVertexFromFile(comm, filename, interpolate, dm);
3691: } else SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Cannot load file %s: unrecognized extension", filename);
3692: PetscLogEventEnd(DMPLEX_CreateFromFile,0,0,0,0);
3693: return(0);
3694: }
3696: /*@
3697: DMPlexCreateReferenceCellByType - Create a DMPLEX with the appropriate FEM reference cell
3699: Collective
3701: Input Parameters:
3702: + comm - The communicator
3703: - ct - The cell type of the reference cell
3705: Output Parameter:
3706: . refdm - The reference cell
3708: Options Database Keys:
3709: . -dm_plex_ref_type <ct> - Specify the celltyoe for the reference cell
3711: Level: intermediate
3713: .seealso: DMPlexCreateReferenceCell(), DMPlexCreateBoxMesh()
3714: @*/
3715: PetscErrorCode DMPlexCreateReferenceCellByType(MPI_Comm comm, DMPolytopeType ct, DM *refdm)
3716: {
3717: DM rdm;
3718: Vec coords;
3722: PetscOptionsGetEnum(NULL, NULL, "-dm_plex_ref_type", DMPolytopeTypes, (PetscEnum *) &ct, NULL);
3723: DMCreate(comm, &rdm);
3724: DMSetType(rdm, DMPLEX);
3725: switch (ct) {
3726: case DM_POLYTOPE_POINT:
3727: {
3728: PetscInt numPoints[1] = {1};
3729: PetscInt coneSize[1] = {0};
3730: PetscInt cones[1] = {0};
3731: PetscInt coneOrientations[1] = {0};
3732: PetscScalar vertexCoords[1] = {0.0};
3734: DMSetDimension(rdm, 0);
3735: DMPlexCreateFromDAG(rdm, 0, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3736: }
3737: break;
3738: case DM_POLYTOPE_SEGMENT:
3739: {
3740: PetscInt numPoints[2] = {2, 1};
3741: PetscInt coneSize[3] = {2, 0, 0};
3742: PetscInt cones[2] = {1, 2};
3743: PetscInt coneOrientations[2] = {0, 0};
3744: PetscScalar vertexCoords[2] = {-1.0, 1.0};
3746: DMSetDimension(rdm, 1);
3747: DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3748: }
3749: break;
3750: case DM_POLYTOPE_TRIANGLE:
3751: {
3752: PetscInt numPoints[2] = {3, 1};
3753: PetscInt coneSize[4] = {3, 0, 0, 0};
3754: PetscInt cones[3] = {1, 2, 3};
3755: PetscInt coneOrientations[3] = {0, 0, 0};
3756: PetscScalar vertexCoords[6] = {-1.0, -1.0, 1.0, -1.0, -1.0, 1.0};
3758: DMSetDimension(rdm, 2);
3759: DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3760: }
3761: break;
3762: case DM_POLYTOPE_QUADRILATERAL:
3763: {
3764: PetscInt numPoints[2] = {4, 1};
3765: PetscInt coneSize[5] = {4, 0, 0, 0, 0};
3766: PetscInt cones[4] = {1, 2, 3, 4};
3767: PetscInt coneOrientations[4] = {0, 0, 0, 0};
3768: PetscScalar vertexCoords[8] = {-1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.0, 1.0};
3770: DMSetDimension(rdm, 2);
3771: DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3772: }
3773: break;
3774: case DM_POLYTOPE_SEG_PRISM_TENSOR:
3775: {
3776: PetscInt numPoints[2] = {4, 1};
3777: PetscInt coneSize[5] = {4, 0, 0, 0, 0};
3778: PetscInt cones[4] = {1, 2, 3, 4};
3779: PetscInt coneOrientations[4] = {0, 0, 0, 0};
3780: PetscScalar vertexCoords[8] = {-1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0};
3782: DMSetDimension(rdm, 2);
3783: DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3784: }
3785: break;
3786: case DM_POLYTOPE_TETRAHEDRON:
3787: {
3788: PetscInt numPoints[2] = {4, 1};
3789: PetscInt coneSize[5] = {4, 0, 0, 0, 0};
3790: PetscInt cones[4] = {1, 3, 2, 4};
3791: PetscInt coneOrientations[4] = {0, 0, 0, 0};
3792: 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};
3794: DMSetDimension(rdm, 3);
3795: DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3796: }
3797: break;
3798: case DM_POLYTOPE_HEXAHEDRON:
3799: {
3800: PetscInt numPoints[2] = {8, 1};
3801: PetscInt coneSize[9] = {8, 0, 0, 0, 0, 0, 0, 0, 0};
3802: PetscInt cones[8] = {1, 4, 3, 2, 5, 6, 7, 8};
3803: PetscInt coneOrientations[8] = {0, 0, 0, 0, 0, 0, 0, 0};
3804: 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,
3805: -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0, 1.0, 1.0, -1.0, 1.0, 1.0};
3807: DMSetDimension(rdm, 3);
3808: DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3809: }
3810: break;
3811: case DM_POLYTOPE_TRI_PRISM:
3812: {
3813: PetscInt numPoints[2] = {6, 1};
3814: PetscInt coneSize[7] = {6, 0, 0, 0, 0, 0, 0};
3815: PetscInt cones[6] = {1, 3, 2, 4, 5, 6};
3816: PetscInt coneOrientations[6] = {0, 0, 0, 0, 0, 0};
3817: PetscScalar vertexCoords[18] = {-1.0, -1.0, -1.0, 1.0, -1.0, -1.0, -1.0, 1.0, -1.0,
3818: -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, -1.0, 1.0, 1.0};
3820: DMSetDimension(rdm, 3);
3821: DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3822: }
3823: break;
3824: case DM_POLYTOPE_TRI_PRISM_TENSOR:
3825: {
3826: PetscInt numPoints[2] = {6, 1};
3827: PetscInt coneSize[7] = {6, 0, 0, 0, 0, 0, 0};
3828: PetscInt cones[6] = {1, 2, 3, 4, 5, 6};
3829: PetscInt coneOrientations[6] = {0, 0, 0, 0, 0, 0};
3830: PetscScalar vertexCoords[18] = {-1.0, -1.0, -1.0, 1.0, -1.0, -1.0, -1.0, 1.0, -1.0,
3831: -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, -1.0, 1.0, 1.0};
3833: DMSetDimension(rdm, 3);
3834: DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3835: }
3836: break;
3837: case DM_POLYTOPE_QUAD_PRISM_TENSOR:
3838: {
3839: PetscInt numPoints[2] = {8, 1};
3840: PetscInt coneSize[9] = {8, 0, 0, 0, 0, 0, 0, 0, 0};
3841: PetscInt cones[8] = {1, 2, 3, 4, 5, 6, 7, 8};
3842: PetscInt coneOrientations[8] = {0, 0, 0, 0, 0, 0, 0, 0};
3843: 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,
3844: -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0, 1.0, 1.0, -1.0, 1.0, 1.0};
3846: DMSetDimension(rdm, 3);
3847: DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3848: }
3849: break;
3850: case DM_POLYTOPE_PYRAMID:
3851: {
3852: PetscInt numPoints[2] = {5, 1};
3853: PetscInt coneSize[6] = {5, 0, 0, 0, 0, 0};
3854: PetscInt cones[5] = {1, 4, 3, 2, 5};
3855: PetscInt coneOrientations[8] = {0, 0, 0, 0, 0, 0, 0, 0};
3856: 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,
3857: 0.0, 0.0, 1.0};
3859: DMSetDimension(rdm, 3);
3860: DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords);
3861: }
3862: break;
3863: default: SETERRQ1(comm, PETSC_ERR_ARG_WRONG, "Cannot create reference cell for cell type %s", DMPolytopeTypes[ct]);
3864: }
3865: {
3866: PetscInt Nv, v;
3868: /* Must create the celltype label here so that we do not automatically try to compute the types */
3869: DMCreateLabel(rdm, "celltype");
3870: DMPlexSetCellType(rdm, 0, ct);
3871: DMPlexGetChart(rdm, NULL, &Nv);
3872: for (v = 1; v < Nv; ++v) {DMPlexSetCellType(rdm, v, DM_POLYTOPE_POINT);}
3873: }
3874: DMPlexInterpolate(rdm, refdm);
3875: if (rdm->coordinateDM) {
3876: DM ncdm;
3877: PetscSection cs;
3878: PetscInt pEnd = -1;
3880: DMGetLocalSection(rdm->coordinateDM, &cs);
3881: if (cs) {PetscSectionGetChart(cs, NULL, &pEnd);}
3882: if (pEnd >= 0) {
3883: DMClone(*refdm, &ncdm);
3884: DMCopyDisc(rdm->coordinateDM, ncdm);
3885: DMSetLocalSection(ncdm, cs);
3886: DMSetCoordinateDM(*refdm, ncdm);
3887: DMDestroy(&ncdm);
3888: }
3889: }
3890: DMGetCoordinatesLocal(rdm, &coords);
3891: if (coords) {
3892: DMSetCoordinatesLocal(*refdm, coords);
3893: } else {
3894: DMGetCoordinates(rdm, &coords);
3895: if (coords) {DMSetCoordinates(*refdm, coords);}
3896: }
3897: DMDestroy(&rdm);
3898: return(0);
3899: }
3901: /*@
3902: DMPlexCreateReferenceCell - Create a DMPLEX with the appropriate FEM reference cell
3904: Collective
3906: Input Parameters:
3907: + comm - The communicator
3908: . dim - The spatial dimension
3909: - simplex - Flag for simplex, otherwise use a tensor-product cell
3911: Output Parameter:
3912: . refdm - The reference cell
3914: Level: intermediate
3916: .seealso: DMPlexCreateReferenceCellByType(), DMPlexCreateBoxMesh()
3917: @*/
3918: PetscErrorCode DMPlexCreateReferenceCell(MPI_Comm comm, PetscInt dim, PetscBool simplex, DM *refdm)
3919: {
3923: switch (dim) {
3924: case 0: DMPlexCreateReferenceCellByType(comm, DM_POLYTOPE_POINT, refdm);break;
3925: case 1: DMPlexCreateReferenceCellByType(comm, DM_POLYTOPE_SEGMENT, refdm);break;
3926: case 2:
3927: if (simplex) {DMPlexCreateReferenceCellByType(comm, DM_POLYTOPE_TRIANGLE, refdm);}
3928: else {DMPlexCreateReferenceCellByType(comm, DM_POLYTOPE_QUADRILATERAL, refdm);}
3929: break;
3930: case 3:
3931: if (simplex) {DMPlexCreateReferenceCellByType(comm, DM_POLYTOPE_TETRAHEDRON, refdm);}
3932: else {DMPlexCreateReferenceCellByType(comm, DM_POLYTOPE_HEXAHEDRON, refdm);}
3933: break;
3934: default:
3935: SETERRQ1(comm, PETSC_ERR_ARG_WRONG, "Cannot create reference cell for dimension %D", dim);
3936: }
3937: return(0);
3938: }