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>
5: #include <petscdmplextransform.h>
6: #include <petscdmlabelephemeral.h>
7: #include <petsc/private/kernels/blockmatmult.h>
8: #include <petsc/private/kernels/blockinvert.h>
10: PetscLogEvent DMPLEX_CreateFromFile, DMPLEX_CreateFromOptions, DMPLEX_BuildFromCellList, DMPLEX_BuildCoordinatesFromCellList;
12: /* External function declarations here */
13: static PetscErrorCode DMInitialize_Plex(DM dm);
15: /* This copies internal things in the Plex structure that we generally want when making a new, related Plex */
16: PetscErrorCode DMPlexCopy_Internal(DM dmin, PetscBool copyPeriodicity, PetscBool copyOverlap, DM dmout)
17: {
18: const PetscReal *maxCell, *Lstart, *L;
19: VecType vecType;
20: MatType matType;
21: PetscBool dist, useCeed;
22: DMReorderDefaultFlag reorder;
24: PetscFunctionBegin;
25: PetscCall(DMGetVecType(dmin, &vecType));
26: PetscCall(DMSetVecType(dmout, vecType));
27: PetscCall(DMGetMatType(dmin, &matType));
28: PetscCall(DMSetMatType(dmout, matType));
29: if (copyPeriodicity) {
30: PetscCall(DMGetPeriodicity(dmin, &maxCell, &Lstart, &L));
31: PetscCall(DMSetPeriodicity(dmout, maxCell, Lstart, L));
32: }
33: PetscCall(DMPlexDistributeGetDefault(dmin, &dist));
34: PetscCall(DMPlexDistributeSetDefault(dmout, dist));
35: PetscCall(DMPlexReorderGetDefault(dmin, &reorder));
36: PetscCall(DMPlexReorderSetDefault(dmout, reorder));
37: PetscCall(DMPlexGetUseCeed(dmin, &useCeed));
38: PetscCall(DMPlexSetUseCeed(dmout, useCeed));
39: ((DM_Plex *)dmout->data)->useHashLocation = ((DM_Plex *)dmin->data)->useHashLocation;
40: ((DM_Plex *)dmout->data)->printSetValues = ((DM_Plex *)dmin->data)->printSetValues;
41: ((DM_Plex *)dmout->data)->printFEM = ((DM_Plex *)dmin->data)->printFEM;
42: ((DM_Plex *)dmout->data)->printFVM = ((DM_Plex *)dmin->data)->printFVM;
43: ((DM_Plex *)dmout->data)->printL2 = ((DM_Plex *)dmin->data)->printL2;
44: ((DM_Plex *)dmout->data)->printLocate = ((DM_Plex *)dmin->data)->printLocate;
45: ((DM_Plex *)dmout->data)->printTol = ((DM_Plex *)dmin->data)->printTol;
46: if (copyOverlap) PetscCall(DMPlexSetOverlap_Plex(dmout, dmin, 0));
47: PetscFunctionReturn(PETSC_SUCCESS);
48: }
50: /* Replace dm with the contents of ndm, and then destroy ndm
51: - Share the DM_Plex structure
52: - Share the coordinates
53: - Share the SF
54: */
55: PetscErrorCode DMPlexReplace_Internal(DM dm, DM *ndm)
56: {
57: PetscSF sf;
58: DM dmNew = *ndm, coordDM, coarseDM;
59: Vec coords;
60: const PetscReal *maxCell, *Lstart, *L;
61: PetscInt dim, cdim;
63: PetscFunctionBegin;
64: if (dm == dmNew) {
65: PetscCall(DMDestroy(ndm));
66: PetscFunctionReturn(PETSC_SUCCESS);
67: }
68: dm->setupcalled = dmNew->setupcalled;
69: PetscCall(DMGetDimension(dmNew, &dim));
70: PetscCall(DMSetDimension(dm, dim));
71: PetscCall(DMGetCoordinateDim(dmNew, &cdim));
72: PetscCall(DMSetCoordinateDim(dm, cdim));
73: PetscCall(DMGetPointSF(dmNew, &sf));
74: PetscCall(DMSetPointSF(dm, sf));
75: PetscCall(DMGetCoordinateDM(dmNew, &coordDM));
76: PetscCall(DMGetCoordinatesLocal(dmNew, &coords));
77: PetscCall(DMSetCoordinateDM(dm, coordDM));
78: PetscCall(DMSetCoordinatesLocal(dm, coords));
79: PetscCall(DMGetCellCoordinateDM(dmNew, &coordDM));
80: PetscCall(DMGetCellCoordinatesLocal(dmNew, &coords));
81: PetscCall(DMSetCellCoordinateDM(dm, coordDM));
82: PetscCall(DMSetCellCoordinatesLocal(dm, coords));
83: /* Do not want to create the coordinate field if it does not already exist, so do not call DMGetCoordinateField() */
84: PetscCall(DMFieldDestroy(&dm->coordinates[0].field));
85: dm->coordinates[0].field = dmNew->coordinates[0].field;
86: ((DM_Plex *)dmNew->data)->coordFunc = ((DM_Plex *)dm->data)->coordFunc;
87: PetscCall(DMGetPeriodicity(dmNew, &maxCell, &Lstart, &L));
88: PetscCall(DMSetPeriodicity(dm, maxCell, Lstart, L));
89: PetscCall(DMPlexGetGlobalToNaturalSF(dmNew, &sf));
90: PetscCall(DMPlexSetGlobalToNaturalSF(dm, sf));
91: PetscCall(DMDestroy_Plex(dm));
92: PetscCall(DMInitialize_Plex(dm));
93: dm->data = dmNew->data;
94: ((DM_Plex *)dmNew->data)->refct++;
95: {
96: PetscInt num_face_sfs;
97: const PetscSF *sfs;
98: PetscCall(DMPlexGetIsoperiodicFaceSF(dm, &num_face_sfs, &sfs));
99: PetscCall(DMPlexSetIsoperiodicFaceSF(dm, num_face_sfs, (PetscSF *)sfs)); // for the compose function effect on dm
100: }
101: PetscCall(DMDestroyLabelLinkList_Internal(dm));
102: PetscCall(DMCopyLabels(dmNew, dm, PETSC_OWN_POINTER, PETSC_TRUE, DM_COPY_LABELS_FAIL));
103: PetscCall(DMGetCoarseDM(dmNew, &coarseDM));
104: PetscCall(DMSetCoarseDM(dm, coarseDM));
105: PetscCall(DMDestroy(ndm));
106: PetscFunctionReturn(PETSC_SUCCESS);
107: }
109: /* Swap dm with the contents of dmNew
110: - Swap the DM_Plex structure
111: - Swap the coordinates
112: - Swap the point PetscSF
113: */
114: static PetscErrorCode DMPlexSwap_Static(DM dmA, DM dmB)
115: {
116: DM coordDMA, coordDMB;
117: Vec coordsA, coordsB;
118: PetscSF sfA, sfB;
119: DMField fieldTmp;
120: void *tmp;
121: DMLabelLink listTmp;
122: DMLabel depthTmp;
123: PetscInt tmpI;
125: PetscFunctionBegin;
126: if (dmA == dmB) PetscFunctionReturn(PETSC_SUCCESS);
127: PetscCall(DMGetPointSF(dmA, &sfA));
128: PetscCall(DMGetPointSF(dmB, &sfB));
129: PetscCall(PetscObjectReference((PetscObject)sfA));
130: PetscCall(DMSetPointSF(dmA, sfB));
131: PetscCall(DMSetPointSF(dmB, sfA));
132: PetscCall(PetscObjectDereference((PetscObject)sfA));
134: PetscCall(DMGetCoordinateDM(dmA, &coordDMA));
135: PetscCall(DMGetCoordinateDM(dmB, &coordDMB));
136: PetscCall(PetscObjectReference((PetscObject)coordDMA));
137: PetscCall(DMSetCoordinateDM(dmA, coordDMB));
138: PetscCall(DMSetCoordinateDM(dmB, coordDMA));
139: PetscCall(PetscObjectDereference((PetscObject)coordDMA));
141: PetscCall(DMGetCoordinatesLocal(dmA, &coordsA));
142: PetscCall(DMGetCoordinatesLocal(dmB, &coordsB));
143: PetscCall(PetscObjectReference((PetscObject)coordsA));
144: PetscCall(DMSetCoordinatesLocal(dmA, coordsB));
145: PetscCall(DMSetCoordinatesLocal(dmB, coordsA));
146: PetscCall(PetscObjectDereference((PetscObject)coordsA));
148: PetscCall(DMGetCellCoordinateDM(dmA, &coordDMA));
149: PetscCall(DMGetCellCoordinateDM(dmB, &coordDMB));
150: PetscCall(PetscObjectReference((PetscObject)coordDMA));
151: PetscCall(DMSetCellCoordinateDM(dmA, coordDMB));
152: PetscCall(DMSetCellCoordinateDM(dmB, coordDMA));
153: PetscCall(PetscObjectDereference((PetscObject)coordDMA));
155: PetscCall(DMGetCellCoordinatesLocal(dmA, &coordsA));
156: PetscCall(DMGetCellCoordinatesLocal(dmB, &coordsB));
157: PetscCall(PetscObjectReference((PetscObject)coordsA));
158: PetscCall(DMSetCellCoordinatesLocal(dmA, coordsB));
159: PetscCall(DMSetCellCoordinatesLocal(dmB, coordsA));
160: PetscCall(PetscObjectDereference((PetscObject)coordsA));
162: fieldTmp = dmA->coordinates[0].field;
163: dmA->coordinates[0].field = dmB->coordinates[0].field;
164: dmB->coordinates[0].field = fieldTmp;
165: fieldTmp = dmA->coordinates[1].field;
166: dmA->coordinates[1].field = dmB->coordinates[1].field;
167: dmB->coordinates[1].field = fieldTmp;
168: tmp = dmA->data;
169: dmA->data = dmB->data;
170: dmB->data = tmp;
171: listTmp = dmA->labels;
172: dmA->labels = dmB->labels;
173: dmB->labels = listTmp;
174: depthTmp = dmA->depthLabel;
175: dmA->depthLabel = dmB->depthLabel;
176: dmB->depthLabel = depthTmp;
177: depthTmp = dmA->celltypeLabel;
178: dmA->celltypeLabel = dmB->celltypeLabel;
179: dmB->celltypeLabel = depthTmp;
180: tmpI = dmA->levelup;
181: dmA->levelup = dmB->levelup;
182: dmB->levelup = tmpI;
183: PetscFunctionReturn(PETSC_SUCCESS);
184: }
186: PetscErrorCode DMPlexInterpolateInPlace_Internal(DM dm)
187: {
188: DM idm;
190: PetscFunctionBegin;
191: PetscCall(DMPlexInterpolate(dm, &idm));
192: PetscCall(DMPlexCopyCoordinates(dm, idm));
193: PetscCall(DMPlexReplace_Internal(dm, &idm));
194: PetscFunctionReturn(PETSC_SUCCESS);
195: }
197: /*@C
198: DMPlexCreateCoordinateSpace - Creates a finite element space for the coordinates
200: Collective
202: Input Parameters:
203: + dm - The `DMPLEX`
204: . degree - The degree of the finite element or `PETSC_DECIDE`
205: . project - Flag to project current coordinates into the space
206: - coordFunc - An optional function to map new points from refinement to the surface
208: Level: advanced
210: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `PetscPointFunc`, `PetscFECreateLagrange()`, `DMGetCoordinateDM()`
211: @*/
212: PetscErrorCode DMPlexCreateCoordinateSpace(DM dm, PetscInt degree, PetscBool project, PetscPointFunc coordFunc)
213: {
214: DM_Plex *mesh = (DM_Plex *)dm->data;
215: PetscFE fe = NULL;
216: DM cdm;
217: PetscInt dim, dE, qorder, height;
219: PetscFunctionBegin;
220: PetscCall(DMGetDimension(dm, &dim));
221: PetscCall(DMGetCoordinateDim(dm, &dE));
222: qorder = degree;
223: PetscCall(DMGetCoordinateDM(dm, &cdm));
224: PetscObjectOptionsBegin((PetscObject)cdm);
225: PetscCall(PetscOptionsBoundedInt("-default_quadrature_order", "Quadrature order is one less than quadrature points per edge", "DMPlexCreateCoordinateSpace", qorder, &qorder, NULL, 0));
226: PetscOptionsEnd();
227: PetscCall(DMPlexGetVTKCellHeight(dm, &height));
228: if (degree >= 0) {
229: DMPolytopeType ct = DM_POLYTOPE_UNKNOWN;
230: PetscInt cStart, cEnd, gct;
232: PetscCall(DMPlexGetHeightStratum(dm, height, &cStart, &cEnd));
233: if (cEnd > cStart) PetscCall(DMPlexGetCellType(dm, cStart, &ct));
234: gct = (PetscInt)ct;
235: PetscCall(MPIU_Allreduce(MPI_IN_PLACE, &gct, 1, MPIU_INT, MPI_MIN, PetscObjectComm((PetscObject)dm)));
236: ct = (DMPolytopeType)gct;
237: // Work around current bug in PetscDualSpaceSetUp_Lagrange()
238: // Can be seen in plex_tutorials-ex10_1
239: if (ct != DM_POLYTOPE_SEG_PRISM_TENSOR && ct != DM_POLYTOPE_TRI_PRISM_TENSOR && ct != DM_POLYTOPE_QUAD_PRISM_TENSOR) PetscCall(PetscFECreateLagrangeByCell(PETSC_COMM_SELF, dim, dE, ct, degree, qorder, &fe));
240: }
241: PetscCall(DMSetCoordinateDisc(dm, fe, project));
242: PetscCall(PetscFEDestroy(&fe));
243: mesh->coordFunc = coordFunc;
244: PetscFunctionReturn(PETSC_SUCCESS);
245: }
247: /*@
248: DMPlexCreateDoublet - Creates a mesh of two cells of the specified type, optionally with later refinement.
250: Collective
252: Input Parameters:
253: + comm - The communicator for the `DM` object
254: . dim - The spatial dimension
255: . simplex - Flag for simplicial cells, otherwise they are tensor product cells
256: . interpolate - Flag to create intermediate mesh pieces (edges, faces)
257: - refinementLimit - A nonzero number indicates the largest admissible volume for a refined cell
259: Output Parameter:
260: . newdm - The `DM` object
262: Level: beginner
264: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMSetType()`, `DMCreate()`
265: @*/
266: PetscErrorCode DMPlexCreateDoublet(MPI_Comm comm, PetscInt dim, PetscBool simplex, PetscBool interpolate, PetscReal refinementLimit, DM *newdm)
267: {
268: DM dm;
269: PetscMPIInt rank;
271: PetscFunctionBegin;
272: PetscCall(DMCreate(comm, &dm));
273: PetscCall(DMSetType(dm, DMPLEX));
274: PetscCall(DMSetDimension(dm, dim));
275: PetscCall(PetscLogEventBegin(DMPLEX_Generate, dm, 0, 0, 0));
276: PetscCallMPI(MPI_Comm_rank(comm, &rank));
277: switch (dim) {
278: case 2:
279: if (simplex) PetscCall(PetscObjectSetName((PetscObject)dm, "triangular"));
280: else PetscCall(PetscObjectSetName((PetscObject)dm, "quadrilateral"));
281: break;
282: case 3:
283: if (simplex) PetscCall(PetscObjectSetName((PetscObject)dm, "tetrahedral"));
284: else PetscCall(PetscObjectSetName((PetscObject)dm, "hexahedral"));
285: break;
286: default:
287: SETERRQ(comm, PETSC_ERR_ARG_OUTOFRANGE, "Cannot make meshes for dimension %" PetscInt_FMT, dim);
288: }
289: if (rank) {
290: PetscInt numPoints[2] = {0, 0};
291: PetscCall(DMPlexCreateFromDAG(dm, 1, numPoints, NULL, NULL, NULL, NULL));
292: } else {
293: switch (dim) {
294: case 2:
295: if (simplex) {
296: PetscInt numPoints[2] = {4, 2};
297: PetscInt coneSize[6] = {3, 3, 0, 0, 0, 0};
298: PetscInt cones[6] = {2, 3, 4, 5, 4, 3};
299: PetscInt coneOrientations[6] = {0, 0, 0, 0, 0, 0};
300: PetscScalar vertexCoords[8] = {-0.5, 0.5, 0.0, 0.0, 0.0, 1.0, 0.5, 0.5};
302: PetscCall(DMPlexCreateFromDAG(dm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
303: } else {
304: PetscInt numPoints[2] = {6, 2};
305: PetscInt coneSize[8] = {4, 4, 0, 0, 0, 0, 0, 0};
306: PetscInt cones[8] = {2, 3, 4, 5, 3, 6, 7, 4};
307: PetscInt coneOrientations[8] = {0, 0, 0, 0, 0, 0, 0, 0};
308: 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};
310: PetscCall(DMPlexCreateFromDAG(dm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
311: }
312: break;
313: case 3:
314: if (simplex) {
315: PetscInt numPoints[2] = {5, 2};
316: PetscInt coneSize[7] = {4, 4, 0, 0, 0, 0, 0};
317: PetscInt cones[8] = {4, 3, 5, 2, 5, 3, 4, 6};
318: PetscInt coneOrientations[8] = {0, 0, 0, 0, 0, 0, 0, 0};
319: 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};
321: PetscCall(DMPlexCreateFromDAG(dm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
322: } else {
323: PetscInt numPoints[2] = {12, 2};
324: PetscInt coneSize[14] = {8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
325: PetscInt cones[16] = {2, 3, 4, 5, 6, 7, 8, 9, 5, 4, 10, 11, 7, 12, 13, 8};
326: PetscInt coneOrientations[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
327: 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, -1.0, -0.5, 0.5, 0.0, -0.5, 0.5, 0.0, 0.5, 0.5, -1.0, 0.5, 0.5, 1.0, 0.5, -0.5, 1.0, -0.5, -0.5, 1.0, -0.5, 0.5, 1.0, 0.5, 0.5};
329: PetscCall(DMPlexCreateFromDAG(dm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
330: }
331: break;
332: default:
333: SETERRQ(comm, PETSC_ERR_ARG_OUTOFRANGE, "Cannot make meshes for dimension %" PetscInt_FMT, dim);
334: }
335: }
336: PetscCall(PetscLogEventEnd(DMPLEX_Generate, dm, 0, 0, 0));
337: *newdm = dm;
338: if (refinementLimit > 0.0) {
339: DM rdm;
340: const char *name;
342: PetscCall(DMPlexSetRefinementUniform(*newdm, PETSC_FALSE));
343: PetscCall(DMPlexSetRefinementLimit(*newdm, refinementLimit));
344: PetscCall(DMRefine(*newdm, comm, &rdm));
345: PetscCall(PetscObjectGetName((PetscObject)*newdm, &name));
346: PetscCall(PetscObjectSetName((PetscObject)rdm, name));
347: PetscCall(DMDestroy(newdm));
348: *newdm = rdm;
349: }
350: if (interpolate) {
351: DM idm;
353: PetscCall(DMPlexInterpolate(*newdm, &idm));
354: PetscCall(DMDestroy(newdm));
355: *newdm = idm;
356: }
357: PetscFunctionReturn(PETSC_SUCCESS);
358: }
360: static PetscErrorCode DMPlexCreateBoxSurfaceMesh_Tensor_1D_Internal(DM dm, const PetscReal lower[], const PetscReal upper[], const PetscInt edges[])
361: {
362: const PetscInt numVertices = 2;
363: PetscInt markerRight = 1;
364: PetscInt markerLeft = 1;
365: PetscBool markerSeparate = PETSC_FALSE;
366: Vec coordinates;
367: PetscSection coordSection;
368: PetscScalar *coords;
369: PetscInt coordSize;
370: PetscMPIInt rank;
371: PetscInt cdim = 1, v;
373: PetscFunctionBegin;
374: PetscCall(PetscOptionsGetBool(((PetscObject)dm)->options, ((PetscObject)dm)->prefix, "-dm_plex_separate_marker", &markerSeparate, NULL));
375: if (markerSeparate) {
376: markerRight = 2;
377: markerLeft = 1;
378: }
379: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank));
380: if (rank == 0) {
381: PetscCall(DMPlexSetChart(dm, 0, numVertices));
382: PetscCall(DMSetUp(dm)); /* Allocate space for cones */
383: PetscCall(DMSetLabelValue(dm, "marker", 0, markerLeft));
384: PetscCall(DMSetLabelValue(dm, "marker", 1, markerRight));
385: }
386: PetscCall(DMPlexSymmetrize(dm));
387: PetscCall(DMPlexStratify(dm));
388: /* Build coordinates */
389: PetscCall(DMSetCoordinateDim(dm, cdim));
390: PetscCall(DMGetCoordinateSection(dm, &coordSection));
391: PetscCall(PetscSectionSetNumFields(coordSection, 1));
392: PetscCall(PetscSectionSetChart(coordSection, 0, numVertices));
393: PetscCall(PetscSectionSetFieldComponents(coordSection, 0, cdim));
394: for (v = 0; v < numVertices; ++v) {
395: PetscCall(PetscSectionSetDof(coordSection, v, cdim));
396: PetscCall(PetscSectionSetFieldDof(coordSection, v, 0, cdim));
397: }
398: PetscCall(PetscSectionSetUp(coordSection));
399: PetscCall(PetscSectionGetStorageSize(coordSection, &coordSize));
400: PetscCall(VecCreate(PETSC_COMM_SELF, &coordinates));
401: PetscCall(PetscObjectSetName((PetscObject)coordinates, "coordinates"));
402: PetscCall(VecSetSizes(coordinates, coordSize, PETSC_DETERMINE));
403: PetscCall(VecSetBlockSize(coordinates, cdim));
404: PetscCall(VecSetType(coordinates, VECSTANDARD));
405: PetscCall(VecGetArray(coordinates, &coords));
406: coords[0] = lower[0];
407: coords[1] = upper[0];
408: PetscCall(VecRestoreArray(coordinates, &coords));
409: PetscCall(DMSetCoordinatesLocal(dm, coordinates));
410: PetscCall(VecDestroy(&coordinates));
411: PetscFunctionReturn(PETSC_SUCCESS);
412: }
414: static PetscErrorCode DMPlexCreateBoxSurfaceMesh_Tensor_2D_Internal(DM dm, const PetscReal lower[], const PetscReal upper[], const PetscInt edges[])
415: {
416: const PetscInt numVertices = (edges[0] + 1) * (edges[1] + 1);
417: const PetscInt numEdges = edges[0] * (edges[1] + 1) + (edges[0] + 1) * edges[1];
418: PetscInt markerTop = 1;
419: PetscInt markerBottom = 1;
420: PetscInt markerRight = 1;
421: PetscInt markerLeft = 1;
422: PetscBool markerSeparate = PETSC_FALSE;
423: Vec coordinates;
424: PetscSection coordSection;
425: PetscScalar *coords;
426: PetscInt coordSize;
427: PetscMPIInt rank;
428: PetscInt v, vx, vy;
430: PetscFunctionBegin;
431: PetscCall(PetscOptionsGetBool(((PetscObject)dm)->options, ((PetscObject)dm)->prefix, "-dm_plex_separate_marker", &markerSeparate, NULL));
432: if (markerSeparate) {
433: markerTop = 3;
434: markerBottom = 1;
435: markerRight = 2;
436: markerLeft = 4;
437: }
438: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank));
439: if (rank == 0) {
440: PetscInt e, ex, ey;
442: PetscCall(DMPlexSetChart(dm, 0, numEdges + numVertices));
443: for (e = 0; e < numEdges; ++e) PetscCall(DMPlexSetConeSize(dm, e, 2));
444: PetscCall(DMSetUp(dm)); /* Allocate space for cones */
445: for (vx = 0; vx <= edges[0]; vx++) {
446: for (ey = 0; ey < edges[1]; ey++) {
447: PetscInt edge = vx * edges[1] + ey + edges[0] * (edges[1] + 1);
448: PetscInt vertex = ey * (edges[0] + 1) + vx + numEdges;
449: PetscInt cone[2];
451: cone[0] = vertex;
452: cone[1] = vertex + edges[0] + 1;
453: PetscCall(DMPlexSetCone(dm, edge, cone));
454: if (vx == edges[0]) {
455: PetscCall(DMSetLabelValue(dm, "marker", edge, markerRight));
456: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerRight));
457: if (ey == edges[1] - 1) {
458: PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerRight));
459: PetscCall(DMSetLabelValue(dm, "Face Sets", cone[1], markerRight));
460: }
461: } else if (vx == 0) {
462: PetscCall(DMSetLabelValue(dm, "marker", edge, markerLeft));
463: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerLeft));
464: if (ey == edges[1] - 1) {
465: PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerLeft));
466: PetscCall(DMSetLabelValue(dm, "Face Sets", cone[1], markerLeft));
467: }
468: }
469: }
470: }
471: for (vy = 0; vy <= edges[1]; vy++) {
472: for (ex = 0; ex < edges[0]; ex++) {
473: PetscInt edge = vy * edges[0] + ex;
474: PetscInt vertex = vy * (edges[0] + 1) + ex + numEdges;
475: PetscInt cone[2];
477: cone[0] = vertex;
478: cone[1] = vertex + 1;
479: PetscCall(DMPlexSetCone(dm, edge, cone));
480: if (vy == edges[1]) {
481: PetscCall(DMSetLabelValue(dm, "marker", edge, markerTop));
482: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerTop));
483: if (ex == edges[0] - 1) {
484: PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerTop));
485: PetscCall(DMSetLabelValue(dm, "Face Sets", cone[1], markerTop));
486: }
487: } else if (vy == 0) {
488: PetscCall(DMSetLabelValue(dm, "marker", edge, markerBottom));
489: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerBottom));
490: if (ex == edges[0] - 1) {
491: PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerBottom));
492: PetscCall(DMSetLabelValue(dm, "Face Sets", cone[1], markerBottom));
493: }
494: }
495: }
496: }
497: }
498: PetscCall(DMPlexSymmetrize(dm));
499: PetscCall(DMPlexStratify(dm));
500: /* Build coordinates */
501: PetscCall(DMSetCoordinateDim(dm, 2));
502: PetscCall(DMGetCoordinateSection(dm, &coordSection));
503: PetscCall(PetscSectionSetNumFields(coordSection, 1));
504: PetscCall(PetscSectionSetChart(coordSection, numEdges, numEdges + numVertices));
505: PetscCall(PetscSectionSetFieldComponents(coordSection, 0, 2));
506: for (v = numEdges; v < numEdges + numVertices; ++v) {
507: PetscCall(PetscSectionSetDof(coordSection, v, 2));
508: PetscCall(PetscSectionSetFieldDof(coordSection, v, 0, 2));
509: }
510: PetscCall(PetscSectionSetUp(coordSection));
511: PetscCall(PetscSectionGetStorageSize(coordSection, &coordSize));
512: PetscCall(VecCreate(PETSC_COMM_SELF, &coordinates));
513: PetscCall(PetscObjectSetName((PetscObject)coordinates, "coordinates"));
514: PetscCall(VecSetSizes(coordinates, coordSize, PETSC_DETERMINE));
515: PetscCall(VecSetBlockSize(coordinates, 2));
516: PetscCall(VecSetType(coordinates, VECSTANDARD));
517: PetscCall(VecGetArray(coordinates, &coords));
518: for (vy = 0; vy <= edges[1]; ++vy) {
519: for (vx = 0; vx <= edges[0]; ++vx) {
520: coords[(vy * (edges[0] + 1) + vx) * 2 + 0] = lower[0] + ((upper[0] - lower[0]) / edges[0]) * vx;
521: coords[(vy * (edges[0] + 1) + vx) * 2 + 1] = lower[1] + ((upper[1] - lower[1]) / edges[1]) * vy;
522: }
523: }
524: PetscCall(VecRestoreArray(coordinates, &coords));
525: PetscCall(DMSetCoordinatesLocal(dm, coordinates));
526: PetscCall(VecDestroy(&coordinates));
527: PetscFunctionReturn(PETSC_SUCCESS);
528: }
530: static PetscErrorCode DMPlexCreateBoxSurfaceMesh_Tensor_3D_Internal(DM dm, const PetscReal lower[], const PetscReal upper[], const PetscInt faces[])
531: {
532: PetscInt vertices[3], numVertices;
533: PetscInt numFaces = 2 * faces[0] * faces[1] + 2 * faces[1] * faces[2] + 2 * faces[0] * faces[2];
534: PetscInt markerTop = 1;
535: PetscInt markerBottom = 1;
536: PetscInt markerFront = 1;
537: PetscInt markerBack = 1;
538: PetscInt markerRight = 1;
539: PetscInt markerLeft = 1;
540: PetscBool markerSeparate = PETSC_FALSE;
541: Vec coordinates;
542: PetscSection coordSection;
543: PetscScalar *coords;
544: PetscInt coordSize;
545: PetscMPIInt rank;
546: PetscInt v, vx, vy, vz;
547: PetscInt voffset, iface = 0, cone[4];
549: PetscFunctionBegin;
550: PetscCheck(faces[0] >= 1 && faces[1] >= 1 && faces[2] >= 1, PetscObjectComm((PetscObject)dm), PETSC_ERR_SUP, "Must have at least 1 face per side");
551: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank));
552: PetscCall(PetscOptionsGetBool(((PetscObject)dm)->options, ((PetscObject)dm)->prefix, "-dm_plex_separate_marker", &markerSeparate, NULL));
553: if (markerSeparate) {
554: markerBottom = 1;
555: markerTop = 2;
556: markerFront = 3;
557: markerBack = 4;
558: markerRight = 5;
559: markerLeft = 6;
560: }
561: vertices[0] = faces[0] + 1;
562: vertices[1] = faces[1] + 1;
563: vertices[2] = faces[2] + 1;
564: numVertices = vertices[0] * vertices[1] * vertices[2];
565: if (rank == 0) {
566: PetscInt f;
568: PetscCall(DMPlexSetChart(dm, 0, numFaces + numVertices));
569: for (f = 0; f < numFaces; ++f) PetscCall(DMPlexSetConeSize(dm, f, 4));
570: PetscCall(DMSetUp(dm)); /* Allocate space for cones */
572: /* Side 0 (Top) */
573: for (vy = 0; vy < faces[1]; vy++) {
574: for (vx = 0; vx < faces[0]; vx++) {
575: voffset = numFaces + vertices[0] * vertices[1] * (vertices[2] - 1) + vy * vertices[0] + vx;
576: cone[0] = voffset;
577: cone[1] = voffset + 1;
578: cone[2] = voffset + vertices[0] + 1;
579: cone[3] = voffset + vertices[0];
580: PetscCall(DMPlexSetCone(dm, iface, cone));
581: PetscCall(DMSetLabelValue(dm, "marker", iface, markerTop));
582: PetscCall(DMSetLabelValue(dm, "marker", voffset + 0, markerTop));
583: PetscCall(DMSetLabelValue(dm, "marker", voffset + 1, markerTop));
584: PetscCall(DMSetLabelValue(dm, "marker", voffset + vertices[0] + 0, markerTop));
585: PetscCall(DMSetLabelValue(dm, "marker", voffset + vertices[0] + 1, markerTop));
586: iface++;
587: }
588: }
590: /* Side 1 (Bottom) */
591: for (vy = 0; vy < faces[1]; vy++) {
592: for (vx = 0; vx < faces[0]; vx++) {
593: voffset = numFaces + vy * (faces[0] + 1) + vx;
594: cone[0] = voffset + 1;
595: cone[1] = voffset;
596: cone[2] = voffset + vertices[0];
597: cone[3] = voffset + vertices[0] + 1;
598: PetscCall(DMPlexSetCone(dm, iface, cone));
599: PetscCall(DMSetLabelValue(dm, "marker", iface, markerBottom));
600: PetscCall(DMSetLabelValue(dm, "marker", voffset + 0, markerBottom));
601: PetscCall(DMSetLabelValue(dm, "marker", voffset + 1, markerBottom));
602: PetscCall(DMSetLabelValue(dm, "marker", voffset + vertices[0] + 0, markerBottom));
603: PetscCall(DMSetLabelValue(dm, "marker", voffset + vertices[0] + 1, markerBottom));
604: iface++;
605: }
606: }
608: /* Side 2 (Front) */
609: for (vz = 0; vz < faces[2]; vz++) {
610: for (vx = 0; vx < faces[0]; vx++) {
611: voffset = numFaces + vz * vertices[0] * vertices[1] + vx;
612: cone[0] = voffset;
613: cone[1] = voffset + 1;
614: cone[2] = voffset + vertices[0] * vertices[1] + 1;
615: cone[3] = voffset + vertices[0] * vertices[1];
616: PetscCall(DMPlexSetCone(dm, iface, cone));
617: PetscCall(DMSetLabelValue(dm, "marker", iface, markerFront));
618: PetscCall(DMSetLabelValue(dm, "marker", voffset + 0, markerFront));
619: PetscCall(DMSetLabelValue(dm, "marker", voffset + 1, markerFront));
620: PetscCall(DMSetLabelValue(dm, "marker", voffset + vertices[0] * vertices[1] + 0, markerFront));
621: PetscCall(DMSetLabelValue(dm, "marker", voffset + vertices[0] * vertices[1] + 1, markerFront));
622: iface++;
623: }
624: }
626: /* Side 3 (Back) */
627: for (vz = 0; vz < faces[2]; vz++) {
628: for (vx = 0; vx < faces[0]; vx++) {
629: voffset = numFaces + vz * vertices[0] * vertices[1] + vertices[0] * (vertices[1] - 1) + vx;
630: cone[0] = voffset + vertices[0] * vertices[1];
631: cone[1] = voffset + vertices[0] * vertices[1] + 1;
632: cone[2] = voffset + 1;
633: cone[3] = voffset;
634: PetscCall(DMPlexSetCone(dm, iface, cone));
635: PetscCall(DMSetLabelValue(dm, "marker", iface, markerBack));
636: PetscCall(DMSetLabelValue(dm, "marker", voffset + 0, markerBack));
637: PetscCall(DMSetLabelValue(dm, "marker", voffset + 1, markerBack));
638: PetscCall(DMSetLabelValue(dm, "marker", voffset + vertices[0] * vertices[1] + 0, markerBack));
639: PetscCall(DMSetLabelValue(dm, "marker", voffset + vertices[0] * vertices[1] + 1, markerBack));
640: iface++;
641: }
642: }
644: /* Side 4 (Left) */
645: for (vz = 0; vz < faces[2]; vz++) {
646: for (vy = 0; vy < faces[1]; vy++) {
647: voffset = numFaces + vz * vertices[0] * vertices[1] + vy * vertices[0];
648: cone[0] = voffset;
649: cone[1] = voffset + vertices[0] * vertices[1];
650: cone[2] = voffset + vertices[0] * vertices[1] + vertices[0];
651: cone[3] = voffset + vertices[0];
652: PetscCall(DMPlexSetCone(dm, iface, cone));
653: PetscCall(DMSetLabelValue(dm, "marker", iface, markerLeft));
654: PetscCall(DMSetLabelValue(dm, "marker", voffset + 0, markerLeft));
655: PetscCall(DMSetLabelValue(dm, "marker", voffset + vertices[0] + 0, markerLeft));
656: PetscCall(DMSetLabelValue(dm, "marker", voffset + vertices[1] + 0, markerLeft));
657: PetscCall(DMSetLabelValue(dm, "marker", voffset + vertices[0] * vertices[1] + vertices[0], markerLeft));
658: iface++;
659: }
660: }
662: /* Side 5 (Right) */
663: for (vz = 0; vz < faces[2]; vz++) {
664: for (vy = 0; vy < faces[1]; vy++) {
665: voffset = numFaces + vz * vertices[0] * vertices[1] + vy * vertices[0] + faces[0];
666: cone[0] = voffset + vertices[0] * vertices[1];
667: cone[1] = voffset;
668: cone[2] = voffset + vertices[0];
669: cone[3] = voffset + vertices[0] * vertices[1] + vertices[0];
670: PetscCall(DMPlexSetCone(dm, iface, cone));
671: PetscCall(DMSetLabelValue(dm, "marker", iface, markerRight));
672: PetscCall(DMSetLabelValue(dm, "marker", voffset + 0, markerRight));
673: PetscCall(DMSetLabelValue(dm, "marker", voffset + vertices[0] + 0, markerRight));
674: PetscCall(DMSetLabelValue(dm, "marker", voffset + vertices[0] * vertices[1] + 0, markerRight));
675: PetscCall(DMSetLabelValue(dm, "marker", voffset + vertices[0] * vertices[1] + vertices[0], markerRight));
676: iface++;
677: }
678: }
679: }
680: PetscCall(DMPlexSymmetrize(dm));
681: PetscCall(DMPlexStratify(dm));
682: /* Build coordinates */
683: PetscCall(DMSetCoordinateDim(dm, 3));
684: PetscCall(DMGetCoordinateSection(dm, &coordSection));
685: PetscCall(PetscSectionSetNumFields(coordSection, 1));
686: PetscCall(PetscSectionSetChart(coordSection, numFaces, numFaces + numVertices));
687: PetscCall(PetscSectionSetFieldComponents(coordSection, 0, 3));
688: for (v = numFaces; v < numFaces + numVertices; ++v) {
689: PetscCall(PetscSectionSetDof(coordSection, v, 3));
690: PetscCall(PetscSectionSetFieldDof(coordSection, v, 0, 3));
691: }
692: PetscCall(PetscSectionSetUp(coordSection));
693: PetscCall(PetscSectionGetStorageSize(coordSection, &coordSize));
694: PetscCall(VecCreate(PETSC_COMM_SELF, &coordinates));
695: PetscCall(PetscObjectSetName((PetscObject)coordinates, "coordinates"));
696: PetscCall(VecSetSizes(coordinates, coordSize, PETSC_DETERMINE));
697: PetscCall(VecSetBlockSize(coordinates, 3));
698: PetscCall(VecSetType(coordinates, VECSTANDARD));
699: PetscCall(VecGetArray(coordinates, &coords));
700: for (vz = 0; vz <= faces[2]; ++vz) {
701: for (vy = 0; vy <= faces[1]; ++vy) {
702: for (vx = 0; vx <= faces[0]; ++vx) {
703: coords[((vz * (faces[1] + 1) + vy) * (faces[0] + 1) + vx) * 3 + 0] = lower[0] + ((upper[0] - lower[0]) / faces[0]) * vx;
704: coords[((vz * (faces[1] + 1) + vy) * (faces[0] + 1) + vx) * 3 + 1] = lower[1] + ((upper[1] - lower[1]) / faces[1]) * vy;
705: coords[((vz * (faces[1] + 1) + vy) * (faces[0] + 1) + vx) * 3 + 2] = lower[2] + ((upper[2] - lower[2]) / faces[2]) * vz;
706: }
707: }
708: }
709: PetscCall(VecRestoreArray(coordinates, &coords));
710: PetscCall(DMSetCoordinatesLocal(dm, coordinates));
711: PetscCall(VecDestroy(&coordinates));
712: PetscFunctionReturn(PETSC_SUCCESS);
713: }
715: static PetscErrorCode DMPlexCreateBoxSurfaceMesh_Internal(DM dm, PetscInt dim, const PetscInt faces[], const PetscReal lower[], const PetscReal upper[], PetscBool interpolate)
716: {
717: PetscFunctionBegin;
719: PetscCall(PetscLogEventBegin(DMPLEX_Generate, dm, 0, 0, 0));
720: PetscCall(DMSetDimension(dm, dim - 1));
721: PetscCall(DMSetCoordinateDim(dm, dim));
722: switch (dim) {
723: case 1:
724: PetscCall(DMPlexCreateBoxSurfaceMesh_Tensor_1D_Internal(dm, lower, upper, faces));
725: break;
726: case 2:
727: PetscCall(DMPlexCreateBoxSurfaceMesh_Tensor_2D_Internal(dm, lower, upper, faces));
728: break;
729: case 3:
730: PetscCall(DMPlexCreateBoxSurfaceMesh_Tensor_3D_Internal(dm, lower, upper, faces));
731: break;
732: default:
733: SETERRQ(PetscObjectComm((PetscObject)dm), PETSC_ERR_SUP, "Dimension not supported: %" PetscInt_FMT, dim);
734: }
735: PetscCall(PetscLogEventEnd(DMPLEX_Generate, dm, 0, 0, 0));
736: if (interpolate) PetscCall(DMPlexInterpolateInPlace_Internal(dm));
737: PetscFunctionReturn(PETSC_SUCCESS);
738: }
740: /*@C
741: DMPlexCreateBoxSurfaceMesh - Creates a mesh on the surface of the tensor product of unit intervals (box) using tensor cells (hexahedra).
743: Collective
745: Input Parameters:
746: + comm - The communicator for the `DM` object
747: . dim - The spatial dimension of the box, so the resulting mesh is has dimension `dim`-1
748: . faces - Number of faces per dimension, or `NULL` for (1,) in 1D and (2, 2) in 2D and (1, 1, 1) in 3D
749: . lower - The lower left corner, or `NULL` for (0, 0, 0)
750: . upper - The upper right corner, or `NULL` for (1, 1, 1)
751: - interpolate - Flag to create intermediate mesh pieces (edges, faces)
753: Output Parameter:
754: . dm - The `DM` object
756: Level: beginner
758: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMSetFromOptions()`, `DMPlexCreateBoxMesh()`, `DMPlexCreateFromFile()`, `DMSetType()`, `DMCreate()`
759: @*/
760: PetscErrorCode DMPlexCreateBoxSurfaceMesh(MPI_Comm comm, PetscInt dim, const PetscInt faces[], const PetscReal lower[], const PetscReal upper[], PetscBool interpolate, DM *dm)
761: {
762: PetscInt fac[3] = {1, 1, 1};
763: PetscReal low[3] = {0, 0, 0};
764: PetscReal upp[3] = {1, 1, 1};
766: PetscFunctionBegin;
767: PetscCall(DMCreate(comm, dm));
768: PetscCall(DMSetType(*dm, DMPLEX));
769: PetscCall(DMPlexCreateBoxSurfaceMesh_Internal(*dm, dim, faces ? faces : fac, lower ? lower : low, upper ? upper : upp, interpolate));
770: PetscFunctionReturn(PETSC_SUCCESS);
771: }
773: static PetscErrorCode DMPlexCreateLineMesh_Internal(DM dm, PetscInt segments, PetscReal lower, PetscReal upper, DMBoundaryType bd)
774: {
775: PetscInt i, fStart, fEnd, numCells = 0, numVerts = 0;
776: PetscInt numPoints[2], *coneSize, *cones, *coneOrientations;
777: PetscScalar *vertexCoords;
778: PetscReal L, maxCell;
779: PetscBool markerSeparate = PETSC_FALSE;
780: PetscInt markerLeft = 1, faceMarkerLeft = 1;
781: PetscInt markerRight = 1, faceMarkerRight = 2;
782: PetscBool wrap = (bd == DM_BOUNDARY_PERIODIC || bd == DM_BOUNDARY_TWIST) ? PETSC_TRUE : PETSC_FALSE;
783: PetscMPIInt rank;
785: PetscFunctionBegin;
786: PetscAssertPointer(dm, 1);
788: PetscCall(DMSetDimension(dm, 1));
789: PetscCall(DMCreateLabel(dm, "marker"));
790: PetscCall(DMCreateLabel(dm, "Face Sets"));
792: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank));
793: if (rank == 0) numCells = segments;
794: if (rank == 0) numVerts = segments + (wrap ? 0 : 1);
796: numPoints[0] = numVerts;
797: numPoints[1] = numCells;
798: PetscCall(PetscMalloc4(numCells + numVerts, &coneSize, numCells * 2, &cones, numCells + numVerts, &coneOrientations, numVerts, &vertexCoords));
799: PetscCall(PetscArrayzero(coneOrientations, numCells + numVerts));
800: for (i = 0; i < numCells; ++i) coneSize[i] = 2;
801: for (i = 0; i < numVerts; ++i) coneSize[numCells + i] = 0;
802: for (i = 0; i < numCells; ++i) {
803: cones[2 * i] = numCells + i % numVerts;
804: cones[2 * i + 1] = numCells + (i + 1) % numVerts;
805: }
806: for (i = 0; i < numVerts; ++i) vertexCoords[i] = lower + (upper - lower) * ((PetscReal)i / (PetscReal)numCells);
807: PetscCall(DMPlexCreateFromDAG(dm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
808: PetscCall(PetscFree4(coneSize, cones, coneOrientations, vertexCoords));
810: PetscCall(PetscOptionsGetBool(((PetscObject)dm)->options, ((PetscObject)dm)->prefix, "-dm_plex_separate_marker", &markerSeparate, NULL));
811: if (markerSeparate) {
812: markerLeft = faceMarkerLeft;
813: markerRight = faceMarkerRight;
814: }
815: if (!wrap && rank == 0) {
816: PetscCall(DMPlexGetHeightStratum(dm, 1, &fStart, &fEnd));
817: PetscCall(DMSetLabelValue(dm, "marker", fStart, markerLeft));
818: PetscCall(DMSetLabelValue(dm, "marker", fEnd - 1, markerRight));
819: PetscCall(DMSetLabelValue(dm, "Face Sets", fStart, faceMarkerLeft));
820: PetscCall(DMSetLabelValue(dm, "Face Sets", fEnd - 1, faceMarkerRight));
821: }
822: if (wrap) {
823: L = upper - lower;
824: maxCell = (PetscReal)1.1 * (L / (PetscReal)PetscMax(1, segments));
825: PetscCall(DMSetPeriodicity(dm, &maxCell, &lower, &L));
826: }
827: PetscCall(DMPlexSetRefinementUniform(dm, PETSC_TRUE));
828: PetscFunctionReturn(PETSC_SUCCESS);
829: }
831: static PetscErrorCode DMPlexCreateBoxMesh_Simplex_Internal(DM dm, PetscInt dim, const PetscInt faces[], const PetscReal lower[], const PetscReal upper[], const DMBoundaryType periodicity[], PetscBool interpolate)
832: {
833: DM boundary, vol;
834: DMLabel bdlabel;
836: PetscFunctionBegin;
837: PetscAssertPointer(dm, 1);
838: for (PetscInt i = 0; i < dim; ++i) PetscCheck(periodicity[i] == DM_BOUNDARY_NONE, PetscObjectComm((PetscObject)dm), PETSC_ERR_SUP, "Periodicity is not supported for simplex meshes");
839: PetscCall(DMCreate(PetscObjectComm((PetscObject)dm), &boundary));
840: PetscCall(DMSetType(boundary, DMPLEX));
841: PetscCall(DMPlexCreateBoxSurfaceMesh_Internal(boundary, dim, faces, lower, upper, PETSC_FALSE));
842: PetscCall(DMPlexGenerate(boundary, NULL, interpolate, &vol));
843: PetscCall(DMGetLabel(vol, "marker", &bdlabel));
844: if (bdlabel) PetscCall(DMPlexLabelComplete(vol, bdlabel));
845: PetscCall(DMPlexCopy_Internal(dm, PETSC_TRUE, PETSC_FALSE, vol));
846: PetscCall(DMPlexReplace_Internal(dm, &vol));
847: PetscCall(DMDestroy(&boundary));
848: PetscFunctionReturn(PETSC_SUCCESS);
849: }
851: static PetscErrorCode DMPlexCreateCubeMesh_Internal(DM dm, const PetscReal lower[], const PetscReal upper[], const PetscInt edges[], DMBoundaryType bdX, DMBoundaryType bdY, DMBoundaryType bdZ)
852: {
853: DMLabel cutLabel = NULL;
854: PetscInt markerTop = 1, faceMarkerTop = 1;
855: PetscInt markerBottom = 1, faceMarkerBottom = 1;
856: PetscInt markerFront = 1, faceMarkerFront = 1;
857: PetscInt markerBack = 1, faceMarkerBack = 1;
858: PetscInt markerRight = 1, faceMarkerRight = 1;
859: PetscInt markerLeft = 1, faceMarkerLeft = 1;
860: PetscInt dim;
861: PetscBool markerSeparate = PETSC_FALSE, cutMarker = PETSC_FALSE;
862: PetscMPIInt rank;
864: PetscFunctionBegin;
865: PetscCall(DMGetDimension(dm, &dim));
866: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank));
867: PetscCall(DMCreateLabel(dm, "marker"));
868: PetscCall(DMCreateLabel(dm, "Face Sets"));
869: PetscCall(PetscOptionsGetBool(((PetscObject)dm)->options, ((PetscObject)dm)->prefix, "-dm_plex_periodic_cut", &cutMarker, NULL));
870: if (bdX == DM_BOUNDARY_PERIODIC || bdX == DM_BOUNDARY_TWIST || bdY == DM_BOUNDARY_PERIODIC || bdY == DM_BOUNDARY_TWIST || bdZ == DM_BOUNDARY_PERIODIC || bdZ == DM_BOUNDARY_TWIST) {
871: if (cutMarker) {
872: PetscCall(DMCreateLabel(dm, "periodic_cut"));
873: PetscCall(DMGetLabel(dm, "periodic_cut", &cutLabel));
874: }
875: }
876: switch (dim) {
877: case 2:
878: faceMarkerTop = 3;
879: faceMarkerBottom = 1;
880: faceMarkerRight = 2;
881: faceMarkerLeft = 4;
882: break;
883: case 3:
884: faceMarkerBottom = 1;
885: faceMarkerTop = 2;
886: faceMarkerFront = 3;
887: faceMarkerBack = 4;
888: faceMarkerRight = 5;
889: faceMarkerLeft = 6;
890: break;
891: default:
892: SETERRQ(PETSC_COMM_SELF, PETSC_ERR_SUP, "Dimension %" PetscInt_FMT " not supported", dim);
893: }
894: PetscCall(PetscOptionsGetBool(((PetscObject)dm)->options, ((PetscObject)dm)->prefix, "-dm_plex_separate_marker", &markerSeparate, NULL));
895: if (markerSeparate) {
896: markerBottom = faceMarkerBottom;
897: markerTop = faceMarkerTop;
898: markerFront = faceMarkerFront;
899: markerBack = faceMarkerBack;
900: markerRight = faceMarkerRight;
901: markerLeft = faceMarkerLeft;
902: }
903: {
904: const PetscInt numXEdges = rank == 0 ? edges[0] : 0;
905: const PetscInt numYEdges = rank == 0 ? edges[1] : 0;
906: const PetscInt numZEdges = rank == 0 ? edges[2] : 0;
907: const PetscInt numXVertices = rank == 0 ? (bdX == DM_BOUNDARY_PERIODIC || bdX == DM_BOUNDARY_TWIST ? edges[0] : edges[0] + 1) : 0;
908: const PetscInt numYVertices = rank == 0 ? (bdY == DM_BOUNDARY_PERIODIC || bdY == DM_BOUNDARY_TWIST ? edges[1] : edges[1] + 1) : 0;
909: const PetscInt numZVertices = rank == 0 ? (bdZ == DM_BOUNDARY_PERIODIC || bdZ == DM_BOUNDARY_TWIST ? edges[2] : edges[2] + 1) : 0;
910: const PetscInt numCells = numXEdges * numYEdges * numZEdges;
911: const PetscInt numXFaces = numYEdges * numZEdges;
912: const PetscInt numYFaces = numXEdges * numZEdges;
913: const PetscInt numZFaces = numXEdges * numYEdges;
914: const PetscInt numTotXFaces = numXVertices * numXFaces;
915: const PetscInt numTotYFaces = numYVertices * numYFaces;
916: const PetscInt numTotZFaces = numZVertices * numZFaces;
917: const PetscInt numFaces = numTotXFaces + numTotYFaces + numTotZFaces;
918: const PetscInt numTotXEdges = numXEdges * numYVertices * numZVertices;
919: const PetscInt numTotYEdges = numYEdges * numXVertices * numZVertices;
920: const PetscInt numTotZEdges = numZEdges * numXVertices * numYVertices;
921: const PetscInt numVertices = numXVertices * numYVertices * numZVertices;
922: const PetscInt numEdges = numTotXEdges + numTotYEdges + numTotZEdges;
923: const PetscInt firstVertex = (dim == 2) ? numFaces : numCells;
924: const PetscInt firstXFace = (dim == 2) ? 0 : numCells + numVertices;
925: const PetscInt firstYFace = firstXFace + numTotXFaces;
926: const PetscInt firstZFace = firstYFace + numTotYFaces;
927: const PetscInt firstXEdge = numCells + numFaces + numVertices;
928: const PetscInt firstYEdge = firstXEdge + numTotXEdges;
929: const PetscInt firstZEdge = firstYEdge + numTotYEdges;
930: Vec coordinates;
931: PetscSection coordSection;
932: PetscScalar *coords;
933: PetscInt coordSize;
934: PetscInt v, vx, vy, vz;
935: PetscInt c, f, fx, fy, fz, e, ex, ey, ez;
937: PetscCall(DMPlexSetChart(dm, 0, numCells + numFaces + numEdges + numVertices));
938: for (c = 0; c < numCells; c++) PetscCall(DMPlexSetConeSize(dm, c, 6));
939: for (f = firstXFace; f < firstXFace + numFaces; ++f) PetscCall(DMPlexSetConeSize(dm, f, 4));
940: for (e = firstXEdge; e < firstXEdge + numEdges; ++e) PetscCall(DMPlexSetConeSize(dm, e, 2));
941: PetscCall(DMSetUp(dm)); /* Allocate space for cones */
942: /* Build cells */
943: for (fz = 0; fz < numZEdges; ++fz) {
944: for (fy = 0; fy < numYEdges; ++fy) {
945: for (fx = 0; fx < numXEdges; ++fx) {
946: PetscInt cell = (fz * numYEdges + fy) * numXEdges + fx;
947: PetscInt faceB = firstZFace + (fy * numXEdges + fx) * numZVertices + fz;
948: PetscInt faceT = firstZFace + (fy * numXEdges + fx) * numZVertices + ((fz + 1) % numZVertices);
949: PetscInt faceF = firstYFace + (fz * numXEdges + fx) * numYVertices + fy;
950: PetscInt faceK = firstYFace + (fz * numXEdges + fx) * numYVertices + ((fy + 1) % numYVertices);
951: PetscInt faceL = firstXFace + (fz * numYEdges + fy) * numXVertices + fx;
952: PetscInt faceR = firstXFace + (fz * numYEdges + fy) * numXVertices + ((fx + 1) % numXVertices);
953: /* B, T, F, K, R, L */
954: PetscInt ornt[6] = {-2, 0, 0, -3, 0, -2}; /* ??? */
955: PetscInt cone[6];
957: /* no boundary twisting in 3D */
958: cone[0] = faceB;
959: cone[1] = faceT;
960: cone[2] = faceF;
961: cone[3] = faceK;
962: cone[4] = faceR;
963: cone[5] = faceL;
964: PetscCall(DMPlexSetCone(dm, cell, cone));
965: PetscCall(DMPlexSetConeOrientation(dm, cell, ornt));
966: if (bdX != DM_BOUNDARY_NONE && fx == numXEdges - 1 && cutLabel) PetscCall(DMLabelSetValue(cutLabel, cell, 2));
967: if (bdY != DM_BOUNDARY_NONE && fy == numYEdges - 1 && cutLabel) PetscCall(DMLabelSetValue(cutLabel, cell, 2));
968: if (bdZ != DM_BOUNDARY_NONE && fz == numZEdges - 1 && cutLabel) PetscCall(DMLabelSetValue(cutLabel, cell, 2));
969: }
970: }
971: }
972: /* Build x faces */
973: for (fz = 0; fz < numZEdges; ++fz) {
974: for (fy = 0; fy < numYEdges; ++fy) {
975: for (fx = 0; fx < numXVertices; ++fx) {
976: PetscInt face = firstXFace + (fz * numYEdges + fy) * numXVertices + fx;
977: PetscInt edgeL = firstZEdge + (fy * numXVertices + fx) * numZEdges + fz;
978: PetscInt edgeR = firstZEdge + (((fy + 1) % numYVertices) * numXVertices + fx) * numZEdges + fz;
979: PetscInt edgeB = firstYEdge + (fz * numXVertices + fx) * numYEdges + fy;
980: PetscInt edgeT = firstYEdge + (((fz + 1) % numZVertices) * numXVertices + fx) * numYEdges + fy;
981: PetscInt ornt[4] = {0, 0, -1, -1};
982: PetscInt cone[4];
984: if (dim == 3) {
985: /* markers */
986: if (bdX != DM_BOUNDARY_PERIODIC) {
987: if (fx == numXVertices - 1) {
988: PetscCall(DMSetLabelValue(dm, "Face Sets", face, faceMarkerRight));
989: PetscCall(DMSetLabelValue(dm, "marker", face, markerRight));
990: } else if (fx == 0) {
991: PetscCall(DMSetLabelValue(dm, "Face Sets", face, faceMarkerLeft));
992: PetscCall(DMSetLabelValue(dm, "marker", face, markerLeft));
993: }
994: }
995: }
996: cone[0] = edgeB;
997: cone[1] = edgeR;
998: cone[2] = edgeT;
999: cone[3] = edgeL;
1000: PetscCall(DMPlexSetCone(dm, face, cone));
1001: PetscCall(DMPlexSetConeOrientation(dm, face, ornt));
1002: }
1003: }
1004: }
1005: /* Build y faces */
1006: for (fz = 0; fz < numZEdges; ++fz) {
1007: for (fx = 0; fx < numXEdges; ++fx) {
1008: for (fy = 0; fy < numYVertices; ++fy) {
1009: PetscInt face = firstYFace + (fz * numXEdges + fx) * numYVertices + fy;
1010: PetscInt edgeL = firstZEdge + (fy * numXVertices + fx) * numZEdges + fz;
1011: PetscInt edgeR = firstZEdge + (fy * numXVertices + ((fx + 1) % numXVertices)) * numZEdges + fz;
1012: PetscInt edgeB = firstXEdge + (fz * numYVertices + fy) * numXEdges + fx;
1013: PetscInt edgeT = firstXEdge + (((fz + 1) % numZVertices) * numYVertices + fy) * numXEdges + fx;
1014: PetscInt ornt[4] = {0, 0, -1, -1};
1015: PetscInt cone[4];
1017: if (dim == 3) {
1018: /* markers */
1019: if (bdY != DM_BOUNDARY_PERIODIC) {
1020: if (fy == numYVertices - 1) {
1021: PetscCall(DMSetLabelValue(dm, "Face Sets", face, faceMarkerBack));
1022: PetscCall(DMSetLabelValue(dm, "marker", face, markerBack));
1023: } else if (fy == 0) {
1024: PetscCall(DMSetLabelValue(dm, "Face Sets", face, faceMarkerFront));
1025: PetscCall(DMSetLabelValue(dm, "marker", face, markerFront));
1026: }
1027: }
1028: }
1029: cone[0] = edgeB;
1030: cone[1] = edgeR;
1031: cone[2] = edgeT;
1032: cone[3] = edgeL;
1033: PetscCall(DMPlexSetCone(dm, face, cone));
1034: PetscCall(DMPlexSetConeOrientation(dm, face, ornt));
1035: }
1036: }
1037: }
1038: /* Build z faces */
1039: for (fy = 0; fy < numYEdges; ++fy) {
1040: for (fx = 0; fx < numXEdges; ++fx) {
1041: for (fz = 0; fz < numZVertices; fz++) {
1042: PetscInt face = firstZFace + (fy * numXEdges + fx) * numZVertices + fz;
1043: PetscInt edgeL = firstYEdge + (fz * numXVertices + fx) * numYEdges + fy;
1044: PetscInt edgeR = firstYEdge + (fz * numXVertices + ((fx + 1) % numXVertices)) * numYEdges + fy;
1045: PetscInt edgeB = firstXEdge + (fz * numYVertices + fy) * numXEdges + fx;
1046: PetscInt edgeT = firstXEdge + (fz * numYVertices + ((fy + 1) % numYVertices)) * numXEdges + fx;
1047: PetscInt ornt[4] = {0, 0, -1, -1};
1048: PetscInt cone[4];
1050: if (dim == 2) {
1051: if (bdX == DM_BOUNDARY_TWIST && fx == numXEdges - 1) {
1052: edgeR += numYEdges - 1 - 2 * fy;
1053: ornt[1] = -1;
1054: }
1055: if (bdY == DM_BOUNDARY_TWIST && fy == numYEdges - 1) {
1056: edgeT += numXEdges - 1 - 2 * fx;
1057: ornt[2] = 0;
1058: }
1059: if (bdX != DM_BOUNDARY_NONE && fx == numXEdges - 1 && cutLabel) PetscCall(DMLabelSetValue(cutLabel, face, 2));
1060: if (bdY != DM_BOUNDARY_NONE && fy == numYEdges - 1 && cutLabel) PetscCall(DMLabelSetValue(cutLabel, face, 2));
1061: } else {
1062: /* markers */
1063: if (bdZ != DM_BOUNDARY_PERIODIC) {
1064: if (fz == numZVertices - 1) {
1065: PetscCall(DMSetLabelValue(dm, "Face Sets", face, faceMarkerTop));
1066: PetscCall(DMSetLabelValue(dm, "marker", face, markerTop));
1067: } else if (fz == 0) {
1068: PetscCall(DMSetLabelValue(dm, "Face Sets", face, faceMarkerBottom));
1069: PetscCall(DMSetLabelValue(dm, "marker", face, markerBottom));
1070: }
1071: }
1072: }
1073: cone[0] = edgeB;
1074: cone[1] = edgeR;
1075: cone[2] = edgeT;
1076: cone[3] = edgeL;
1077: PetscCall(DMPlexSetCone(dm, face, cone));
1078: PetscCall(DMPlexSetConeOrientation(dm, face, ornt));
1079: }
1080: }
1081: }
1082: /* Build Z edges*/
1083: for (vy = 0; vy < numYVertices; vy++) {
1084: for (vx = 0; vx < numXVertices; vx++) {
1085: for (ez = 0; ez < numZEdges; ez++) {
1086: const PetscInt edge = firstZEdge + (vy * numXVertices + vx) * numZEdges + ez;
1087: const PetscInt vertexB = firstVertex + (ez * numYVertices + vy) * numXVertices + vx;
1088: const PetscInt vertexT = firstVertex + (((ez + 1) % numZVertices) * numYVertices + vy) * numXVertices + vx;
1089: PetscInt cone[2];
1091: cone[0] = vertexB;
1092: cone[1] = vertexT;
1093: PetscCall(DMPlexSetCone(dm, edge, cone));
1094: if (dim == 3) {
1095: if (bdX != DM_BOUNDARY_PERIODIC) {
1096: if (vx == numXVertices - 1) {
1097: PetscCall(DMSetLabelValue(dm, "marker", edge, markerRight));
1098: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerRight));
1099: if (ez == numZEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerRight));
1100: } else if (vx == 0) {
1101: PetscCall(DMSetLabelValue(dm, "marker", edge, markerLeft));
1102: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerLeft));
1103: if (ez == numZEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerLeft));
1104: }
1105: }
1106: if (bdY != DM_BOUNDARY_PERIODIC) {
1107: if (vy == numYVertices - 1) {
1108: PetscCall(DMSetLabelValue(dm, "marker", edge, markerBack));
1109: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerBack));
1110: if (ez == numZEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerBack));
1111: } else if (vy == 0) {
1112: PetscCall(DMSetLabelValue(dm, "marker", edge, markerFront));
1113: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerFront));
1114: if (ez == numZEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerFront));
1115: }
1116: }
1117: }
1118: }
1119: }
1120: }
1121: /* Build Y edges*/
1122: for (vz = 0; vz < numZVertices; vz++) {
1123: for (vx = 0; vx < numXVertices; vx++) {
1124: for (ey = 0; ey < numYEdges; ey++) {
1125: const PetscInt nextv = (dim == 2 && bdY == DM_BOUNDARY_TWIST && ey == numYEdges - 1) ? (numXVertices - vx - 1) : (vz * numYVertices + ((ey + 1) % numYVertices)) * numXVertices + vx;
1126: const PetscInt edge = firstYEdge + (vz * numXVertices + vx) * numYEdges + ey;
1127: const PetscInt vertexF = firstVertex + (vz * numYVertices + ey) * numXVertices + vx;
1128: const PetscInt vertexK = firstVertex + nextv;
1129: PetscInt cone[2];
1131: cone[0] = vertexF;
1132: cone[1] = vertexK;
1133: PetscCall(DMPlexSetCone(dm, edge, cone));
1134: if (dim == 2) {
1135: if ((bdX != DM_BOUNDARY_PERIODIC) && (bdX != DM_BOUNDARY_TWIST)) {
1136: if (vx == numXVertices - 1) {
1137: PetscCall(DMSetLabelValue(dm, "Face Sets", edge, faceMarkerRight));
1138: PetscCall(DMSetLabelValue(dm, "marker", edge, markerRight));
1139: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerRight));
1140: if (ey == numYEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerRight));
1141: } else if (vx == 0) {
1142: PetscCall(DMSetLabelValue(dm, "Face Sets", edge, faceMarkerLeft));
1143: PetscCall(DMSetLabelValue(dm, "marker", edge, markerLeft));
1144: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerLeft));
1145: if (ey == numYEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerLeft));
1146: }
1147: } else {
1148: if (vx == 0 && cutLabel) {
1149: PetscCall(DMLabelSetValue(cutLabel, edge, 1));
1150: PetscCall(DMLabelSetValue(cutLabel, cone[0], 1));
1151: if (ey == numYEdges - 1) PetscCall(DMLabelSetValue(cutLabel, cone[1], 1));
1152: }
1153: }
1154: } else {
1155: if (bdX != DM_BOUNDARY_PERIODIC) {
1156: if (vx == numXVertices - 1) {
1157: PetscCall(DMSetLabelValue(dm, "marker", edge, markerRight));
1158: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerRight));
1159: if (ey == numYEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerRight));
1160: } else if (vx == 0) {
1161: PetscCall(DMSetLabelValue(dm, "marker", edge, markerLeft));
1162: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerLeft));
1163: if (ey == numYEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerLeft));
1164: }
1165: }
1166: if (bdZ != DM_BOUNDARY_PERIODIC) {
1167: if (vz == numZVertices - 1) {
1168: PetscCall(DMSetLabelValue(dm, "marker", edge, markerTop));
1169: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerTop));
1170: if (ey == numYEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerTop));
1171: } else if (vz == 0) {
1172: PetscCall(DMSetLabelValue(dm, "marker", edge, markerBottom));
1173: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerBottom));
1174: if (ey == numYEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerBottom));
1175: }
1176: }
1177: }
1178: }
1179: }
1180: }
1181: /* Build X edges*/
1182: for (vz = 0; vz < numZVertices; vz++) {
1183: for (vy = 0; vy < numYVertices; vy++) {
1184: for (ex = 0; ex < numXEdges; ex++) {
1185: const PetscInt nextv = (dim == 2 && bdX == DM_BOUNDARY_TWIST && ex == numXEdges - 1) ? (numYVertices - vy - 1) * numXVertices : (vz * numYVertices + vy) * numXVertices + (ex + 1) % numXVertices;
1186: const PetscInt edge = firstXEdge + (vz * numYVertices + vy) * numXEdges + ex;
1187: const PetscInt vertexL = firstVertex + (vz * numYVertices + vy) * numXVertices + ex;
1188: const PetscInt vertexR = firstVertex + nextv;
1189: PetscInt cone[2];
1191: cone[0] = vertexL;
1192: cone[1] = vertexR;
1193: PetscCall(DMPlexSetCone(dm, edge, cone));
1194: if (dim == 2) {
1195: if ((bdY != DM_BOUNDARY_PERIODIC) && (bdY != DM_BOUNDARY_TWIST)) {
1196: if (vy == numYVertices - 1) {
1197: PetscCall(DMSetLabelValue(dm, "Face Sets", edge, faceMarkerTop));
1198: PetscCall(DMSetLabelValue(dm, "marker", edge, markerTop));
1199: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerTop));
1200: if (ex == numXEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerTop));
1201: } else if (vy == 0) {
1202: PetscCall(DMSetLabelValue(dm, "Face Sets", edge, faceMarkerBottom));
1203: PetscCall(DMSetLabelValue(dm, "marker", edge, markerBottom));
1204: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerBottom));
1205: if (ex == numXEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerBottom));
1206: }
1207: } else {
1208: if (vy == 0 && cutLabel) {
1209: PetscCall(DMLabelSetValue(cutLabel, edge, 1));
1210: PetscCall(DMLabelSetValue(cutLabel, cone[0], 1));
1211: if (ex == numXEdges - 1) PetscCall(DMLabelSetValue(cutLabel, cone[1], 1));
1212: }
1213: }
1214: } else {
1215: if (bdY != DM_BOUNDARY_PERIODIC) {
1216: if (vy == numYVertices - 1) {
1217: PetscCall(DMSetLabelValue(dm, "marker", edge, markerBack));
1218: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerBack));
1219: if (ex == numXEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerBack));
1220: } else if (vy == 0) {
1221: PetscCall(DMSetLabelValue(dm, "marker", edge, markerFront));
1222: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerFront));
1223: if (ex == numXEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerFront));
1224: }
1225: }
1226: if (bdZ != DM_BOUNDARY_PERIODIC) {
1227: if (vz == numZVertices - 1) {
1228: PetscCall(DMSetLabelValue(dm, "marker", edge, markerTop));
1229: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerTop));
1230: if (ex == numXEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerTop));
1231: } else if (vz == 0) {
1232: PetscCall(DMSetLabelValue(dm, "marker", edge, markerBottom));
1233: PetscCall(DMSetLabelValue(dm, "marker", cone[0], markerBottom));
1234: if (ex == numXEdges - 1) PetscCall(DMSetLabelValue(dm, "marker", cone[1], markerBottom));
1235: }
1236: }
1237: }
1238: }
1239: }
1240: }
1241: PetscCall(DMPlexSymmetrize(dm));
1242: PetscCall(DMPlexStratify(dm));
1243: /* Build coordinates */
1244: PetscCall(DMGetCoordinateSection(dm, &coordSection));
1245: PetscCall(PetscSectionSetNumFields(coordSection, 1));
1246: PetscCall(PetscSectionSetFieldComponents(coordSection, 0, dim));
1247: PetscCall(PetscSectionSetChart(coordSection, firstVertex, firstVertex + numVertices));
1248: for (v = firstVertex; v < firstVertex + numVertices; ++v) {
1249: PetscCall(PetscSectionSetDof(coordSection, v, dim));
1250: PetscCall(PetscSectionSetFieldDof(coordSection, v, 0, dim));
1251: }
1252: PetscCall(PetscSectionSetUp(coordSection));
1253: PetscCall(PetscSectionGetStorageSize(coordSection, &coordSize));
1254: PetscCall(VecCreate(PETSC_COMM_SELF, &coordinates));
1255: PetscCall(PetscObjectSetName((PetscObject)coordinates, "coordinates"));
1256: PetscCall(VecSetSizes(coordinates, coordSize, PETSC_DETERMINE));
1257: PetscCall(VecSetBlockSize(coordinates, dim));
1258: PetscCall(VecSetType(coordinates, VECSTANDARD));
1259: PetscCall(VecGetArray(coordinates, &coords));
1260: for (vz = 0; vz < numZVertices; ++vz) {
1261: for (vy = 0; vy < numYVertices; ++vy) {
1262: for (vx = 0; vx < numXVertices; ++vx) {
1263: coords[((vz * numYVertices + vy) * numXVertices + vx) * dim + 0] = lower[0] + ((upper[0] - lower[0]) / numXEdges) * vx;
1264: coords[((vz * numYVertices + vy) * numXVertices + vx) * dim + 1] = lower[1] + ((upper[1] - lower[1]) / numYEdges) * vy;
1265: if (dim == 3) coords[((vz * numYVertices + vy) * numXVertices + vx) * dim + 2] = lower[2] + ((upper[2] - lower[2]) / numZEdges) * vz;
1266: }
1267: }
1268: }
1269: PetscCall(VecRestoreArray(coordinates, &coords));
1270: PetscCall(DMSetCoordinatesLocal(dm, coordinates));
1271: PetscCall(VecDestroy(&coordinates));
1272: }
1273: PetscFunctionReturn(PETSC_SUCCESS);
1274: }
1276: static PetscErrorCode DMPlexCreateBoxMesh_Tensor_Internal(DM dm, PetscInt dim, const PetscInt faces[], const PetscReal lower[], const PetscReal upper[], const DMBoundaryType periodicity[])
1277: {
1278: DMBoundaryType bdt[3] = {DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE};
1279: PetscInt fac[3] = {0, 0, 0}, d;
1281: PetscFunctionBegin;
1282: PetscAssertPointer(dm, 1);
1284: PetscCall(DMSetDimension(dm, dim));
1285: for (d = 0; d < dim; ++d) {
1286: fac[d] = faces[d];
1287: bdt[d] = periodicity[d];
1288: }
1289: PetscCall(DMPlexCreateCubeMesh_Internal(dm, lower, upper, fac, bdt[0], bdt[1], bdt[2]));
1290: if (periodicity[0] == DM_BOUNDARY_PERIODIC || periodicity[0] == DM_BOUNDARY_TWIST || periodicity[1] == DM_BOUNDARY_PERIODIC || periodicity[1] == DM_BOUNDARY_TWIST || (dim > 2 && (periodicity[2] == DM_BOUNDARY_PERIODIC || periodicity[2] == DM_BOUNDARY_TWIST))) {
1291: PetscReal L[3] = {-1., -1., 0.};
1292: PetscReal maxCell[3] = {-1., -1., 0.};
1294: for (d = 0; d < dim; ++d) {
1295: if (periodicity[d] != DM_BOUNDARY_NONE) {
1296: L[d] = upper[d] - lower[d];
1297: maxCell[d] = 1.1 * (L[d] / PetscMax(1, faces[d]));
1298: }
1299: }
1300: PetscCall(DMSetPeriodicity(dm, maxCell, lower, L));
1301: }
1302: PetscCall(DMPlexSetRefinementUniform(dm, PETSC_TRUE));
1303: PetscFunctionReturn(PETSC_SUCCESS);
1304: }
1306: static PetscErrorCode DMPlexCreateBoxMesh_Internal(DM dm, DMPlexShape shape, PetscInt dim, PetscBool simplex, const PetscInt faces[], const PetscReal lower[], const PetscReal upper[], const DMBoundaryType periodicity[], PetscBool interpolate)
1307: {
1308: PetscFunctionBegin;
1309: PetscCall(PetscLogEventBegin(DMPLEX_Generate, dm, 0, 0, 0));
1310: if (shape == DM_SHAPE_ZBOX) PetscCall(DMPlexCreateBoxMesh_Tensor_SFC_Internal(dm, dim, faces, lower, upper, periodicity, interpolate));
1311: else if (dim == 1) PetscCall(DMPlexCreateLineMesh_Internal(dm, faces[0], lower[0], upper[0], periodicity[0]));
1312: else if (simplex) PetscCall(DMPlexCreateBoxMesh_Simplex_Internal(dm, dim, faces, lower, upper, periodicity, interpolate));
1313: else PetscCall(DMPlexCreateBoxMesh_Tensor_Internal(dm, dim, faces, lower, upper, periodicity));
1314: if (!interpolate && dim > 1 && !simplex) {
1315: DM udm;
1317: PetscCall(DMPlexUninterpolate(dm, &udm));
1318: PetscCall(DMPlexCopyCoordinates(dm, udm));
1319: PetscCall(DMPlexReplace_Internal(dm, &udm));
1320: }
1321: PetscCall(PetscLogEventEnd(DMPLEX_Generate, dm, 0, 0, 0));
1322: PetscFunctionReturn(PETSC_SUCCESS);
1323: }
1325: /*@C
1326: DMPlexCreateBoxMesh - Creates a mesh on the tensor product of unit intervals (box) using simplices or tensor cells (hexahedra).
1328: Collective
1330: Input Parameters:
1331: + comm - The communicator for the `DM` object
1332: . dim - The spatial dimension
1333: . simplex - `PETSC_TRUE` for simplices, `PETSC_FALSE` for tensor cells
1334: . faces - Number of faces per dimension, or `NULL` for (1,) in 1D and (2, 2) in 2D and (1, 1, 1) in 3D
1335: . lower - The lower left corner, or `NULL` for (0, 0, 0)
1336: . upper - The upper right corner, or `NULL` for (1, 1, 1)
1337: . periodicity - The boundary type for the X,Y,Z direction, or `NULL` for `DM_BOUNDARY_NONE`
1338: - interpolate - Flag to create intermediate mesh pieces (edges, faces)
1340: Output Parameter:
1341: . dm - The `DM` object
1343: Level: beginner
1345: Note:
1346: To customize this mesh using options, use
1347: .vb
1348: DMCreate(comm, &dm);
1349: DMSetType(dm, DMPLEX);
1350: DMSetFromOptions(dm);
1351: .ve
1352: and use the options in `DMSetFromOptions()`.
1354: Here is the numbering returned for 2 faces in each direction for tensor cells\:
1355: .vb
1356: 10---17---11---18----12
1357: | | |
1358: | | |
1359: 20 2 22 3 24
1360: | | |
1361: | | |
1362: 7---15----8---16----9
1363: | | |
1364: | | |
1365: 19 0 21 1 23
1366: | | |
1367: | | |
1368: 4---13----5---14----6
1369: .ve
1370: and for simplicial cells
1371: .vb
1372: 14----8---15----9----16
1373: |\ 5 |\ 7 |
1374: | \ | \ |
1375: 13 2 14 3 15
1376: | 4 \ | 6 \ |
1377: | \ | \ |
1378: 11----6---12----7----13
1379: |\ |\ |
1380: | \ 1 | \ 3 |
1381: 10 0 11 1 12
1382: | 0 \ | 2 \ |
1383: | \ | \ |
1384: 8----4----9----5----10
1385: .ve
1387: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMSetFromOptions()`, `DMPlexCreateFromFile()`, `DMPlexCreateHexCylinderMesh()`, `DMSetType()`, `DMCreate()`
1388: @*/
1389: 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)
1390: {
1391: PetscInt fac[3] = {1, 1, 1};
1392: PetscReal low[3] = {0, 0, 0};
1393: PetscReal upp[3] = {1, 1, 1};
1394: DMBoundaryType bdt[3] = {DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE};
1396: PetscFunctionBegin;
1397: PetscCall(DMCreate(comm, dm));
1398: PetscCall(DMSetType(*dm, DMPLEX));
1399: PetscCall(DMPlexCreateBoxMesh_Internal(*dm, DM_SHAPE_BOX, dim, simplex, faces ? faces : fac, lower ? lower : low, upper ? upper : upp, periodicity ? periodicity : bdt, interpolate));
1400: if (periodicity) PetscCall(DMLocalizeCoordinates(*dm));
1401: PetscFunctionReturn(PETSC_SUCCESS);
1402: }
1404: static PetscErrorCode DMPlexCreateWedgeBoxMesh_Internal(DM dm, const PetscInt faces[], const PetscReal lower[], const PetscReal upper[], const DMBoundaryType periodicity[])
1405: {
1406: DM bdm, vol;
1407: PetscInt i;
1409: PetscFunctionBegin;
1410: // TODO Now we can support periodicity
1411: for (i = 0; i < 3; ++i) PetscCheck(periodicity[i] == DM_BOUNDARY_NONE, PetscObjectComm((PetscObject)dm), PETSC_ERR_SUP, "Periodicity not yet supported");
1412: PetscCall(DMCreate(PetscObjectComm((PetscObject)dm), &bdm));
1413: PetscCall(DMSetType(bdm, DMPLEX));
1414: PetscCall(DMSetDimension(bdm, 2));
1415: PetscCall(PetscLogEventBegin(DMPLEX_Generate, bdm, 0, 0, 0));
1416: PetscCall(DMPlexCreateBoxMesh_Simplex_Internal(bdm, 2, faces, lower, upper, periodicity, PETSC_TRUE));
1417: PetscCall(DMPlexExtrude(bdm, faces[2], upper[2] - lower[2], PETSC_TRUE, PETSC_FALSE, PETSC_FALSE, NULL, NULL, &vol));
1418: PetscCall(PetscLogEventEnd(DMPLEX_Generate, bdm, 0, 0, 0));
1419: PetscCall(DMDestroy(&bdm));
1420: PetscCall(DMPlexReplace_Internal(dm, &vol));
1421: if (lower[2] != 0.0) {
1422: Vec v;
1423: PetscScalar *x;
1424: PetscInt cDim, n;
1426: PetscCall(DMGetCoordinatesLocal(dm, &v));
1427: PetscCall(VecGetBlockSize(v, &cDim));
1428: PetscCall(VecGetLocalSize(v, &n));
1429: PetscCall(VecGetArray(v, &x));
1430: x += cDim;
1431: for (i = 0; i < n; i += cDim) x[i] += lower[2];
1432: PetscCall(VecRestoreArray(v, &x));
1433: PetscCall(DMSetCoordinatesLocal(dm, v));
1434: }
1435: PetscFunctionReturn(PETSC_SUCCESS);
1436: }
1438: /*@
1439: DMPlexCreateWedgeBoxMesh - Creates a 3-D mesh tessellating the (x,y) plane and extruding in the third direction using wedge cells.
1441: Collective
1443: Input Parameters:
1444: + comm - The communicator for the `DM` object
1445: . faces - Number of faces per dimension, or `NULL` for (1, 1, 1)
1446: . lower - The lower left corner, or `NULL` for (0, 0, 0)
1447: . upper - The upper right corner, or `NULL` for (1, 1, 1)
1448: . periodicity - The boundary type for the X,Y,Z direction, or `NULL` for `DM_BOUNDARY_NONE`
1449: . orderHeight - If `PETSC_TRUE`, orders the extruded cells in the height first. Otherwise, orders the cell on the layers first
1450: - interpolate - Flag to create intermediate mesh pieces (edges, faces)
1452: Output Parameter:
1453: . dm - The `DM` object
1455: Level: beginner
1457: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexCreateHexCylinderMesh()`, `DMPlexCreateWedgeCylinderMesh()`, `DMExtrude()`, `DMPlexCreateBoxMesh()`, `DMSetType()`, `DMCreate()`
1458: @*/
1459: PetscErrorCode DMPlexCreateWedgeBoxMesh(MPI_Comm comm, const PetscInt faces[], const PetscReal lower[], const PetscReal upper[], const DMBoundaryType periodicity[], PetscBool orderHeight, PetscBool interpolate, DM *dm)
1460: {
1461: PetscInt fac[3] = {1, 1, 1};
1462: PetscReal low[3] = {0, 0, 0};
1463: PetscReal upp[3] = {1, 1, 1};
1464: DMBoundaryType bdt[3] = {DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE};
1466: PetscFunctionBegin;
1467: PetscCall(DMCreate(comm, dm));
1468: PetscCall(DMSetType(*dm, DMPLEX));
1469: PetscCall(DMPlexCreateWedgeBoxMesh_Internal(*dm, faces ? faces : fac, lower ? lower : low, upper ? upper : upp, periodicity ? periodicity : bdt));
1470: if (!interpolate) {
1471: DM udm;
1473: PetscCall(DMPlexUninterpolate(*dm, &udm));
1474: PetscCall(DMPlexReplace_Internal(*dm, &udm));
1475: }
1476: if (periodicity) PetscCall(DMLocalizeCoordinates(*dm));
1477: PetscFunctionReturn(PETSC_SUCCESS);
1478: }
1480: /*
1481: DMPlexTensorPointLexicographic_Private - Returns all tuples of size 'len' with nonnegative integers that are all less than or equal to 'max' for that dimension.
1483: Input Parameters:
1484: + len - The length of the tuple
1485: . max - The maximum for each dimension, so values are in [0, max)
1486: - tup - A tuple of length len+1: tup[len] > 0 indicates a stopping condition
1488: Output Parameter:
1489: . tup - A tuple of `len` integers whose entries are at most `max`
1491: Level: developer
1493: Note:
1494: Ordering is lexicographic with lowest index as least significant in ordering.
1495: e.g. for len == 2 and max == 2, this will return, in order, {0,0}, {1,0}, {2,0}, {0,1}, {1,1}, {2,1}, {0,2}, {1,2}, {2,2}.
1497: .seealso: PetscDualSpaceTensorPointLexicographic_Internal(), PetscDualSpaceLatticePointLexicographic_Internal()
1498: */
1499: static PetscErrorCode DMPlexTensorPointLexicographic_Private(PetscInt len, const PetscInt max[], PetscInt tup[])
1500: {
1501: PetscInt i;
1503: PetscFunctionBegin;
1504: for (i = 0; i < len; ++i) {
1505: if (tup[i] < max[i] - 1) {
1506: break;
1507: } else {
1508: tup[i] = 0;
1509: }
1510: }
1511: if (i == len) tup[i - 1] = max[i - 1];
1512: else ++tup[i];
1513: PetscFunctionReturn(PETSC_SUCCESS);
1514: }
1516: static PetscInt TupleToIndex_Private(PetscInt len, const PetscInt max[], const PetscInt tup[])
1517: {
1518: PetscInt i, idx = tup[len - 1];
1520: for (i = len - 2; i >= 0; --i) {
1521: idx *= max[i];
1522: idx += tup[i];
1523: }
1524: return idx;
1525: }
1527: static PetscErrorCode DestroyExtent_Private(void *extent)
1528: {
1529: return PetscFree(extent);
1530: }
1532: static PetscErrorCode DMPlexCreateHypercubicMesh_Internal(DM dm, PetscInt dim, const PetscReal lower[], const PetscReal upper[], const PetscInt edges[], const DMBoundaryType bd[])
1533: {
1534: Vec coordinates;
1535: PetscSection coordSection;
1536: DMLabel cutLabel = NULL;
1537: PetscBool cutMarker = PETSC_FALSE;
1538: PetscBool periodic = PETSC_FALSE;
1539: PetscInt numCells = 1, c;
1540: PetscInt numVertices = 1, v;
1541: PetscScalar *coords;
1542: PetscInt *vertices, *vert, *vtmp, *supp, cone[2];
1543: PetscInt d, e, cell = 0, coordSize;
1544: PetscMPIInt rank;
1546: PetscFunctionBegin;
1547: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank));
1548: PetscCall(DMSetDimension(dm, dim));
1549: PetscCall(PetscCalloc4(dim, &vertices, dim, &vert, dim, &vtmp, 2 * dim, &supp));
1550: PetscCall(DMCreateLabel(dm, "marker"));
1551: PetscCall(PetscOptionsGetBool(((PetscObject)dm)->options, ((PetscObject)dm)->prefix, "-dm_plex_periodic_cut", &cutMarker, NULL));
1552: for (d = 0; d < dim; ++d) periodic = (periodic || bd[d] == DM_BOUNDARY_PERIODIC) ? PETSC_TRUE : PETSC_FALSE;
1553: if (periodic && cutMarker) {
1554: PetscCall(DMCreateLabel(dm, "periodic_cut"));
1555: PetscCall(DMGetLabel(dm, "periodic_cut", &cutLabel));
1556: }
1557: for (d = 0; d < dim; ++d) PetscCheck(bd[d] == DM_BOUNDARY_PERIODIC, PetscObjectComm((PetscObject)dm), PETSC_ERR_SUP, "Hypercubic mesh must be periodic now");
1558: for (d = 0; d < dim; ++d) {
1559: vertices[d] = edges[d];
1560: numVertices *= vertices[d];
1561: }
1562: numCells = numVertices * dim;
1563: PetscCall(DMPlexSetChart(dm, 0, numCells + numVertices));
1564: for (c = 0; c < numCells; ++c) PetscCall(DMPlexSetConeSize(dm, c, 2));
1565: for (v = numCells; v < numCells + numVertices; ++v) PetscCall(DMPlexSetSupportSize(dm, v, 2 * dim));
1566: /* TODO Loop over boundary and reset support sizes */
1567: PetscCall(DMSetUp(dm)); /* Allocate space for cones and supports */
1568: /* Build cell cones and vertex supports */
1569: PetscCall(DMCreateLabel(dm, "celltype"));
1570: while (vert[dim - 1] < vertices[dim - 1]) {
1571: const PetscInt vertex = TupleToIndex_Private(dim, vertices, vert) + numCells;
1572: PetscInt s = 0;
1574: PetscCall(PetscPrintf(PETSC_COMM_SELF, "Vertex %" PetscInt_FMT ":", vertex));
1575: for (d = 0; d < dim; ++d) PetscCall(PetscPrintf(PETSC_COMM_SELF, " %" PetscInt_FMT, vert[d]));
1576: PetscCall(PetscPrintf(PETSC_COMM_SELF, "\n"));
1577: PetscCall(DMPlexSetCellType(dm, vertex, DM_POLYTOPE_POINT));
1578: for (d = 0; d < dim; ++d) {
1579: for (e = 0; e < dim; ++e) vtmp[e] = vert[e];
1580: vtmp[d] = (vert[d] + 1) % vertices[d];
1581: cone[0] = vertex;
1582: cone[1] = TupleToIndex_Private(dim, vertices, vtmp) + numCells;
1583: PetscCall(PetscPrintf(PETSC_COMM_SELF, " Vertex %" PetscInt_FMT ":", cone[1]));
1584: for (e = 0; e < dim; ++e) PetscCall(PetscPrintf(PETSC_COMM_SELF, " %" PetscInt_FMT, vtmp[e]));
1585: PetscCall(PetscPrintf(PETSC_COMM_SELF, "\n"));
1586: PetscCall(DMPlexSetCone(dm, cell, cone));
1587: PetscCall(DMPlexSetCellType(dm, cell, DM_POLYTOPE_SEGMENT));
1588: PetscCall(PetscPrintf(PETSC_COMM_SELF, " Edge %" PetscInt_FMT " (%" PetscInt_FMT " %" PetscInt_FMT ")\n", cell, cone[0], cone[1]));
1589: ++cell;
1590: }
1591: for (d = 0; d < dim; ++d) {
1592: for (e = 0; e < dim; ++e) vtmp[e] = vert[e];
1593: vtmp[d] = (vert[d] + vertices[d] - 1) % vertices[d];
1594: supp[s++] = TupleToIndex_Private(dim, vertices, vtmp) * dim + d;
1595: supp[s++] = (vertex - numCells) * dim + d;
1596: PetscCall(DMPlexSetSupport(dm, vertex, supp));
1597: }
1598: PetscCall(DMPlexTensorPointLexicographic_Private(dim, vertices, vert));
1599: }
1600: PetscCall(DMPlexStratify(dm));
1601: /* Build coordinates */
1602: PetscCall(DMGetCoordinateSection(dm, &coordSection));
1603: PetscCall(PetscSectionSetNumFields(coordSection, 1));
1604: PetscCall(PetscSectionSetFieldComponents(coordSection, 0, dim));
1605: PetscCall(PetscSectionSetChart(coordSection, numCells, numCells + numVertices));
1606: for (v = numCells; v < numCells + numVertices; ++v) {
1607: PetscCall(PetscSectionSetDof(coordSection, v, dim));
1608: PetscCall(PetscSectionSetFieldDof(coordSection, v, 0, dim));
1609: }
1610: PetscCall(PetscSectionSetUp(coordSection));
1611: PetscCall(PetscSectionGetStorageSize(coordSection, &coordSize));
1612: PetscCall(VecCreate(PETSC_COMM_SELF, &coordinates));
1613: PetscCall(PetscObjectSetName((PetscObject)coordinates, "coordinates"));
1614: PetscCall(VecSetSizes(coordinates, coordSize, PETSC_DETERMINE));
1615: PetscCall(VecSetBlockSize(coordinates, dim));
1616: PetscCall(VecSetType(coordinates, VECSTANDARD));
1617: PetscCall(VecGetArray(coordinates, &coords));
1618: for (d = 0; d < dim; ++d) vert[d] = 0;
1619: while (vert[dim - 1] < vertices[dim - 1]) {
1620: const PetscInt vertex = TupleToIndex_Private(dim, vertices, vert);
1622: for (d = 0; d < dim; ++d) coords[vertex * dim + d] = lower[d] + ((upper[d] - lower[d]) / vertices[d]) * vert[d];
1623: PetscCall(PetscPrintf(PETSC_COMM_SELF, "Vertex %" PetscInt_FMT ":", vertex));
1624: for (d = 0; d < dim; ++d) PetscCall(PetscPrintf(PETSC_COMM_SELF, " %" PetscInt_FMT, vert[d]));
1625: for (d = 0; d < dim; ++d) PetscCall(PetscPrintf(PETSC_COMM_SELF, " %g", (double)PetscRealPart(coords[vertex * dim + d])));
1626: PetscCall(PetscPrintf(PETSC_COMM_SELF, "\n"));
1627: PetscCall(DMPlexTensorPointLexicographic_Private(dim, vertices, vert));
1628: }
1629: PetscCall(VecRestoreArray(coordinates, &coords));
1630: PetscCall(DMSetCoordinatesLocal(dm, coordinates));
1631: PetscCall(VecDestroy(&coordinates));
1632: PetscCall(PetscFree4(vertices, vert, vtmp, supp));
1633: //PetscCall(DMSetPeriodicity(dm, NULL, lower, upper));
1634: // Attach the extent
1635: {
1636: PetscContainer c;
1637: PetscInt *extent;
1639: PetscCall(PetscMalloc1(dim, &extent));
1640: for (PetscInt d = 0; d < dim; ++d) extent[d] = edges[d];
1641: PetscCall(PetscContainerCreate(PETSC_COMM_SELF, &c));
1642: PetscCall(PetscContainerSetUserDestroy(c, DestroyExtent_Private));
1643: PetscCall(PetscContainerSetPointer(c, extent));
1644: PetscCall(PetscObjectCompose((PetscObject)dm, "_extent", (PetscObject)c));
1645: PetscCall(PetscContainerDestroy(&c));
1646: }
1647: PetscFunctionReturn(PETSC_SUCCESS);
1648: }
1650: /*@C
1651: DMPlexCreateHypercubicMesh - Creates a periodic mesh on the tensor product of unit intervals using only vertices and edges.
1653: Collective
1655: Input Parameters:
1656: + comm - The communicator for the DM object
1657: . dim - The spatial dimension
1658: . edges - Number of edges per dimension, or `NULL` for (1,) in 1D and (2, 2) in 2D and (1, 1, 1) in 3D
1659: . lower - The lower left corner, or `NULL` for (0, 0, 0)
1660: - upper - The upper right corner, or `NULL` for (1, 1, 1)
1662: Output Parameter:
1663: . dm - The DM object
1665: Level: beginner
1667: Note:
1668: If you want to customize this mesh using options, you just need to
1669: .vb
1670: DMCreate(comm, &dm);
1671: DMSetType(dm, DMPLEX);
1672: DMSetFromOptions(dm);
1673: .ve
1674: and use the options on the `DMSetFromOptions()` page.
1676: The vertices are numbered is lexicographic order, and the dim edges exiting a vertex in the positive orthant are number consecutively,
1677: .vb
1678: 18--0-19--2-20--4-18
1679: | | | |
1680: 13 15 17 13
1681: | | | |
1682: 24-12-25-14-26-16-24
1683: | | | |
1684: 7 9 11 7
1685: | | | |
1686: 21--6-22--8-23-10-21
1687: | | | |
1688: 1 3 5 1
1689: | | | |
1690: 18--0-19--2-20--4-18
1691: .ve
1693: .seealso: `DMSetFromOptions()`, `DMPlexCreateFromFile()`, `DMPlexCreateHexCylinderMesh()`, `DMSetType()`, `DMCreate()`
1694: @*/
1695: PetscErrorCode DMPlexCreateHypercubicMesh(MPI_Comm comm, PetscInt dim, const PetscInt edges[], const PetscReal lower[], const PetscReal upper[], DM *dm)
1696: {
1697: PetscInt *edg;
1698: PetscReal *low, *upp;
1699: DMBoundaryType *bdt;
1700: PetscInt d;
1702: PetscFunctionBegin;
1703: PetscCall(DMCreate(comm, dm));
1704: PetscCall(DMSetType(*dm, DMPLEX));
1705: PetscCall(PetscMalloc4(dim, &edg, dim, &low, dim, &upp, dim, &bdt));
1706: for (d = 0; d < dim; ++d) {
1707: edg[d] = edges ? edges[d] : 1;
1708: low[d] = lower ? lower[d] : 0.;
1709: upp[d] = upper ? upper[d] : 1.;
1710: bdt[d] = DM_BOUNDARY_PERIODIC;
1711: }
1712: PetscCall(DMPlexCreateHypercubicMesh_Internal(*dm, dim, low, upp, edg, bdt));
1713: PetscCall(PetscFree4(edg, low, upp, bdt));
1714: PetscFunctionReturn(PETSC_SUCCESS);
1715: }
1717: /*@C
1718: DMPlexSetOptionsPrefix - Sets the prefix used for searching for all `DM` options in the database.
1720: Logically Collective
1722: Input Parameters:
1723: + dm - the `DM` context
1724: - prefix - the prefix to prepend to all option names
1726: Level: advanced
1728: Note:
1729: A hyphen (-) must NOT be given at the beginning of the prefix name.
1730: The first character of all runtime options is AUTOMATICALLY the hyphen.
1732: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `SNESSetFromOptions()`
1733: @*/
1734: PetscErrorCode DMPlexSetOptionsPrefix(DM dm, const char prefix[])
1735: {
1736: DM_Plex *mesh = (DM_Plex *)dm->data;
1738: PetscFunctionBegin;
1740: PetscCall(PetscObjectSetOptionsPrefix((PetscObject)dm, prefix));
1741: PetscCall(PetscObjectSetOptionsPrefix((PetscObject)mesh->partitioner, prefix));
1742: PetscFunctionReturn(PETSC_SUCCESS);
1743: }
1745: /* Remap geometry to cylinder
1746: TODO: This only works for a single refinement, then it is broken
1748: Interior square: Linear interpolation is correct
1749: The other cells all have vertices on rays from the origin. We want to uniformly expand the spacing
1750: such that the last vertex is on the unit circle. So the closest and farthest vertices are at distance
1752: phi = arctan(y/x)
1753: d_close = sqrt(1/8 + 1/4 sin^2(phi))
1754: d_far = sqrt(1/2 + sin^2(phi))
1756: so we remap them using
1758: x_new = x_close + (x - x_close) (1 - d_close) / (d_far - d_close)
1759: y_new = y_close + (y - y_close) (1 - d_close) / (d_far - d_close)
1761: If pi/4 < phi < 3pi/4 or -3pi/4 < phi < -pi/4, then we switch x and y.
1762: */
1763: static void snapToCylinder(PetscInt dim, PetscInt Nf, PetscInt NfAux, const PetscInt uOff[], const PetscInt uOff_x[], const PetscScalar u[], const PetscScalar u_t[], const PetscScalar u_x[], const PetscInt aOff[], const PetscInt aOff_x[], const PetscScalar a[], const PetscScalar a_t[], const PetscScalar a_x[], PetscReal t, const PetscReal x[], PetscInt numConstants, const PetscScalar constants[], PetscScalar f0[])
1764: {
1765: const PetscReal dis = 1.0 / PetscSqrtReal(2.0);
1766: const PetscReal ds2 = 0.5 * dis;
1768: if ((PetscAbsScalar(u[0]) <= ds2) && (PetscAbsScalar(u[1]) <= ds2)) {
1769: f0[0] = u[0];
1770: f0[1] = u[1];
1771: } else {
1772: PetscReal phi, sinp, cosp, dc, df, x, y, xc, yc;
1774: x = PetscRealPart(u[0]);
1775: y = PetscRealPart(u[1]);
1776: phi = PetscAtan2Real(y, x);
1777: sinp = PetscSinReal(phi);
1778: cosp = PetscCosReal(phi);
1779: if ((PetscAbsReal(phi) > PETSC_PI / 4.0) && (PetscAbsReal(phi) < 3.0 * PETSC_PI / 4.0)) {
1780: dc = PetscAbsReal(ds2 / sinp);
1781: df = PetscAbsReal(dis / sinp);
1782: xc = ds2 * x / PetscAbsReal(y);
1783: yc = ds2 * PetscSignReal(y);
1784: } else {
1785: dc = PetscAbsReal(ds2 / cosp);
1786: df = PetscAbsReal(dis / cosp);
1787: xc = ds2 * PetscSignReal(x);
1788: yc = ds2 * y / PetscAbsReal(x);
1789: }
1790: f0[0] = xc + (u[0] - xc) * (1.0 - dc) / (df - dc);
1791: f0[1] = yc + (u[1] - yc) * (1.0 - dc) / (df - dc);
1792: }
1793: f0[2] = u[2];
1794: }
1796: static PetscErrorCode DMPlexCreateHexCylinderMesh_Internal(DM dm, DMBoundaryType periodicZ)
1797: {
1798: const PetscInt dim = 3;
1799: PetscInt numCells, numVertices;
1800: PetscMPIInt rank;
1802: PetscFunctionBegin;
1803: PetscCall(PetscLogEventBegin(DMPLEX_Generate, dm, 0, 0, 0));
1804: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank));
1805: PetscCall(DMSetDimension(dm, dim));
1806: /* Create topology */
1807: {
1808: PetscInt cone[8], c;
1810: numCells = rank == 0 ? 5 : 0;
1811: numVertices = rank == 0 ? 16 : 0;
1812: if (periodicZ == DM_BOUNDARY_PERIODIC) {
1813: numCells *= 3;
1814: numVertices = rank == 0 ? 24 : 0;
1815: }
1816: PetscCall(DMPlexSetChart(dm, 0, numCells + numVertices));
1817: for (c = 0; c < numCells; c++) PetscCall(DMPlexSetConeSize(dm, c, 8));
1818: PetscCall(DMSetUp(dm));
1819: if (rank == 0) {
1820: if (periodicZ == DM_BOUNDARY_PERIODIC) {
1821: cone[0] = 15;
1822: cone[1] = 18;
1823: cone[2] = 17;
1824: cone[3] = 16;
1825: cone[4] = 31;
1826: cone[5] = 32;
1827: cone[6] = 33;
1828: cone[7] = 34;
1829: PetscCall(DMPlexSetCone(dm, 0, cone));
1830: cone[0] = 16;
1831: cone[1] = 17;
1832: cone[2] = 24;
1833: cone[3] = 23;
1834: cone[4] = 32;
1835: cone[5] = 36;
1836: cone[6] = 37;
1837: cone[7] = 33; /* 22 25 26 21 */
1838: PetscCall(DMPlexSetCone(dm, 1, cone));
1839: cone[0] = 18;
1840: cone[1] = 27;
1841: cone[2] = 24;
1842: cone[3] = 17;
1843: cone[4] = 34;
1844: cone[5] = 33;
1845: cone[6] = 37;
1846: cone[7] = 38;
1847: PetscCall(DMPlexSetCone(dm, 2, cone));
1848: cone[0] = 29;
1849: cone[1] = 27;
1850: cone[2] = 18;
1851: cone[3] = 15;
1852: cone[4] = 35;
1853: cone[5] = 31;
1854: cone[6] = 34;
1855: cone[7] = 38;
1856: PetscCall(DMPlexSetCone(dm, 3, cone));
1857: cone[0] = 29;
1858: cone[1] = 15;
1859: cone[2] = 16;
1860: cone[3] = 23;
1861: cone[4] = 35;
1862: cone[5] = 36;
1863: cone[6] = 32;
1864: cone[7] = 31;
1865: PetscCall(DMPlexSetCone(dm, 4, cone));
1867: cone[0] = 31;
1868: cone[1] = 34;
1869: cone[2] = 33;
1870: cone[3] = 32;
1871: cone[4] = 19;
1872: cone[5] = 22;
1873: cone[6] = 21;
1874: cone[7] = 20;
1875: PetscCall(DMPlexSetCone(dm, 5, cone));
1876: cone[0] = 32;
1877: cone[1] = 33;
1878: cone[2] = 37;
1879: cone[3] = 36;
1880: cone[4] = 22;
1881: cone[5] = 25;
1882: cone[6] = 26;
1883: cone[7] = 21;
1884: PetscCall(DMPlexSetCone(dm, 6, cone));
1885: cone[0] = 34;
1886: cone[1] = 38;
1887: cone[2] = 37;
1888: cone[3] = 33;
1889: cone[4] = 20;
1890: cone[5] = 21;
1891: cone[6] = 26;
1892: cone[7] = 28;
1893: PetscCall(DMPlexSetCone(dm, 7, cone));
1894: cone[0] = 35;
1895: cone[1] = 38;
1896: cone[2] = 34;
1897: cone[3] = 31;
1898: cone[4] = 30;
1899: cone[5] = 19;
1900: cone[6] = 20;
1901: cone[7] = 28;
1902: PetscCall(DMPlexSetCone(dm, 8, cone));
1903: cone[0] = 35;
1904: cone[1] = 31;
1905: cone[2] = 32;
1906: cone[3] = 36;
1907: cone[4] = 30;
1908: cone[5] = 25;
1909: cone[6] = 22;
1910: cone[7] = 19;
1911: PetscCall(DMPlexSetCone(dm, 9, cone));
1913: cone[0] = 19;
1914: cone[1] = 20;
1915: cone[2] = 21;
1916: cone[3] = 22;
1917: cone[4] = 15;
1918: cone[5] = 16;
1919: cone[6] = 17;
1920: cone[7] = 18;
1921: PetscCall(DMPlexSetCone(dm, 10, cone));
1922: cone[0] = 22;
1923: cone[1] = 21;
1924: cone[2] = 26;
1925: cone[3] = 25;
1926: cone[4] = 16;
1927: cone[5] = 23;
1928: cone[6] = 24;
1929: cone[7] = 17;
1930: PetscCall(DMPlexSetCone(dm, 11, cone));
1931: cone[0] = 20;
1932: cone[1] = 28;
1933: cone[2] = 26;
1934: cone[3] = 21;
1935: cone[4] = 18;
1936: cone[5] = 17;
1937: cone[6] = 24;
1938: cone[7] = 27;
1939: PetscCall(DMPlexSetCone(dm, 12, cone));
1940: cone[0] = 30;
1941: cone[1] = 28;
1942: cone[2] = 20;
1943: cone[3] = 19;
1944: cone[4] = 29;
1945: cone[5] = 15;
1946: cone[6] = 18;
1947: cone[7] = 27;
1948: PetscCall(DMPlexSetCone(dm, 13, cone));
1949: cone[0] = 30;
1950: cone[1] = 19;
1951: cone[2] = 22;
1952: cone[3] = 25;
1953: cone[4] = 29;
1954: cone[5] = 23;
1955: cone[6] = 16;
1956: cone[7] = 15;
1957: PetscCall(DMPlexSetCone(dm, 14, cone));
1958: } else {
1959: cone[0] = 5;
1960: cone[1] = 8;
1961: cone[2] = 7;
1962: cone[3] = 6;
1963: cone[4] = 9;
1964: cone[5] = 12;
1965: cone[6] = 11;
1966: cone[7] = 10;
1967: PetscCall(DMPlexSetCone(dm, 0, cone));
1968: cone[0] = 6;
1969: cone[1] = 7;
1970: cone[2] = 14;
1971: cone[3] = 13;
1972: cone[4] = 12;
1973: cone[5] = 15;
1974: cone[6] = 16;
1975: cone[7] = 11;
1976: PetscCall(DMPlexSetCone(dm, 1, cone));
1977: cone[0] = 8;
1978: cone[1] = 17;
1979: cone[2] = 14;
1980: cone[3] = 7;
1981: cone[4] = 10;
1982: cone[5] = 11;
1983: cone[6] = 16;
1984: cone[7] = 18;
1985: PetscCall(DMPlexSetCone(dm, 2, cone));
1986: cone[0] = 19;
1987: cone[1] = 17;
1988: cone[2] = 8;
1989: cone[3] = 5;
1990: cone[4] = 20;
1991: cone[5] = 9;
1992: cone[6] = 10;
1993: cone[7] = 18;
1994: PetscCall(DMPlexSetCone(dm, 3, cone));
1995: cone[0] = 19;
1996: cone[1] = 5;
1997: cone[2] = 6;
1998: cone[3] = 13;
1999: cone[4] = 20;
2000: cone[5] = 15;
2001: cone[6] = 12;
2002: cone[7] = 9;
2003: PetscCall(DMPlexSetCone(dm, 4, cone));
2004: }
2005: }
2006: PetscCall(DMPlexSymmetrize(dm));
2007: PetscCall(DMPlexStratify(dm));
2008: }
2009: /* Create cube geometry */
2010: {
2011: Vec coordinates;
2012: PetscSection coordSection;
2013: PetscScalar *coords;
2014: PetscInt coordSize, v;
2015: const PetscReal dis = 1.0 / PetscSqrtReal(2.0);
2016: const PetscReal ds2 = dis / 2.0;
2018: /* Build coordinates */
2019: PetscCall(DMGetCoordinateSection(dm, &coordSection));
2020: PetscCall(PetscSectionSetNumFields(coordSection, 1));
2021: PetscCall(PetscSectionSetFieldComponents(coordSection, 0, dim));
2022: PetscCall(PetscSectionSetChart(coordSection, numCells, numCells + numVertices));
2023: for (v = numCells; v < numCells + numVertices; ++v) {
2024: PetscCall(PetscSectionSetDof(coordSection, v, dim));
2025: PetscCall(PetscSectionSetFieldDof(coordSection, v, 0, dim));
2026: }
2027: PetscCall(PetscSectionSetUp(coordSection));
2028: PetscCall(PetscSectionGetStorageSize(coordSection, &coordSize));
2029: PetscCall(VecCreate(PETSC_COMM_SELF, &coordinates));
2030: PetscCall(PetscObjectSetName((PetscObject)coordinates, "coordinates"));
2031: PetscCall(VecSetSizes(coordinates, coordSize, PETSC_DETERMINE));
2032: PetscCall(VecSetBlockSize(coordinates, dim));
2033: PetscCall(VecSetType(coordinates, VECSTANDARD));
2034: PetscCall(VecGetArray(coordinates, &coords));
2035: if (rank == 0) {
2036: coords[0 * dim + 0] = -ds2;
2037: coords[0 * dim + 1] = -ds2;
2038: coords[0 * dim + 2] = 0.0;
2039: coords[1 * dim + 0] = ds2;
2040: coords[1 * dim + 1] = -ds2;
2041: coords[1 * dim + 2] = 0.0;
2042: coords[2 * dim + 0] = ds2;
2043: coords[2 * dim + 1] = ds2;
2044: coords[2 * dim + 2] = 0.0;
2045: coords[3 * dim + 0] = -ds2;
2046: coords[3 * dim + 1] = ds2;
2047: coords[3 * dim + 2] = 0.0;
2048: coords[4 * dim + 0] = -ds2;
2049: coords[4 * dim + 1] = -ds2;
2050: coords[4 * dim + 2] = 1.0;
2051: coords[5 * dim + 0] = -ds2;
2052: coords[5 * dim + 1] = ds2;
2053: coords[5 * dim + 2] = 1.0;
2054: coords[6 * dim + 0] = ds2;
2055: coords[6 * dim + 1] = ds2;
2056: coords[6 * dim + 2] = 1.0;
2057: coords[7 * dim + 0] = ds2;
2058: coords[7 * dim + 1] = -ds2;
2059: coords[7 * dim + 2] = 1.0;
2060: coords[8 * dim + 0] = dis;
2061: coords[8 * dim + 1] = -dis;
2062: coords[8 * dim + 2] = 0.0;
2063: coords[9 * dim + 0] = dis;
2064: coords[9 * dim + 1] = dis;
2065: coords[9 * dim + 2] = 0.0;
2066: coords[10 * dim + 0] = dis;
2067: coords[10 * dim + 1] = -dis;
2068: coords[10 * dim + 2] = 1.0;
2069: coords[11 * dim + 0] = dis;
2070: coords[11 * dim + 1] = dis;
2071: coords[11 * dim + 2] = 1.0;
2072: coords[12 * dim + 0] = -dis;
2073: coords[12 * dim + 1] = dis;
2074: coords[12 * dim + 2] = 0.0;
2075: coords[13 * dim + 0] = -dis;
2076: coords[13 * dim + 1] = dis;
2077: coords[13 * dim + 2] = 1.0;
2078: coords[14 * dim + 0] = -dis;
2079: coords[14 * dim + 1] = -dis;
2080: coords[14 * dim + 2] = 0.0;
2081: coords[15 * dim + 0] = -dis;
2082: coords[15 * dim + 1] = -dis;
2083: coords[15 * dim + 2] = 1.0;
2084: if (periodicZ == DM_BOUNDARY_PERIODIC) {
2085: /* 15 31 19 */ coords[16 * dim + 0] = -ds2;
2086: coords[16 * dim + 1] = -ds2;
2087: coords[16 * dim + 2] = 0.5;
2088: /* 16 32 22 */ coords[17 * dim + 0] = ds2;
2089: coords[17 * dim + 1] = -ds2;
2090: coords[17 * dim + 2] = 0.5;
2091: /* 17 33 21 */ coords[18 * dim + 0] = ds2;
2092: coords[18 * dim + 1] = ds2;
2093: coords[18 * dim + 2] = 0.5;
2094: /* 18 34 20 */ coords[19 * dim + 0] = -ds2;
2095: coords[19 * dim + 1] = ds2;
2096: coords[19 * dim + 2] = 0.5;
2097: /* 29 35 30 */ coords[20 * dim + 0] = -dis;
2098: coords[20 * dim + 1] = -dis;
2099: coords[20 * dim + 2] = 0.5;
2100: /* 23 36 25 */ coords[21 * dim + 0] = dis;
2101: coords[21 * dim + 1] = -dis;
2102: coords[21 * dim + 2] = 0.5;
2103: /* 24 37 26 */ coords[22 * dim + 0] = dis;
2104: coords[22 * dim + 1] = dis;
2105: coords[22 * dim + 2] = 0.5;
2106: /* 27 38 28 */ coords[23 * dim + 0] = -dis;
2107: coords[23 * dim + 1] = dis;
2108: coords[23 * dim + 2] = 0.5;
2109: }
2110: }
2111: PetscCall(VecRestoreArray(coordinates, &coords));
2112: PetscCall(DMSetCoordinatesLocal(dm, coordinates));
2113: PetscCall(VecDestroy(&coordinates));
2114: }
2115: /* Create periodicity */
2116: if (periodicZ == DM_BOUNDARY_PERIODIC || periodicZ == DM_BOUNDARY_TWIST) {
2117: PetscReal L[3] = {-1., -1., 0.};
2118: PetscReal maxCell[3] = {-1., -1., 0.};
2119: PetscReal lower[3] = {0.0, 0.0, 0.0};
2120: PetscReal upper[3] = {1.0, 1.0, 1.5};
2121: PetscInt numZCells = 3;
2123: L[2] = upper[2] - lower[2];
2124: maxCell[2] = 1.1 * (L[2] / numZCells);
2125: PetscCall(DMSetPeriodicity(dm, maxCell, lower, L));
2126: }
2127: {
2128: DM cdm;
2129: PetscDS cds;
2130: PetscScalar c[2] = {1.0, 1.0};
2132: PetscCall(DMPlexCreateCoordinateSpace(dm, 1, PETSC_TRUE, snapToCylinder));
2133: PetscCall(DMGetCoordinateDM(dm, &cdm));
2134: PetscCall(DMGetDS(cdm, &cds));
2135: PetscCall(PetscDSSetConstants(cds, 2, c));
2136: }
2137: PetscCall(PetscLogEventEnd(DMPLEX_Generate, dm, 0, 0, 0));
2139: /* Wait for coordinate creation before doing in-place modification */
2140: PetscCall(DMPlexInterpolateInPlace_Internal(dm));
2141: PetscFunctionReturn(PETSC_SUCCESS);
2142: }
2144: /*@
2145: DMPlexCreateHexCylinderMesh - Creates a mesh on the tensor product of the unit interval with the circle (cylinder) using hexahedra.
2147: Collective
2149: Input Parameters:
2150: + comm - The communicator for the `DM` object
2151: - periodicZ - The boundary type for the Z direction
2153: Output Parameter:
2154: . dm - The `DM` object
2156: Level: beginner
2158: Note:
2159: Here is the output numbering looking from the bottom of the cylinder\:
2160: .vb
2161: 17-----14
2162: | |
2163: | 2 |
2164: | |
2165: 17-----8-----7-----14
2166: | | | |
2167: | 3 | 0 | 1 |
2168: | | | |
2169: 19-----5-----6-----13
2170: | |
2171: | 4 |
2172: | |
2173: 19-----13
2175: and up through the top
2177: 18-----16
2178: | |
2179: | 2 |
2180: | |
2181: 18----10----11-----16
2182: | | | |
2183: | 3 | 0 | 1 |
2184: | | | |
2185: 20-----9----12-----15
2186: | |
2187: | 4 |
2188: | |
2189: 20-----15
2190: .ve
2192: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexCreateBoxMesh()`, `DMSetType()`, `DMCreate()`
2193: @*/
2194: PetscErrorCode DMPlexCreateHexCylinderMesh(MPI_Comm comm, DMBoundaryType periodicZ, DM *dm)
2195: {
2196: PetscFunctionBegin;
2197: PetscAssertPointer(dm, 3);
2198: PetscCall(DMCreate(comm, dm));
2199: PetscCall(DMSetType(*dm, DMPLEX));
2200: PetscCall(DMPlexCreateHexCylinderMesh_Internal(*dm, periodicZ));
2201: PetscFunctionReturn(PETSC_SUCCESS);
2202: }
2204: static PetscErrorCode DMPlexCreateWedgeCylinderMesh_Internal(DM dm, PetscInt n, PetscBool interpolate)
2205: {
2206: const PetscInt dim = 3;
2207: PetscInt numCells, numVertices, v;
2208: PetscMPIInt rank;
2210: PetscFunctionBegin;
2211: PetscCheck(n >= 0, PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_OUTOFRANGE, "Number of wedges %" PetscInt_FMT " cannot be negative", n);
2212: PetscCall(PetscLogEventBegin(DMPLEX_Generate, dm, 0, 0, 0));
2213: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank));
2214: PetscCall(DMSetDimension(dm, dim));
2215: /* Must create the celltype label here so that we do not automatically try to compute the types */
2216: PetscCall(DMCreateLabel(dm, "celltype"));
2217: /* Create topology */
2218: {
2219: PetscInt cone[6], c;
2221: numCells = rank == 0 ? n : 0;
2222: numVertices = rank == 0 ? 2 * (n + 1) : 0;
2223: PetscCall(DMPlexSetChart(dm, 0, numCells + numVertices));
2224: for (c = 0; c < numCells; c++) PetscCall(DMPlexSetConeSize(dm, c, 6));
2225: PetscCall(DMSetUp(dm));
2226: for (c = 0; c < numCells; c++) {
2227: cone[0] = c + n * 1;
2228: cone[1] = (c + 1) % n + n * 1;
2229: cone[2] = 0 + 3 * n;
2230: cone[3] = c + n * 2;
2231: cone[4] = (c + 1) % n + n * 2;
2232: cone[5] = 1 + 3 * n;
2233: PetscCall(DMPlexSetCone(dm, c, cone));
2234: PetscCall(DMPlexSetCellType(dm, c, DM_POLYTOPE_TRI_PRISM_TENSOR));
2235: }
2236: PetscCall(DMPlexSymmetrize(dm));
2237: PetscCall(DMPlexStratify(dm));
2238: }
2239: for (v = numCells; v < numCells + numVertices; ++v) PetscCall(DMPlexSetCellType(dm, v, DM_POLYTOPE_POINT));
2240: /* Create cylinder geometry */
2241: {
2242: Vec coordinates;
2243: PetscSection coordSection;
2244: PetscScalar *coords;
2245: PetscInt coordSize, c;
2247: /* Build coordinates */
2248: PetscCall(DMGetCoordinateSection(dm, &coordSection));
2249: PetscCall(PetscSectionSetNumFields(coordSection, 1));
2250: PetscCall(PetscSectionSetFieldComponents(coordSection, 0, dim));
2251: PetscCall(PetscSectionSetChart(coordSection, numCells, numCells + numVertices));
2252: for (v = numCells; v < numCells + numVertices; ++v) {
2253: PetscCall(PetscSectionSetDof(coordSection, v, dim));
2254: PetscCall(PetscSectionSetFieldDof(coordSection, v, 0, dim));
2255: }
2256: PetscCall(PetscSectionSetUp(coordSection));
2257: PetscCall(PetscSectionGetStorageSize(coordSection, &coordSize));
2258: PetscCall(VecCreate(PETSC_COMM_SELF, &coordinates));
2259: PetscCall(PetscObjectSetName((PetscObject)coordinates, "coordinates"));
2260: PetscCall(VecSetSizes(coordinates, coordSize, PETSC_DETERMINE));
2261: PetscCall(VecSetBlockSize(coordinates, dim));
2262: PetscCall(VecSetType(coordinates, VECSTANDARD));
2263: PetscCall(VecGetArray(coordinates, &coords));
2264: for (c = 0; c < numCells; c++) {
2265: coords[(c + 0 * n) * dim + 0] = PetscCosReal(2.0 * c * PETSC_PI / n);
2266: coords[(c + 0 * n) * dim + 1] = PetscSinReal(2.0 * c * PETSC_PI / n);
2267: coords[(c + 0 * n) * dim + 2] = 1.0;
2268: coords[(c + 1 * n) * dim + 0] = PetscCosReal(2.0 * c * PETSC_PI / n);
2269: coords[(c + 1 * n) * dim + 1] = PetscSinReal(2.0 * c * PETSC_PI / n);
2270: coords[(c + 1 * n) * dim + 2] = 0.0;
2271: }
2272: if (rank == 0) {
2273: coords[(2 * n + 0) * dim + 0] = 0.0;
2274: coords[(2 * n + 0) * dim + 1] = 0.0;
2275: coords[(2 * n + 0) * dim + 2] = 1.0;
2276: coords[(2 * n + 1) * dim + 0] = 0.0;
2277: coords[(2 * n + 1) * dim + 1] = 0.0;
2278: coords[(2 * n + 1) * dim + 2] = 0.0;
2279: }
2280: PetscCall(VecRestoreArray(coordinates, &coords));
2281: PetscCall(DMSetCoordinatesLocal(dm, coordinates));
2282: PetscCall(VecDestroy(&coordinates));
2283: }
2284: PetscCall(PetscLogEventEnd(DMPLEX_Generate, dm, 0, 0, 0));
2285: /* Interpolate */
2286: if (interpolate) PetscCall(DMPlexInterpolateInPlace_Internal(dm));
2287: PetscFunctionReturn(PETSC_SUCCESS);
2288: }
2290: /*@
2291: DMPlexCreateWedgeCylinderMesh - Creates a mesh on the tensor product of the unit interval with the circle (cylinder) using wedges.
2293: Collective
2295: Input Parameters:
2296: + comm - The communicator for the `DM` object
2297: . n - The number of wedges around the origin
2298: - interpolate - Create edges and faces
2300: Output Parameter:
2301: . dm - The `DM` object
2303: Level: beginner
2305: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexCreateHexCylinderMesh()`, `DMPlexCreateBoxMesh()`, `DMSetType()`, `DMCreate()`
2306: @*/
2307: PetscErrorCode DMPlexCreateWedgeCylinderMesh(MPI_Comm comm, PetscInt n, PetscBool interpolate, DM *dm)
2308: {
2309: PetscFunctionBegin;
2310: PetscAssertPointer(dm, 4);
2311: PetscCall(DMCreate(comm, dm));
2312: PetscCall(DMSetType(*dm, DMPLEX));
2313: PetscCall(DMPlexCreateWedgeCylinderMesh_Internal(*dm, n, interpolate));
2314: PetscFunctionReturn(PETSC_SUCCESS);
2315: }
2317: static inline PetscReal DiffNormReal(PetscInt dim, const PetscReal x[], const PetscReal y[])
2318: {
2319: PetscReal prod = 0.0;
2320: PetscInt i;
2321: for (i = 0; i < dim; ++i) prod += PetscSqr(x[i] - y[i]);
2322: return PetscSqrtReal(prod);
2323: }
2325: static inline PetscReal DotReal(PetscInt dim, const PetscReal x[], const PetscReal y[])
2326: {
2327: PetscReal prod = 0.0;
2328: PetscInt i;
2329: for (i = 0; i < dim; ++i) prod += x[i] * y[i];
2330: return prod;
2331: }
2333: /* The first constant is the sphere radius */
2334: static void snapToSphere(PetscInt dim, PetscInt Nf, PetscInt NfAux, const PetscInt uOff[], const PetscInt uOff_x[], const PetscScalar u[], const PetscScalar u_t[], const PetscScalar u_x[], const PetscInt aOff[], const PetscInt aOff_x[], const PetscScalar a[], const PetscScalar a_t[], const PetscScalar a_x[], PetscReal t, const PetscReal x[], PetscInt numConstants, const PetscScalar constants[], PetscScalar f0[])
2335: {
2336: PetscReal r = PetscRealPart(constants[0]);
2337: PetscReal norm2 = 0.0, fac;
2338: PetscInt n = uOff[1] - uOff[0], d;
2340: for (d = 0; d < n; ++d) norm2 += PetscSqr(PetscRealPart(u[d]));
2341: fac = r / PetscSqrtReal(norm2);
2342: for (d = 0; d < n; ++d) f0[d] = u[d] * fac;
2343: }
2345: static PetscErrorCode DMPlexCreateSphereMesh_Internal(DM dm, PetscInt dim, PetscBool simplex, PetscReal R)
2346: {
2347: const PetscInt embedDim = dim + 1;
2348: PetscSection coordSection;
2349: Vec coordinates;
2350: PetscScalar *coords;
2351: PetscReal *coordsIn;
2352: PetscInt numCells, numEdges, numVerts = 0, firstVertex = 0, v, firstEdge, coordSize, d, e;
2353: PetscMPIInt rank;
2355: PetscFunctionBegin;
2357: PetscCall(PetscLogEventBegin(DMPLEX_Generate, dm, 0, 0, 0));
2358: PetscCall(DMSetDimension(dm, dim));
2359: PetscCall(DMSetCoordinateDim(dm, dim + 1));
2360: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank));
2361: switch (dim) {
2362: case 1:
2363: numCells = 16;
2364: numVerts = numCells;
2366: // Build Topology
2367: PetscCall(DMPlexSetChart(dm, 0, numCells + numVerts));
2368: for (PetscInt c = 0; c < numCells; c++) PetscCall(DMPlexSetConeSize(dm, c, embedDim));
2369: PetscCall(DMSetUp(dm));
2370: for (PetscInt c = 0; c < numCells; ++c) {
2371: PetscInt cone[2];
2373: cone[0] = c + numCells;
2374: cone[1] = (c + 1) % numVerts + numCells;
2375: PetscCall(DMPlexSetCone(dm, c, cone));
2376: }
2377: PetscCall(DMPlexSymmetrize(dm));
2378: PetscCall(DMPlexStratify(dm));
2379: PetscCall(PetscMalloc1(numVerts * embedDim, &coordsIn));
2380: for (PetscInt v = 0; v < numVerts; ++v) {
2381: const PetscReal rad = 2. * PETSC_PI * v / numVerts;
2383: coordsIn[v * embedDim + 0] = PetscCosReal(rad);
2384: coordsIn[v * embedDim + 1] = PetscSinReal(rad);
2385: }
2386: break;
2387: case 2:
2388: if (simplex) {
2389: const PetscReal radius = PetscSqrtReal(1 + PETSC_PHI * PETSC_PHI) / (1.0 + PETSC_PHI);
2390: const PetscReal edgeLen = 2.0 / (1.0 + PETSC_PHI) * (R / radius);
2391: const PetscInt degree = 5;
2392: PetscReal vertex[3] = {0.0, 1.0 / (1.0 + PETSC_PHI), PETSC_PHI / (1.0 + PETSC_PHI)};
2393: PetscInt s[3] = {1, 1, 1};
2394: PetscInt cone[3];
2395: PetscInt *graph;
2397: vertex[0] *= R / radius;
2398: vertex[1] *= R / radius;
2399: vertex[2] *= R / radius;
2400: numCells = rank == 0 ? 20 : 0;
2401: numVerts = rank == 0 ? 12 : 0;
2402: firstVertex = numCells;
2403: /* Use icosahedron, which for a R-sphere has coordinates which are all cyclic permutations of
2405: (0, \pm 1/\phi+1, \pm \phi/\phi+1)
2407: where \phi^2 - \phi - 1 = 0, meaning \phi is the golden ratio \frac{1 + \sqrt{5}}{2}. The edge
2408: length is then given by 2/(1+\phi) = 2 * 0.38197 = 0.76393.
2409: */
2410: /* Construct vertices */
2411: PetscCall(PetscCalloc1(numVerts * embedDim, &coordsIn));
2412: if (rank == 0) {
2413: for (PetscInt p = 0, i = 0; p < embedDim; ++p) {
2414: for (s[1] = -1; s[1] < 2; s[1] += 2) {
2415: for (s[2] = -1; s[2] < 2; s[2] += 2) {
2416: for (d = 0; d < embedDim; ++d) coordsIn[i * embedDim + d] = s[(d + p) % embedDim] * vertex[(d + p) % embedDim];
2417: ++i;
2418: }
2419: }
2420: }
2421: }
2422: /* Construct graph */
2423: PetscCall(PetscCalloc1(numVerts * numVerts, &graph));
2424: for (PetscInt i = 0; i < numVerts; ++i) {
2425: PetscInt k = 0;
2426: for (PetscInt j = 0; j < numVerts; ++j) {
2427: if (PetscAbsReal(DiffNormReal(embedDim, &coordsIn[i * embedDim], &coordsIn[j * embedDim]) - edgeLen) < PETSC_SMALL) {
2428: graph[i * numVerts + j] = 1;
2429: ++k;
2430: }
2431: }
2432: PetscCheck(k == degree, PetscObjectComm((PetscObject)dm), PETSC_ERR_PLIB, "Invalid icosahedron, vertex %" PetscInt_FMT " degree %" PetscInt_FMT " != %" PetscInt_FMT, i, k, degree);
2433: }
2434: /* Build Topology */
2435: PetscCall(DMPlexSetChart(dm, 0, numCells + numVerts));
2436: for (PetscInt c = 0; c < numCells; c++) PetscCall(DMPlexSetConeSize(dm, c, embedDim));
2437: PetscCall(DMSetUp(dm)); /* Allocate space for cones */
2438: /* Cells */
2439: for (PetscInt i = 0, c = 0; i < numVerts; ++i) {
2440: for (PetscInt j = 0; j < i; ++j) {
2441: for (PetscInt k = 0; k < j; ++k) {
2442: if (graph[i * numVerts + j] && graph[j * numVerts + k] && graph[k * numVerts + i]) {
2443: cone[0] = firstVertex + i;
2444: cone[1] = firstVertex + j;
2445: cone[2] = firstVertex + k;
2446: /* Check orientation */
2447: {
2448: const PetscInt epsilon[3][3][3] = {
2449: {{0, 0, 0}, {0, 0, 1}, {0, -1, 0}},
2450: {{0, 0, -1}, {0, 0, 0}, {1, 0, 0} },
2451: {{0, 1, 0}, {-1, 0, 0}, {0, 0, 0} }
2452: };
2453: PetscReal normal[3];
2454: PetscInt e, f;
2456: for (d = 0; d < embedDim; ++d) {
2457: normal[d] = 0.0;
2458: for (e = 0; e < embedDim; ++e) {
2459: for (f = 0; f < embedDim; ++f) normal[d] += epsilon[d][e][f] * (coordsIn[j * embedDim + e] - coordsIn[i * embedDim + e]) * (coordsIn[k * embedDim + f] - coordsIn[i * embedDim + f]);
2460: }
2461: }
2462: if (DotReal(embedDim, normal, &coordsIn[i * embedDim]) < 0) {
2463: PetscInt tmp = cone[1];
2464: cone[1] = cone[2];
2465: cone[2] = tmp;
2466: }
2467: }
2468: PetscCall(DMPlexSetCone(dm, c++, cone));
2469: }
2470: }
2471: }
2472: }
2473: PetscCall(DMPlexSymmetrize(dm));
2474: PetscCall(DMPlexStratify(dm));
2475: PetscCall(PetscFree(graph));
2476: } else {
2477: /*
2478: 12-21--13
2479: | |
2480: 25 4 24
2481: | |
2482: 12-25--9-16--8-24--13
2483: | | | |
2484: 23 5 17 0 15 3 22
2485: | | | |
2486: 10-20--6-14--7-19--11
2487: | |
2488: 20 1 19
2489: | |
2490: 10-18--11
2491: | |
2492: 23 2 22
2493: | |
2494: 12-21--13
2495: */
2496: PetscInt cone[4], ornt[4];
2498: numCells = rank == 0 ? 6 : 0;
2499: numEdges = rank == 0 ? 12 : 0;
2500: numVerts = rank == 0 ? 8 : 0;
2501: firstVertex = numCells;
2502: firstEdge = numCells + numVerts;
2503: /* Build Topology */
2504: PetscCall(DMPlexSetChart(dm, 0, numCells + numEdges + numVerts));
2505: for (PetscInt c = 0; c < numCells; c++) PetscCall(DMPlexSetConeSize(dm, c, 4));
2506: for (e = firstEdge; e < firstEdge + numEdges; ++e) PetscCall(DMPlexSetConeSize(dm, e, 2));
2507: PetscCall(DMSetUp(dm)); /* Allocate space for cones */
2508: if (rank == 0) {
2509: /* Cell 0 */
2510: cone[0] = 14;
2511: cone[1] = 15;
2512: cone[2] = 16;
2513: cone[3] = 17;
2514: PetscCall(DMPlexSetCone(dm, 0, cone));
2515: ornt[0] = 0;
2516: ornt[1] = 0;
2517: ornt[2] = 0;
2518: ornt[3] = 0;
2519: PetscCall(DMPlexSetConeOrientation(dm, 0, ornt));
2520: /* Cell 1 */
2521: cone[0] = 18;
2522: cone[1] = 19;
2523: cone[2] = 14;
2524: cone[3] = 20;
2525: PetscCall(DMPlexSetCone(dm, 1, cone));
2526: ornt[0] = 0;
2527: ornt[1] = 0;
2528: ornt[2] = -1;
2529: ornt[3] = 0;
2530: PetscCall(DMPlexSetConeOrientation(dm, 1, ornt));
2531: /* Cell 2 */
2532: cone[0] = 21;
2533: cone[1] = 22;
2534: cone[2] = 18;
2535: cone[3] = 23;
2536: PetscCall(DMPlexSetCone(dm, 2, cone));
2537: ornt[0] = 0;
2538: ornt[1] = 0;
2539: ornt[2] = -1;
2540: ornt[3] = 0;
2541: PetscCall(DMPlexSetConeOrientation(dm, 2, ornt));
2542: /* Cell 3 */
2543: cone[0] = 19;
2544: cone[1] = 22;
2545: cone[2] = 24;
2546: cone[3] = 15;
2547: PetscCall(DMPlexSetCone(dm, 3, cone));
2548: ornt[0] = -1;
2549: ornt[1] = -1;
2550: ornt[2] = 0;
2551: ornt[3] = -1;
2552: PetscCall(DMPlexSetConeOrientation(dm, 3, ornt));
2553: /* Cell 4 */
2554: cone[0] = 16;
2555: cone[1] = 24;
2556: cone[2] = 21;
2557: cone[3] = 25;
2558: PetscCall(DMPlexSetCone(dm, 4, cone));
2559: ornt[0] = -1;
2560: ornt[1] = -1;
2561: ornt[2] = -1;
2562: ornt[3] = 0;
2563: PetscCall(DMPlexSetConeOrientation(dm, 4, ornt));
2564: /* Cell 5 */
2565: cone[0] = 20;
2566: cone[1] = 17;
2567: cone[2] = 25;
2568: cone[3] = 23;
2569: PetscCall(DMPlexSetCone(dm, 5, cone));
2570: ornt[0] = -1;
2571: ornt[1] = -1;
2572: ornt[2] = -1;
2573: ornt[3] = -1;
2574: PetscCall(DMPlexSetConeOrientation(dm, 5, ornt));
2575: /* Edges */
2576: cone[0] = 6;
2577: cone[1] = 7;
2578: PetscCall(DMPlexSetCone(dm, 14, cone));
2579: cone[0] = 7;
2580: cone[1] = 8;
2581: PetscCall(DMPlexSetCone(dm, 15, cone));
2582: cone[0] = 8;
2583: cone[1] = 9;
2584: PetscCall(DMPlexSetCone(dm, 16, cone));
2585: cone[0] = 9;
2586: cone[1] = 6;
2587: PetscCall(DMPlexSetCone(dm, 17, cone));
2588: cone[0] = 10;
2589: cone[1] = 11;
2590: PetscCall(DMPlexSetCone(dm, 18, cone));
2591: cone[0] = 11;
2592: cone[1] = 7;
2593: PetscCall(DMPlexSetCone(dm, 19, cone));
2594: cone[0] = 6;
2595: cone[1] = 10;
2596: PetscCall(DMPlexSetCone(dm, 20, cone));
2597: cone[0] = 12;
2598: cone[1] = 13;
2599: PetscCall(DMPlexSetCone(dm, 21, cone));
2600: cone[0] = 13;
2601: cone[1] = 11;
2602: PetscCall(DMPlexSetCone(dm, 22, cone));
2603: cone[0] = 10;
2604: cone[1] = 12;
2605: PetscCall(DMPlexSetCone(dm, 23, cone));
2606: cone[0] = 13;
2607: cone[1] = 8;
2608: PetscCall(DMPlexSetCone(dm, 24, cone));
2609: cone[0] = 12;
2610: cone[1] = 9;
2611: PetscCall(DMPlexSetCone(dm, 25, cone));
2612: }
2613: PetscCall(DMPlexSymmetrize(dm));
2614: PetscCall(DMPlexStratify(dm));
2615: /* Build coordinates */
2616: PetscCall(PetscCalloc1(numVerts * embedDim, &coordsIn));
2617: if (rank == 0) {
2618: coordsIn[0 * embedDim + 0] = -R;
2619: coordsIn[0 * embedDim + 1] = R;
2620: coordsIn[0 * embedDim + 2] = -R;
2621: coordsIn[1 * embedDim + 0] = R;
2622: coordsIn[1 * embedDim + 1] = R;
2623: coordsIn[1 * embedDim + 2] = -R;
2624: coordsIn[2 * embedDim + 0] = R;
2625: coordsIn[2 * embedDim + 1] = -R;
2626: coordsIn[2 * embedDim + 2] = -R;
2627: coordsIn[3 * embedDim + 0] = -R;
2628: coordsIn[3 * embedDim + 1] = -R;
2629: coordsIn[3 * embedDim + 2] = -R;
2630: coordsIn[4 * embedDim + 0] = -R;
2631: coordsIn[4 * embedDim + 1] = R;
2632: coordsIn[4 * embedDim + 2] = R;
2633: coordsIn[5 * embedDim + 0] = R;
2634: coordsIn[5 * embedDim + 1] = R;
2635: coordsIn[5 * embedDim + 2] = R;
2636: coordsIn[6 * embedDim + 0] = -R;
2637: coordsIn[6 * embedDim + 1] = -R;
2638: coordsIn[6 * embedDim + 2] = R;
2639: coordsIn[7 * embedDim + 0] = R;
2640: coordsIn[7 * embedDim + 1] = -R;
2641: coordsIn[7 * embedDim + 2] = R;
2642: }
2643: }
2644: break;
2645: case 3:
2646: if (simplex) {
2647: const PetscReal edgeLen = 1.0 / PETSC_PHI;
2648: PetscReal vertexA[4] = {0.5, 0.5, 0.5, 0.5};
2649: PetscReal vertexB[4] = {1.0, 0.0, 0.0, 0.0};
2650: PetscReal vertexC[4] = {0.5, 0.5 * PETSC_PHI, 0.5 / PETSC_PHI, 0.0};
2651: const PetscInt degree = 12;
2652: PetscInt s[4] = {1, 1, 1};
2653: PetscInt evenPerm[12][4] = {
2654: {0, 1, 2, 3},
2655: {0, 2, 3, 1},
2656: {0, 3, 1, 2},
2657: {1, 0, 3, 2},
2658: {1, 2, 0, 3},
2659: {1, 3, 2, 0},
2660: {2, 0, 1, 3},
2661: {2, 1, 3, 0},
2662: {2, 3, 0, 1},
2663: {3, 0, 2, 1},
2664: {3, 1, 0, 2},
2665: {3, 2, 1, 0}
2666: };
2667: PetscInt cone[4];
2668: PetscInt *graph, p, i, j, k, l;
2670: vertexA[0] *= R;
2671: vertexA[1] *= R;
2672: vertexA[2] *= R;
2673: vertexA[3] *= R;
2674: vertexB[0] *= R;
2675: vertexB[1] *= R;
2676: vertexB[2] *= R;
2677: vertexB[3] *= R;
2678: vertexC[0] *= R;
2679: vertexC[1] *= R;
2680: vertexC[2] *= R;
2681: vertexC[3] *= R;
2682: numCells = rank == 0 ? 600 : 0;
2683: numVerts = rank == 0 ? 120 : 0;
2684: firstVertex = numCells;
2685: /* Use the 600-cell, which for a unit sphere has coordinates which are
2687: 1/2 (\pm 1, \pm 1, \pm 1, \pm 1) 16
2688: (\pm 1, 0, 0, 0) all cyclic permutations 8
2689: 1/2 (\pm 1, \pm phi, \pm 1/phi, 0) all even permutations 96
2691: where \phi^2 - \phi - 1 = 0, meaning \phi is the golden ratio \frac{1 + \sqrt{5}}{2}. The edge
2692: length is then given by 1/\phi = 0.61803.
2694: http://buzzard.pugetsound.edu/sage-practice/ch03s03.html
2695: http://mathworld.wolfram.com/600-Cell.html
2696: */
2697: /* Construct vertices */
2698: PetscCall(PetscCalloc1(numVerts * embedDim, &coordsIn));
2699: i = 0;
2700: if (rank == 0) {
2701: for (s[0] = -1; s[0] < 2; s[0] += 2) {
2702: for (s[1] = -1; s[1] < 2; s[1] += 2) {
2703: for (s[2] = -1; s[2] < 2; s[2] += 2) {
2704: for (s[3] = -1; s[3] < 2; s[3] += 2) {
2705: for (d = 0; d < embedDim; ++d) coordsIn[i * embedDim + d] = s[d] * vertexA[d];
2706: ++i;
2707: }
2708: }
2709: }
2710: }
2711: for (p = 0; p < embedDim; ++p) {
2712: s[1] = s[2] = s[3] = 1;
2713: for (s[0] = -1; s[0] < 2; s[0] += 2) {
2714: for (d = 0; d < embedDim; ++d) coordsIn[i * embedDim + d] = s[(d + p) % embedDim] * vertexB[(d + p) % embedDim];
2715: ++i;
2716: }
2717: }
2718: for (p = 0; p < 12; ++p) {
2719: s[3] = 1;
2720: for (s[0] = -1; s[0] < 2; s[0] += 2) {
2721: for (s[1] = -1; s[1] < 2; s[1] += 2) {
2722: for (s[2] = -1; s[2] < 2; s[2] += 2) {
2723: for (d = 0; d < embedDim; ++d) coordsIn[i * embedDim + d] = s[evenPerm[p][d]] * vertexC[evenPerm[p][d]];
2724: ++i;
2725: }
2726: }
2727: }
2728: }
2729: }
2730: PetscCheck(i == numVerts, PetscObjectComm((PetscObject)dm), PETSC_ERR_PLIB, "Invalid 600-cell, vertices %" PetscInt_FMT " != %" PetscInt_FMT, i, numVerts);
2731: /* Construct graph */
2732: PetscCall(PetscCalloc1(numVerts * numVerts, &graph));
2733: for (i = 0; i < numVerts; ++i) {
2734: for (j = 0, k = 0; j < numVerts; ++j) {
2735: if (PetscAbsReal(DiffNormReal(embedDim, &coordsIn[i * embedDim], &coordsIn[j * embedDim]) - edgeLen) < PETSC_SMALL) {
2736: graph[i * numVerts + j] = 1;
2737: ++k;
2738: }
2739: }
2740: PetscCheck(k == degree, PetscObjectComm((PetscObject)dm), PETSC_ERR_PLIB, "Invalid 600-cell, vertex %" PetscInt_FMT " degree %" PetscInt_FMT " != %" PetscInt_FMT, i, k, degree);
2741: }
2742: /* Build Topology */
2743: PetscCall(DMPlexSetChart(dm, 0, numCells + numVerts));
2744: for (PetscInt c = 0; c < numCells; c++) PetscCall(DMPlexSetConeSize(dm, c, embedDim));
2745: PetscCall(DMSetUp(dm)); /* Allocate space for cones */
2746: /* Cells */
2747: if (rank == 0) {
2748: for (PetscInt i = 0, c = 0; i < numVerts; ++i) {
2749: for (j = 0; j < i; ++j) {
2750: for (k = 0; k < j; ++k) {
2751: for (l = 0; l < k; ++l) {
2752: if (graph[i * numVerts + j] && graph[j * numVerts + k] && graph[k * numVerts + i] && graph[l * numVerts + i] && graph[l * numVerts + j] && graph[l * numVerts + k]) {
2753: cone[0] = firstVertex + i;
2754: cone[1] = firstVertex + j;
2755: cone[2] = firstVertex + k;
2756: cone[3] = firstVertex + l;
2757: /* Check orientation: https://ef.gy/linear-algebra:normal-vectors-in-higher-dimensional-spaces */
2758: {
2759: const PetscInt epsilon[4][4][4][4] = {
2760: {{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}, {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 1}, {0, 0, -1, 0}}, {{0, 0, 0, 0}, {0, 0, 0, -1}, {0, 0, 0, 0}, {0, 1, 0, 0}}, {{0, 0, 0, 0}, {0, 0, 1, 0}, {0, -1, 0, 0}, {0, 0, 0, 0}}},
2762: {{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, -1}, {0, 0, 1, 0}}, {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}, {{0, 0, 0, 1}, {0, 0, 0, 0}, {0, 0, 0, 0}, {-1, 0, 0, 0}}, {{0, 0, -1, 0}, {0, 0, 0, 0}, {1, 0, 0, 0}, {0, 0, 0, 0}}},
2764: {{{0, 0, 0, 0}, {0, 0, 0, 1}, {0, 0, 0, 0}, {0, -1, 0, 0}}, {{0, 0, 0, -1}, {0, 0, 0, 0}, {0, 0, 0, 0}, {1, 0, 0, 0}}, {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}, {{0, 1, 0, 0}, {-1, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}},
2766: {{{0, 0, 0, 0}, {0, 0, -1, 0}, {0, 1, 0, 0}, {0, 0, 0, 0}}, {{0, 0, 1, 0}, {0, 0, 0, 0}, {-1, 0, 0, 0}, {0, 0, 0, 0}}, {{0, -1, 0, 0}, {1, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}, {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}} }
2767: };
2768: PetscReal normal[4];
2769: PetscInt e, f, g;
2771: for (d = 0; d < embedDim; ++d) {
2772: normal[d] = 0.0;
2773: for (e = 0; e < embedDim; ++e) {
2774: for (f = 0; f < embedDim; ++f) {
2775: for (g = 0; g < embedDim; ++g) {
2776: 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]);
2777: }
2778: }
2779: }
2780: }
2781: if (DotReal(embedDim, normal, &coordsIn[i * embedDim]) < 0) {
2782: PetscInt tmp = cone[1];
2783: cone[1] = cone[2];
2784: cone[2] = tmp;
2785: }
2786: }
2787: PetscCall(DMPlexSetCone(dm, c++, cone));
2788: }
2789: }
2790: }
2791: }
2792: }
2793: }
2794: PetscCall(DMPlexSymmetrize(dm));
2795: PetscCall(DMPlexStratify(dm));
2796: PetscCall(PetscFree(graph));
2797: }
2798: break;
2799: default:
2800: SETERRQ(PetscObjectComm((PetscObject)dm), PETSC_ERR_SUP, "Unsupported dimension for sphere: %" PetscInt_FMT, dim);
2801: }
2802: /* Create coordinates */
2803: PetscCall(DMGetCoordinateSection(dm, &coordSection));
2804: PetscCall(PetscSectionSetNumFields(coordSection, 1));
2805: PetscCall(PetscSectionSetFieldComponents(coordSection, 0, embedDim));
2806: PetscCall(PetscSectionSetChart(coordSection, firstVertex, firstVertex + numVerts));
2807: for (v = firstVertex; v < firstVertex + numVerts; ++v) {
2808: PetscCall(PetscSectionSetDof(coordSection, v, embedDim));
2809: PetscCall(PetscSectionSetFieldDof(coordSection, v, 0, embedDim));
2810: }
2811: PetscCall(PetscSectionSetUp(coordSection));
2812: PetscCall(PetscSectionGetStorageSize(coordSection, &coordSize));
2813: PetscCall(VecCreate(PETSC_COMM_SELF, &coordinates));
2814: PetscCall(VecSetBlockSize(coordinates, embedDim));
2815: PetscCall(PetscObjectSetName((PetscObject)coordinates, "coordinates"));
2816: PetscCall(VecSetSizes(coordinates, coordSize, PETSC_DETERMINE));
2817: PetscCall(VecSetType(coordinates, VECSTANDARD));
2818: PetscCall(VecGetArray(coordinates, &coords));
2819: for (v = 0; v < numVerts; ++v)
2820: for (d = 0; d < embedDim; ++d) coords[v * embedDim + d] = coordsIn[v * embedDim + d];
2821: PetscCall(VecRestoreArray(coordinates, &coords));
2822: PetscCall(DMSetCoordinatesLocal(dm, coordinates));
2823: PetscCall(VecDestroy(&coordinates));
2824: PetscCall(PetscFree(coordsIn));
2825: {
2826: DM cdm;
2827: PetscDS cds;
2828: PetscScalar c = R;
2830: PetscCall(DMPlexCreateCoordinateSpace(dm, 1, PETSC_TRUE, snapToSphere));
2831: PetscCall(DMGetCoordinateDM(dm, &cdm));
2832: PetscCall(DMGetDS(cdm, &cds));
2833: PetscCall(PetscDSSetConstants(cds, 1, &c));
2834: }
2835: PetscCall(PetscLogEventEnd(DMPLEX_Generate, dm, 0, 0, 0));
2836: /* Wait for coordinate creation before doing in-place modification */
2837: if (simplex) PetscCall(DMPlexInterpolateInPlace_Internal(dm));
2838: PetscFunctionReturn(PETSC_SUCCESS);
2839: }
2841: typedef void (*TPSEvaluateFunc)(const PetscReal[], PetscReal *, PetscReal[], PetscReal (*)[3]);
2843: /*
2844: The Schwarz P implicit surface is
2846: f(x) = cos(x0) + cos(x1) + cos(x2) = 0
2847: */
2848: static void TPSEvaluate_SchwarzP(const PetscReal y[3], PetscReal *f, PetscReal grad[], PetscReal (*hess)[3])
2849: {
2850: PetscReal c[3] = {PetscCosReal(y[0] * PETSC_PI), PetscCosReal(y[1] * PETSC_PI), PetscCosReal(y[2] * PETSC_PI)};
2851: PetscReal g[3] = {-PetscSinReal(y[0] * PETSC_PI), -PetscSinReal(y[1] * PETSC_PI), -PetscSinReal(y[2] * PETSC_PI)};
2852: f[0] = c[0] + c[1] + c[2];
2853: for (PetscInt i = 0; i < 3; i++) {
2854: grad[i] = PETSC_PI * g[i];
2855: for (PetscInt j = 0; j < 3; j++) hess[i][j] = (i == j) ? -PetscSqr(PETSC_PI) * c[i] : 0.;
2856: }
2857: }
2859: // u[] is a tentative normal on input. Replace with the implicit function gradient in the same direction
2860: static PetscErrorCode TPSExtrudeNormalFunc_SchwarzP(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt r, PetscScalar u[], void *ctx)
2861: {
2862: for (PetscInt i = 0; i < 3; i++) u[i] = -PETSC_PI * PetscSinReal(x[i] * PETSC_PI);
2863: return PETSC_SUCCESS;
2864: }
2866: /*
2867: The Gyroid implicit surface is
2869: f(x,y,z) = sin(pi * x) * cos (pi * (y + 1/2)) + sin(pi * (y + 1/2)) * cos(pi * (z + 1/4)) + sin(pi * (z + 1/4)) * cos(pi * x)
2871: */
2872: static void TPSEvaluate_Gyroid(const PetscReal y[3], PetscReal *f, PetscReal grad[], PetscReal (*hess)[3])
2873: {
2874: PetscReal s[3] = {PetscSinReal(PETSC_PI * y[0]), PetscSinReal(PETSC_PI * (y[1] + .5)), PetscSinReal(PETSC_PI * (y[2] + .25))};
2875: PetscReal c[3] = {PetscCosReal(PETSC_PI * y[0]), PetscCosReal(PETSC_PI * (y[1] + .5)), PetscCosReal(PETSC_PI * (y[2] + .25))};
2876: f[0] = s[0] * c[1] + s[1] * c[2] + s[2] * c[0];
2877: grad[0] = PETSC_PI * (c[0] * c[1] - s[2] * s[0]);
2878: grad[1] = PETSC_PI * (c[1] * c[2] - s[0] * s[1]);
2879: grad[2] = PETSC_PI * (c[2] * c[0] - s[1] * s[2]);
2880: hess[0][0] = -PetscSqr(PETSC_PI) * (s[0] * c[1] + s[2] * c[0]);
2881: hess[0][1] = -PetscSqr(PETSC_PI) * (c[0] * s[1]);
2882: hess[0][2] = -PetscSqr(PETSC_PI) * (c[2] * s[0]);
2883: hess[1][0] = -PetscSqr(PETSC_PI) * (s[1] * c[2] + s[0] * c[1]);
2884: hess[1][1] = -PetscSqr(PETSC_PI) * (c[1] * s[2]);
2885: hess[2][2] = -PetscSqr(PETSC_PI) * (c[0] * s[1]);
2886: hess[2][0] = -PetscSqr(PETSC_PI) * (s[2] * c[0] + s[1] * c[2]);
2887: hess[2][1] = -PetscSqr(PETSC_PI) * (c[2] * s[0]);
2888: hess[2][2] = -PetscSqr(PETSC_PI) * (c[1] * s[2]);
2889: }
2891: // u[] is a tentative normal on input. Replace with the implicit function gradient in the same direction
2892: static PetscErrorCode TPSExtrudeNormalFunc_Gyroid(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt r, PetscScalar u[], void *ctx)
2893: {
2894: PetscReal s[3] = {PetscSinReal(PETSC_PI * x[0]), PetscSinReal(PETSC_PI * (x[1] + .5)), PetscSinReal(PETSC_PI * (x[2] + .25))};
2895: PetscReal c[3] = {PetscCosReal(PETSC_PI * x[0]), PetscCosReal(PETSC_PI * (x[1] + .5)), PetscCosReal(PETSC_PI * (x[2] + .25))};
2896: u[0] = PETSC_PI * (c[0] * c[1] - s[2] * s[0]);
2897: u[1] = PETSC_PI * (c[1] * c[2] - s[0] * s[1]);
2898: u[2] = PETSC_PI * (c[2] * c[0] - s[1] * s[2]);
2899: return PETSC_SUCCESS;
2900: }
2902: /*
2903: We wish to solve
2905: min_y || y - x ||^2 subject to f(y) = 0
2907: Let g(y) = grad(f). The minimization problem is equivalent to asking to satisfy
2908: f(y) = 0 and (y-x) is parallel to g(y). We do this by using Householder QR to obtain a basis for the
2909: tangent space and ask for both components in the tangent space to be zero.
2911: Take g to be a column vector and compute the "full QR" factorization Q R = g,
2912: where Q = I - 2 n n^T is a symmetric orthogonal matrix.
2913: The first column of Q is parallel to g so the remaining two columns span the null space.
2914: Let Qn = Q[:,1:] be those remaining columns. Then Qn Qn^T is an orthogonal projector into the tangent space.
2915: Since Q is symmetric, this is equivalent to multiplying by Q and taking the last two entries.
2916: In total, we have a system of 3 equations in 3 unknowns:
2918: f(y) = 0 1 equation
2919: Qn^T (y - x) = 0 2 equations
2921: Here, we compute the residual and Jacobian of this system.
2922: */
2923: static void TPSNearestPointResJac(TPSEvaluateFunc feval, const PetscScalar x[], const PetscScalar y[], PetscScalar res[], PetscScalar J[])
2924: {
2925: PetscReal yreal[3] = {PetscRealPart(y[0]), PetscRealPart(y[1]), PetscRealPart(y[2])};
2926: PetscReal d[3] = {PetscRealPart(y[0] - x[0]), PetscRealPart(y[1] - x[1]), PetscRealPart(y[2] - x[2])};
2927: PetscReal f, grad[3], n[3], norm, norm_y[3], nd, nd_y[3], sign;
2928: PetscReal n_y[3][3] = {
2929: {0, 0, 0},
2930: {0, 0, 0},
2931: {0, 0, 0}
2932: };
2934: feval(yreal, &f, grad, n_y);
2936: for (PetscInt i = 0; i < 3; i++) n[i] = grad[i];
2937: norm = PetscSqrtReal(PetscSqr(n[0]) + PetscSqr(n[1]) + PetscSqr(n[2]));
2938: for (PetscInt i = 0; i < 3; i++) norm_y[i] = 1. / norm * n[i] * n_y[i][i];
2940: // Define the Householder reflector
2941: sign = n[0] >= 0 ? 1. : -1.;
2942: n[0] += norm * sign;
2943: for (PetscInt i = 0; i < 3; i++) n_y[0][i] += norm_y[i] * sign;
2945: norm = PetscSqrtReal(PetscSqr(n[0]) + PetscSqr(n[1]) + PetscSqr(n[2]));
2946: norm_y[0] = 1. / norm * (n[0] * n_y[0][0]);
2947: norm_y[1] = 1. / norm * (n[0] * n_y[0][1] + n[1] * n_y[1][1]);
2948: norm_y[2] = 1. / norm * (n[0] * n_y[0][2] + n[2] * n_y[2][2]);
2950: for (PetscInt i = 0; i < 3; i++) {
2951: n[i] /= norm;
2952: for (PetscInt j = 0; j < 3; j++) {
2953: // note that n[i] is n_old[i]/norm when executing the code below
2954: n_y[i][j] = n_y[i][j] / norm - n[i] / norm * norm_y[j];
2955: }
2956: }
2958: nd = n[0] * d[0] + n[1] * d[1] + n[2] * d[2];
2959: for (PetscInt i = 0; i < 3; i++) nd_y[i] = n[i] + n_y[0][i] * d[0] + n_y[1][i] * d[1] + n_y[2][i] * d[2];
2961: res[0] = f;
2962: res[1] = d[1] - 2 * n[1] * nd;
2963: res[2] = d[2] - 2 * n[2] * nd;
2964: // J[j][i] is J_{ij} (column major)
2965: for (PetscInt j = 0; j < 3; j++) {
2966: J[0 + j * 3] = grad[j];
2967: J[1 + j * 3] = (j == 1) * 1. - 2 * (n_y[1][j] * nd + n[1] * nd_y[j]);
2968: J[2 + j * 3] = (j == 2) * 1. - 2 * (n_y[2][j] * nd + n[2] * nd_y[j]);
2969: }
2970: }
2972: /*
2973: Project x to the nearest point on the implicit surface using Newton's method.
2974: */
2975: static PetscErrorCode TPSNearestPoint(TPSEvaluateFunc feval, PetscScalar x[])
2976: {
2977: PetscScalar y[3] = {x[0], x[1], x[2]}; // Initial guess
2979: PetscFunctionBegin;
2980: for (PetscInt iter = 0; iter < 10; iter++) {
2981: PetscScalar res[3], J[9];
2982: PetscReal resnorm;
2983: TPSNearestPointResJac(feval, x, y, res, J);
2984: resnorm = PetscSqrtReal(PetscSqr(PetscRealPart(res[0])) + PetscSqr(PetscRealPart(res[1])) + PetscSqr(PetscRealPart(res[2])));
2985: if (0) { // Turn on this monitor if you need to confirm quadratic convergence
2986: PetscCall(PetscPrintf(PETSC_COMM_SELF, "[%" PetscInt_FMT "] res [%g %g %g]\n", iter, (double)PetscRealPart(res[0]), (double)PetscRealPart(res[1]), (double)PetscRealPart(res[2])));
2987: }
2988: if (resnorm < PETSC_SMALL) break;
2990: // Take the Newton step
2991: PetscCall(PetscKernel_A_gets_inverse_A_3(J, 0., PETSC_FALSE, NULL));
2992: PetscKernel_v_gets_v_minus_A_times_w_3(y, J, res);
2993: }
2994: for (PetscInt i = 0; i < 3; i++) x[i] = y[i];
2995: PetscFunctionReturn(PETSC_SUCCESS);
2996: }
2998: const char *const DMPlexTPSTypes[] = {"SCHWARZ_P", "GYROID", "DMPlexTPSType", "DMPLEX_TPS_", NULL};
3000: static PetscErrorCode DMPlexCreateTPSMesh_Internal(DM dm, DMPlexTPSType tpstype, const PetscInt extent[], const DMBoundaryType periodic[], PetscBool tps_distribute, PetscInt refinements, PetscInt layers, PetscReal thickness)
3001: {
3002: PetscMPIInt rank;
3003: PetscInt topoDim = 2, spaceDim = 3, numFaces = 0, numVertices = 0, numEdges = 0;
3004: PetscInt(*edges)[2] = NULL, *edgeSets = NULL;
3005: PetscInt *cells_flat = NULL;
3006: PetscReal *vtxCoords = NULL;
3007: TPSEvaluateFunc evalFunc = NULL;
3008: PetscSimplePointFn *normalFunc = NULL;
3009: DMLabel label;
3011: PetscFunctionBegin;
3012: PetscCall(PetscLogEventBegin(DMPLEX_Generate, dm, 0, 0, 0));
3013: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank));
3014: PetscCheck((layers != 0) ^ (thickness == 0.), PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_INCOMP, "Layers %" PetscInt_FMT " must be nonzero iff thickness %g is nonzero", layers, (double)thickness);
3015: switch (tpstype) {
3016: case DMPLEX_TPS_SCHWARZ_P:
3017: PetscCheck(!periodic || (periodic[0] == DM_BOUNDARY_NONE && periodic[1] == DM_BOUNDARY_NONE && periodic[2] == DM_BOUNDARY_NONE), PetscObjectComm((PetscObject)dm), PETSC_ERR_SUP, "Schwarz P does not support periodic meshes");
3018: if (rank == 0) {
3019: PetscInt(*cells)[6][4][4] = NULL; // [junction, junction-face, cell, conn]
3020: PetscInt Njunctions = 0, Ncuts = 0, Npipes[3], vcount;
3021: PetscReal L = 1;
3023: Npipes[0] = (extent[0] + 1) * extent[1] * extent[2];
3024: Npipes[1] = extent[0] * (extent[1] + 1) * extent[2];
3025: Npipes[2] = extent[0] * extent[1] * (extent[2] + 1);
3026: Njunctions = extent[0] * extent[1] * extent[2];
3027: Ncuts = 2 * (extent[0] * extent[1] + extent[1] * extent[2] + extent[2] * extent[0]);
3028: numVertices = 4 * (Npipes[0] + Npipes[1] + Npipes[2]) + 8 * Njunctions;
3029: PetscCall(PetscMalloc1(3 * numVertices, &vtxCoords));
3030: PetscCall(PetscMalloc1(Njunctions, &cells));
3031: PetscCall(PetscMalloc1(Ncuts * 4, &edges));
3032: PetscCall(PetscMalloc1(Ncuts * 4, &edgeSets));
3033: // x-normal pipes
3034: vcount = 0;
3035: for (PetscInt i = 0; i < extent[0] + 1; i++) {
3036: for (PetscInt j = 0; j < extent[1]; j++) {
3037: for (PetscInt k = 0; k < extent[2]; k++) {
3038: for (PetscInt l = 0; l < 4; l++) {
3039: vtxCoords[vcount++] = (2 * i - 1) * L;
3040: vtxCoords[vcount++] = 2 * j * L + PetscCosReal((2 * l + 1) * PETSC_PI / 4) * L / 2;
3041: vtxCoords[vcount++] = 2 * k * L + PetscSinReal((2 * l + 1) * PETSC_PI / 4) * L / 2;
3042: }
3043: }
3044: }
3045: }
3046: // y-normal pipes
3047: for (PetscInt i = 0; i < extent[0]; i++) {
3048: for (PetscInt j = 0; j < extent[1] + 1; j++) {
3049: for (PetscInt k = 0; k < extent[2]; k++) {
3050: for (PetscInt l = 0; l < 4; l++) {
3051: vtxCoords[vcount++] = 2 * i * L + PetscSinReal((2 * l + 1) * PETSC_PI / 4) * L / 2;
3052: vtxCoords[vcount++] = (2 * j - 1) * L;
3053: vtxCoords[vcount++] = 2 * k * L + PetscCosReal((2 * l + 1) * PETSC_PI / 4) * L / 2;
3054: }
3055: }
3056: }
3057: }
3058: // z-normal pipes
3059: for (PetscInt i = 0; i < extent[0]; i++) {
3060: for (PetscInt j = 0; j < extent[1]; j++) {
3061: for (PetscInt k = 0; k < extent[2] + 1; k++) {
3062: for (PetscInt l = 0; l < 4; l++) {
3063: vtxCoords[vcount++] = 2 * i * L + PetscCosReal((2 * l + 1) * PETSC_PI / 4) * L / 2;
3064: vtxCoords[vcount++] = 2 * j * L + PetscSinReal((2 * l + 1) * PETSC_PI / 4) * L / 2;
3065: vtxCoords[vcount++] = (2 * k - 1) * L;
3066: }
3067: }
3068: }
3069: }
3070: // junctions
3071: for (PetscInt i = 0; i < extent[0]; i++) {
3072: for (PetscInt j = 0; j < extent[1]; j++) {
3073: for (PetscInt k = 0; k < extent[2]; k++) {
3074: const PetscInt J = (i * extent[1] + j) * extent[2] + k, Jvoff = (Npipes[0] + Npipes[1] + Npipes[2]) * 4 + J * 8;
3075: PetscCheck(vcount / 3 == Jvoff, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Unexpected vertex count");
3076: for (PetscInt ii = 0; ii < 2; ii++) {
3077: for (PetscInt jj = 0; jj < 2; jj++) {
3078: for (PetscInt kk = 0; kk < 2; kk++) {
3079: double Ls = (1 - sqrt(2) / 4) * L;
3080: vtxCoords[vcount++] = 2 * i * L + (2 * ii - 1) * Ls;
3081: vtxCoords[vcount++] = 2 * j * L + (2 * jj - 1) * Ls;
3082: vtxCoords[vcount++] = 2 * k * L + (2 * kk - 1) * Ls;
3083: }
3084: }
3085: }
3086: const PetscInt jfaces[3][2][4] = {
3087: {{3, 1, 0, 2}, {7, 5, 4, 6}}, // x-aligned
3088: {{5, 4, 0, 1}, {7, 6, 2, 3}}, // y-aligned
3089: {{6, 2, 0, 4}, {7, 3, 1, 5}} // z-aligned
3090: };
3091: const PetscInt pipe_lo[3] = {// vertex numbers of pipes
3092: ((i * extent[1] + j) * extent[2] + k) * 4, ((i * (extent[1] + 1) + j) * extent[2] + k + Npipes[0]) * 4, ((i * extent[1] + j) * (extent[2] + 1) + k + Npipes[0] + Npipes[1]) * 4};
3093: const PetscInt pipe_hi[3] = {// vertex numbers of pipes
3094: (((i + 1) * extent[1] + j) * extent[2] + k) * 4, ((i * (extent[1] + 1) + j + 1) * extent[2] + k + Npipes[0]) * 4, ((i * extent[1] + j) * (extent[2] + 1) + k + 1 + Npipes[0] + Npipes[1]) * 4};
3095: for (PetscInt dir = 0; dir < 3; dir++) { // x,y,z
3096: const PetscInt ijk[3] = {i, j, k};
3097: for (PetscInt l = 0; l < 4; l++) { // rotations
3098: cells[J][dir * 2 + 0][l][0] = pipe_lo[dir] + l;
3099: cells[J][dir * 2 + 0][l][1] = Jvoff + jfaces[dir][0][l];
3100: cells[J][dir * 2 + 0][l][2] = Jvoff + jfaces[dir][0][(l - 1 + 4) % 4];
3101: cells[J][dir * 2 + 0][l][3] = pipe_lo[dir] + (l - 1 + 4) % 4;
3102: cells[J][dir * 2 + 1][l][0] = Jvoff + jfaces[dir][1][l];
3103: cells[J][dir * 2 + 1][l][1] = pipe_hi[dir] + l;
3104: cells[J][dir * 2 + 1][l][2] = pipe_hi[dir] + (l - 1 + 4) % 4;
3105: cells[J][dir * 2 + 1][l][3] = Jvoff + jfaces[dir][1][(l - 1 + 4) % 4];
3106: if (ijk[dir] == 0) {
3107: edges[numEdges][0] = pipe_lo[dir] + l;
3108: edges[numEdges][1] = pipe_lo[dir] + (l + 1) % 4;
3109: edgeSets[numEdges] = dir * 2 + 1;
3110: numEdges++;
3111: }
3112: if (ijk[dir] + 1 == extent[dir]) {
3113: edges[numEdges][0] = pipe_hi[dir] + l;
3114: edges[numEdges][1] = pipe_hi[dir] + (l + 1) % 4;
3115: edgeSets[numEdges] = dir * 2 + 2;
3116: numEdges++;
3117: }
3118: }
3119: }
3120: }
3121: }
3122: }
3123: PetscCheck(numEdges == Ncuts * 4, PetscObjectComm((PetscObject)dm), PETSC_ERR_PLIB, "Edge count %" PetscInt_FMT " incompatible with number of cuts %" PetscInt_FMT, numEdges, Ncuts);
3124: numFaces = 24 * Njunctions;
3125: cells_flat = cells[0][0][0];
3126: }
3127: evalFunc = TPSEvaluate_SchwarzP;
3128: normalFunc = TPSExtrudeNormalFunc_SchwarzP;
3129: break;
3130: case DMPLEX_TPS_GYROID:
3131: if (rank == 0) {
3132: // This is a coarse mesh approximation of the gyroid shifted to being the zero of the level set
3133: //
3134: // sin(pi*x)*cos(pi*(y+1/2)) + sin(pi*(y+1/2))*cos(pi*(z+1/4)) + sin(pi*(z+1/4))*cos(x)
3135: //
3136: // on the cell [0,2]^3.
3137: //
3138: // Think about dividing that cell into four columns, and focus on the column [0,1]x[0,1]x[0,2].
3139: // If you looked at the gyroid in that column at different slices of z you would see that it kind of spins
3140: // like a boomerang:
3141: //
3142: // z = 0 z = 1/4 z = 1/2 z = 3/4 //
3143: // ----- ------- ------- ------- //
3144: // //
3145: // + + + + + + + \ + //
3146: // \ / \ //
3147: // \ `-_ _-' / } //
3148: // *-_ `-' _-' / //
3149: // + `-+ + + +-' + + / + //
3150: // //
3151: // //
3152: // z = 1 z = 5/4 z = 3/2 z = 7/4 //
3153: // ----- ------- ------- ------- //
3154: // //
3155: // +-_ + + + + _-+ + / + //
3156: // `-_ _-_ _-` / //
3157: // \ _-' `-_ / { //
3158: // \ / \ //
3159: // + + + + + + + \ + //
3160: //
3161: //
3162: // This course mesh approximates each of these slices by two line segments,
3163: // and then connects the segments in consecutive layers with quadrilateral faces.
3164: // All of the end points of the segments are multiples of 1/4 except for the
3165: // point * in the picture for z = 0 above and the similar points in other layers.
3166: // That point is at (gamma, gamma, 0), where gamma is calculated below.
3167: //
3168: // The column [1,2]x[1,2]x[0,2] looks the same as this column;
3169: // The columns [1,2]x[0,1]x[0,2] and [0,1]x[1,2]x[0,2] are mirror images.
3170: //
3171: // As for how this method turned into the names given to the vertices:
3172: // that was not systematic, it was just the way it worked out in my handwritten notes.
3174: PetscInt facesPerBlock = 64;
3175: PetscInt vertsPerBlock = 56;
3176: PetscInt extentPlus[3];
3177: PetscInt numBlocks, numBlocksPlus;
3178: const PetscInt A = 0, B = 1, C = 2, D = 3, E = 4, F = 5, G = 6, H = 7, II = 8, J = 9, K = 10, L = 11, M = 12, N = 13, O = 14, P = 15, Q = 16, R = 17, S = 18, T = 19, U = 20, V = 21, W = 22, X = 23, Y = 24, Z = 25, Ap = 26, Bp = 27, Cp = 28, Dp = 29, Ep = 30, Fp = 31, Gp = 32, Hp = 33, Ip = 34, Jp = 35, Kp = 36, Lp = 37, Mp = 38, Np = 39, Op = 40, Pp = 41, Qp = 42, Rp = 43, Sp = 44, Tp = 45, Up = 46, Vp = 47, Wp = 48, Xp = 49, Yp = 50, Zp = 51, Aq = 52, Bq = 53, Cq = 54, Dq = 55;
3179: const PetscInt pattern[64][4] = {
3180: /* face to vertex within the coarse discretization of a single gyroid block */
3181: /* layer 0 */
3182: {A, C, K, G },
3183: {C, B, II, K },
3184: {D, A, H, L },
3185: {B + 56 * 1, D, L, J },
3186: {E, B + 56 * 1, J, N },
3187: {A + 56 * 2, E, N, H + 56 * 2 },
3188: {F, A + 56 * 2, G + 56 * 2, M },
3189: {B, F, M, II },
3190: /* layer 1 */
3191: {G, K, Q, O },
3192: {K, II, P, Q },
3193: {L, H, O + 56 * 1, R },
3194: {J, L, R, P },
3195: {N, J, P, S },
3196: {H + 56 * 2, N, S, O + 56 * 3 },
3197: {M, G + 56 * 2, O + 56 * 2, T },
3198: {II, M, T, P },
3199: /* layer 2 */
3200: {O, Q, Y, U },
3201: {Q, P, W, Y },
3202: {R, O + 56 * 1, U + 56 * 1, Ap },
3203: {P, R, Ap, W },
3204: {S, P, X, Bp },
3205: {O + 56 * 3, S, Bp, V + 56 * 1 },
3206: {T, O + 56 * 2, V, Z },
3207: {P, T, Z, X },
3208: /* layer 3 */
3209: {U, Y, Ep, Dp },
3210: {Y, W, Cp, Ep },
3211: {Ap, U + 56 * 1, Dp + 56 * 1, Gp },
3212: {W, Ap, Gp, Cp },
3213: {Bp, X, Cp + 56 * 2, Fp },
3214: {V + 56 * 1, Bp, Fp, Dp + 56 * 1},
3215: {Z, V, Dp, Hp },
3216: {X, Z, Hp, Cp + 56 * 2},
3217: /* layer 4 */
3218: {Dp, Ep, Mp, Kp },
3219: {Ep, Cp, Ip, Mp },
3220: {Gp, Dp + 56 * 1, Lp, Np },
3221: {Cp, Gp, Np, Jp },
3222: {Fp, Cp + 56 * 2, Jp + 56 * 2, Pp },
3223: {Dp + 56 * 1, Fp, Pp, Lp },
3224: {Hp, Dp, Kp, Op },
3225: {Cp + 56 * 2, Hp, Op, Ip + 56 * 2},
3226: /* layer 5 */
3227: {Kp, Mp, Sp, Rp },
3228: {Mp, Ip, Qp, Sp },
3229: {Np, Lp, Rp, Tp },
3230: {Jp, Np, Tp, Qp + 56 * 1},
3231: {Pp, Jp + 56 * 2, Qp + 56 * 3, Up },
3232: {Lp, Pp, Up, Rp },
3233: {Op, Kp, Rp, Vp },
3234: {Ip + 56 * 2, Op, Vp, Qp + 56 * 2},
3235: /* layer 6 */
3236: {Rp, Sp, Aq, Yp },
3237: {Sp, Qp, Wp, Aq },
3238: {Tp, Rp, Yp, Cq },
3239: {Qp + 56 * 1, Tp, Cq, Wp + 56 * 1},
3240: {Up, Qp + 56 * 3, Xp + 56 * 1, Dq },
3241: {Rp, Up, Dq, Zp },
3242: {Vp, Rp, Zp, Bq },
3243: {Qp + 56 * 2, Vp, Bq, Xp },
3244: /* layer 7 (the top is the periodic image of the bottom of layer 0) */
3245: {Yp, Aq, C + 56 * 4, A + 56 * 4 },
3246: {Aq, Wp, B + 56 * 4, C + 56 * 4 },
3247: {Cq, Yp, A + 56 * 4, D + 56 * 4 },
3248: {Wp + 56 * 1, Cq, D + 56 * 4, B + 56 * 5 },
3249: {Dq, Xp + 56 * 1, B + 56 * 5, E + 56 * 4 },
3250: {Zp, Dq, E + 56 * 4, A + 56 * 6 },
3251: {Bq, Zp, A + 56 * 6, F + 56 * 4 },
3252: {Xp, Bq, F + 56 * 4, B + 56 * 4 }
3253: };
3254: const PetscReal gamma = PetscAcosReal((PetscSqrtReal(3.) - 1.) / PetscSqrtReal(2.)) / PETSC_PI;
3255: const PetscReal patternCoords[56][3] = {
3256: {1., 0., 0. }, /* A */
3257: {0., 1., 0. }, /* B */
3258: {gamma, gamma, 0. }, /* C */
3259: {1 + gamma, 1 - gamma, 0. }, /* D */
3260: {2 - gamma, 2 - gamma, 0. }, /* E */
3261: {1 - gamma, 1 + gamma, 0. }, /* F */
3263: {.5, 0, .25 }, /* G */
3264: {1.5, 0., .25 }, /* H */
3265: {.5, 1., .25 }, /* II */
3266: {1.5, 1., .25 }, /* J */
3267: {.25, .5, .25 }, /* K */
3268: {1.25, .5, .25 }, /* L */
3269: {.75, 1.5, .25 }, /* M */
3270: {1.75, 1.5, .25 }, /* N */
3272: {0., 0., .5 }, /* O */
3273: {1., 1., .5 }, /* P */
3274: {gamma, 1 - gamma, .5 }, /* Q */
3275: {1 + gamma, gamma, .5 }, /* R */
3276: {2 - gamma, 1 + gamma, .5 }, /* S */
3277: {1 - gamma, 2 - gamma, .5 }, /* T */
3279: {0., .5, .75 }, /* U */
3280: {0., 1.5, .75 }, /* V */
3281: {1., .5, .75 }, /* W */
3282: {1., 1.5, .75 }, /* X */
3283: {.5, .75, .75 }, /* Y */
3284: {.5, 1.75, .75 }, /* Z */
3285: {1.5, .25, .75 }, /* Ap */
3286: {1.5, 1.25, .75 }, /* Bp */
3288: {1., 0., 1. }, /* Cp */
3289: {0., 1., 1. }, /* Dp */
3290: {1 - gamma, 1 - gamma, 1. }, /* Ep */
3291: {1 + gamma, 1 + gamma, 1. }, /* Fp */
3292: {2 - gamma, gamma, 1. }, /* Gp */
3293: {gamma, 2 - gamma, 1. }, /* Hp */
3295: {.5, 0., 1.25}, /* Ip */
3296: {1.5, 0., 1.25}, /* Jp */
3297: {.5, 1., 1.25}, /* Kp */
3298: {1.5, 1., 1.25}, /* Lp */
3299: {.75, .5, 1.25}, /* Mp */
3300: {1.75, .5, 1.25}, /* Np */
3301: {.25, 1.5, 1.25}, /* Op */
3302: {1.25, 1.5, 1.25}, /* Pp */
3304: {0., 0., 1.5 }, /* Qp */
3305: {1., 1., 1.5 }, /* Rp */
3306: {1 - gamma, gamma, 1.5 }, /* Sp */
3307: {2 - gamma, 1 - gamma, 1.5 }, /* Tp */
3308: {1 + gamma, 2 - gamma, 1.5 }, /* Up */
3309: {gamma, 1 + gamma, 1.5 }, /* Vp */
3311: {0., .5, 1.75}, /* Wp */
3312: {0., 1.5, 1.75}, /* Xp */
3313: {1., .5, 1.75}, /* Yp */
3314: {1., 1.5, 1.75}, /* Zp */
3315: {.5, .25, 1.75}, /* Aq */
3316: {.5, 1.25, 1.75}, /* Bq */
3317: {1.5, .75, 1.75}, /* Cq */
3318: {1.5, 1.75, 1.75}, /* Dq */
3319: };
3320: PetscInt(*cells)[64][4] = NULL;
3321: PetscBool *seen;
3322: PetscInt *vertToTrueVert;
3323: PetscInt count;
3325: for (PetscInt i = 0; i < 3; i++) extentPlus[i] = extent[i] + 1;
3326: numBlocks = 1;
3327: for (PetscInt i = 0; i < 3; i++) numBlocks *= extent[i];
3328: numBlocksPlus = 1;
3329: for (PetscInt i = 0; i < 3; i++) numBlocksPlus *= extentPlus[i];
3330: numFaces = numBlocks * facesPerBlock;
3331: PetscCall(PetscMalloc1(numBlocks, &cells));
3332: PetscCall(PetscCalloc1(numBlocksPlus * vertsPerBlock, &seen));
3333: for (PetscInt k = 0; k < extent[2]; k++) {
3334: for (PetscInt j = 0; j < extent[1]; j++) {
3335: for (PetscInt i = 0; i < extent[0]; i++) {
3336: for (PetscInt f = 0; f < facesPerBlock; f++) {
3337: for (PetscInt v = 0; v < 4; v++) {
3338: PetscInt vertRaw = pattern[f][v];
3339: PetscInt blockidx = vertRaw / 56;
3340: PetscInt patternvert = vertRaw % 56;
3341: PetscInt xplus = (blockidx & 1);
3342: PetscInt yplus = (blockidx & 2) >> 1;
3343: PetscInt zplus = (blockidx & 4) >> 2;
3344: PetscInt zcoord = (periodic && periodic[2] == DM_BOUNDARY_PERIODIC) ? ((k + zplus) % extent[2]) : (k + zplus);
3345: PetscInt ycoord = (periodic && periodic[1] == DM_BOUNDARY_PERIODIC) ? ((j + yplus) % extent[1]) : (j + yplus);
3346: PetscInt xcoord = (periodic && periodic[0] == DM_BOUNDARY_PERIODIC) ? ((i + xplus) % extent[0]) : (i + xplus);
3347: PetscInt vert = ((zcoord * extentPlus[1] + ycoord) * extentPlus[0] + xcoord) * 56 + patternvert;
3349: cells[(k * extent[1] + j) * extent[0] + i][f][v] = vert;
3350: seen[vert] = PETSC_TRUE;
3351: }
3352: }
3353: }
3354: }
3355: }
3356: for (PetscInt i = 0; i < numBlocksPlus * vertsPerBlock; i++)
3357: if (seen[i]) numVertices++;
3358: count = 0;
3359: PetscCall(PetscMalloc1(numBlocksPlus * vertsPerBlock, &vertToTrueVert));
3360: PetscCall(PetscMalloc1(numVertices * 3, &vtxCoords));
3361: for (PetscInt i = 0; i < numBlocksPlus * vertsPerBlock; i++) vertToTrueVert[i] = -1;
3362: for (PetscInt k = 0; k < extentPlus[2]; k++) {
3363: for (PetscInt j = 0; j < extentPlus[1]; j++) {
3364: for (PetscInt i = 0; i < extentPlus[0]; i++) {
3365: for (PetscInt v = 0; v < vertsPerBlock; v++) {
3366: PetscInt vIdx = ((k * extentPlus[1] + j) * extentPlus[0] + i) * vertsPerBlock + v;
3368: if (seen[vIdx]) {
3369: PetscInt thisVert;
3371: vertToTrueVert[vIdx] = thisVert = count++;
3373: for (PetscInt d = 0; d < 3; d++) vtxCoords[3 * thisVert + d] = patternCoords[v][d];
3374: vtxCoords[3 * thisVert + 0] += i * 2;
3375: vtxCoords[3 * thisVert + 1] += j * 2;
3376: vtxCoords[3 * thisVert + 2] += k * 2;
3377: }
3378: }
3379: }
3380: }
3381: }
3382: for (PetscInt i = 0; i < numBlocks; i++) {
3383: for (PetscInt f = 0; f < facesPerBlock; f++) {
3384: for (PetscInt v = 0; v < 4; v++) cells[i][f][v] = vertToTrueVert[cells[i][f][v]];
3385: }
3386: }
3387: PetscCall(PetscFree(vertToTrueVert));
3388: PetscCall(PetscFree(seen));
3389: cells_flat = cells[0][0];
3390: numEdges = 0;
3391: for (PetscInt i = 0; i < numFaces; i++) {
3392: for (PetscInt e = 0; e < 4; e++) {
3393: PetscInt ev[] = {cells_flat[i * 4 + e], cells_flat[i * 4 + ((e + 1) % 4)]};
3394: const PetscReal *evCoords[] = {&vtxCoords[3 * ev[0]], &vtxCoords[3 * ev[1]]};
3396: for (PetscInt d = 0; d < 3; d++) {
3397: if (!periodic || periodic[0] != DM_BOUNDARY_PERIODIC) {
3398: if (evCoords[0][d] == 0. && evCoords[1][d] == 0.) numEdges++;
3399: if (evCoords[0][d] == 2. * extent[d] && evCoords[1][d] == 2. * extent[d]) numEdges++;
3400: }
3401: }
3402: }
3403: }
3404: PetscCall(PetscMalloc1(numEdges, &edges));
3405: PetscCall(PetscMalloc1(numEdges, &edgeSets));
3406: for (PetscInt edge = 0, i = 0; i < numFaces; i++) {
3407: for (PetscInt e = 0; e < 4; e++) {
3408: PetscInt ev[] = {cells_flat[i * 4 + e], cells_flat[i * 4 + ((e + 1) % 4)]};
3409: const PetscReal *evCoords[] = {&vtxCoords[3 * ev[0]], &vtxCoords[3 * ev[1]]};
3411: for (PetscInt d = 0; d < 3; d++) {
3412: if (!periodic || periodic[d] != DM_BOUNDARY_PERIODIC) {
3413: if (evCoords[0][d] == 0. && evCoords[1][d] == 0.) {
3414: edges[edge][0] = ev[0];
3415: edges[edge][1] = ev[1];
3416: edgeSets[edge++] = 2 * d;
3417: }
3418: if (evCoords[0][d] == 2. * extent[d] && evCoords[1][d] == 2. * extent[d]) {
3419: edges[edge][0] = ev[0];
3420: edges[edge][1] = ev[1];
3421: edgeSets[edge++] = 2 * d + 1;
3422: }
3423: }
3424: }
3425: }
3426: }
3427: }
3428: evalFunc = TPSEvaluate_Gyroid;
3429: normalFunc = TPSExtrudeNormalFunc_Gyroid;
3430: break;
3431: }
3433: PetscCall(DMSetDimension(dm, topoDim));
3434: if (rank == 0) PetscCall(DMPlexBuildFromCellList(dm, numFaces, numVertices, 4, cells_flat));
3435: else PetscCall(DMPlexBuildFromCellList(dm, 0, 0, 0, NULL));
3436: PetscCall(PetscFree(cells_flat));
3437: {
3438: DM idm;
3439: PetscCall(DMPlexInterpolate(dm, &idm));
3440: PetscCall(DMPlexReplace_Internal(dm, &idm));
3441: }
3442: if (rank == 0) PetscCall(DMPlexBuildCoordinatesFromCellList(dm, spaceDim, vtxCoords));
3443: else PetscCall(DMPlexBuildCoordinatesFromCellList(dm, spaceDim, NULL));
3444: PetscCall(PetscFree(vtxCoords));
3446: PetscCall(DMCreateLabel(dm, "Face Sets"));
3447: PetscCall(DMGetLabel(dm, "Face Sets", &label));
3448: for (PetscInt e = 0; e < numEdges; e++) {
3449: PetscInt njoin;
3450: const PetscInt *join, verts[] = {numFaces + edges[e][0], numFaces + edges[e][1]};
3451: PetscCall(DMPlexGetJoin(dm, 2, verts, &njoin, &join));
3452: PetscCheck(njoin == 1, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Expected unique join of vertices %" PetscInt_FMT " and %" PetscInt_FMT, edges[e][0], edges[e][1]);
3453: PetscCall(DMLabelSetValue(label, join[0], edgeSets[e]));
3454: PetscCall(DMPlexRestoreJoin(dm, 2, verts, &njoin, &join));
3455: }
3456: PetscCall(PetscFree(edges));
3457: PetscCall(PetscFree(edgeSets));
3458: if (tps_distribute) {
3459: DM pdm = NULL;
3460: PetscPartitioner part;
3462: PetscCall(DMPlexGetPartitioner(dm, &part));
3463: PetscCall(PetscPartitionerSetFromOptions(part));
3464: PetscCall(DMPlexDistribute(dm, 0, NULL, &pdm));
3465: if (pdm) PetscCall(DMPlexReplace_Internal(dm, &pdm));
3466: // Do not auto-distribute again
3467: PetscCall(DMPlexDistributeSetDefault(dm, PETSC_FALSE));
3468: }
3470: PetscCall(DMPlexSetRefinementUniform(dm, PETSC_TRUE));
3471: for (PetscInt refine = 0; refine < refinements; refine++) {
3472: PetscInt m;
3473: DM dmf;
3474: Vec X;
3475: PetscScalar *x;
3476: PetscCall(DMRefine(dm, MPI_COMM_NULL, &dmf));
3477: PetscCall(DMPlexReplace_Internal(dm, &dmf));
3479: PetscCall(DMGetCoordinatesLocal(dm, &X));
3480: PetscCall(VecGetLocalSize(X, &m));
3481: PetscCall(VecGetArray(X, &x));
3482: for (PetscInt i = 0; i < m; i += 3) PetscCall(TPSNearestPoint(evalFunc, &x[i]));
3483: PetscCall(VecRestoreArray(X, &x));
3484: }
3486: // Face Sets has already been propagated to new vertices during refinement; this propagates to the initial vertices.
3487: PetscCall(DMGetLabel(dm, "Face Sets", &label));
3488: PetscCall(DMPlexLabelComplete(dm, label));
3490: PetscCall(PetscLogEventEnd(DMPLEX_Generate, dm, 0, 0, 0));
3492: if (thickness > 0) {
3493: DM edm, cdm, ecdm;
3494: DMPlexTransform tr;
3495: const char *prefix;
3496: PetscOptions options;
3497: // Code from DMPlexExtrude
3498: PetscCall(DMPlexTransformCreate(PetscObjectComm((PetscObject)dm), &tr));
3499: PetscCall(DMPlexTransformSetDM(tr, dm));
3500: PetscCall(DMPlexTransformSetType(tr, DMPLEXEXTRUDE));
3501: PetscCall(PetscObjectGetOptionsPrefix((PetscObject)dm, &prefix));
3502: PetscCall(PetscObjectSetOptionsPrefix((PetscObject)tr, prefix));
3503: PetscCall(PetscObjectGetOptions((PetscObject)dm, &options));
3504: PetscCall(PetscObjectSetOptions((PetscObject)tr, options));
3505: PetscCall(DMPlexTransformExtrudeSetLayers(tr, layers));
3506: PetscCall(DMPlexTransformExtrudeSetThickness(tr, thickness));
3507: PetscCall(DMPlexTransformExtrudeSetTensor(tr, PETSC_FALSE));
3508: PetscCall(DMPlexTransformExtrudeSetSymmetric(tr, PETSC_TRUE));
3509: PetscCall(DMPlexTransformExtrudeSetNormalFunction(tr, normalFunc));
3510: PetscCall(DMPlexTransformSetFromOptions(tr));
3511: PetscCall(PetscObjectSetOptions((PetscObject)tr, NULL));
3512: PetscCall(DMPlexTransformSetUp(tr));
3513: PetscCall(PetscObjectViewFromOptions((PetscObject)tr, NULL, "-dm_plex_tps_transform_view"));
3514: PetscCall(DMPlexTransformApply(tr, dm, &edm));
3515: PetscCall(DMCopyDisc(dm, edm));
3516: PetscCall(DMGetCoordinateDM(dm, &cdm));
3517: PetscCall(DMGetCoordinateDM(edm, &ecdm));
3518: PetscCall(DMCopyDisc(cdm, ecdm));
3519: PetscCall(DMPlexTransformCreateDiscLabels(tr, edm));
3520: PetscCall(DMPlexTransformDestroy(&tr));
3521: if (edm) {
3522: ((DM_Plex *)edm->data)->printFEM = ((DM_Plex *)dm->data)->printFEM;
3523: ((DM_Plex *)edm->data)->printL2 = ((DM_Plex *)dm->data)->printL2;
3524: ((DM_Plex *)edm->data)->printLocate = ((DM_Plex *)dm->data)->printLocate;
3525: }
3526: PetscCall(DMPlexReplace_Internal(dm, &edm));
3527: }
3528: PetscFunctionReturn(PETSC_SUCCESS);
3529: }
3531: /*@
3532: DMPlexCreateTPSMesh - Create a distributed, interpolated mesh of a triply-periodic surface
3534: Collective
3536: Input Parameters:
3537: + comm - The communicator for the `DM` object
3538: . tpstype - Type of triply-periodic surface
3539: . extent - Array of length 3 containing number of periods in each direction
3540: . periodic - array of length 3 with periodicity, or `NULL` for non-periodic
3541: . tps_distribute - Distribute 2D manifold mesh prior to refinement and extrusion (more scalable)
3542: . refinements - Number of factor-of-2 refinements of 2D manifold mesh
3543: . layers - Number of cell layers extruded in normal direction
3544: - thickness - Thickness in normal direction
3546: Output Parameter:
3547: . dm - The `DM` object
3549: Level: beginner
3551: Notes:
3552: This meshes the surface of the Schwarz P or Gyroid surfaces. Schwarz P is the simplest member of the triply-periodic minimal surfaces.
3553: <https://en.wikipedia.org/wiki/Schwarz_minimal_surface#Schwarz_P_(%22Primitive%22)> and can be cut with "clean" boundaries.
3554: The Gyroid <https://en.wikipedia.org/wiki/Gyroid> is another triply-periodic minimal surface with applications in additive manufacturing; it is much more difficult to "cut" since there are no planes of symmetry.
3555: Our implementation creates a very coarse mesh of the surface and refines (by 4-way splitting) as many times as requested.
3556: On each refinement, all vertices are projected to their nearest point on the surface.
3557: This projection could readily be extended to related surfaces.
3559: See {cite}`maskery2018insights`
3561: The face (edge) sets for the Schwarz P surface are numbered $1(-x), 2(+x), 3(-y), 4(+y), 5(-z), 6(+z)$.
3562: When the mesh is refined, "Face Sets" contain the new vertices (created during refinement).
3563: Use `DMPlexLabelComplete()` to propagate to coarse-level vertices.
3565: Developer Notes:
3566: The Gyroid mesh does not currently mark boundary sets.
3568: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexCreateSphereMesh()`, `DMSetType()`, `DMCreate()`
3569: @*/
3570: PetscErrorCode DMPlexCreateTPSMesh(MPI_Comm comm, DMPlexTPSType tpstype, const PetscInt extent[], const DMBoundaryType periodic[], PetscBool tps_distribute, PetscInt refinements, PetscInt layers, PetscReal thickness, DM *dm)
3571: {
3572: PetscFunctionBegin;
3573: PetscCall(DMCreate(comm, dm));
3574: PetscCall(DMSetType(*dm, DMPLEX));
3575: PetscCall(DMPlexCreateTPSMesh_Internal(*dm, tpstype, extent, periodic, tps_distribute, refinements, layers, thickness));
3576: PetscFunctionReturn(PETSC_SUCCESS);
3577: }
3579: /*@
3580: DMPlexCreateSphereMesh - Creates a mesh on the d-dimensional sphere, S^d.
3582: Collective
3584: Input Parameters:
3585: + comm - The communicator for the `DM` object
3586: . dim - The dimension
3587: . simplex - Use simplices, or tensor product cells
3588: - R - The radius
3590: Output Parameter:
3591: . dm - The `DM` object
3593: Level: beginner
3595: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexCreateBallMesh()`, `DMPlexCreateBoxMesh()`, `DMSetType()`, `DMCreate()`
3596: @*/
3597: PetscErrorCode DMPlexCreateSphereMesh(MPI_Comm comm, PetscInt dim, PetscBool simplex, PetscReal R, DM *dm)
3598: {
3599: PetscFunctionBegin;
3600: PetscAssertPointer(dm, 5);
3601: PetscCall(DMCreate(comm, dm));
3602: PetscCall(DMSetType(*dm, DMPLEX));
3603: PetscCall(DMPlexCreateSphereMesh_Internal(*dm, dim, simplex, R));
3604: PetscFunctionReturn(PETSC_SUCCESS);
3605: }
3607: static PetscErrorCode DMPlexCreateBallMesh_Internal(DM dm, PetscInt dim, PetscReal R)
3608: {
3609: DM sdm, vol;
3610: DMLabel bdlabel;
3611: const char *prefix;
3613: PetscFunctionBegin;
3614: PetscCall(DMCreate(PetscObjectComm((PetscObject)dm), &sdm));
3615: PetscCall(DMSetType(sdm, DMPLEX));
3616: PetscCall(DMGetOptionsPrefix(dm, &prefix));
3617: PetscCall(DMSetOptionsPrefix(sdm, prefix));
3618: PetscCall(DMAppendOptionsPrefix(sdm, "bd_"));
3619: PetscCall(DMPlexDistributeSetDefault(sdm, PETSC_FALSE));
3620: PetscCall(DMPlexCreateSphereMesh_Internal(sdm, dim - 1, PETSC_TRUE, R));
3621: PetscCall(DMSetFromOptions(sdm));
3622: PetscCall(DMViewFromOptions(sdm, NULL, "-dm_view"));
3623: PetscCall(DMPlexGenerate(sdm, NULL, PETSC_TRUE, &vol));
3624: PetscCall(DMDestroy(&sdm));
3625: PetscCall(DMPlexReplace_Internal(dm, &vol));
3626: PetscCall(DMCreateLabel(dm, "marker"));
3627: PetscCall(DMGetLabel(dm, "marker", &bdlabel));
3628: PetscCall(DMPlexMarkBoundaryFaces(dm, PETSC_DETERMINE, bdlabel));
3629: PetscCall(DMPlexLabelComplete(dm, bdlabel));
3630: PetscFunctionReturn(PETSC_SUCCESS);
3631: }
3633: /*@
3634: DMPlexCreateBallMesh - Creates a simplex mesh on the d-dimensional ball, B^d.
3636: Collective
3638: Input Parameters:
3639: + comm - The communicator for the `DM` object
3640: . dim - The dimension
3641: - R - The radius
3643: Output Parameter:
3644: . dm - The `DM` object
3646: Options Database Key:
3647: . bd_dm_refine - This will refine the surface mesh preserving the sphere geometry
3649: Level: beginner
3651: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexCreateSphereMesh()`, `DMPlexCreateBoxMesh()`, `DMSetType()`, `DMCreate()`
3652: @*/
3653: PetscErrorCode DMPlexCreateBallMesh(MPI_Comm comm, PetscInt dim, PetscReal R, DM *dm)
3654: {
3655: PetscFunctionBegin;
3656: PetscCall(DMCreate(comm, dm));
3657: PetscCall(DMSetType(*dm, DMPLEX));
3658: PetscCall(DMPlexCreateBallMesh_Internal(*dm, dim, R));
3659: PetscFunctionReturn(PETSC_SUCCESS);
3660: }
3662: static PetscErrorCode DMPlexCreateReferenceCell_Internal(DM rdm, DMPolytopeType ct)
3663: {
3664: PetscFunctionBegin;
3665: switch (ct) {
3666: case DM_POLYTOPE_POINT: {
3667: PetscInt numPoints[1] = {1};
3668: PetscInt coneSize[1] = {0};
3669: PetscInt cones[1] = {0};
3670: PetscInt coneOrientations[1] = {0};
3671: PetscScalar vertexCoords[1] = {0.0};
3673: PetscCall(DMSetDimension(rdm, 0));
3674: PetscCall(DMPlexCreateFromDAG(rdm, 0, numPoints, coneSize, cones, coneOrientations, vertexCoords));
3675: } break;
3676: case DM_POLYTOPE_SEGMENT: {
3677: PetscInt numPoints[2] = {2, 1};
3678: PetscInt coneSize[3] = {2, 0, 0};
3679: PetscInt cones[2] = {1, 2};
3680: PetscInt coneOrientations[2] = {0, 0};
3681: PetscScalar vertexCoords[2] = {-1.0, 1.0};
3683: PetscCall(DMSetDimension(rdm, 1));
3684: PetscCall(DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
3685: } break;
3686: case DM_POLYTOPE_POINT_PRISM_TENSOR: {
3687: PetscInt numPoints[2] = {2, 1};
3688: PetscInt coneSize[3] = {2, 0, 0};
3689: PetscInt cones[2] = {1, 2};
3690: PetscInt coneOrientations[2] = {0, 0};
3691: PetscScalar vertexCoords[2] = {-1.0, 1.0};
3693: PetscCall(DMSetDimension(rdm, 1));
3694: PetscCall(DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
3695: } break;
3696: case DM_POLYTOPE_TRIANGLE: {
3697: PetscInt numPoints[2] = {3, 1};
3698: PetscInt coneSize[4] = {3, 0, 0, 0};
3699: PetscInt cones[3] = {1, 2, 3};
3700: PetscInt coneOrientations[3] = {0, 0, 0};
3701: PetscScalar vertexCoords[6] = {-1.0, -1.0, 1.0, -1.0, -1.0, 1.0};
3703: PetscCall(DMSetDimension(rdm, 2));
3704: PetscCall(DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
3705: } break;
3706: case DM_POLYTOPE_QUADRILATERAL: {
3707: PetscInt numPoints[2] = {4, 1};
3708: PetscInt coneSize[5] = {4, 0, 0, 0, 0};
3709: PetscInt cones[4] = {1, 2, 3, 4};
3710: PetscInt coneOrientations[4] = {0, 0, 0, 0};
3711: PetscScalar vertexCoords[8] = {-1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.0, 1.0};
3713: PetscCall(DMSetDimension(rdm, 2));
3714: PetscCall(DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
3715: } break;
3716: case DM_POLYTOPE_SEG_PRISM_TENSOR: {
3717: PetscInt numPoints[2] = {4, 1};
3718: PetscInt coneSize[5] = {4, 0, 0, 0, 0};
3719: PetscInt cones[4] = {1, 2, 3, 4};
3720: PetscInt coneOrientations[4] = {0, 0, 0, 0};
3721: PetscScalar vertexCoords[8] = {-1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0};
3723: PetscCall(DMSetDimension(rdm, 2));
3724: PetscCall(DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
3725: } break;
3726: case DM_POLYTOPE_TETRAHEDRON: {
3727: PetscInt numPoints[2] = {4, 1};
3728: PetscInt coneSize[5] = {4, 0, 0, 0, 0};
3729: PetscInt cones[4] = {1, 2, 3, 4};
3730: PetscInt coneOrientations[4] = {0, 0, 0, 0};
3731: 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};
3733: PetscCall(DMSetDimension(rdm, 3));
3734: PetscCall(DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
3735: } break;
3736: case DM_POLYTOPE_HEXAHEDRON: {
3737: PetscInt numPoints[2] = {8, 1};
3738: PetscInt coneSize[9] = {8, 0, 0, 0, 0, 0, 0, 0, 0};
3739: PetscInt cones[8] = {1, 2, 3, 4, 5, 6, 7, 8};
3740: PetscInt coneOrientations[8] = {0, 0, 0, 0, 0, 0, 0, 0};
3741: 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, -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0, 1.0, 1.0, -1.0, 1.0, 1.0};
3743: PetscCall(DMSetDimension(rdm, 3));
3744: PetscCall(DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
3745: } break;
3746: case DM_POLYTOPE_TRI_PRISM: {
3747: PetscInt numPoints[2] = {6, 1};
3748: PetscInt coneSize[7] = {6, 0, 0, 0, 0, 0, 0};
3749: PetscInt cones[6] = {1, 2, 3, 4, 5, 6};
3750: PetscInt coneOrientations[6] = {0, 0, 0, 0, 0, 0};
3751: PetscScalar vertexCoords[18] = {-1.0, -1.0, -1.0, -1.0, 1.0, -1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, -1.0, 1.0, 1.0};
3753: PetscCall(DMSetDimension(rdm, 3));
3754: PetscCall(DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
3755: } break;
3756: case DM_POLYTOPE_TRI_PRISM_TENSOR: {
3757: PetscInt numPoints[2] = {6, 1};
3758: PetscInt coneSize[7] = {6, 0, 0, 0, 0, 0, 0};
3759: PetscInt cones[6] = {1, 2, 3, 4, 5, 6};
3760: PetscInt coneOrientations[6] = {0, 0, 0, 0, 0, 0};
3761: PetscScalar vertexCoords[18] = {-1.0, -1.0, -1.0, 1.0, -1.0, -1.0, -1.0, 1.0, -1.0, -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, -1.0, 1.0, 1.0};
3763: PetscCall(DMSetDimension(rdm, 3));
3764: PetscCall(DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
3765: } break;
3766: case DM_POLYTOPE_QUAD_PRISM_TENSOR: {
3767: PetscInt numPoints[2] = {8, 1};
3768: PetscInt coneSize[9] = {8, 0, 0, 0, 0, 0, 0, 0, 0};
3769: PetscInt cones[8] = {1, 2, 3, 4, 5, 6, 7, 8};
3770: PetscInt coneOrientations[8] = {0, 0, 0, 0, 0, 0, 0, 0};
3771: 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, -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0, 1.0, 1.0, -1.0, 1.0, 1.0};
3773: PetscCall(DMSetDimension(rdm, 3));
3774: PetscCall(DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
3775: } break;
3776: case DM_POLYTOPE_PYRAMID: {
3777: PetscInt numPoints[2] = {5, 1};
3778: PetscInt coneSize[6] = {5, 0, 0, 0, 0, 0};
3779: PetscInt cones[5] = {1, 2, 3, 4, 5};
3780: PetscInt coneOrientations[8] = {0, 0, 0, 0, 0, 0, 0, 0};
3781: 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, 0.0, 0.0, 1.0};
3783: PetscCall(DMSetDimension(rdm, 3));
3784: PetscCall(DMPlexCreateFromDAG(rdm, 1, numPoints, coneSize, cones, coneOrientations, vertexCoords));
3785: } break;
3786: default:
3787: SETERRQ(PetscObjectComm((PetscObject)rdm), PETSC_ERR_ARG_WRONG, "Cannot create reference cell for cell type %s", DMPolytopeTypes[ct]);
3788: }
3789: {
3790: PetscInt Nv, v;
3792: /* Must create the celltype label here so that we do not automatically try to compute the types */
3793: PetscCall(DMCreateLabel(rdm, "celltype"));
3794: PetscCall(DMPlexSetCellType(rdm, 0, ct));
3795: PetscCall(DMPlexGetChart(rdm, NULL, &Nv));
3796: for (v = 1; v < Nv; ++v) PetscCall(DMPlexSetCellType(rdm, v, DM_POLYTOPE_POINT));
3797: }
3798: PetscCall(DMPlexInterpolateInPlace_Internal(rdm));
3799: PetscCall(PetscObjectSetName((PetscObject)rdm, DMPolytopeTypes[ct]));
3800: PetscFunctionReturn(PETSC_SUCCESS);
3801: }
3803: /*@
3804: DMPlexCreateReferenceCell - Create a `DMPLEX` with the appropriate FEM reference cell
3806: Collective
3808: Input Parameters:
3809: + comm - The communicator
3810: - ct - The cell type of the reference cell
3812: Output Parameter:
3813: . refdm - The reference cell
3815: Level: intermediate
3817: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexCreateBoxMesh()`
3818: @*/
3819: PetscErrorCode DMPlexCreateReferenceCell(MPI_Comm comm, DMPolytopeType ct, DM *refdm)
3820: {
3821: PetscFunctionBegin;
3822: PetscCall(DMCreate(comm, refdm));
3823: PetscCall(DMSetType(*refdm, DMPLEX));
3824: PetscCall(DMPlexCreateReferenceCell_Internal(*refdm, ct));
3825: PetscFunctionReturn(PETSC_SUCCESS);
3826: }
3828: static PetscErrorCode DMPlexCreateBoundaryLabel_Private(DM dm, const char name[])
3829: {
3830: DM plex;
3831: DMLabel label;
3832: PetscBool hasLabel;
3834: PetscFunctionBegin;
3835: PetscCall(DMHasLabel(dm, name, &hasLabel));
3836: if (hasLabel) PetscFunctionReturn(PETSC_SUCCESS);
3837: PetscCall(DMCreateLabel(dm, name));
3838: PetscCall(DMGetLabel(dm, name, &label));
3839: PetscCall(DMConvert(dm, DMPLEX, &plex));
3840: PetscCall(DMPlexMarkBoundaryFaces(plex, 1, label));
3841: PetscCall(DMPlexLabelComplete(plex, label));
3842: PetscCall(DMDestroy(&plex));
3843: PetscFunctionReturn(PETSC_SUCCESS);
3844: }
3846: /*
3847: We use the last coordinate as the radius, the inner radius is lower[dim-1] and the outer radius is upper[dim-1]. Then we map the first coordinate around the circle.
3849: (x, y) -> (r, theta) = (x[1], (x[0] - lower[0]) * 2\pi/(upper[0] - lower[0]))
3850: */
3851: static void boxToAnnulus(PetscInt dim, PetscInt Nf, PetscInt NfAux, const PetscInt uOff[], const PetscInt uOff_x[], const PetscScalar u[], const PetscScalar u_t[], const PetscScalar u_x[], const PetscInt aOff[], const PetscInt aOff_x[], const PetscScalar a[], const PetscScalar a_t[], const PetscScalar a_x[], PetscReal t, const PetscReal x[], PetscInt numConstants, const PetscScalar constants[], PetscScalar f0[])
3852: {
3853: const PetscReal low = PetscRealPart(constants[0]);
3854: const PetscReal upp = PetscRealPart(constants[1]);
3855: const PetscReal r = PetscRealPart(u[1]);
3856: const PetscReal th = 2. * PETSC_PI * (PetscRealPart(u[0]) - low) / (upp - low);
3858: f0[0] = r * PetscCosReal(th);
3859: f0[1] = r * PetscSinReal(th);
3860: }
3862: PETSC_EXTERN PetscErrorCode PetscOptionsFindPairPrefix_Private(PetscOptions, const char pre[], const char name[], const char *option[], const char *value[], PetscBool *flg);
3864: const char *const DMPlexShapes[] = {"box", "box_surface", "ball", "sphere", "cylinder", "schwarz_p", "gyroid", "doublet", "annulus", "hypercubic", "zbox", "unknown", "DMPlexShape", "DM_SHAPE_", NULL};
3866: static PetscErrorCode DMPlexCreateFromOptions_Internal(PetscOptionItems *PetscOptionsObject, PetscBool *useCoordSpace, DM dm)
3867: {
3868: DMPlexShape shape = DM_SHAPE_BOX;
3869: DMPolytopeType cell = DM_POLYTOPE_TRIANGLE;
3870: PetscInt dim = 2;
3871: PetscBool simplex = PETSC_TRUE, interpolate = PETSC_TRUE, adjCone = PETSC_FALSE, adjClosure = PETSC_TRUE, refDomain = PETSC_FALSE;
3872: PetscBool flg, flg2, fflg, bdfflg, nameflg;
3873: MPI_Comm comm;
3874: char filename[PETSC_MAX_PATH_LEN] = "<unspecified>";
3875: char bdFilename[PETSC_MAX_PATH_LEN] = "<unspecified>";
3876: char plexname[PETSC_MAX_PATH_LEN] = "";
3877: const char *option;
3879: PetscFunctionBegin;
3880: PetscCall(PetscLogEventBegin(DMPLEX_CreateFromOptions, dm, 0, 0, 0));
3881: PetscCall(PetscObjectGetComm((PetscObject)dm, &comm));
3882: /* TODO Turn this into a registration interface */
3883: PetscCall(PetscOptionsString("-dm_plex_filename", "File containing a mesh", "DMPlexCreateFromFile", filename, filename, sizeof(filename), &fflg));
3884: PetscCall(PetscOptionsString("-dm_plex_boundary_filename", "File containing a mesh boundary", "DMPlexCreateFromFile", bdFilename, bdFilename, sizeof(bdFilename), &bdfflg));
3885: PetscCall(PetscOptionsString("-dm_plex_name", "Name of the mesh in the file", "DMPlexCreateFromFile", plexname, plexname, sizeof(plexname), &nameflg));
3886: PetscCall(PetscOptionsEnum("-dm_plex_cell", "Cell shape", "", DMPolytopeTypes, (PetscEnum)cell, (PetscEnum *)&cell, NULL));
3887: PetscCall(PetscOptionsBool("-dm_plex_reference_cell_domain", "Use a reference cell domain", "", refDomain, &refDomain, NULL));
3888: PetscCall(PetscOptionsEnum("-dm_plex_shape", "Shape for built-in mesh", "", DMPlexShapes, (PetscEnum)shape, (PetscEnum *)&shape, &flg));
3889: PetscCall(PetscOptionsBoundedInt("-dm_plex_dim", "Topological dimension of the mesh", "DMGetDimension", dim, &dim, &flg, 0));
3890: PetscCall(PetscOptionsBool("-dm_plex_simplex", "Mesh cell shape", "", simplex, &simplex, &flg));
3891: PetscCall(PetscOptionsBool("-dm_plex_interpolate", "Flag to create edges and faces automatically", "", interpolate, &interpolate, &flg));
3892: PetscCall(PetscOptionsBool("-dm_plex_adj_cone", "Set adjacency direction", "DMSetBasicAdjacency", adjCone, &adjCone, &flg));
3893: PetscCall(PetscOptionsBool("-dm_plex_adj_closure", "Set adjacency size", "DMSetBasicAdjacency", adjClosure, &adjClosure, &flg2));
3894: if (flg || flg2) PetscCall(DMSetBasicAdjacency(dm, adjCone, adjClosure));
3896: switch (cell) {
3897: case DM_POLYTOPE_POINT:
3898: case DM_POLYTOPE_SEGMENT:
3899: case DM_POLYTOPE_POINT_PRISM_TENSOR:
3900: case DM_POLYTOPE_TRIANGLE:
3901: case DM_POLYTOPE_QUADRILATERAL:
3902: case DM_POLYTOPE_TETRAHEDRON:
3903: case DM_POLYTOPE_HEXAHEDRON:
3904: *useCoordSpace = PETSC_TRUE;
3905: break;
3906: default:
3907: *useCoordSpace = PETSC_FALSE;
3908: break;
3909: }
3911: if (fflg) {
3912: DM dmnew;
3914: PetscCall(DMPlexCreateFromFile(PetscObjectComm((PetscObject)dm), filename, plexname, interpolate, &dmnew));
3915: PetscCall(DMPlexCopy_Internal(dm, PETSC_FALSE, PETSC_FALSE, dmnew));
3916: PetscCall(DMPlexReplace_Internal(dm, &dmnew));
3917: } else if (refDomain) {
3918: PetscCall(DMPlexCreateReferenceCell_Internal(dm, cell));
3919: } else if (bdfflg) {
3920: DM bdm, dmnew;
3922: PetscCall(DMPlexCreateFromFile(PetscObjectComm((PetscObject)dm), bdFilename, plexname, interpolate, &bdm));
3923: PetscCall(PetscObjectSetOptionsPrefix((PetscObject)bdm, "bd_"));
3924: PetscCall(DMSetFromOptions(bdm));
3925: PetscCall(DMPlexGenerate(bdm, NULL, interpolate, &dmnew));
3926: PetscCall(DMDestroy(&bdm));
3927: PetscCall(DMPlexCopy_Internal(dm, PETSC_FALSE, PETSC_FALSE, dmnew));
3928: PetscCall(DMPlexReplace_Internal(dm, &dmnew));
3929: } else {
3930: PetscCall(PetscObjectSetName((PetscObject)dm, DMPlexShapes[shape]));
3931: switch (shape) {
3932: case DM_SHAPE_BOX:
3933: case DM_SHAPE_ZBOX:
3934: case DM_SHAPE_ANNULUS: {
3935: PetscInt faces[3] = {0, 0, 0};
3936: PetscReal lower[3] = {0, 0, 0};
3937: PetscReal upper[3] = {1, 1, 1};
3938: DMBoundaryType bdt[3] = {DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE};
3939: PetscBool isAnnular = shape == DM_SHAPE_ANNULUS ? PETSC_TRUE : PETSC_FALSE;
3940: PetscInt i, n;
3942: n = dim;
3943: for (i = 0; i < dim; ++i) faces[i] = (dim == 1 ? 1 : 4 - dim);
3944: PetscCall(PetscOptionsIntArray("-dm_plex_box_faces", "Number of faces along each dimension", "", faces, &n, &flg));
3945: n = 3;
3946: PetscCall(PetscOptionsRealArray("-dm_plex_box_lower", "Lower left corner of box", "", lower, &n, &flg));
3947: PetscCheck(!flg || !(n != dim), comm, PETSC_ERR_ARG_SIZ, "Lower box point had %" PetscInt_FMT " values, should have been %" PetscInt_FMT, n, dim);
3948: n = 3;
3949: PetscCall(PetscOptionsRealArray("-dm_plex_box_upper", "Upper right corner of box", "", upper, &n, &flg));
3950: PetscCheck(!flg || !(n != dim), comm, PETSC_ERR_ARG_SIZ, "Upper box point had %" PetscInt_FMT " values, should have been %" PetscInt_FMT, n, dim);
3951: n = 3;
3952: PetscCall(PetscOptionsEnumArray("-dm_plex_box_bd", "Boundary type for each dimension", "", DMBoundaryTypes, (PetscEnum *)bdt, &n, &flg));
3953: PetscCheck(!flg || !(n != dim), comm, PETSC_ERR_ARG_SIZ, "Box boundary types had %" PetscInt_FMT " values, should have been %" PetscInt_FMT, n, dim);
3955: PetscCheck(!isAnnular || dim == 2, comm, PETSC_ERR_ARG_OUTOFRANGE, "Only two dimensional annuli have been implemented");
3956: if (isAnnular)
3957: for (i = 0; i < dim - 1; ++i) bdt[i] = DM_BOUNDARY_PERIODIC;
3959: switch (cell) {
3960: case DM_POLYTOPE_TRI_PRISM_TENSOR:
3961: PetscCall(DMPlexCreateWedgeBoxMesh_Internal(dm, faces, lower, upper, bdt));
3962: if (!interpolate) {
3963: DM udm;
3965: PetscCall(DMPlexUninterpolate(dm, &udm));
3966: PetscCall(DMPlexReplace_Internal(dm, &udm));
3967: }
3968: break;
3969: default:
3970: PetscCall(DMPlexCreateBoxMesh_Internal(dm, shape, dim, simplex, faces, lower, upper, bdt, interpolate));
3971: break;
3972: }
3973: if (isAnnular) {
3974: DM cdm;
3975: PetscDS cds;
3976: PetscScalar bounds[2] = {lower[0], upper[0]};
3978: // Fix coordinates for annular region
3979: PetscCall(DMSetPeriodicity(dm, NULL, NULL, NULL));
3980: PetscCall(DMSetCellCoordinatesLocal(dm, NULL));
3981: PetscCall(DMSetCellCoordinates(dm, NULL));
3982: PetscCall(DMPlexCreateCoordinateSpace(dm, 1, PETSC_TRUE, NULL));
3983: PetscCall(DMGetCoordinateDM(dm, &cdm));
3984: PetscCall(DMGetDS(cdm, &cds));
3985: PetscCall(PetscDSSetConstants(cds, 2, bounds));
3986: PetscCall(DMPlexRemapGeometry(dm, 0.0, boxToAnnulus));
3987: }
3988: } break;
3989: case DM_SHAPE_BOX_SURFACE: {
3990: PetscInt faces[3] = {0, 0, 0};
3991: PetscReal lower[3] = {0, 0, 0};
3992: PetscReal upper[3] = {1, 1, 1};
3993: PetscInt i, n;
3995: n = dim + 1;
3996: for (i = 0; i < dim + 1; ++i) faces[i] = (dim + 1 == 1 ? 1 : 4 - (dim + 1));
3997: PetscCall(PetscOptionsIntArray("-dm_plex_box_faces", "Number of faces along each dimension", "", faces, &n, &flg));
3998: n = 3;
3999: PetscCall(PetscOptionsRealArray("-dm_plex_box_lower", "Lower left corner of box", "", lower, &n, &flg));
4000: PetscCheck(!flg || !(n != dim + 1), comm, PETSC_ERR_ARG_SIZ, "Lower box point had %" PetscInt_FMT " values, should have been %" PetscInt_FMT, n, dim + 1);
4001: n = 3;
4002: PetscCall(PetscOptionsRealArray("-dm_plex_box_upper", "Upper right corner of box", "", upper, &n, &flg));
4003: PetscCheck(!flg || !(n != dim + 1), comm, PETSC_ERR_ARG_SIZ, "Upper box point had %" PetscInt_FMT " values, should have been %" PetscInt_FMT, n, dim + 1);
4004: PetscCall(DMPlexCreateBoxSurfaceMesh_Internal(dm, dim + 1, faces, lower, upper, interpolate));
4005: } break;
4006: case DM_SHAPE_SPHERE: {
4007: PetscReal R = 1.0;
4009: PetscCall(PetscOptionsReal("-dm_plex_sphere_radius", "Radius of the sphere", "", R, &R, &flg));
4010: PetscCall(DMPlexCreateSphereMesh_Internal(dm, dim, simplex, R));
4011: } break;
4012: case DM_SHAPE_BALL: {
4013: PetscReal R = 1.0;
4015: PetscCall(PetscOptionsReal("-dm_plex_ball_radius", "Radius of the ball", "", R, &R, &flg));
4016: PetscCall(DMPlexCreateBallMesh_Internal(dm, dim, R));
4017: } break;
4018: case DM_SHAPE_CYLINDER: {
4019: DMBoundaryType bdt = DM_BOUNDARY_NONE;
4020: PetscInt Nw = 6;
4022: PetscCall(PetscOptionsEnum("-dm_plex_cylinder_bd", "Boundary type in the z direction", "", DMBoundaryTypes, (PetscEnum)bdt, (PetscEnum *)&bdt, NULL));
4023: PetscCall(PetscOptionsInt("-dm_plex_cylinder_num_wedges", "Number of wedges around the cylinder", "", Nw, &Nw, NULL));
4024: switch (cell) {
4025: case DM_POLYTOPE_TRI_PRISM_TENSOR:
4026: PetscCall(DMPlexCreateWedgeCylinderMesh_Internal(dm, Nw, interpolate));
4027: break;
4028: default:
4029: PetscCall(DMPlexCreateHexCylinderMesh_Internal(dm, bdt));
4030: break;
4031: }
4032: } break;
4033: case DM_SHAPE_SCHWARZ_P: // fallthrough
4034: case DM_SHAPE_GYROID: {
4035: PetscInt extent[3] = {1, 1, 1}, refine = 0, layers = 0, three;
4036: PetscReal thickness = 0.;
4037: DMBoundaryType periodic[3] = {DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE};
4038: DMPlexTPSType tps_type = shape == DM_SHAPE_SCHWARZ_P ? DMPLEX_TPS_SCHWARZ_P : DMPLEX_TPS_GYROID;
4039: PetscBool tps_distribute;
4040: PetscCall(PetscOptionsIntArray("-dm_plex_tps_extent", "Number of replicas for each of three dimensions", NULL, extent, (three = 3, &three), NULL));
4041: PetscCall(PetscOptionsInt("-dm_plex_tps_refine", "Number of refinements", NULL, refine, &refine, NULL));
4042: PetscCall(PetscOptionsEnumArray("-dm_plex_tps_periodic", "Periodicity in each of three dimensions", NULL, DMBoundaryTypes, (PetscEnum *)periodic, (three = 3, &three), NULL));
4043: PetscCall(PetscOptionsInt("-dm_plex_tps_layers", "Number of layers in volumetric extrusion (or zero to not extrude)", NULL, layers, &layers, NULL));
4044: PetscCall(PetscOptionsReal("-dm_plex_tps_thickness", "Thickness of volumetric extrusion", NULL, thickness, &thickness, NULL));
4045: PetscCall(DMPlexDistributeGetDefault(dm, &tps_distribute));
4046: PetscCall(PetscOptionsBool("-dm_plex_tps_distribute", "Distribute the 2D mesh prior to refinement and extrusion", NULL, tps_distribute, &tps_distribute, NULL));
4047: PetscCall(DMPlexCreateTPSMesh_Internal(dm, tps_type, extent, periodic, tps_distribute, refine, layers, thickness));
4048: } break;
4049: case DM_SHAPE_DOUBLET: {
4050: DM dmnew;
4051: PetscReal rl = 0.0;
4053: PetscCall(PetscOptionsReal("-dm_plex_doublet_refinementlimit", "Refinement limit", NULL, rl, &rl, NULL));
4054: PetscCall(DMPlexCreateDoublet(PetscObjectComm((PetscObject)dm), dim, simplex, interpolate, rl, &dmnew));
4055: PetscCall(DMPlexCopy_Internal(dm, PETSC_FALSE, PETSC_FALSE, dmnew));
4056: PetscCall(DMPlexReplace_Internal(dm, &dmnew));
4057: } break;
4058: case DM_SHAPE_HYPERCUBIC: {
4059: PetscInt *edges;
4060: PetscReal *lower, *upper;
4061: DMBoundaryType *bdt;
4062: PetscInt n, d;
4064: *useCoordSpace = PETSC_FALSE;
4065: PetscCall(PetscMalloc4(dim, &edges, dim, &lower, dim, &upper, dim, &bdt));
4066: for (d = 0; d < dim; ++d) {
4067: edges[d] = 1;
4068: lower[d] = 0.;
4069: upper[d] = 1.;
4070: bdt[d] = DM_BOUNDARY_PERIODIC;
4071: }
4072: n = dim;
4073: PetscCall(PetscOptionsIntArray("-dm_plex_box_faces", "Number of faces along each dimension", "", edges, &n, &flg));
4074: n = dim;
4075: PetscCall(PetscOptionsRealArray("-dm_plex_box_lower", "Lower left corner of box", "", lower, &n, &flg));
4076: PetscCheck(!flg || n == dim, comm, PETSC_ERR_ARG_SIZ, "Lower box point had %" PetscInt_FMT " values, should have been %" PetscInt_FMT, n, dim);
4077: n = dim;
4078: PetscCall(PetscOptionsRealArray("-dm_plex_box_upper", "Upper right corner of box", "", upper, &n, &flg));
4079: PetscCheck(!flg || n == dim, comm, PETSC_ERR_ARG_SIZ, "Upper box point had %" PetscInt_FMT " values, should have been %" PetscInt_FMT, n, dim);
4080: n = dim;
4081: PetscCall(PetscOptionsEnumArray("-dm_plex_box_bd", "Boundary type for each dimension", "", DMBoundaryTypes, (PetscEnum *)bdt, &n, &flg));
4082: PetscCheck(!flg || n == dim, comm, PETSC_ERR_ARG_SIZ, "Box boundary types had %" PetscInt_FMT " values, should have been %" PetscInt_FMT, n, dim);
4083: PetscCall(DMPlexCreateHypercubicMesh_Internal(dm, dim, lower, upper, edges, bdt));
4084: PetscCall(PetscFree4(edges, lower, upper, bdt));
4085: } break;
4086: default:
4087: SETERRQ(comm, PETSC_ERR_SUP, "Domain shape %s is unsupported", DMPlexShapes[shape]);
4088: }
4089: }
4090: PetscCall(DMPlexSetRefinementUniform(dm, PETSC_TRUE));
4091: if (!((PetscObject)dm)->name && nameflg) PetscCall(PetscObjectSetName((PetscObject)dm, plexname));
4092: // Allow label creation
4093: PetscCall(PetscOptionsFindPairPrefix_Private(NULL, ((PetscObject)dm)->prefix, "-dm_plex_label_", &option, NULL, &flg));
4094: if (flg) {
4095: DMLabel label;
4096: PetscInt points[1024], n = 1024;
4097: char fulloption[PETSC_MAX_PATH_LEN];
4098: const char *name = &option[14];
4100: PetscCall(DMCreateLabel(dm, name));
4101: PetscCall(DMGetLabel(dm, name, &label));
4102: fulloption[0] = '-';
4103: fulloption[1] = 0;
4104: PetscCall(PetscStrlcat(fulloption, option, PETSC_MAX_PATH_LEN));
4105: PetscCall(PetscOptionsGetIntArray(NULL, ((PetscObject)dm)->prefix, fulloption, points, &n, NULL));
4106: for (PetscInt p = 0; p < n; ++p) PetscCall(DMLabelSetValue(label, points[p], 1));
4107: }
4108: PetscCall(PetscLogEventEnd(DMPLEX_CreateFromOptions, dm, 0, 0, 0));
4109: PetscFunctionReturn(PETSC_SUCCESS);
4110: }
4112: PetscErrorCode DMSetFromOptions_NonRefinement_Plex(DM dm, PetscOptionItems *PetscOptionsObject)
4113: {
4114: DM_Plex *mesh = (DM_Plex *)dm->data;
4115: PetscBool flg, flg2;
4116: char bdLabel[PETSC_MAX_PATH_LEN];
4117: char method[PETSC_MAX_PATH_LEN];
4119: PetscFunctionBegin;
4120: /* Handle viewing */
4121: PetscCall(PetscOptionsBool("-dm_plex_print_set_values", "Output all set values info", "DMPlexMatSetClosure", PETSC_FALSE, &mesh->printSetValues, NULL));
4122: PetscCall(PetscOptionsBoundedInt("-dm_plex_print_fem", "Debug output level for all fem computations", "DMPlexSNESComputeResidualFEM", 0, &mesh->printFEM, NULL, 0));
4123: PetscCall(PetscOptionsBoundedInt("-dm_plex_print_fvm", "Debug output level for all fvm computations", "DMPlexSNESComputeResidualFVM", 0, &mesh->printFVM, NULL, 0));
4124: PetscCall(PetscOptionsReal("-dm_plex_print_tol", "Tolerance for FEM output", "DMPlexSNESComputeResidualFEM", mesh->printTol, &mesh->printTol, NULL));
4125: PetscCall(PetscOptionsBoundedInt("-dm_plex_print_l2", "Debug output level all L2 diff computations", "DMComputeL2Diff", 0, &mesh->printL2, NULL, 0));
4126: PetscCall(PetscOptionsBoundedInt("-dm_plex_print_locate", "Debug output level all point location computations", "DMLocatePoints", 0, &mesh->printLocate, NULL, 0));
4127: PetscCall(DMMonitorSetFromOptions(dm, "-dm_plex_monitor_throughput", "Monitor the simulation throughput", "DMPlexMonitorThroughput", DMPlexMonitorThroughput, NULL, &flg));
4128: if (flg) PetscCall(PetscLogDefaultBegin());
4129: /* Labeling */
4130: PetscCall(PetscOptionsString("-dm_plex_boundary_label", "Label to mark the mesh boundary", "", bdLabel, bdLabel, sizeof(bdLabel), &flg));
4131: if (flg) PetscCall(DMPlexCreateBoundaryLabel_Private(dm, bdLabel));
4132: /* Point Location */
4133: PetscCall(PetscOptionsBool("-dm_plex_hash_location", "Use grid hashing for point location", "DMInterpolate", PETSC_FALSE, &mesh->useHashLocation, NULL));
4134: /* Partitioning and distribution */
4135: PetscCall(PetscOptionsBool("-dm_plex_partition_balance", "Attempt to evenly divide points on partition boundary between processes", "DMPlexSetPartitionBalance", PETSC_FALSE, &mesh->partitionBalance, NULL));
4136: /* Reordering */
4137: PetscCall(PetscOptionsBool("-dm_reorder_section", "Compute point permutation for local section", "DMReorderSectionSetDefault", PETSC_FALSE, &flg2, &flg));
4138: if (flg) PetscCall(DMReorderSectionSetDefault(dm, flg2 ? DM_REORDER_DEFAULT_TRUE : DM_REORDER_DEFAULT_FALSE));
4139: PetscCall(PetscOptionsString("-dm_reorder_section_type", "Reordering method for local section", "DMReorderSectionSetType", method, method, PETSC_MAX_PATH_LEN, &flg));
4140: if (flg) PetscCall(DMReorderSectionSetType(dm, method));
4141: /* Generation and remeshing */
4142: PetscCall(PetscOptionsBool("-dm_plex_remesh_bd", "Allow changes to the boundary on remeshing", "DMAdapt", PETSC_FALSE, &mesh->remeshBd, NULL));
4143: /* Projection behavior */
4144: PetscCall(PetscOptionsBoundedInt("-dm_plex_max_projection_height", "Maximum mesh point height used to project locally", "DMPlexSetMaxProjectionHeight", 0, &mesh->maxProjectionHeight, NULL, 0));
4145: PetscCall(PetscOptionsBool("-dm_plex_regular_refinement", "Use special nested projection algorithm for regular refinement", "DMPlexSetRegularRefinement", mesh->regularRefinement, &mesh->regularRefinement, NULL));
4146: /* Checking structure */
4147: {
4148: PetscBool all = PETSC_FALSE;
4150: PetscCall(PetscOptionsBool("-dm_plex_check_all", "Perform all basic checks", "DMPlexCheck", PETSC_FALSE, &all, NULL));
4151: if (all) {
4152: PetscCall(DMPlexCheck(dm));
4153: } else {
4154: PetscCall(PetscOptionsBool("-dm_plex_check_symmetry", "Check that the adjacency information in the mesh is symmetric", "DMPlexCheckSymmetry", PETSC_FALSE, &flg, &flg2));
4155: if (flg && flg2) PetscCall(DMPlexCheckSymmetry(dm));
4156: PetscCall(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));
4157: if (flg && flg2) PetscCall(DMPlexCheckSkeleton(dm, 0));
4158: PetscCall(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));
4159: if (flg && flg2) PetscCall(DMPlexCheckFaces(dm, 0));
4160: PetscCall(PetscOptionsBool("-dm_plex_check_geometry", "Check that cells have positive volume", "DMPlexCheckGeometry", PETSC_FALSE, &flg, &flg2));
4161: if (flg && flg2) PetscCall(DMPlexCheckGeometry(dm));
4162: PetscCall(PetscOptionsBool("-dm_plex_check_pointsf", "Check some necessary conditions for PointSF", "DMPlexCheckPointSF", PETSC_FALSE, &flg, &flg2));
4163: if (flg && flg2) PetscCall(DMPlexCheckPointSF(dm, NULL, PETSC_FALSE));
4164: PetscCall(PetscOptionsBool("-dm_plex_check_interface_cones", "Check points on inter-partition interfaces have conforming order of cone points", "DMPlexCheckInterfaceCones", PETSC_FALSE, &flg, &flg2));
4165: if (flg && flg2) PetscCall(DMPlexCheckInterfaceCones(dm));
4166: }
4167: PetscCall(PetscOptionsBool("-dm_plex_check_cell_shape", "Check cell shape", "DMPlexCheckCellShape", PETSC_FALSE, &flg, &flg2));
4168: if (flg && flg2) PetscCall(DMPlexCheckCellShape(dm, PETSC_TRUE, PETSC_DETERMINE));
4169: }
4170: {
4171: PetscReal scale = 1.0;
4173: PetscCall(PetscOptionsReal("-dm_plex_scale", "Scale factor for mesh coordinates", "DMPlexScale", scale, &scale, &flg));
4174: if (flg) {
4175: Vec coordinates, coordinatesLocal;
4177: PetscCall(DMGetCoordinates(dm, &coordinates));
4178: PetscCall(DMGetCoordinatesLocal(dm, &coordinatesLocal));
4179: PetscCall(VecScale(coordinates, scale));
4180: PetscCall(VecScale(coordinatesLocal, scale));
4181: }
4182: }
4183: PetscCall(PetscPartitionerSetFromOptions(mesh->partitioner));
4184: PetscFunctionReturn(PETSC_SUCCESS);
4185: }
4187: PetscErrorCode DMSetFromOptions_Overlap_Plex(DM dm, PetscOptionItems *PetscOptionsObject, PetscInt *overlap)
4188: {
4189: PetscInt numOvLabels = 16, numOvExLabels = 16;
4190: char *ovLabelNames[16], *ovExLabelNames[16];
4191: PetscInt numOvValues = 16, numOvExValues = 16, l;
4192: PetscBool flg;
4194: PetscFunctionBegin;
4195: PetscCall(PetscOptionsBoundedInt("-dm_distribute_overlap", "The size of the overlap halo", "DMPlexDistribute", *overlap, overlap, NULL, 0));
4196: PetscCall(PetscOptionsStringArray("-dm_distribute_overlap_labels", "List of overlap label names", "DMPlexDistribute", ovLabelNames, &numOvLabels, &flg));
4197: if (!flg) numOvLabels = 0;
4198: if (numOvLabels) {
4199: ((DM_Plex *)dm->data)->numOvLabels = numOvLabels;
4200: for (l = 0; l < numOvLabels; ++l) {
4201: PetscCall(DMGetLabel(dm, ovLabelNames[l], &((DM_Plex *)dm->data)->ovLabels[l]));
4202: PetscCheck(((DM_Plex *)dm->data)->ovLabels[l], PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Invalid label name %s", ovLabelNames[l]);
4203: PetscCall(PetscFree(ovLabelNames[l]));
4204: }
4205: PetscCall(PetscOptionsIntArray("-dm_distribute_overlap_values", "List of overlap label values", "DMPlexDistribute", ((DM_Plex *)dm->data)->ovValues, &numOvValues, &flg));
4206: if (!flg) numOvValues = 0;
4207: PetscCheck(numOvLabels == numOvValues, PETSC_COMM_SELF, PETSC_ERR_ARG_INCOMP, "The number of labels %" PetscInt_FMT " must match the number of values %" PetscInt_FMT, numOvLabels, numOvValues);
4209: PetscCall(PetscOptionsStringArray("-dm_distribute_overlap_exclude_labels", "List of overlap exclude label names", "DMPlexDistribute", ovExLabelNames, &numOvExLabels, &flg));
4210: if (!flg) numOvExLabels = 0;
4211: ((DM_Plex *)dm->data)->numOvExLabels = numOvExLabels;
4212: for (l = 0; l < numOvExLabels; ++l) {
4213: PetscCall(DMGetLabel(dm, ovExLabelNames[l], &((DM_Plex *)dm->data)->ovExLabels[l]));
4214: PetscCheck(((DM_Plex *)dm->data)->ovExLabels[l], PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Invalid label name %s", ovExLabelNames[l]);
4215: PetscCall(PetscFree(ovExLabelNames[l]));
4216: }
4217: PetscCall(PetscOptionsIntArray("-dm_distribute_overlap_exclude_values", "List of overlap exclude label values", "DMPlexDistribute", ((DM_Plex *)dm->data)->ovExValues, &numOvExValues, &flg));
4218: if (!flg) numOvExValues = 0;
4219: PetscCheck(numOvExLabels == numOvExValues, PETSC_COMM_SELF, PETSC_ERR_ARG_INCOMP, "The number of exclude labels %" PetscInt_FMT " must match the number of values %" PetscInt_FMT, numOvExLabels, numOvExValues);
4220: }
4221: PetscFunctionReturn(PETSC_SUCCESS);
4222: }
4224: static PetscErrorCode DMSetFromOptions_Plex(DM dm, PetscOptionItems *PetscOptionsObject)
4225: {
4226: PetscFunctionList ordlist;
4227: char oname[256];
4228: char sublabelname[PETSC_MAX_PATH_LEN] = "";
4229: DMReorderDefaultFlag reorder;
4230: PetscReal volume = -1.0;
4231: PetscInt prerefine = 0, refine = 0, r, coarsen = 0, overlap = 0, extLayers = 0, dim;
4232: PetscBool uniformOrig = PETSC_FALSE, created = PETSC_FALSE, uniform = PETSC_TRUE, distribute, saveSF = PETSC_FALSE, interpolate = PETSC_TRUE, coordSpace = PETSC_TRUE, remap = PETSC_TRUE, ghostCells = PETSC_FALSE, isHierarchy, ignoreModel = PETSC_FALSE, flg;
4234: PetscFunctionBegin;
4235: PetscOptionsHeadBegin(PetscOptionsObject, "DMPlex Options");
4236: if (dm->cloneOpts) goto non_refine;
4237: /* Handle automatic creation */
4238: PetscCall(DMGetDimension(dm, &dim));
4239: if (dim < 0) {
4240: PetscCall(DMPlexCreateFromOptions_Internal(PetscOptionsObject, &coordSpace, dm));
4241: created = PETSC_TRUE;
4242: }
4243: PetscCall(DMGetDimension(dm, &dim));
4244: /* Handle interpolation before distribution */
4245: PetscCall(PetscOptionsBool("-dm_plex_interpolate_pre", "Flag to interpolate mesh before distribution", "", interpolate, &interpolate, &flg));
4246: if (flg) {
4247: DMPlexInterpolatedFlag interpolated;
4249: PetscCall(DMPlexIsInterpolated(dm, &interpolated));
4250: if (interpolated == DMPLEX_INTERPOLATED_FULL && !interpolate) {
4251: DM udm;
4253: PetscCall(DMPlexUninterpolate(dm, &udm));
4254: PetscCall(DMPlexReplace_Internal(dm, &udm));
4255: } else if (interpolated != DMPLEX_INTERPOLATED_FULL && interpolate) {
4256: DM idm;
4258: PetscCall(DMPlexInterpolate(dm, &idm));
4259: PetscCall(DMPlexReplace_Internal(dm, &idm));
4260: }
4261: }
4262: // Handle submesh selection before distribution
4263: PetscCall(PetscOptionsString("-dm_plex_submesh", "Label to use for submesh selection", "", sublabelname, sublabelname, PETSC_MAX_PATH_LEN, &flg));
4264: if (flg) {
4265: DM subdm;
4266: DMLabel label;
4267: IS valueIS, pointIS;
4268: const PetscInt *values, *points;
4269: PetscBool markedFaces = PETSC_FALSE;
4270: PetscInt Nv, value, Np;
4272: PetscCall(DMGetLabel(dm, sublabelname, &label));
4273: PetscCall(DMLabelGetNumValues(label, &Nv));
4274: PetscCheck(Nv == 1, PetscObjectComm((PetscObject)dm), PETSC_ERR_SUP, "Only a single label value is currently supported for submesh selection, not %" PetscInt_FMT, Nv);
4275: PetscCall(DMLabelGetValueIS(label, &valueIS));
4276: PetscCall(ISGetIndices(valueIS, &values));
4277: value = values[0];
4278: PetscCall(ISRestoreIndices(valueIS, &values));
4279: PetscCall(ISDestroy(&valueIS));
4280: PetscCall(DMLabelGetStratumSize(label, value, &Np));
4281: PetscCall(DMLabelGetStratumIS(label, value, &pointIS));
4282: PetscCall(ISGetIndices(pointIS, &points));
4283: for (PetscInt p = 0; p < Np; ++p) {
4284: PetscInt pdepth;
4286: PetscCall(DMPlexGetPointDepth(dm, points[p], &pdepth));
4287: if (pdepth) {
4288: markedFaces = PETSC_TRUE;
4289: break;
4290: }
4291: }
4292: PetscCall(ISRestoreIndices(pointIS, &points));
4293: PetscCall(ISDestroy(&pointIS));
4294: PetscCall(DMPlexCreateSubmesh(dm, label, value, markedFaces, &subdm));
4295: PetscCall(DMPlexReplace_Internal(dm, &subdm));
4296: PetscCall(DMSetFromOptions_NonRefinement_Plex(dm, PetscOptionsObject));
4297: }
4298: /* Handle DMPlex refinement before distribution */
4299: PetscCall(PetscOptionsBool("-dm_refine_ignore_model", "Flag to ignore the geometry model when refining", "DMCreate", ignoreModel, &ignoreModel, &flg));
4300: if (flg) ((DM_Plex *)dm->data)->ignoreModel = ignoreModel;
4301: PetscCall(DMPlexGetRefinementUniform(dm, &uniformOrig));
4302: PetscCall(PetscOptionsBoundedInt("-dm_refine_pre", "The number of refinements before distribution", "DMCreate", prerefine, &prerefine, NULL, 0));
4303: PetscCall(PetscOptionsBool("-dm_refine_remap_pre", "Flag to control coordinate remapping", "DMCreate", remap, &remap, NULL));
4304: PetscCall(PetscOptionsBool("-dm_refine_uniform_pre", "Flag for uniform refinement before distribution", "DMCreate", uniform, &uniform, &flg));
4305: if (flg) PetscCall(DMPlexSetRefinementUniform(dm, uniform));
4306: PetscCall(PetscOptionsReal("-dm_refine_volume_limit_pre", "The maximum cell volume after refinement before distribution", "DMCreate", volume, &volume, &flg));
4307: if (flg) {
4308: PetscCall(DMPlexSetRefinementUniform(dm, PETSC_FALSE));
4309: PetscCall(DMPlexSetRefinementLimit(dm, volume));
4310: prerefine = PetscMax(prerefine, 1);
4311: }
4312: if (prerefine) PetscCall(DMLocalizeCoordinates(dm));
4313: for (r = 0; r < prerefine; ++r) {
4314: DM rdm;
4315: PetscPointFunc coordFunc = ((DM_Plex *)dm->data)->coordFunc;
4317: PetscCall(DMSetFromOptions_NonRefinement_Plex(dm, PetscOptionsObject));
4318: PetscCall(DMRefine(dm, PetscObjectComm((PetscObject)dm), &rdm));
4319: PetscCall(DMPlexReplace_Internal(dm, &rdm));
4320: PetscCall(DMSetFromOptions_NonRefinement_Plex(dm, PetscOptionsObject));
4321: if (coordFunc && remap) {
4322: PetscCall(DMPlexRemapGeometry(dm, 0.0, coordFunc));
4323: ((DM_Plex *)dm->data)->coordFunc = coordFunc;
4324: }
4325: }
4326: PetscCall(DMPlexSetRefinementUniform(dm, uniformOrig));
4327: /* Handle DMPlex extrusion before distribution */
4328: PetscCall(PetscOptionsBoundedInt("-dm_extrude", "The number of layers to extrude", "", extLayers, &extLayers, NULL, 0));
4329: if (extLayers) {
4330: DM edm;
4332: PetscCall(DMExtrude(dm, extLayers, &edm));
4333: PetscCall(DMPlexReplace_Internal(dm, &edm));
4334: ((DM_Plex *)dm->data)->coordFunc = NULL;
4335: PetscCall(DMSetFromOptions_NonRefinement_Plex(dm, PetscOptionsObject));
4336: extLayers = 0;
4337: PetscCall(DMGetDimension(dm, &dim));
4338: }
4339: /* Handle DMPlex reordering before distribution */
4340: PetscCall(DMPlexReorderGetDefault(dm, &reorder));
4341: PetscCall(MatGetOrderingList(&ordlist));
4342: PetscCall(PetscStrncpy(oname, MATORDERINGNATURAL, sizeof(oname)));
4343: PetscCall(PetscOptionsFList("-dm_plex_reorder", "Set mesh reordering type", "DMPlexGetOrdering", ordlist, MATORDERINGNATURAL, oname, sizeof(oname), &flg));
4344: if (reorder == DM_REORDER_DEFAULT_TRUE || flg) {
4345: DM pdm;
4346: IS perm;
4348: PetscCall(DMPlexGetOrdering(dm, oname, NULL, &perm));
4349: PetscCall(DMPlexPermute(dm, perm, &pdm));
4350: PetscCall(ISDestroy(&perm));
4351: PetscCall(DMPlexReplace_Internal(dm, &pdm));
4352: PetscCall(DMSetFromOptions_NonRefinement_Plex(dm, PetscOptionsObject));
4353: }
4354: /* Handle DMPlex distribution */
4355: PetscCall(DMPlexDistributeGetDefault(dm, &distribute));
4356: PetscCall(PetscOptionsBool("-dm_distribute", "Flag to redistribute a mesh among processes", "DMPlexDistribute", distribute, &distribute, NULL));
4357: PetscCall(PetscOptionsBool("-dm_distribute_save_sf", "Flag to save the migration SF", "DMPlexSetMigrationSF", saveSF, &saveSF, NULL));
4358: PetscCall(DMSetFromOptions_Overlap_Plex(dm, PetscOptionsObject, &overlap));
4359: if (distribute) {
4360: DM pdm = NULL;
4361: PetscPartitioner part;
4362: PetscSF sfMigration;
4364: PetscCall(DMPlexGetPartitioner(dm, &part));
4365: PetscCall(PetscPartitionerSetFromOptions(part));
4366: PetscCall(DMPlexDistribute(dm, overlap, &sfMigration, &pdm));
4367: if (pdm) PetscCall(DMPlexReplace_Internal(dm, &pdm));
4368: if (saveSF) PetscCall(DMPlexSetMigrationSF(dm, sfMigration));
4369: PetscCall(PetscSFDestroy(&sfMigration));
4370: }
4371: /* Must check CEED options before creating function space for coordinates */
4372: {
4373: PetscBool useCeed = PETSC_FALSE, flg;
4375: PetscCall(PetscOptionsBool("-dm_plex_use_ceed", "Use LibCEED as the FEM backend", "DMPlexSetUseCeed", useCeed, &useCeed, &flg));
4376: if (flg) PetscCall(DMPlexSetUseCeed(dm, useCeed));
4377: }
4378: /* Create coordinate space */
4379: if (created) {
4380: DM_Plex *mesh = (DM_Plex *)dm->data;
4381: PetscInt degree = 1, deg;
4382: PetscInt height = 0;
4383: DM cdm;
4384: PetscBool flg;
4386: PetscCall(PetscOptionsBool("-dm_coord_space", "Use an FEM space for coordinates", "", coordSpace, &coordSpace, &flg));
4387: PetscCall(PetscOptionsInt("-dm_coord_petscspace_degree", "FEM degree for coordinate space", "", degree, °ree, NULL));
4388: PetscCall(DMGetCoordinateDegree_Internal(dm, °));
4389: if (coordSpace && deg <= 1) PetscCall(DMPlexCreateCoordinateSpace(dm, degree, PETSC_TRUE, mesh->coordFunc));
4390: PetscCall(DMGetCoordinateDM(dm, &cdm));
4391: if (flg && !coordSpace) {
4392: PetscDS cds;
4393: PetscObject obj;
4394: PetscClassId id;
4396: PetscCall(DMGetDS(cdm, &cds));
4397: PetscCall(PetscDSGetDiscretization(cds, 0, &obj));
4398: PetscCall(PetscObjectGetClassId(obj, &id));
4399: if (id == PETSCFE_CLASSID) {
4400: PetscContainer dummy;
4402: PetscCall(PetscContainerCreate(PETSC_COMM_SELF, &dummy));
4403: PetscCall(PetscObjectSetName((PetscObject)dummy, "coordinates"));
4404: PetscCall(DMSetField(cdm, 0, NULL, (PetscObject)dummy));
4405: PetscCall(PetscContainerDestroy(&dummy));
4406: PetscCall(DMClearDS(cdm));
4407: }
4408: mesh->coordFunc = NULL;
4409: }
4410: PetscCall(PetscOptionsBool("-dm_sparse_localize", "Localize only necessary cells", "", dm->sparseLocalize, &dm->sparseLocalize, &flg));
4411: PetscCall(PetscOptionsInt("-dm_localize_height", "Localize edges and faces in addition to cells", "", height, &height, &flg));
4412: if (flg) PetscCall(DMPlexSetMaxProjectionHeight(cdm, height));
4413: PetscCall(DMLocalizeCoordinates(dm));
4414: }
4415: /* Handle DMPlex refinement */
4416: remap = PETSC_TRUE;
4417: PetscCall(PetscOptionsBoundedInt("-dm_refine", "The number of uniform refinements", "DMCreate", refine, &refine, NULL, 0));
4418: PetscCall(PetscOptionsBool("-dm_refine_remap", "Flag to control coordinate remapping", "DMCreate", remap, &remap, NULL));
4419: PetscCall(PetscOptionsBoundedInt("-dm_refine_hierarchy", "The number of uniform refinements", "DMCreate", refine, &refine, &isHierarchy, 0));
4420: if (refine) PetscCall(DMPlexSetRefinementUniform(dm, PETSC_TRUE));
4421: if (refine && isHierarchy) {
4422: DM *dms, coarseDM;
4424: PetscCall(DMGetCoarseDM(dm, &coarseDM));
4425: PetscCall(PetscObjectReference((PetscObject)coarseDM));
4426: PetscCall(PetscMalloc1(refine, &dms));
4427: PetscCall(DMRefineHierarchy(dm, refine, dms));
4428: /* Total hack since we do not pass in a pointer */
4429: PetscCall(DMPlexSwap_Static(dm, dms[refine - 1]));
4430: if (refine == 1) {
4431: PetscCall(DMSetCoarseDM(dm, dms[0]));
4432: PetscCall(DMPlexSetRegularRefinement(dm, PETSC_TRUE));
4433: } else {
4434: PetscCall(DMSetCoarseDM(dm, dms[refine - 2]));
4435: PetscCall(DMPlexSetRegularRefinement(dm, PETSC_TRUE));
4436: PetscCall(DMSetCoarseDM(dms[0], dms[refine - 1]));
4437: PetscCall(DMPlexSetRegularRefinement(dms[0], PETSC_TRUE));
4438: }
4439: PetscCall(DMSetCoarseDM(dms[refine - 1], coarseDM));
4440: PetscCall(PetscObjectDereference((PetscObject)coarseDM));
4441: /* Free DMs */
4442: for (r = 0; r < refine; ++r) {
4443: PetscCall(DMSetFromOptions_NonRefinement_Plex(dms[r], PetscOptionsObject));
4444: PetscCall(DMDestroy(&dms[r]));
4445: }
4446: PetscCall(PetscFree(dms));
4447: } else {
4448: for (r = 0; r < refine; ++r) {
4449: DM rdm;
4450: PetscPointFunc coordFunc = ((DM_Plex *)dm->data)->coordFunc;
4452: PetscCall(DMSetFromOptions_NonRefinement_Plex(dm, PetscOptionsObject));
4453: PetscCall(DMRefine(dm, PetscObjectComm((PetscObject)dm), &rdm));
4454: /* Total hack since we do not pass in a pointer */
4455: PetscCall(DMPlexReplace_Internal(dm, &rdm));
4456: PetscCall(DMSetFromOptions_NonRefinement_Plex(dm, PetscOptionsObject));
4457: if (coordFunc && remap) {
4458: PetscCall(DMPlexRemapGeometry(dm, 0.0, coordFunc));
4459: ((DM_Plex *)dm->data)->coordFunc = coordFunc;
4460: }
4461: }
4462: }
4463: /* Handle DMPlex coarsening */
4464: PetscCall(PetscOptionsBoundedInt("-dm_coarsen", "Coarsen the mesh", "DMCreate", coarsen, &coarsen, NULL, 0));
4465: PetscCall(PetscOptionsBoundedInt("-dm_coarsen_hierarchy", "The number of coarsenings", "DMCreate", coarsen, &coarsen, &isHierarchy, 0));
4466: if (coarsen && isHierarchy) {
4467: DM *dms;
4469: PetscCall(PetscMalloc1(coarsen, &dms));
4470: PetscCall(DMCoarsenHierarchy(dm, coarsen, dms));
4471: /* Free DMs */
4472: for (r = 0; r < coarsen; ++r) {
4473: PetscCall(DMSetFromOptions_NonRefinement_Plex(dms[r], PetscOptionsObject));
4474: PetscCall(DMDestroy(&dms[r]));
4475: }
4476: PetscCall(PetscFree(dms));
4477: } else {
4478: for (r = 0; r < coarsen; ++r) {
4479: DM cdm;
4480: PetscPointFunc coordFunc = ((DM_Plex *)dm->data)->coordFunc;
4482: PetscCall(DMSetFromOptions_NonRefinement_Plex(dm, PetscOptionsObject));
4483: PetscCall(DMCoarsen(dm, PetscObjectComm((PetscObject)dm), &cdm));
4484: /* Total hack since we do not pass in a pointer */
4485: PetscCall(DMPlexReplace_Internal(dm, &cdm));
4486: PetscCall(DMSetFromOptions_NonRefinement_Plex(dm, PetscOptionsObject));
4487: if (coordFunc) {
4488: PetscCall(DMPlexRemapGeometry(dm, 0.0, coordFunc));
4489: ((DM_Plex *)dm->data)->coordFunc = coordFunc;
4490: }
4491: }
4492: }
4493: // Handle coordinate remapping
4494: remap = PETSC_FALSE;
4495: PetscCall(PetscOptionsBool("-dm_coord_remap", "Flag to control coordinate remapping", "", remap, &remap, NULL));
4496: if (remap) {
4497: DMPlexCoordMap map = DM_COORD_MAP_NONE;
4498: PetscPointFunc mapFunc = NULL;
4499: PetscScalar params[16];
4500: PetscInt Np = PETSC_STATIC_ARRAY_LENGTH(params), cdim;
4501: MPI_Comm comm;
4503: PetscCall(PetscObjectGetComm((PetscObject)dm, &comm));
4504: PetscCall(DMGetCoordinateDim(dm, &cdim));
4505: PetscCall(PetscOptionsScalarArray("-dm_coord_map_params", "Parameters for the coordinate remapping", "", params, &Np, &flg));
4506: if (!flg) Np = 0;
4507: // TODO Allow user to pass a map function by name
4508: PetscCall(PetscOptionsEnum("-dm_coord_map", "Coordinate mapping for built-in mesh", "", DMPlexCoordMaps, (PetscEnum)map, (PetscEnum *)&map, &flg));
4509: if (flg) {
4510: switch (map) {
4511: case DM_COORD_MAP_NONE:
4512: mapFunc = coordMap_identity;
4513: break;
4514: case DM_COORD_MAP_SHEAR:
4515: mapFunc = coordMap_shear;
4516: if (!Np) {
4517: Np = cdim + 1;
4518: params[0] = 0;
4519: for (PetscInt d = 1; d <= cdim; ++d) params[d] = 1.0;
4520: }
4521: PetscCheck(Np == cdim + 1, comm, PETSC_ERR_ARG_WRONG, "The shear coordinate map must have cdim + 1 = %" PetscInt_FMT " parameters, not %" PetscInt_FMT, cdim + 1, Np);
4522: break;
4523: case DM_COORD_MAP_FLARE:
4524: mapFunc = coordMap_flare;
4525: if (!Np) {
4526: Np = cdim + 1;
4527: params[0] = 0;
4528: for (PetscInt d = 1; d <= cdim; ++d) params[d] = 1.0;
4529: }
4530: PetscCheck(Np == cdim + 1, comm, PETSC_ERR_ARG_WRONG, "The flare coordinate map must have cdim + 1 = %" PetscInt_FMT " parameters, not %" PetscInt_FMT, cdim + 1, Np);
4531: break;
4532: case DM_COORD_MAP_ANNULUS:
4533: mapFunc = coordMap_annulus;
4534: if (!Np) {
4535: Np = 2;
4536: params[0] = 1.;
4537: params[1] = 2.;
4538: }
4539: PetscCheck(Np == 2, comm, PETSC_ERR_ARG_WRONG, "The annulus coordinate map must have 2 parameters, not %" PetscInt_FMT, Np);
4540: break;
4541: case DM_COORD_MAP_SHELL:
4542: mapFunc = coordMap_shell;
4543: if (!Np) {
4544: Np = 2;
4545: params[0] = 1.;
4546: params[1] = 2.;
4547: }
4548: PetscCheck(Np == 2, comm, PETSC_ERR_ARG_WRONG, "The spherical shell coordinate map must have 2 parameters, not %" PetscInt_FMT, Np);
4549: break;
4550: default:
4551: mapFunc = coordMap_identity;
4552: }
4553: }
4554: if (Np) {
4555: DM cdm;
4556: PetscDS cds;
4558: PetscCall(DMGetCoordinateDM(dm, &cdm));
4559: PetscCall(DMGetDS(cdm, &cds));
4560: PetscCall(PetscDSSetConstants(cds, Np, params));
4561: }
4562: PetscCall(DMPlexRemapGeometry(dm, 0.0, mapFunc));
4563: }
4564: /* Handle ghost cells */
4565: PetscCall(PetscOptionsBool("-dm_plex_create_fv_ghost_cells", "Flag to create finite volume ghost cells on the boundary", "DMCreate", ghostCells, &ghostCells, NULL));
4566: if (ghostCells) {
4567: DM gdm;
4568: char lname[PETSC_MAX_PATH_LEN];
4570: lname[0] = '\0';
4571: PetscCall(PetscOptionsString("-dm_plex_fv_ghost_cells_label", "Label name for ghost cells boundary", "DMCreate", lname, lname, sizeof(lname), &flg));
4572: PetscCall(DMPlexConstructGhostCells(dm, flg ? lname : NULL, NULL, &gdm));
4573: PetscCall(DMPlexReplace_Internal(dm, &gdm));
4574: }
4575: /* Handle 1D order */
4576: if (reorder != DM_REORDER_DEFAULT_FALSE && dim == 1) {
4577: DM cdm, rdm;
4578: PetscDS cds;
4579: PetscObject obj;
4580: PetscClassId id = PETSC_OBJECT_CLASSID;
4581: IS perm;
4582: PetscInt Nf;
4583: PetscBool distributed;
4585: PetscCall(DMPlexIsDistributed(dm, &distributed));
4586: PetscCall(DMGetCoordinateDM(dm, &cdm));
4587: PetscCall(DMGetDS(cdm, &cds));
4588: PetscCall(PetscDSGetNumFields(cds, &Nf));
4589: if (Nf) {
4590: PetscCall(PetscDSGetDiscretization(cds, 0, &obj));
4591: PetscCall(PetscObjectGetClassId(obj, &id));
4592: }
4593: if (!distributed && id != PETSCFE_CLASSID) {
4594: PetscCall(DMPlexGetOrdering1D(dm, &perm));
4595: PetscCall(DMPlexPermute(dm, perm, &rdm));
4596: PetscCall(DMPlexReplace_Internal(dm, &rdm));
4597: PetscCall(ISDestroy(&perm));
4598: }
4599: }
4600: /* Handle */
4601: non_refine:
4602: PetscCall(DMSetFromOptions_NonRefinement_Plex(dm, PetscOptionsObject));
4603: PetscOptionsHeadEnd();
4604: PetscFunctionReturn(PETSC_SUCCESS);
4605: }
4607: static PetscErrorCode DMCreateGlobalVector_Plex(DM dm, Vec *vec)
4608: {
4609: PetscFunctionBegin;
4610: PetscCall(DMCreateGlobalVector_Section_Private(dm, vec));
4611: /* PetscCall(VecSetOperation(*vec, VECOP_DUPLICATE, (void(*)(void)) VecDuplicate_MPI_DM)); */
4612: PetscCall(VecSetOperation(*vec, VECOP_VIEW, (void (*)(void))VecView_Plex));
4613: PetscCall(VecSetOperation(*vec, VECOP_VIEWNATIVE, (void (*)(void))VecView_Plex_Native));
4614: PetscCall(VecSetOperation(*vec, VECOP_LOAD, (void (*)(void))VecLoad_Plex));
4615: PetscCall(VecSetOperation(*vec, VECOP_LOADNATIVE, (void (*)(void))VecLoad_Plex_Native));
4616: PetscFunctionReturn(PETSC_SUCCESS);
4617: }
4619: static PetscErrorCode DMCreateLocalVector_Plex(DM dm, Vec *vec)
4620: {
4621: PetscFunctionBegin;
4622: PetscCall(DMCreateLocalVector_Section_Private(dm, vec));
4623: PetscCall(VecSetOperation(*vec, VECOP_VIEW, (void (*)(void))VecView_Plex_Local));
4624: PetscCall(VecSetOperation(*vec, VECOP_LOAD, (void (*)(void))VecLoad_Plex_Local));
4625: PetscFunctionReturn(PETSC_SUCCESS);
4626: }
4628: static PetscErrorCode DMGetDimPoints_Plex(DM dm, PetscInt dim, PetscInt *pStart, PetscInt *pEnd)
4629: {
4630: PetscInt depth, d;
4632: PetscFunctionBegin;
4633: PetscCall(DMPlexGetDepth(dm, &depth));
4634: if (depth == 1) {
4635: PetscCall(DMGetDimension(dm, &d));
4636: if (dim == 0) PetscCall(DMPlexGetDepthStratum(dm, dim, pStart, pEnd));
4637: else if (dim == d) PetscCall(DMPlexGetDepthStratum(dm, 1, pStart, pEnd));
4638: else {
4639: *pStart = 0;
4640: *pEnd = 0;
4641: }
4642: } else {
4643: PetscCall(DMPlexGetDepthStratum(dm, dim, pStart, pEnd));
4644: }
4645: PetscFunctionReturn(PETSC_SUCCESS);
4646: }
4648: static PetscErrorCode DMGetNeighbors_Plex(DM dm, PetscInt *nranks, const PetscMPIInt *ranks[])
4649: {
4650: PetscSF sf;
4651: PetscInt niranks, njranks, n;
4652: const PetscMPIInt *iranks, *jranks;
4653: DM_Plex *data = (DM_Plex *)dm->data;
4655: PetscFunctionBegin;
4656: PetscCall(DMGetPointSF(dm, &sf));
4657: if (!data->neighbors) {
4658: PetscCall(PetscSFSetUp(sf));
4659: PetscCall(PetscSFGetRootRanks(sf, &njranks, &jranks, NULL, NULL, NULL));
4660: PetscCall(PetscSFGetLeafRanks(sf, &niranks, &iranks, NULL, NULL));
4661: PetscCall(PetscMalloc1(njranks + niranks + 1, &data->neighbors));
4662: PetscCall(PetscArraycpy(data->neighbors + 1, jranks, njranks));
4663: PetscCall(PetscArraycpy(data->neighbors + njranks + 1, iranks, niranks));
4664: n = njranks + niranks;
4665: PetscCall(PetscSortRemoveDupsMPIInt(&n, data->neighbors + 1));
4666: /* The following cast should never fail: can't have more neighbors than PETSC_MPI_INT_MAX */
4667: PetscCall(PetscMPIIntCast(n, data->neighbors));
4668: }
4669: if (nranks) *nranks = data->neighbors[0];
4670: if (ranks) {
4671: if (data->neighbors[0]) *ranks = data->neighbors + 1;
4672: else *ranks = NULL;
4673: }
4674: PetscFunctionReturn(PETSC_SUCCESS);
4675: }
4677: PETSC_INTERN PetscErrorCode DMInterpolateSolution_Plex(DM, DM, Mat, Vec, Vec);
4679: static PetscErrorCode DMInitialize_Plex(DM dm)
4680: {
4681: PetscFunctionBegin;
4682: dm->ops->view = DMView_Plex;
4683: dm->ops->load = DMLoad_Plex;
4684: dm->ops->setfromoptions = DMSetFromOptions_Plex;
4685: dm->ops->clone = DMClone_Plex;
4686: dm->ops->setup = DMSetUp_Plex;
4687: dm->ops->createlocalsection = DMCreateLocalSection_Plex;
4688: dm->ops->createsectionpermutation = DMCreateSectionPermutation_Plex;
4689: dm->ops->createdefaultconstraints = DMCreateDefaultConstraints_Plex;
4690: dm->ops->createglobalvector = DMCreateGlobalVector_Plex;
4691: dm->ops->createlocalvector = DMCreateLocalVector_Plex;
4692: dm->ops->getlocaltoglobalmapping = NULL;
4693: dm->ops->createfieldis = NULL;
4694: dm->ops->createcoordinatedm = DMCreateCoordinateDM_Plex;
4695: dm->ops->createcoordinatefield = DMCreateCoordinateField_Plex;
4696: dm->ops->getcoloring = NULL;
4697: dm->ops->creatematrix = DMCreateMatrix_Plex;
4698: dm->ops->createinterpolation = DMCreateInterpolation_Plex;
4699: dm->ops->createmassmatrix = DMCreateMassMatrix_Plex;
4700: dm->ops->createmassmatrixlumped = DMCreateMassMatrixLumped_Plex;
4701: dm->ops->createinjection = DMCreateInjection_Plex;
4702: dm->ops->refine = DMRefine_Plex;
4703: dm->ops->coarsen = DMCoarsen_Plex;
4704: dm->ops->refinehierarchy = DMRefineHierarchy_Plex;
4705: dm->ops->coarsenhierarchy = DMCoarsenHierarchy_Plex;
4706: dm->ops->extrude = DMExtrude_Plex;
4707: dm->ops->globaltolocalbegin = NULL;
4708: dm->ops->globaltolocalend = NULL;
4709: dm->ops->localtoglobalbegin = NULL;
4710: dm->ops->localtoglobalend = NULL;
4711: dm->ops->destroy = DMDestroy_Plex;
4712: dm->ops->createsubdm = DMCreateSubDM_Plex;
4713: dm->ops->createsuperdm = DMCreateSuperDM_Plex;
4714: dm->ops->getdimpoints = DMGetDimPoints_Plex;
4715: dm->ops->locatepoints = DMLocatePoints_Plex;
4716: dm->ops->projectfunctionlocal = DMProjectFunctionLocal_Plex;
4717: dm->ops->projectfunctionlabellocal = DMProjectFunctionLabelLocal_Plex;
4718: dm->ops->projectfieldlocal = DMProjectFieldLocal_Plex;
4719: dm->ops->projectfieldlabellocal = DMProjectFieldLabelLocal_Plex;
4720: dm->ops->projectbdfieldlabellocal = DMProjectBdFieldLabelLocal_Plex;
4721: dm->ops->computel2diff = DMComputeL2Diff_Plex;
4722: dm->ops->computel2gradientdiff = DMComputeL2GradientDiff_Plex;
4723: dm->ops->computel2fielddiff = DMComputeL2FieldDiff_Plex;
4724: dm->ops->getneighbors = DMGetNeighbors_Plex;
4725: dm->ops->getlocalboundingbox = DMGetLocalBoundingBox_Coordinates;
4726: dm->ops->createdomaindecomposition = DMCreateDomainDecomposition_Plex;
4727: dm->ops->createddscatters = DMCreateDomainDecompositionScatters_Plex;
4728: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMPlexInsertBoundaryValues_C", DMPlexInsertBoundaryValues_Plex));
4729: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMPlexInsertTimeDerivativeBoundaryValues_C", DMPlexInsertTimeDerivativeBoundaryValues_Plex));
4730: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMSetUpGLVisViewer_C", DMSetUpGLVisViewer_Plex));
4731: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMCreateNeumannOverlap_C", DMCreateNeumannOverlap_Plex));
4732: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMPlexDistributeGetDefault_C", DMPlexDistributeGetDefault_Plex));
4733: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMPlexDistributeSetDefault_C", DMPlexDistributeSetDefault_Plex));
4734: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMPlexReorderGetDefault_C", DMPlexReorderGetDefault_Plex));
4735: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMPlexReorderSetDefault_C", DMPlexReorderSetDefault_Plex));
4736: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMReorderSectionGetDefault_C", DMReorderSectionGetDefault_Plex));
4737: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMReorderSectionSetDefault_C", DMReorderSectionSetDefault_Plex));
4738: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMReorderSectionGetType_C", DMReorderSectionGetType_Plex));
4739: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMReorderSectionSetType_C", DMReorderSectionSetType_Plex));
4740: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMInterpolateSolution_C", DMInterpolateSolution_Plex));
4741: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMPlexGetOverlap_C", DMPlexGetOverlap_Plex));
4742: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMPlexSetOverlap_C", DMPlexSetOverlap_Plex));
4743: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMPlexGetUseCeed_C", DMPlexGetUseCeed_Plex));
4744: PetscCall(PetscObjectComposeFunction((PetscObject)dm, "DMPlexSetUseCeed_C", DMPlexSetUseCeed_Plex));
4745: PetscFunctionReturn(PETSC_SUCCESS);
4746: }
4748: PETSC_INTERN PetscErrorCode DMClone_Plex(DM dm, DM *newdm)
4749: {
4750: DM_Plex *mesh = (DM_Plex *)dm->data;
4751: const PetscSF *face_sfs;
4752: PetscInt num_face_sfs;
4754: PetscFunctionBegin;
4755: mesh->refct++;
4756: (*newdm)->data = mesh;
4757: PetscCall(DMPlexGetIsoperiodicFaceSF(dm, &num_face_sfs, &face_sfs));
4758: PetscCall(DMPlexSetIsoperiodicFaceSF(*newdm, num_face_sfs, (PetscSF *)face_sfs));
4759: PetscCall(PetscObjectChangeTypeName((PetscObject)*newdm, DMPLEX));
4760: PetscCall(DMInitialize_Plex(*newdm));
4761: PetscFunctionReturn(PETSC_SUCCESS);
4762: }
4764: /*MC
4765: DMPLEX = "plex" - A `DM` object that encapsulates an unstructured mesh, or CW Complex, which can be expressed using a Hasse Diagram.
4766: In the local representation, `Vec`s contain all unknowns in the interior and shared boundary. This is
4767: specified by a PetscSection object. Ownership in the global representation is determined by
4768: ownership of the underlying `DMPLEX` points. This is specified by another `PetscSection` object.
4770: Options Database Keys:
4771: + -dm_refine_pre - Refine mesh before distribution
4772: + -dm_refine_uniform_pre - Choose uniform or generator-based refinement
4773: + -dm_refine_volume_limit_pre - Cell volume limit after pre-refinement using generator
4774: . -dm_distribute - Distribute mesh across processes
4775: . -dm_distribute_overlap - Number of cells to overlap for distribution
4776: . -dm_refine - Refine mesh after distribution
4777: . -dm_plex_hash_location - Use grid hashing for point location
4778: . -dm_plex_hash_box_faces <n,m,p> - The number of divisions in each direction of the grid hash
4779: . -dm_plex_partition_balance - Attempt to evenly divide points on partition boundary between processes
4780: . -dm_plex_remesh_bd - Allow changes to the boundary on remeshing
4781: . -dm_plex_max_projection_height - Maximum mesh point height used to project locally
4782: . -dm_plex_regular_refinement - Use special nested projection algorithm for regular refinement
4783: . -dm_plex_reorder_section - Use specialized blocking if available
4784: . -dm_plex_check_all - Perform all checks below
4785: . -dm_plex_check_symmetry - Check that the adjacency information in the mesh is symmetric
4786: . -dm_plex_check_skeleton <celltype> - Check that each cell has the correct number of vertices
4787: . -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
4788: . -dm_plex_check_geometry - Check that cells have positive volume
4789: . -dm_view :mesh.tex:ascii_latex - View the mesh in LaTeX/TikZ
4790: . -dm_plex_view_scale <num> - Scale the TikZ
4791: . -dm_plex_print_fem <num> - View FEM assembly information, such as element vectors and matrices
4792: - -dm_plex_print_fvm <num> - View FVM assembly information, such as flux updates
4794: Level: intermediate
4796: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMType`, `DMPlexCreate()`, `DMCreate()`, `DMSetType()`, `PetscSection`
4797: M*/
4799: PETSC_EXTERN PetscErrorCode DMCreate_Plex(DM dm)
4800: {
4801: DM_Plex *mesh;
4802: PetscInt unit;
4804: PetscFunctionBegin;
4805: PetscCall(PetscCitationsRegister(PlexCitation, &Plexcite));
4807: PetscCall(PetscNew(&mesh));
4808: dm->reorderSection = DM_REORDER_DEFAULT_NOTSET;
4809: dm->data = mesh;
4811: mesh->refct = 1;
4812: PetscCall(PetscSectionCreate(PetscObjectComm((PetscObject)dm), &mesh->coneSection));
4813: PetscCall(PetscSectionCreate(PetscObjectComm((PetscObject)dm), &mesh->supportSection));
4814: mesh->refinementUniform = PETSC_TRUE;
4815: mesh->refinementLimit = -1.0;
4816: mesh->distDefault = PETSC_TRUE;
4817: mesh->reorderDefault = DM_REORDER_DEFAULT_NOTSET;
4818: mesh->distributionName = NULL;
4819: mesh->interpolated = DMPLEX_INTERPOLATED_INVALID;
4820: mesh->interpolatedCollective = DMPLEX_INTERPOLATED_INVALID;
4822: PetscCall(PetscPartitionerCreate(PetscObjectComm((PetscObject)dm), &mesh->partitioner));
4823: mesh->remeshBd = PETSC_FALSE;
4825: for (unit = 0; unit < NUM_PETSC_UNITS; ++unit) mesh->scale[unit] = 1.0;
4827: mesh->depthState = -1;
4828: mesh->celltypeState = -1;
4829: mesh->printTol = 1.0e-10;
4831: PetscCall(DMInitialize_Plex(dm));
4832: PetscFunctionReturn(PETSC_SUCCESS);
4833: }
4835: /*@
4836: DMPlexCreate - Creates a `DMPLEX` object, which encapsulates an unstructured mesh, or CW complex, which can be expressed using a Hasse Diagram.
4838: Collective
4840: Input Parameter:
4841: . comm - The communicator for the `DMPLEX` object
4843: Output Parameter:
4844: . mesh - The `DMPLEX` object
4846: Level: beginner
4848: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMType`, `DMCreate()`, `DMSetType()`
4849: @*/
4850: PetscErrorCode DMPlexCreate(MPI_Comm comm, DM *mesh)
4851: {
4852: PetscFunctionBegin;
4853: PetscAssertPointer(mesh, 2);
4854: PetscCall(DMCreate(comm, mesh));
4855: PetscCall(DMSetType(*mesh, DMPLEX));
4856: PetscFunctionReturn(PETSC_SUCCESS);
4857: }
4859: /*@C
4860: DMPlexBuildFromCellListParallel - Build distributed `DMPLEX` topology from a list of vertices for each cell (common mesh generator output)
4862: Collective; No Fortran Support
4864: Input Parameters:
4865: + dm - The `DM`
4866: . numCells - The number of cells owned by this process
4867: . numVertices - The number of vertices to be owned by this process, or `PETSC_DECIDE`
4868: . NVertices - The global number of vertices, or `PETSC_DETERMINE`
4869: . numCorners - The number of vertices for each cell
4870: - cells - An array of numCells*numCorners numbers, the global vertex numbers for each cell
4872: Output Parameters:
4873: + vertexSF - (Optional) `PetscSF` describing complete vertex ownership
4874: - verticesAdjSaved - (Optional) vertex adjacency array
4876: Level: advanced
4878: Notes:
4879: Two triangles sharing a face
4880: .vb
4882: 2
4883: / | \
4884: / | \
4885: / | \
4886: 0 0 | 1 3
4887: \ | /
4888: \ | /
4889: \ | /
4890: 1
4891: .ve
4892: would have input
4893: .vb
4894: numCells = 2, numVertices = 4
4895: cells = [0 1 2 1 3 2]
4896: .ve
4897: which would result in the `DMPLEX`
4898: .vb
4900: 4
4901: / | \
4902: / | \
4903: / | \
4904: 2 0 | 1 5
4905: \ | /
4906: \ | /
4907: \ | /
4908: 3
4909: .ve
4911: Vertices are implicitly numbered consecutively 0,...,NVertices.
4912: Each rank owns a chunk of numVertices consecutive vertices.
4913: If numVertices is `PETSC_DECIDE`, PETSc will distribute them as evenly as possible using PetscLayout.
4914: If NVertices is `PETSC_DETERMINE` and numVertices is PETSC_DECIDE, NVertices is computed by PETSc as the maximum vertex index in cells + 1.
4915: If only NVertices is `PETSC_DETERMINE`, it is computed as the sum of numVertices over all ranks.
4917: The cell distribution is arbitrary non-overlapping, independent of the vertex distribution.
4919: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexBuildFromCellList()`, `DMPlexCreateFromCellListParallelPetsc()`, `DMPlexBuildCoordinatesFromCellListParallel()`,
4920: `PetscSF`
4921: @*/
4922: PetscErrorCode DMPlexBuildFromCellListParallel(DM dm, PetscInt numCells, PetscInt numVertices, PetscInt NVertices, PetscInt numCorners, const PetscInt cells[], PetscSF *vertexSF, PetscInt **verticesAdjSaved)
4923: {
4924: PetscSF sfPoint;
4925: PetscLayout layout;
4926: PetscInt numVerticesAdj, *verticesAdj, *cones, c, p;
4928: PetscFunctionBegin;
4930: PetscCall(PetscLogEventBegin(DMPLEX_BuildFromCellList, dm, 0, 0, 0));
4931: /* Get/check global number of vertices */
4932: {
4933: PetscInt NVerticesInCells, i;
4934: const PetscInt len = numCells * numCorners;
4936: /* NVerticesInCells = max(cells) + 1 */
4937: NVerticesInCells = PETSC_MIN_INT;
4938: for (i = 0; i < len; i++)
4939: if (cells[i] > NVerticesInCells) NVerticesInCells = cells[i];
4940: ++NVerticesInCells;
4941: PetscCall(MPIU_Allreduce(MPI_IN_PLACE, &NVerticesInCells, 1, MPIU_INT, MPI_MAX, PetscObjectComm((PetscObject)dm)));
4943: if (numVertices == PETSC_DECIDE && NVertices == PETSC_DECIDE) NVertices = NVerticesInCells;
4944: else
4945: PetscCheck(NVertices == PETSC_DECIDE || NVertices >= NVerticesInCells, PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "Specified global number of vertices %" PetscInt_FMT " must be greater than or equal to the number of vertices in cells %" PetscInt_FMT, NVertices, NVerticesInCells);
4946: }
4947: /* Count locally unique vertices */
4948: {
4949: PetscHSetI vhash;
4950: PetscInt off = 0;
4952: PetscCall(PetscHSetICreate(&vhash));
4953: for (c = 0; c < numCells; ++c) {
4954: for (p = 0; p < numCorners; ++p) PetscCall(PetscHSetIAdd(vhash, cells[c * numCorners + p]));
4955: }
4956: PetscCall(PetscHSetIGetSize(vhash, &numVerticesAdj));
4957: if (!verticesAdjSaved) PetscCall(PetscMalloc1(numVerticesAdj, &verticesAdj));
4958: else verticesAdj = *verticesAdjSaved;
4959: PetscCall(PetscHSetIGetElems(vhash, &off, verticesAdj));
4960: PetscCall(PetscHSetIDestroy(&vhash));
4961: PetscCheck(off == numVerticesAdj, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Invalid number of local vertices %" PetscInt_FMT " should be %" PetscInt_FMT, off, numVerticesAdj);
4962: }
4963: PetscCall(PetscSortInt(numVerticesAdj, verticesAdj));
4964: /* Create cones */
4965: PetscCall(DMPlexSetChart(dm, 0, numCells + numVerticesAdj));
4966: for (c = 0; c < numCells; ++c) PetscCall(DMPlexSetConeSize(dm, c, numCorners));
4967: PetscCall(DMSetUp(dm));
4968: PetscCall(DMPlexGetCones(dm, &cones));
4969: for (c = 0; c < numCells; ++c) {
4970: for (p = 0; p < numCorners; ++p) {
4971: const PetscInt gv = cells[c * numCorners + p];
4972: PetscInt lv;
4974: /* Positions within verticesAdj form 0-based local vertex numbering;
4975: we need to shift it by numCells to get correct DAG points (cells go first) */
4976: PetscCall(PetscFindInt(gv, numVerticesAdj, verticesAdj, &lv));
4977: PetscCheck(lv >= 0, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Could not find global vertex %" PetscInt_FMT " in local connectivity", gv);
4978: cones[c * numCorners + p] = lv + numCells;
4979: }
4980: }
4981: /* Build point sf */
4982: PetscCall(PetscLayoutCreate(PetscObjectComm((PetscObject)dm), &layout));
4983: PetscCall(PetscLayoutSetSize(layout, NVertices));
4984: PetscCall(PetscLayoutSetLocalSize(layout, numVertices));
4985: PetscCall(PetscLayoutSetBlockSize(layout, 1));
4986: PetscCall(PetscSFCreateByMatchingIndices(layout, numVerticesAdj, verticesAdj, NULL, numCells, numVerticesAdj, verticesAdj, NULL, numCells, vertexSF, &sfPoint));
4987: PetscCall(PetscLayoutDestroy(&layout));
4988: if (!verticesAdjSaved) PetscCall(PetscFree(verticesAdj));
4989: PetscCall(PetscObjectSetName((PetscObject)sfPoint, "point SF"));
4990: if (dm->sf) {
4991: const char *prefix;
4993: PetscCall(PetscObjectGetOptionsPrefix((PetscObject)dm->sf, &prefix));
4994: PetscCall(PetscObjectSetOptionsPrefix((PetscObject)sfPoint, prefix));
4995: }
4996: PetscCall(DMSetPointSF(dm, sfPoint));
4997: PetscCall(PetscSFDestroy(&sfPoint));
4998: if (vertexSF) PetscCall(PetscObjectSetName((PetscObject)*vertexSF, "Vertex Ownership SF"));
4999: /* Fill in the rest of the topology structure */
5000: PetscCall(DMPlexSymmetrize(dm));
5001: PetscCall(DMPlexStratify(dm));
5002: PetscCall(PetscLogEventEnd(DMPLEX_BuildFromCellList, dm, 0, 0, 0));
5003: PetscFunctionReturn(PETSC_SUCCESS);
5004: }
5006: /*@C
5007: DMPlexBuildCoordinatesFromCellListParallel - Build `DM` coordinates from a list of coordinates for each owned vertex (common mesh generator output)
5009: Collective; No Fortran Support
5011: Input Parameters:
5012: + dm - The `DM`
5013: . spaceDim - The spatial dimension used for coordinates
5014: . sfVert - `PetscSF` describing complete vertex ownership
5015: - vertexCoords - An array of numVertices*spaceDim numbers, the coordinates of each vertex
5017: Level: advanced
5019: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexBuildCoordinatesFromCellList()`, `DMPlexCreateFromCellListParallelPetsc()`, `DMPlexBuildFromCellListParallel()`
5020: @*/
5021: PetscErrorCode DMPlexBuildCoordinatesFromCellListParallel(DM dm, PetscInt spaceDim, PetscSF sfVert, const PetscReal vertexCoords[])
5022: {
5023: PetscSection coordSection;
5024: Vec coordinates;
5025: PetscScalar *coords;
5026: PetscInt numVertices, numVerticesAdj, coordSize, v, vStart, vEnd;
5028: PetscFunctionBegin;
5029: PetscCall(PetscLogEventBegin(DMPLEX_BuildCoordinatesFromCellList, dm, 0, 0, 0));
5030: PetscCall(DMPlexGetDepthStratum(dm, 0, &vStart, &vEnd));
5031: PetscCheck(vStart >= 0 && vEnd >= 0, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "DM is not set up properly. DMPlexBuildFromCellList() should be called first.");
5032: PetscCall(DMSetCoordinateDim(dm, spaceDim));
5033: PetscCall(PetscSFGetGraph(sfVert, &numVertices, &numVerticesAdj, NULL, NULL));
5034: PetscCheck(vEnd - vStart == numVerticesAdj, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Supplied sfVert has wrong number of leaves = %" PetscInt_FMT " != %" PetscInt_FMT " = vEnd - vStart", numVerticesAdj, vEnd - vStart);
5035: PetscCall(DMGetCoordinateSection(dm, &coordSection));
5036: PetscCall(PetscSectionSetNumFields(coordSection, 1));
5037: PetscCall(PetscSectionSetFieldComponents(coordSection, 0, spaceDim));
5038: PetscCall(PetscSectionSetChart(coordSection, vStart, vEnd));
5039: for (v = vStart; v < vEnd; ++v) {
5040: PetscCall(PetscSectionSetDof(coordSection, v, spaceDim));
5041: PetscCall(PetscSectionSetFieldDof(coordSection, v, 0, spaceDim));
5042: }
5043: PetscCall(PetscSectionSetUp(coordSection));
5044: PetscCall(PetscSectionGetStorageSize(coordSection, &coordSize));
5045: PetscCall(VecCreate(PetscObjectComm((PetscObject)dm), &coordinates));
5046: PetscCall(VecSetBlockSize(coordinates, spaceDim));
5047: PetscCall(PetscObjectSetName((PetscObject)coordinates, "coordinates"));
5048: PetscCall(VecSetSizes(coordinates, coordSize, PETSC_DETERMINE));
5049: PetscCall(VecSetType(coordinates, VECSTANDARD));
5050: PetscCall(VecGetArray(coordinates, &coords));
5051: {
5052: MPI_Datatype coordtype;
5054: /* Need a temp buffer for coords if we have complex/single */
5055: PetscCallMPI(MPI_Type_contiguous(spaceDim, MPIU_SCALAR, &coordtype));
5056: PetscCallMPI(MPI_Type_commit(&coordtype));
5057: #if defined(PETSC_USE_COMPLEX)
5058: {
5059: PetscScalar *svertexCoords;
5060: PetscInt i;
5061: PetscCall(PetscMalloc1(numVertices * spaceDim, &svertexCoords));
5062: for (i = 0; i < numVertices * spaceDim; i++) svertexCoords[i] = vertexCoords[i];
5063: PetscCall(PetscSFBcastBegin(sfVert, coordtype, svertexCoords, coords, MPI_REPLACE));
5064: PetscCall(PetscSFBcastEnd(sfVert, coordtype, svertexCoords, coords, MPI_REPLACE));
5065: PetscCall(PetscFree(svertexCoords));
5066: }
5067: #else
5068: PetscCall(PetscSFBcastBegin(sfVert, coordtype, vertexCoords, coords, MPI_REPLACE));
5069: PetscCall(PetscSFBcastEnd(sfVert, coordtype, vertexCoords, coords, MPI_REPLACE));
5070: #endif
5071: PetscCallMPI(MPI_Type_free(&coordtype));
5072: }
5073: PetscCall(VecRestoreArray(coordinates, &coords));
5074: PetscCall(DMSetCoordinatesLocal(dm, coordinates));
5075: PetscCall(VecDestroy(&coordinates));
5076: PetscCall(PetscLogEventEnd(DMPLEX_BuildCoordinatesFromCellList, dm, 0, 0, 0));
5077: PetscFunctionReturn(PETSC_SUCCESS);
5078: }
5080: /*@
5081: DMPlexCreateFromCellListParallelPetsc - Create distributed `DMPLEX` from a list of vertices for each cell (common mesh generator output)
5083: Collective
5085: Input Parameters:
5086: + comm - The communicator
5087: . dim - The topological dimension of the mesh
5088: . numCells - The number of cells owned by this process
5089: . numVertices - The number of vertices owned by this process, or `PETSC_DECIDE`
5090: . NVertices - The global number of vertices, or `PETSC_DECIDE`
5091: . numCorners - The number of vertices for each cell
5092: . interpolate - Flag indicating that intermediate mesh entities (faces, edges) should be created automatically
5093: . cells - An array of numCells*numCorners numbers, the global vertex numbers for each cell
5094: . spaceDim - The spatial dimension used for coordinates
5095: - vertexCoords - An array of numVertices*spaceDim numbers, the coordinates of each vertex
5097: Output Parameters:
5098: + dm - The `DM`
5099: . vertexSF - (Optional) `PetscSF` describing complete vertex ownership
5100: - verticesAdj - (Optional) vertex adjacency array
5102: Level: intermediate
5104: Notes:
5105: This function is just a convenient sequence of `DMCreate()`, `DMSetType()`, `DMSetDimension()`,
5106: `DMPlexBuildFromCellListParallel()`, `DMPlexInterpolate()`, `DMPlexBuildCoordinatesFromCellListParallel()`
5108: See `DMPlexBuildFromCellListParallel()` for an example and details about the topology-related parameters.
5110: See `DMPlexBuildCoordinatesFromCellListParallel()` for details about the geometry-related parameters.
5112: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexCreateFromCellListPetsc()`, `DMPlexBuildFromCellListParallel()`, `DMPlexBuildCoordinatesFromCellListParallel()`, `DMPlexCreateFromDAG()`, `DMPlexCreate()`
5113: @*/
5114: 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, PetscInt **verticesAdj, DM *dm)
5115: {
5116: PetscSF sfVert;
5118: PetscFunctionBegin;
5119: PetscCall(DMCreate(comm, dm));
5120: PetscCall(DMSetType(*dm, DMPLEX));
5123: PetscCall(DMSetDimension(*dm, dim));
5124: PetscCall(DMPlexBuildFromCellListParallel(*dm, numCells, numVertices, NVertices, numCorners, cells, &sfVert, verticesAdj));
5125: if (interpolate) {
5126: DM idm;
5128: PetscCall(DMPlexInterpolate(*dm, &idm));
5129: PetscCall(DMDestroy(dm));
5130: *dm = idm;
5131: }
5132: PetscCall(DMPlexBuildCoordinatesFromCellListParallel(*dm, spaceDim, sfVert, vertexCoords));
5133: if (vertexSF) *vertexSF = sfVert;
5134: else PetscCall(PetscSFDestroy(&sfVert));
5135: PetscFunctionReturn(PETSC_SUCCESS);
5136: }
5138: /*@C
5139: DMPlexBuildFromCellList - Build `DMPLEX` topology from a list of vertices for each cell (common mesh generator output)
5141: Collective; No Fortran Support
5143: Input Parameters:
5144: + dm - The `DM`
5145: . numCells - The number of cells owned by this process
5146: . numVertices - The number of vertices owned by this process, or `PETSC_DETERMINE`
5147: . numCorners - The number of vertices for each cell
5148: - cells - An array of numCells*numCorners numbers, the global vertex numbers for each cell
5150: Level: advanced
5152: Notes:
5153: Two triangles sharing a face
5154: .vb
5156: 2
5157: / | \
5158: / | \
5159: / | \
5160: 0 0 | 1 3
5161: \ | /
5162: \ | /
5163: \ | /
5164: 1
5165: .ve
5166: would have input
5167: .vb
5168: numCells = 2, numVertices = 4
5169: cells = [0 1 2 1 3 2]
5170: .ve
5171: which would result in the `DMPLEX`
5172: .vb
5174: 4
5175: / | \
5176: / | \
5177: / | \
5178: 2 0 | 1 5
5179: \ | /
5180: \ | /
5181: \ | /
5182: 3
5183: .ve
5185: If numVertices is `PETSC_DETERMINE`, it is computed by PETSc as the maximum vertex index in cells + 1.
5187: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexBuildFromCellListParallel()`, `DMPlexBuildCoordinatesFromCellList()`, `DMPlexCreateFromCellListPetsc()`
5188: @*/
5189: PetscErrorCode DMPlexBuildFromCellList(DM dm, PetscInt numCells, PetscInt numVertices, PetscInt numCorners, const PetscInt cells[])
5190: {
5191: PetscInt *cones, c, p, dim;
5193: PetscFunctionBegin;
5194: PetscCall(PetscLogEventBegin(DMPLEX_BuildFromCellList, dm, 0, 0, 0));
5195: PetscCall(DMGetDimension(dm, &dim));
5196: /* Get/check global number of vertices */
5197: {
5198: PetscInt NVerticesInCells, i;
5199: const PetscInt len = numCells * numCorners;
5201: /* NVerticesInCells = max(cells) + 1 */
5202: NVerticesInCells = PETSC_MIN_INT;
5203: for (i = 0; i < len; i++)
5204: if (cells[i] > NVerticesInCells) NVerticesInCells = cells[i];
5205: ++NVerticesInCells;
5207: if (numVertices == PETSC_DECIDE) numVertices = NVerticesInCells;
5208: else
5209: PetscCheck(numVertices >= NVerticesInCells, PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "Specified number of vertices %" PetscInt_FMT " must be greater than or equal to the number of vertices in cells %" PetscInt_FMT, numVertices, NVerticesInCells);
5210: }
5211: PetscCall(DMPlexSetChart(dm, 0, numCells + numVertices));
5212: for (c = 0; c < numCells; ++c) PetscCall(DMPlexSetConeSize(dm, c, numCorners));
5213: PetscCall(DMSetUp(dm));
5214: PetscCall(DMPlexGetCones(dm, &cones));
5215: for (c = 0; c < numCells; ++c) {
5216: for (p = 0; p < numCorners; ++p) cones[c * numCorners + p] = cells[c * numCorners + p] + numCells;
5217: }
5218: PetscCall(DMPlexSymmetrize(dm));
5219: PetscCall(DMPlexStratify(dm));
5220: PetscCall(PetscLogEventEnd(DMPLEX_BuildFromCellList, dm, 0, 0, 0));
5221: PetscFunctionReturn(PETSC_SUCCESS);
5222: }
5224: /*@C
5225: DMPlexBuildCoordinatesFromCellList - Build `DM` coordinates from a list of coordinates for each owned vertex (common mesh generator output)
5227: Collective; No Fortran Support
5229: Input Parameters:
5230: + dm - The `DM`
5231: . spaceDim - The spatial dimension used for coordinates
5232: - vertexCoords - An array of numVertices*spaceDim numbers, the coordinates of each vertex
5234: Level: advanced
5236: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexBuildCoordinatesFromCellListParallel()`, `DMPlexCreateFromCellListPetsc()`, `DMPlexBuildFromCellList()`
5237: @*/
5238: PetscErrorCode DMPlexBuildCoordinatesFromCellList(DM dm, PetscInt spaceDim, const PetscReal vertexCoords[])
5239: {
5240: PetscSection coordSection;
5241: Vec coordinates;
5242: DM cdm;
5243: PetscScalar *coords;
5244: PetscInt v, vStart, vEnd, d;
5246: PetscFunctionBegin;
5247: PetscCall(PetscLogEventBegin(DMPLEX_BuildCoordinatesFromCellList, dm, 0, 0, 0));
5248: PetscCall(DMPlexGetDepthStratum(dm, 0, &vStart, &vEnd));
5249: PetscCheck(vStart >= 0 && vEnd >= 0, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "DM is not set up properly. DMPlexBuildFromCellList() should be called first.");
5250: PetscCall(DMSetCoordinateDim(dm, spaceDim));
5251: PetscCall(DMGetCoordinateSection(dm, &coordSection));
5252: PetscCall(PetscSectionSetNumFields(coordSection, 1));
5253: PetscCall(PetscSectionSetFieldComponents(coordSection, 0, spaceDim));
5254: PetscCall(PetscSectionSetChart(coordSection, vStart, vEnd));
5255: for (v = vStart; v < vEnd; ++v) {
5256: PetscCall(PetscSectionSetDof(coordSection, v, spaceDim));
5257: PetscCall(PetscSectionSetFieldDof(coordSection, v, 0, spaceDim));
5258: }
5259: PetscCall(PetscSectionSetUp(coordSection));
5261: PetscCall(DMGetCoordinateDM(dm, &cdm));
5262: PetscCall(DMCreateLocalVector(cdm, &coordinates));
5263: PetscCall(VecSetBlockSize(coordinates, spaceDim));
5264: PetscCall(PetscObjectSetName((PetscObject)coordinates, "coordinates"));
5265: PetscCall(VecGetArrayWrite(coordinates, &coords));
5266: for (v = 0; v < vEnd - vStart; ++v) {
5267: for (d = 0; d < spaceDim; ++d) coords[v * spaceDim + d] = vertexCoords[v * spaceDim + d];
5268: }
5269: PetscCall(VecRestoreArrayWrite(coordinates, &coords));
5270: PetscCall(DMSetCoordinatesLocal(dm, coordinates));
5271: PetscCall(VecDestroy(&coordinates));
5272: PetscCall(PetscLogEventEnd(DMPLEX_BuildCoordinatesFromCellList, dm, 0, 0, 0));
5273: PetscFunctionReturn(PETSC_SUCCESS);
5274: }
5276: /*@
5277: DMPlexCreateFromCellListPetsc - Create `DMPLEX` from a list of vertices for each cell (common mesh generator output), but only process 0 takes in the input
5279: Collective
5281: Input Parameters:
5282: + comm - The communicator
5283: . dim - The topological dimension of the mesh
5284: . numCells - The number of cells, only on process 0
5285: . numVertices - The number of vertices owned by this process, or `PETSC_DECIDE`, only on process 0
5286: . numCorners - The number of vertices for each cell, only on process 0
5287: . interpolate - Flag indicating that intermediate mesh entities (faces, edges) should be created automatically
5288: . cells - An array of numCells*numCorners numbers, the vertices for each cell, only on process 0
5289: . spaceDim - The spatial dimension used for coordinates
5290: - vertexCoords - An array of numVertices*spaceDim numbers, the coordinates of each vertex, only on process 0
5292: Output Parameter:
5293: . dm - The `DM`, which only has points on process 0
5295: Level: intermediate
5297: Notes:
5298: This function is just a convenient sequence of `DMCreate()`, `DMSetType()`, `DMSetDimension()`, `DMPlexBuildFromCellList()`,
5299: `DMPlexInterpolate()`, `DMPlexBuildCoordinatesFromCellList()`
5301: See `DMPlexBuildFromCellList()` for an example and details about the topology-related parameters.
5302: See `DMPlexBuildCoordinatesFromCellList()` for details about the geometry-related parameters.
5303: See `DMPlexCreateFromCellListParallelPetsc()` for parallel input
5305: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexCreateFromCellListParallelPetsc()`, `DMPlexBuildFromCellList()`, `DMPlexBuildCoordinatesFromCellList()`, `DMPlexCreateFromDAG()`, `DMPlexCreate()`
5306: @*/
5307: 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)
5308: {
5309: PetscMPIInt rank;
5311: PetscFunctionBegin;
5312: PetscCheck(dim, 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.");
5313: PetscCallMPI(MPI_Comm_rank(comm, &rank));
5314: PetscCall(DMCreate(comm, dm));
5315: PetscCall(DMSetType(*dm, DMPLEX));
5316: PetscCall(DMSetDimension(*dm, dim));
5317: if (rank == 0) PetscCall(DMPlexBuildFromCellList(*dm, numCells, numVertices, numCorners, cells));
5318: else PetscCall(DMPlexBuildFromCellList(*dm, 0, 0, 0, NULL));
5319: if (interpolate) {
5320: DM idm;
5322: PetscCall(DMPlexInterpolate(*dm, &idm));
5323: PetscCall(DMDestroy(dm));
5324: *dm = idm;
5325: }
5326: if (rank == 0) PetscCall(DMPlexBuildCoordinatesFromCellList(*dm, spaceDim, vertexCoords));
5327: else PetscCall(DMPlexBuildCoordinatesFromCellList(*dm, spaceDim, NULL));
5328: PetscFunctionReturn(PETSC_SUCCESS);
5329: }
5331: /*@
5332: DMPlexCreateFromDAG - This takes as input the adjacency-list representation of the Directed Acyclic Graph (Hasse Diagram) encoding a mesh, and produces a `DM`
5334: Input Parameters:
5335: + dm - The empty `DM` object, usually from `DMCreate()` and `DMSetDimension()`
5336: . depth - The depth of the DAG
5337: . numPoints - Array of size depth + 1 containing the number of points at each `depth`
5338: . coneSize - The cone size of each point
5339: . cones - The concatenation of the cone points for each point, the cone list must be oriented correctly for each point
5340: . coneOrientations - The orientation of each cone point
5341: - vertexCoords - An array of `numPoints`[0]*spacedim numbers representing the coordinates of each vertex, with spacedim the value set via `DMSetCoordinateDim()`
5343: Output Parameter:
5344: . dm - The `DM`
5346: Level: advanced
5348: Note:
5349: Two triangles sharing a face would have input
5350: .vb
5351: depth = 1, numPoints = [4 2], coneSize = [3 3 0 0 0 0]
5352: cones = [2 3 4 3 5 4], coneOrientations = [0 0 0 0 0 0]
5353: vertexCoords = [-1.0 0.0 0.0 -1.0 0.0 1.0 1.0 0.0]
5354: .ve
5355: which would result in the DMPlex
5356: .vb
5357: 4
5358: / | \
5359: / | \
5360: / | \
5361: 2 0 | 1 5
5362: \ | /
5363: \ | /
5364: \ | /
5365: 3
5366: .ve
5367: Notice that all points are numbered consecutively, unlike `DMPlexCreateFromCellListPetsc()`
5369: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexCreateFromCellListPetsc()`, `DMPlexCreate()`
5370: @*/
5371: PetscErrorCode DMPlexCreateFromDAG(DM dm, PetscInt depth, const PetscInt numPoints[], const PetscInt coneSize[], const PetscInt cones[], const PetscInt coneOrientations[], const PetscScalar vertexCoords[])
5372: {
5373: Vec coordinates;
5374: PetscSection coordSection;
5375: PetscScalar *coords;
5376: PetscInt coordSize, firstVertex = -1, pStart = 0, pEnd = 0, p, v, dim, dimEmbed, d, off;
5378: PetscFunctionBegin;
5379: PetscCall(DMGetDimension(dm, &dim));
5380: PetscCall(DMGetCoordinateDim(dm, &dimEmbed));
5381: PetscCheck(dimEmbed >= dim, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Embedding dimension %" PetscInt_FMT " cannot be less than intrinsic dimension %" PetscInt_FMT, dimEmbed, dim);
5382: for (d = 0; d <= depth; ++d) pEnd += numPoints[d];
5383: PetscCall(DMPlexSetChart(dm, pStart, pEnd));
5384: for (p = pStart; p < pEnd; ++p) {
5385: PetscCall(DMPlexSetConeSize(dm, p, coneSize[p - pStart]));
5386: if (firstVertex < 0 && !coneSize[p - pStart]) firstVertex = p - pStart;
5387: }
5388: PetscCheck(firstVertex >= 0 || !numPoints[0], PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Expected %" PetscInt_FMT " vertices but could not find any", numPoints[0]);
5389: PetscCall(DMSetUp(dm)); /* Allocate space for cones */
5390: for (p = pStart, off = 0; p < pEnd; off += coneSize[p - pStart], ++p) {
5391: PetscCall(DMPlexSetCone(dm, p, &cones[off]));
5392: PetscCall(DMPlexSetConeOrientation(dm, p, &coneOrientations[off]));
5393: }
5394: PetscCall(DMPlexSymmetrize(dm));
5395: PetscCall(DMPlexStratify(dm));
5396: /* Build coordinates */
5397: PetscCall(DMGetCoordinateSection(dm, &coordSection));
5398: PetscCall(PetscSectionSetNumFields(coordSection, 1));
5399: PetscCall(PetscSectionSetFieldComponents(coordSection, 0, dimEmbed));
5400: PetscCall(PetscSectionSetChart(coordSection, firstVertex, firstVertex + numPoints[0]));
5401: for (v = firstVertex; v < firstVertex + numPoints[0]; ++v) {
5402: PetscCall(PetscSectionSetDof(coordSection, v, dimEmbed));
5403: PetscCall(PetscSectionSetFieldDof(coordSection, v, 0, dimEmbed));
5404: }
5405: PetscCall(PetscSectionSetUp(coordSection));
5406: PetscCall(PetscSectionGetStorageSize(coordSection, &coordSize));
5407: PetscCall(VecCreate(PETSC_COMM_SELF, &coordinates));
5408: PetscCall(PetscObjectSetName((PetscObject)coordinates, "coordinates"));
5409: PetscCall(VecSetSizes(coordinates, coordSize, PETSC_DETERMINE));
5410: PetscCall(VecSetBlockSize(coordinates, dimEmbed));
5411: PetscCall(VecSetType(coordinates, VECSTANDARD));
5412: if (vertexCoords) {
5413: PetscCall(VecGetArray(coordinates, &coords));
5414: for (v = 0; v < numPoints[0]; ++v) {
5415: PetscInt off;
5417: PetscCall(PetscSectionGetOffset(coordSection, v + firstVertex, &off));
5418: for (d = 0; d < dimEmbed; ++d) coords[off + d] = vertexCoords[v * dimEmbed + d];
5419: }
5420: }
5421: PetscCall(VecRestoreArray(coordinates, &coords));
5422: PetscCall(DMSetCoordinatesLocal(dm, coordinates));
5423: PetscCall(VecDestroy(&coordinates));
5424: PetscFunctionReturn(PETSC_SUCCESS);
5425: }
5427: /*
5428: DMPlexCreateCellVertexFromFile - Create a `DMPLEX` mesh from a simple cell-vertex file.
5430: Collective
5432: + comm - The MPI communicator
5433: . filename - Name of the .dat file
5434: - interpolate - Create faces and edges in the mesh
5436: Output Parameter:
5437: . dm - The `DM` object representing the mesh
5439: Level: beginner
5441: Note:
5442: The format is the simplest possible:
5443: .vb
5444: Ne
5445: v0 v1 ... vk
5446: Nv
5447: x y z marker
5448: .ve
5450: Developer Note:
5451: Should use a `PetscViewer` not a filename
5453: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexCreateFromFile()`, `DMPlexCreateGmsh()`, `DMPlexCreate()`
5454: */
5455: static PetscErrorCode DMPlexCreateCellVertexFromFile(MPI_Comm comm, const char filename[], PetscBool interpolate, DM *dm)
5456: {
5457: DMLabel marker;
5458: PetscViewer viewer;
5459: Vec coordinates;
5460: PetscSection coordSection;
5461: PetscScalar *coords;
5462: char line[PETSC_MAX_PATH_LEN];
5463: PetscInt dim = 3, cdim = 3, coordSize, v, c, d;
5464: PetscMPIInt rank;
5465: int snum, Nv, Nc, Ncn, Nl;
5467: PetscFunctionBegin;
5468: PetscCallMPI(MPI_Comm_rank(comm, &rank));
5469: PetscCall(PetscViewerCreate(comm, &viewer));
5470: PetscCall(PetscViewerSetType(viewer, PETSCVIEWERASCII));
5471: PetscCall(PetscViewerFileSetMode(viewer, FILE_MODE_READ));
5472: PetscCall(PetscViewerFileSetName(viewer, filename));
5473: if (rank == 0) {
5474: PetscCall(PetscViewerRead(viewer, line, 4, NULL, PETSC_STRING));
5475: snum = sscanf(line, "%d %d %d %d", &Nc, &Nv, &Ncn, &Nl);
5476: PetscCheck(snum == 4, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Unable to parse cell-vertex file: %s", line);
5477: } else {
5478: Nc = Nv = Ncn = Nl = 0;
5479: }
5480: PetscCall(DMCreate(comm, dm));
5481: PetscCall(DMSetType(*dm, DMPLEX));
5482: PetscCall(DMPlexSetChart(*dm, 0, Nc + Nv));
5483: PetscCall(DMSetDimension(*dm, dim));
5484: PetscCall(DMSetCoordinateDim(*dm, cdim));
5485: /* Read topology */
5486: if (rank == 0) {
5487: char format[PETSC_MAX_PATH_LEN];
5488: PetscInt cone[8];
5489: int vbuf[8], v;
5491: for (c = 0; c < Ncn; ++c) {
5492: format[c * 3 + 0] = '%';
5493: format[c * 3 + 1] = 'd';
5494: format[c * 3 + 2] = ' ';
5495: }
5496: format[Ncn * 3 - 1] = '\0';
5497: for (c = 0; c < Nc; ++c) PetscCall(DMPlexSetConeSize(*dm, c, Ncn));
5498: PetscCall(DMSetUp(*dm));
5499: for (c = 0; c < Nc; ++c) {
5500: PetscCall(PetscViewerRead(viewer, line, Ncn, NULL, PETSC_STRING));
5501: switch (Ncn) {
5502: case 2:
5503: snum = sscanf(line, format, &vbuf[0], &vbuf[1]);
5504: break;
5505: case 3:
5506: snum = sscanf(line, format, &vbuf[0], &vbuf[1], &vbuf[2]);
5507: break;
5508: case 4:
5509: snum = sscanf(line, format, &vbuf[0], &vbuf[1], &vbuf[2], &vbuf[3]);
5510: break;
5511: case 6:
5512: snum = sscanf(line, format, &vbuf[0], &vbuf[1], &vbuf[2], &vbuf[3], &vbuf[4], &vbuf[5]);
5513: break;
5514: case 8:
5515: snum = sscanf(line, format, &vbuf[0], &vbuf[1], &vbuf[2], &vbuf[3], &vbuf[4], &vbuf[5], &vbuf[6], &vbuf[7]);
5516: break;
5517: default:
5518: SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "No cell shape with %d vertices", Ncn);
5519: }
5520: PetscCheck(snum == Ncn, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Unable to parse cell-vertex file: %s", line);
5521: for (v = 0; v < Ncn; ++v) cone[v] = vbuf[v] + Nc;
5522: /* Hexahedra are inverted */
5523: if (Ncn == 8) {
5524: PetscInt tmp = cone[1];
5525: cone[1] = cone[3];
5526: cone[3] = tmp;
5527: }
5528: PetscCall(DMPlexSetCone(*dm, c, cone));
5529: }
5530: }
5531: PetscCall(DMPlexSymmetrize(*dm));
5532: PetscCall(DMPlexStratify(*dm));
5533: /* Read coordinates */
5534: PetscCall(DMGetCoordinateSection(*dm, &coordSection));
5535: PetscCall(PetscSectionSetNumFields(coordSection, 1));
5536: PetscCall(PetscSectionSetFieldComponents(coordSection, 0, cdim));
5537: PetscCall(PetscSectionSetChart(coordSection, Nc, Nc + Nv));
5538: for (v = Nc; v < Nc + Nv; ++v) {
5539: PetscCall(PetscSectionSetDof(coordSection, v, cdim));
5540: PetscCall(PetscSectionSetFieldDof(coordSection, v, 0, cdim));
5541: }
5542: PetscCall(PetscSectionSetUp(coordSection));
5543: PetscCall(PetscSectionGetStorageSize(coordSection, &coordSize));
5544: PetscCall(VecCreate(PETSC_COMM_SELF, &coordinates));
5545: PetscCall(PetscObjectSetName((PetscObject)coordinates, "coordinates"));
5546: PetscCall(VecSetSizes(coordinates, coordSize, PETSC_DETERMINE));
5547: PetscCall(VecSetBlockSize(coordinates, cdim));
5548: PetscCall(VecSetType(coordinates, VECSTANDARD));
5549: PetscCall(VecGetArray(coordinates, &coords));
5550: if (rank == 0) {
5551: char format[PETSC_MAX_PATH_LEN];
5552: double x[3];
5553: int l, val[3];
5555: if (Nl) {
5556: for (l = 0; l < Nl; ++l) {
5557: format[l * 3 + 0] = '%';
5558: format[l * 3 + 1] = 'd';
5559: format[l * 3 + 2] = ' ';
5560: }
5561: format[Nl * 3 - 1] = '\0';
5562: PetscCall(DMCreateLabel(*dm, "marker"));
5563: PetscCall(DMGetLabel(*dm, "marker", &marker));
5564: }
5565: for (v = 0; v < Nv; ++v) {
5566: PetscCall(PetscViewerRead(viewer, line, 3 + Nl, NULL, PETSC_STRING));
5567: snum = sscanf(line, "%lg %lg %lg", &x[0], &x[1], &x[2]);
5568: PetscCheck(snum == 3, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Unable to parse cell-vertex file: %s", line);
5569: switch (Nl) {
5570: case 0:
5571: snum = 0;
5572: break;
5573: case 1:
5574: snum = sscanf(line, format, &val[0]);
5575: break;
5576: case 2:
5577: snum = sscanf(line, format, &val[0], &val[1]);
5578: break;
5579: case 3:
5580: snum = sscanf(line, format, &val[0], &val[1], &val[2]);
5581: break;
5582: default:
5583: SETERRQ(PETSC_COMM_SELF, PETSC_ERR_SUP, "Request support for %d labels", Nl);
5584: }
5585: PetscCheck(snum == Nl, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Unable to parse cell-vertex file: %s", line);
5586: for (d = 0; d < cdim; ++d) coords[v * cdim + d] = x[d];
5587: for (l = 0; l < Nl; ++l) PetscCall(DMLabelSetValue(marker, v + Nc, val[l]));
5588: }
5589: }
5590: PetscCall(VecRestoreArray(coordinates, &coords));
5591: PetscCall(DMSetCoordinatesLocal(*dm, coordinates));
5592: PetscCall(VecDestroy(&coordinates));
5593: PetscCall(PetscViewerDestroy(&viewer));
5594: if (interpolate) {
5595: DM idm;
5596: DMLabel bdlabel;
5598: PetscCall(DMPlexInterpolate(*dm, &idm));
5599: PetscCall(DMDestroy(dm));
5600: *dm = idm;
5602: if (!Nl) {
5603: PetscCall(DMCreateLabel(*dm, "marker"));
5604: PetscCall(DMGetLabel(*dm, "marker", &bdlabel));
5605: PetscCall(DMPlexMarkBoundaryFaces(*dm, PETSC_DETERMINE, bdlabel));
5606: PetscCall(DMPlexLabelComplete(*dm, bdlabel));
5607: }
5608: }
5609: PetscFunctionReturn(PETSC_SUCCESS);
5610: }
5612: /*@C
5613: DMPlexCreateFromFile - This takes a filename and produces a `DM`
5615: Collective
5617: Input Parameters:
5618: + comm - The communicator
5619: . filename - A file name
5620: . plexname - The object name of the resulting `DM`, also used for intra-datafile lookup by some formats
5621: - interpolate - Flag to create intermediate mesh pieces (edges, faces)
5623: Output Parameter:
5624: . dm - The `DM`
5626: Options Database Key:
5627: . -dm_plex_create_from_hdf5_xdmf - use the `PETSC_VIEWER_HDF5_XDMF` format for reading HDF5
5629: Use `-dm_plex_create_ prefix` to pass options to the internal `PetscViewer`, e.g.
5630: $ -dm_plex_create_viewer_hdf5_collective
5632: Level: beginner
5634: Notes:
5635: Using `PETSCVIEWERHDF5` type with `PETSC_VIEWER_HDF5_PETSC` format, one can save multiple `DMPLEX`
5636: meshes in a single HDF5 file. This in turn requires one to name the `DMPLEX` object with `PetscObjectSetName()`
5637: before saving it with `DMView()` and before loading it with `DMLoad()` for identification of the mesh object.
5638: The input parameter name is thus used to name the `DMPLEX` object when `DMPlexCreateFromFile()` internally
5639: calls `DMLoad()`. Currently, name is ignored for other viewer types and/or formats.
5641: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMPlexCreateFromDAG()`, `DMPlexCreateFromCellListPetsc()`, `DMPlexCreate()`, `PetscObjectSetName()`, `DMView()`, `DMLoad()`
5642: @*/
5643: PetscErrorCode DMPlexCreateFromFile(MPI_Comm comm, const char filename[], const char plexname[], PetscBool interpolate, DM *dm)
5644: {
5645: const char extGmsh[] = ".msh";
5646: const char extGmsh2[] = ".msh2";
5647: const char extGmsh4[] = ".msh4";
5648: const char extCGNS[] = ".cgns";
5649: const char extExodus[] = ".exo";
5650: const char extExodus_e[] = ".e";
5651: const char extGenesis[] = ".gen";
5652: const char extFluent[] = ".cas";
5653: const char extHDF5[] = ".h5";
5654: const char extXDMFHDF5[] = ".xdmf.h5";
5655: const char extPLY[] = ".ply";
5656: const char extEGADSLite[] = ".egadslite";
5657: const char extEGADS[] = ".egads";
5658: const char extIGES[] = ".igs";
5659: const char extSTEP[] = ".stp";
5660: const char extCV[] = ".dat";
5661: size_t len;
5662: PetscBool isGmsh, isGmsh2, isGmsh4, isCGNS, isExodus, isGenesis, isFluent, isHDF5, isPLY, isEGADSLite, isEGADS, isIGES, isSTEP, isCV, isXDMFHDF5;
5663: PetscMPIInt rank;
5665: PetscFunctionBegin;
5666: PetscAssertPointer(filename, 2);
5667: if (plexname) PetscAssertPointer(plexname, 3);
5668: PetscAssertPointer(dm, 5);
5669: PetscCall(DMInitializePackage());
5670: PetscCall(PetscLogEventBegin(DMPLEX_CreateFromFile, 0, 0, 0, 0));
5671: PetscCallMPI(MPI_Comm_rank(comm, &rank));
5672: PetscCall(PetscStrlen(filename, &len));
5673: PetscCheck(len, comm, PETSC_ERR_ARG_WRONG, "Filename must be a valid path");
5675: #define CheckExtension(extension__, is_extension__) \
5676: do { \
5677: PetscAssert(sizeof(extension__), comm, PETSC_ERR_PLIB, "Zero-size extension: %s", extension__); \
5678: /* don't count the null-terminator at the end */ \
5679: const size_t ext_len = sizeof(extension__) - 1; \
5680: if (len < ext_len) { \
5681: is_extension__ = PETSC_FALSE; \
5682: } else { \
5683: PetscCall(PetscStrncmp(filename + len - ext_len, extension__, ext_len, &is_extension__)); \
5684: } \
5685: } while (0)
5687: CheckExtension(extGmsh, isGmsh);
5688: CheckExtension(extGmsh2, isGmsh2);
5689: CheckExtension(extGmsh4, isGmsh4);
5690: CheckExtension(extCGNS, isCGNS);
5691: CheckExtension(extExodus, isExodus);
5692: if (!isExodus) CheckExtension(extExodus_e, isExodus);
5693: CheckExtension(extGenesis, isGenesis);
5694: CheckExtension(extFluent, isFluent);
5695: CheckExtension(extHDF5, isHDF5);
5696: CheckExtension(extPLY, isPLY);
5697: CheckExtension(extEGADSLite, isEGADSLite);
5698: CheckExtension(extEGADS, isEGADS);
5699: CheckExtension(extIGES, isIGES);
5700: CheckExtension(extSTEP, isSTEP);
5701: CheckExtension(extCV, isCV);
5702: CheckExtension(extXDMFHDF5, isXDMFHDF5);
5704: #undef CheckExtension
5706: if (isGmsh || isGmsh2 || isGmsh4) {
5707: PetscCall(DMPlexCreateGmshFromFile(comm, filename, interpolate, dm));
5708: } else if (isCGNS) {
5709: PetscCall(DMPlexCreateCGNSFromFile(comm, filename, interpolate, dm));
5710: } else if (isExodus || isGenesis) {
5711: PetscCall(DMPlexCreateExodusFromFile(comm, filename, interpolate, dm));
5712: } else if (isFluent) {
5713: PetscCall(DMPlexCreateFluentFromFile(comm, filename, interpolate, dm));
5714: } else if (isHDF5) {
5715: PetscViewer viewer;
5717: /* PETSC_VIEWER_HDF5_XDMF is used if the filename ends with .xdmf.h5, or if -dm_plex_create_from_hdf5_xdmf option is present */
5718: PetscCall(PetscOptionsGetBool(NULL, NULL, "-dm_plex_create_from_hdf5_xdmf", &isXDMFHDF5, NULL));
5719: PetscCall(PetscViewerCreate(comm, &viewer));
5720: PetscCall(PetscViewerSetType(viewer, PETSCVIEWERHDF5));
5721: PetscCall(PetscViewerSetOptionsPrefix(viewer, "dm_plex_create_"));
5722: PetscCall(PetscViewerSetFromOptions(viewer));
5723: PetscCall(PetscViewerFileSetMode(viewer, FILE_MODE_READ));
5724: PetscCall(PetscViewerFileSetName(viewer, filename));
5726: PetscCall(DMCreate(comm, dm));
5727: PetscCall(PetscObjectSetName((PetscObject)*dm, plexname));
5728: PetscCall(DMSetType(*dm, DMPLEX));
5729: if (isXDMFHDF5) PetscCall(PetscViewerPushFormat(viewer, PETSC_VIEWER_HDF5_XDMF));
5730: PetscCall(DMLoad(*dm, viewer));
5731: if (isXDMFHDF5) PetscCall(PetscViewerPopFormat(viewer));
5732: PetscCall(PetscViewerDestroy(&viewer));
5734: if (interpolate) {
5735: DM idm;
5737: PetscCall(DMPlexInterpolate(*dm, &idm));
5738: PetscCall(DMDestroy(dm));
5739: *dm = idm;
5740: }
5741: } else if (isPLY) {
5742: PetscCall(DMPlexCreatePLYFromFile(comm, filename, interpolate, dm));
5743: } else if (isEGADSLite || isEGADS || isIGES || isSTEP) {
5744: if (isEGADSLite) PetscCall(DMPlexCreateEGADSLiteFromFile(comm, filename, dm));
5745: else PetscCall(DMPlexCreateEGADSFromFile(comm, filename, dm));
5746: if (!interpolate) {
5747: DM udm;
5749: PetscCall(DMPlexUninterpolate(*dm, &udm));
5750: PetscCall(DMDestroy(dm));
5751: *dm = udm;
5752: }
5753: } else if (isCV) {
5754: PetscCall(DMPlexCreateCellVertexFromFile(comm, filename, interpolate, dm));
5755: } else SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Cannot load file %s: unrecognized extension", filename);
5756: PetscCall(PetscStrlen(plexname, &len));
5757: if (len) PetscCall(PetscObjectSetName((PetscObject)*dm, plexname));
5758: PetscCall(PetscLogEventEnd(DMPLEX_CreateFromFile, 0, 0, 0, 0));
5759: PetscFunctionReturn(PETSC_SUCCESS);
5760: }
5762: /*@C
5763: DMPlexCreateEphemeral - This takes a `DMPlexTransform` and a base `DMPlex` and produces an ephemeral `DM`, meaning one that is created on the fly in response to queries.
5765: Input Parameters:
5766: + tr - The `DMPlexTransform`
5767: - prefix - An options prefix, or NULL
5769: Output Parameter:
5770: . dm - The `DM`
5772: Level: beginner
5774: Notes:
5775: An emphemeral mesh is one that is not stored concretely, as in the default `DMPLEX` implementation, but rather is produced on the fly in response to queries, using information from the transform and the base mesh.
5777: .seealso: `DMPlexCreateFromFile`, `DMPlexCreateFromDAG()`, `DMPlexCreateFromCellListPetsc()`, `DMPlexCreate()`
5778: @*/
5779: PetscErrorCode DMPlexCreateEphemeral(DMPlexTransform tr, const char prefix[], DM *dm)
5780: {
5781: DM bdm, bcdm, cdm;
5782: Vec coordinates, coordinatesNew;
5783: PetscSection cs;
5784: PetscInt dim, cdim, Nl;
5786: PetscFunctionBegin;
5787: PetscCall(DMCreate(PetscObjectComm((PetscObject)tr), dm));
5788: PetscCall(DMSetType(*dm, DMPLEX));
5789: ((DM_Plex *)(*dm)->data)->interpolated = DMPLEX_INTERPOLATED_FULL;
5790: // Handle coordinates
5791: PetscCall(DMPlexTransformGetDM(tr, &bdm));
5792: PetscCall(DMGetCoordinateDim(bdm, &cdim));
5793: PetscCall(DMSetCoordinateDim(*dm, cdim));
5794: PetscCall(DMGetDimension(bdm, &dim));
5795: PetscCall(DMSetDimension(*dm, dim));
5796: PetscCall(DMGetCoordinateDM(bdm, &bcdm));
5797: PetscCall(DMGetCoordinateDM(*dm, &cdm));
5798: PetscCall(DMCopyDisc(bcdm, cdm));
5799: PetscCall(DMGetLocalSection(cdm, &cs));
5800: PetscCall(PetscSectionSetNumFields(cs, 1));
5801: PetscCall(PetscSectionSetFieldComponents(cs, 0, cdim));
5802: PetscCall(DMGetCoordinatesLocal(bdm, &coordinates));
5803: PetscCall(VecDuplicate(coordinates, &coordinatesNew));
5804: PetscCall(VecCopy(coordinates, coordinatesNew));
5805: PetscCall(DMSetCoordinatesLocal(*dm, coordinatesNew));
5806: PetscCall(VecDestroy(&coordinatesNew));
5808: PetscCall(PetscObjectReference((PetscObject)tr));
5809: PetscCall(DMPlexTransformDestroy(&((DM_Plex *)(*dm)->data)->tr));
5810: ((DM_Plex *)(*dm)->data)->tr = tr;
5811: PetscCall(DMPlexDistributeSetDefault(*dm, PETSC_FALSE));
5812: PetscCall(PetscObjectSetOptionsPrefix((PetscObject)*dm, prefix));
5813: PetscCall(DMSetFromOptions(*dm));
5815: PetscCall(DMGetNumLabels(bdm, &Nl));
5816: for (PetscInt l = 0; l < Nl; ++l) {
5817: DMLabel label, labelNew;
5818: const char *lname;
5819: PetscBool isDepth, isCellType;
5821: PetscCall(DMGetLabelName(bdm, l, &lname));
5822: PetscCall(PetscStrcmp(lname, "depth", &isDepth));
5823: if (isDepth) continue;
5824: PetscCall(PetscStrcmp(lname, "celltype", &isCellType));
5825: if (isCellType) continue;
5826: PetscCall(DMCreateLabel(*dm, lname));
5827: PetscCall(DMGetLabel(bdm, lname, &label));
5828: PetscCall(DMGetLabel(*dm, lname, &labelNew));
5829: PetscCall(DMLabelSetType(labelNew, DMLABELEPHEMERAL));
5830: PetscCall(DMLabelEphemeralSetLabel(labelNew, label));
5831: PetscCall(DMLabelEphemeralSetTransform(labelNew, tr));
5832: PetscCall(DMLabelSetUp(labelNew));
5833: }
5834: PetscFunctionReturn(PETSC_SUCCESS);
5835: }