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