Actual source code: plexglvis.c

petsc-3.15.0 2021-03-30
Report Typos and Errors
  1: #include <petsc/private/glvisviewerimpl.h>
  2: #include <petsc/private/petscimpl.h>
  3: #include <petsc/private/dmpleximpl.h>
  4: #include <petscbt.h>
  5: #include <petscdmplex.h>
  6: #include <petscsf.h>
  7: #include <petscds.h>

  9: typedef struct {
 10:   PetscInt   nf;
 11:   VecScatter *scctx;
 12: } GLVisViewerCtx;

 14: static PetscErrorCode DestroyGLVisViewerCtx_Private(void *vctx)
 15: {
 16:   GLVisViewerCtx *ctx = (GLVisViewerCtx*)vctx;
 17:   PetscInt       i;

 21:   for (i=0;i<ctx->nf;i++) {
 22:     VecScatterDestroy(&ctx->scctx[i]);
 23:   }
 24:   PetscFree(ctx->scctx);
 25:   PetscFree(vctx);
 26:   return(0);
 27: }

 29: static PetscErrorCode DMPlexSampleGLVisFields_Private(PetscObject oX, PetscInt nf, PetscObject oXfield[], void *vctx)
 30: {
 31:   GLVisViewerCtx *ctx = (GLVisViewerCtx*)vctx;
 32:   PetscInt       f;

 36:   for (f=0;f<nf;f++) {
 37:     VecScatterBegin(ctx->scctx[f],(Vec)oX,(Vec)oXfield[f],INSERT_VALUES,SCATTER_FORWARD);
 38:     VecScatterEnd(ctx->scctx[f],(Vec)oX,(Vec)oXfield[f],INSERT_VALUES,SCATTER_FORWARD);
 39:   }
 40:   return(0);
 41: }

 43: /* for FEM, it works for H1 fields only and extracts dofs at cell vertices, discarding any other dof */
 44: PetscErrorCode DMSetUpGLVisViewer_Plex(PetscObject odm, PetscViewer viewer)
 45: {
 46:   DM             dm = (DM)odm;
 47:   Vec            xlocal,xfield,*Ufield;
 48:   PetscDS        ds;
 49:   IS             globalNum,isfield;
 50:   PetscBT        vown;
 51:   char           **fieldname = NULL,**fec_type = NULL;
 52:   const PetscInt *gNum;
 53:   PetscInt       *nlocal,*bs,*idxs,*dims;
 54:   PetscInt       f,maxfields,nfields,c,totc,totdofs,Nv,cum,i;
 55:   PetscInt       dim,cStart,cEnd,vStart,vEnd;
 56:   GLVisViewerCtx *ctx;
 57:   PetscSection   s;

 61:   DMGetDimension(dm,&dim);
 62:   DMPlexGetDepthStratum(dm,0,&vStart,&vEnd);
 63:   DMPlexGetHeightStratum(dm,0,&cStart,&cEnd);
 64:   PetscObjectQuery((PetscObject)dm,"_glvis_plex_gnum",(PetscObject*)&globalNum);
 65:   if (!globalNum) {
 66:     DMPlexCreateCellNumbering_Internal(dm,PETSC_TRUE,&globalNum);
 67:     PetscObjectCompose((PetscObject)dm,"_glvis_plex_gnum",(PetscObject)globalNum);
 68:     PetscObjectDereference((PetscObject)globalNum);
 69:   }
 70:   ISGetIndices(globalNum,&gNum);
 71:   PetscBTCreate(vEnd-vStart,&vown);
 72:   for (c = cStart, totc = 0; c < cEnd; c++) {
 73:     if (gNum[c-cStart] >= 0) {
 74:       PetscInt i,numPoints,*points = NULL;

 76:       totc++;
 77:       DMPlexGetTransitiveClosure(dm,c,PETSC_TRUE,&numPoints,&points);
 78:       for (i=0;i<numPoints*2;i+= 2) {
 79:         if ((points[i] >= vStart) && (points[i] < vEnd)) {
 80:           PetscBTSet(vown,points[i]-vStart);
 81:         }
 82:       }
 83:       DMPlexRestoreTransitiveClosure(dm,c,PETSC_TRUE,&numPoints,&points);
 84:     }
 85:   }
 86:   for (f=0,Nv=0;f<vEnd-vStart;f++) if (PetscLikely(PetscBTLookup(vown,f))) Nv++;

 88:   DMCreateLocalVector(dm,&xlocal);
 89:   VecGetLocalSize(xlocal,&totdofs);
 90:   DMGetLocalSection(dm,&s);
 91:   PetscSectionGetNumFields(s,&nfields);
 92:   for (f=0,maxfields=0;f<nfields;f++) {
 93:     PetscInt bs;

 95:     PetscSectionGetFieldComponents(s,f,&bs);
 96:     maxfields += bs;
 97:   }
 98:   PetscCalloc7(maxfields,&fieldname,maxfields,&nlocal,maxfields,&bs,maxfields,&dims,maxfields,&fec_type,totdofs,&idxs,maxfields,&Ufield);
 99:   PetscNew(&ctx);
100:   PetscCalloc1(maxfields,&ctx->scctx);
101:   DMGetDS(dm,&ds);
102:   if (ds) {
103:     for (f=0;f<nfields;f++) {
104:       const char* fname;
105:       char        name[256];
106:       PetscObject disc;
107:       size_t      len;

109:       PetscSectionGetFieldName(s,f,&fname);
110:       PetscStrlen(fname,&len);
111:       if (len) {
112:         PetscStrcpy(name,fname);
113:       } else {
114:         PetscSNPrintf(name,256,"Field%D",f);
115:       }
116:       PetscDSGetDiscretization(ds,f,&disc);
117:       if (disc) {
118:         PetscClassId id;
119:         PetscInt     Nc;
120:         char         fec[64];

122:         PetscObjectGetClassId(disc, &id);
123:         if (id == PETSCFE_CLASSID) {
124:           PetscFE            fem = (PetscFE)disc;
125:           PetscDualSpace     sp;
126:           PetscDualSpaceType spname;
127:           PetscInt           order;
128:           PetscBool          islag,continuous,H1 = PETSC_TRUE;

130:           PetscFEGetNumComponents(fem,&Nc);
131:           PetscFEGetDualSpace(fem,&sp);
132:           PetscDualSpaceGetType(sp,&spname);
133:           PetscStrcmp(spname,PETSCDUALSPACELAGRANGE,&islag);
134:           if (!islag) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_SUP,"Unsupported dual space");
135:           PetscDualSpaceLagrangeGetContinuity(sp,&continuous);
136:           PetscDualSpaceGetOrder(sp,&order);
137:           if (continuous && order > 0) { /* no support for high-order viz, still have to figure out the numbering */
138:             PetscSNPrintf(fec,64,"FiniteElementCollection: H1_%DD_P1",dim);
139:           } else {
140:             if (!continuous && order) SETERRQ1(PetscObjectComm((PetscObject)dm),PETSC_ERR_SUP,"Discontinuous space visualization currently unsupported for order %D",order);
141:             H1   = PETSC_FALSE;
142:             PetscSNPrintf(fec,64,"FiniteElementCollection: L2_%DD_P%D",dim,order);
143:           }
144:           PetscStrallocpy(name,&fieldname[ctx->nf]);
145:           bs[ctx->nf]   = Nc;
146:           dims[ctx->nf] = dim;
147:           if (H1) {
148:             nlocal[ctx->nf] = Nc * Nv;
149:             PetscStrallocpy(fec,&fec_type[ctx->nf]);
150:             VecCreateSeq(PETSC_COMM_SELF,Nv*Nc,&xfield);
151:             for (i=0,cum=0;i<vEnd-vStart;i++) {
152:               PetscInt j,off;

154:               if (PetscUnlikely(!PetscBTLookup(vown,i))) continue;
155:               PetscSectionGetFieldOffset(s,i+vStart,f,&off);
156:               for (j=0;j<Nc;j++) idxs[cum++] = off + j;
157:             }
158:             ISCreateGeneral(PetscObjectComm((PetscObject)xlocal),Nv*Nc,idxs,PETSC_USE_POINTER,&isfield);
159:           } else {
160:             nlocal[ctx->nf] = Nc * totc;
161:             PetscStrallocpy(fec,&fec_type[ctx->nf]);
162:             VecCreateSeq(PETSC_COMM_SELF,Nc*totc,&xfield);
163:             for (i=0,cum=0;i<cEnd-cStart;i++) {
164:               PetscInt j,off;

166:               if (PetscUnlikely(gNum[i] < 0)) continue;
167:               PetscSectionGetFieldOffset(s,i+cStart,f,&off);
168:               for (j=0;j<Nc;j++) idxs[cum++] = off + j;
169:             }
170:             ISCreateGeneral(PetscObjectComm((PetscObject)xlocal),totc*Nc,idxs,PETSC_USE_POINTER,&isfield);
171:           }
172:           VecScatterCreate(xlocal,isfield,xfield,NULL,&ctx->scctx[ctx->nf]);
173:           VecDestroy(&xfield);
174:           ISDestroy(&isfield);
175:           ctx->nf++;
176:         } else if (id == PETSCFV_CLASSID) {
177:           PetscInt c;

179:           PetscFVGetNumComponents((PetscFV)disc,&Nc);
180:           PetscSNPrintf(fec,64,"FiniteElementCollection: L2_%DD_P0",dim);
181:           for (c = 0; c < Nc; c++) {
182:             char comp[256];
183:             PetscSNPrintf(comp,256,"%s-Comp%D",name,c);
184:             PetscStrallocpy(comp,&fieldname[ctx->nf]);
185:             bs[ctx->nf] = 1; /* Does PetscFV support components with different block size? */
186:             nlocal[ctx->nf] = totc;
187:             dims[ctx->nf] = dim;
188:             PetscStrallocpy(fec,&fec_type[ctx->nf]);
189:             VecCreateSeq(PETSC_COMM_SELF,totc,&xfield);
190:             for (i=0,cum=0;i<cEnd-cStart;i++) {
191:               PetscInt off;

193:               if (PetscUnlikely(gNum[i])<0) continue;
194:               PetscSectionGetFieldOffset(s,i+cStart,f,&off);
195:               idxs[cum++] = off + c;
196:             }
197:             ISCreateGeneral(PetscObjectComm((PetscObject)xlocal),totc,idxs,PETSC_USE_POINTER,&isfield);
198:             VecScatterCreate(xlocal,isfield,xfield,NULL,&ctx->scctx[ctx->nf]);
199:             VecDestroy(&xfield);
200:             ISDestroy(&isfield);
201:             ctx->nf++;
202:           }
203:         } else SETERRQ1(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_WRONG,"Unknown discretization type for field %D",f);
204:       } else SETERRQ1(PetscObjectComm((PetscObject)dm),PETSC_ERR_SUP,"Missing discretization for field %D",f);
205:     }
206:   } else SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_SUP,"Needs a DS attached to the DM");
207:   PetscBTDestroy(&vown);
208:   VecDestroy(&xlocal);
209:   ISRestoreIndices(globalNum,&gNum);

211:   /* create work vectors */
212:   for (f=0;f<ctx->nf;f++) {
213:     VecCreateMPI(PetscObjectComm((PetscObject)dm),nlocal[f],PETSC_DECIDE,&Ufield[f]);
214:     PetscObjectSetName((PetscObject)Ufield[f],fieldname[f]);
215:     VecSetBlockSize(Ufield[f],bs[f]);
216:     VecSetDM(Ufield[f],dm);
217:   }

219:   /* customize the viewer */
220:   PetscViewerGLVisSetFields(viewer,ctx->nf,(const char**)fec_type,dims,DMPlexSampleGLVisFields_Private,(PetscObject*)Ufield,ctx,DestroyGLVisViewerCtx_Private);
221:   for (f=0;f<ctx->nf;f++) {
222:     PetscFree(fieldname[f]);
223:     PetscFree(fec_type[f]);
224:     VecDestroy(&Ufield[f]);
225:   }
226:   PetscFree7(fieldname,nlocal,bs,dims,fec_type,idxs,Ufield);
227:   return(0);
228: }

230: typedef enum {MFEM_POINT=0,MFEM_SEGMENT,MFEM_TRIANGLE,MFEM_SQUARE,MFEM_TETRAHEDRON,MFEM_CUBE,MFEM_PRISM,MFEM_UNDEF} MFEM_cid;

232: MFEM_cid mfem_table_cid[4][7]       = { {MFEM_POINT,MFEM_UNDEF,MFEM_UNDEF  ,MFEM_UNDEF   ,MFEM_UNDEF      ,MFEM_UNDEF,MFEM_UNDEF},
233:                                         {MFEM_POINT,MFEM_UNDEF,MFEM_SEGMENT,MFEM_UNDEF   ,MFEM_UNDEF      ,MFEM_UNDEF,MFEM_UNDEF},
234:                                         {MFEM_POINT,MFEM_UNDEF,MFEM_SEGMENT,MFEM_TRIANGLE,MFEM_SQUARE     ,MFEM_UNDEF,MFEM_UNDEF},
235:                                         {MFEM_POINT,MFEM_UNDEF,MFEM_SEGMENT,MFEM_UNDEF   ,MFEM_TETRAHEDRON,MFEM_PRISM,MFEM_CUBE } };

237: MFEM_cid mfem_table_cid_unint[4][9] = { {MFEM_POINT,MFEM_UNDEF,MFEM_UNDEF  ,MFEM_UNDEF   ,MFEM_UNDEF      ,MFEM_UNDEF,MFEM_PRISM,MFEM_UNDEF,MFEM_UNDEF},
238:                                         {MFEM_POINT,MFEM_UNDEF,MFEM_SEGMENT,MFEM_UNDEF   ,MFEM_UNDEF      ,MFEM_UNDEF,MFEM_PRISM,MFEM_UNDEF,MFEM_UNDEF},
239:                                         {MFEM_POINT,MFEM_UNDEF,MFEM_SEGMENT,MFEM_TRIANGLE,MFEM_SQUARE     ,MFEM_UNDEF,MFEM_PRISM,MFEM_UNDEF,MFEM_UNDEF},
240:                                         {MFEM_POINT,MFEM_UNDEF,MFEM_SEGMENT,MFEM_UNDEF   ,MFEM_TETRAHEDRON,MFEM_UNDEF,MFEM_PRISM,MFEM_UNDEF,MFEM_CUBE } };

242: static PetscErrorCode DMPlexGetPointMFEMCellID_Internal(DM dm, DMLabel label, PetscInt minl, PetscInt p, PetscInt *mid, PetscInt *cid)
243: {
244:   DMLabel        dlabel;
245:   PetscInt       depth,csize,pdepth,dim;

249:   DMPlexGetDepthLabel(dm,&dlabel);
250:   DMLabelGetValue(dlabel,p,&pdepth);
251:   DMPlexGetConeSize(dm,p,&csize);
252:   DMPlexGetDepth(dm,&depth);
253:   DMGetDimension(dm,&dim);
254:   if (label) {
255:     DMLabelGetValue(label,p,mid);
256:     *mid = *mid - minl + 1; /* MFEM does not like negative markers */
257:   } else *mid = 1;
258:   if (depth >=0 && dim != depth) { /* not interpolated, it assumes cell-vertex mesh */
259:     if (dim < 0 || dim > 3) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"Dimension %D",dim);
260:     if (csize > 8) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_SUP,"Found cone size %D for point %D",csize,p);
261:     if (depth != 1) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_SUP,"Found depth %D for point %D. You should interpolate the mesh first",depth,p);
262:     *cid = mfem_table_cid_unint[dim][csize];
263:   } else {
264:     if (csize > 6) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_SUP,"Cone size %D for point %D",csize,p);
265:     if (pdepth < 0 || pdepth > 3) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_SUP,"Depth %D for point %D",csize,p);
266:     *cid = mfem_table_cid[pdepth][csize];
267:   }
268:   return(0);
269: }

271: static PetscErrorCode DMPlexGetPointMFEMVertexIDs_Internal(DM dm, PetscInt p, PetscSection csec, PetscInt *nv, PetscInt vids[])
272: {
273:   PetscInt       dim,sdim,dof = 0,off = 0,i,q,vStart,vEnd,numPoints,*points = NULL;

277:   DMPlexGetDepthStratum(dm,0,&vStart,&vEnd);
278:   DMGetDimension(dm,&dim);
279:   sdim = dim;
280:   if (csec) {
281:     PetscInt sStart,sEnd;

283:     DMGetCoordinateDim(dm,&sdim);
284:     PetscSectionGetChart(csec,&sStart,&sEnd);
285:     PetscSectionGetOffset(csec,vStart,&off);
286:     off  = off/sdim;
287:     if (p >= sStart && p < sEnd) {
288:       PetscSectionGetDof(csec,p,&dof);
289:     }
290:   }
291:   if (!dof) {
292:     DMPlexGetTransitiveClosure(dm,p,PETSC_TRUE,&numPoints,&points);
293:     for (i=0,q=0;i<numPoints*2;i+= 2)
294:       if ((points[i] >= vStart) && (points[i] < vEnd))
295:         vids[q++] = points[i]-vStart+off;
296:     DMPlexRestoreTransitiveClosure(dm,p,PETSC_TRUE,&numPoints,&points);
297:   } else {
298:     PetscSectionGetOffset(csec,p,&off);
299:     PetscSectionGetDof(csec,p,&dof);
300:     for (q=0;q<dof/sdim;q++) vids[q] = off/sdim + q;
301:   }
302:   *nv = q;
303:   return(0);
304: }

306: static PetscErrorCode GLVisCreateFE(PetscFE femIn,char name[32],PetscFE *fem)
307: {
308:   DM              K;
309:   PetscSpace      P;
310:   PetscDualSpace  Q;
311:   PetscQuadrature q,fq;
312:   PetscInt        dim,deg,dof;
313:   DMPolytopeType  ptype;
314:   PetscBool       isSimplex,isTensor;
315:   PetscBool       continuity = PETSC_FALSE;
316:   PetscDTNodeType nodeType   = PETSCDTNODES_GAUSSJACOBI;
317:   PetscBool       endpoint   = PETSC_TRUE;
318:   MPI_Comm        comm;
319:   PetscErrorCode  ierr;

322:   comm = PetscObjectComm((PetscObject)femIn);
323:   PetscFEGetBasisSpace(femIn,&P);
324:   PetscFEGetDualSpace(femIn,&Q);
325:   PetscDualSpaceGetDM(Q,&K);
326:   DMGetDimension(K,&dim);
327:   PetscSpaceGetDegree(P,&deg,NULL);
328:   PetscSpaceGetNumComponents(P,&dof);
329:   DMPlexGetCellType(K,0,&ptype);
330:   switch (ptype) {
331:   case DM_POLYTOPE_QUADRILATERAL:
332:   case DM_POLYTOPE_HEXAHEDRON:
333:     isSimplex = PETSC_FALSE; break;
334:   default:
335:     isSimplex = PETSC_TRUE; break;
336:   }
337:   isTensor = isSimplex ? PETSC_FALSE : PETSC_TRUE;
338:   /* Create space */
339:   PetscSpaceCreate(comm,&P);
340:   PetscSpaceSetType(P,PETSCSPACEPOLYNOMIAL);
341:   PetscSpacePolynomialSetTensor(P,isTensor);
342:   PetscSpaceSetNumComponents(P,dof);
343:   PetscSpaceSetNumVariables(P,dim);
344:   PetscSpaceSetDegree(P,deg,PETSC_DETERMINE);
345:   PetscSpaceSetUp(P);
346:   /* Create dual space */
347:   PetscDualSpaceCreate(comm,&Q);
348:   PetscDualSpaceSetType(Q,PETSCDUALSPACELAGRANGE);
349:   PetscDualSpaceLagrangeSetTensor(Q,isTensor);
350:   PetscDualSpaceLagrangeSetContinuity(Q,continuity);
351:   PetscDualSpaceLagrangeSetNodeType(Q,nodeType,endpoint,0);
352:   PetscDualSpaceSetNumComponents(Q,dof);
353:   PetscDualSpaceSetOrder(Q,deg);
354:   PetscDualSpaceCreateReferenceCell(Q,dim,isSimplex,&K);
355:   PetscDualSpaceSetDM(Q,K);
356:   DMDestroy(&K);
357:   PetscDualSpaceSetUp(Q);
358:   /* Create quadrature */
359:   if (isSimplex) {
360:     PetscDTStroudConicalQuadrature(dim,  1,deg+1,-1,+1,&q);
361:     PetscDTStroudConicalQuadrature(dim-1,1,deg+1,-1,+1,&fq);
362:   } else {
363:     PetscDTGaussTensorQuadrature(dim,  1,deg+1,-1,+1,&q);
364:     PetscDTGaussTensorQuadrature(dim-1,1,deg+1,-1,+1,&fq);
365:   }
366:   /* Create finite element */
367:   PetscFECreate(comm,fem);
368:   PetscSNPrintf(name,32,"L2_T1_%DD_P%D",dim,deg);
369:   PetscObjectSetName((PetscObject)*fem,name);
370:   PetscFESetType(*fem,PETSCFEBASIC);
371:   PetscFESetNumComponents(*fem,dof);
372:   PetscFESetBasisSpace(*fem,P);
373:   PetscFESetDualSpace(*fem,Q);
374:   PetscFESetQuadrature(*fem,q);
375:   PetscFESetFaceQuadrature(*fem,fq);
376:   PetscFESetUp(*fem);
377:   /* Cleanup */
378:   PetscSpaceDestroy(&P);
379:   PetscDualSpaceDestroy(&Q);
380:   PetscQuadratureDestroy(&q);
381:   PetscQuadratureDestroy(&fq);
382:   return(0);
383: }

385: /*
386:    ASCII visualization/dump: full support for simplices and tensor product cells. It supports AMR
387:    Higher order meshes are also supported
388: */
389: static PetscErrorCode DMPlexView_GLVis_ASCII(DM dm, PetscViewer viewer)
390: {
391:   DMLabel              label;
392:   PetscSection         coordSection,parentSection;
393:   Vec                  coordinates,hovec;
394:   const PetscScalar    *array;
395:   PetscInt             bf,p,sdim,dim,depth,novl,minl;
396:   PetscInt             cStart,cEnd,vStart,vEnd,nvert;
397:   PetscMPIInt          size;
398:   PetscBool            localized,isascii;
399:   PetscBool            enable_mfem,enable_boundary,enable_ncmesh,view_ovl = PETSC_FALSE;
400:   PetscBT              pown,vown;
401:   PetscErrorCode       ierr;
402:   PetscContainer       glvis_container;
403:   PetscBool            cellvertex = PETSC_FALSE, periodic, enabled = PETSC_TRUE;
404:   PetscBool            enable_emark,enable_bmark;
405:   const char           *fmt;
406:   char                 emark[64] = "",bmark[64] = "";

411:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&isascii);
412:   if (!isascii) SETERRQ(PetscObjectComm((PetscObject)viewer),PETSC_ERR_SUP,"Viewer must be of type VIEWERASCII");
413:   MPI_Comm_size(PetscObjectComm((PetscObject)viewer),&size);
414:   if (size > 1) SETERRQ(PetscObjectComm((PetscObject)viewer),PETSC_ERR_SUP,"Use single sequential viewers for parallel visualization");
415:   DMGetDimension(dm,&dim);

417:   /* get container: determines if a process visualizes is portion of the data or not */
418:   PetscObjectQuery((PetscObject)viewer,"_glvis_info_container",(PetscObject*)&glvis_container);
419:   if (!glvis_container) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_PLIB,"Missing GLVis container");
420:   {
421:     PetscViewerGLVisInfo glvis_info;
422:     PetscContainerGetPointer(glvis_container,(void**)&glvis_info);
423:     enabled = glvis_info->enabled;
424:     fmt     = glvis_info->fmt;
425:   }

427:   /* Users can attach a coordinate vector to the DM in case they have a higher-order mesh
428:      DMPlex does not currently support HO meshes, so there's no API for this */
429:   PetscObjectQuery((PetscObject)dm,"_glvis_mesh_coords",(PetscObject*)&hovec);
430:   PetscObjectReference((PetscObject)hovec);
431:   if (!hovec) {
432:     DM           cdm;
433:     PetscFE      disc;
434:     PetscClassId classid;

436:     DMGetCoordinateDM(dm,&cdm);
437:     DMGetField(cdm,0,NULL,(PetscObject*)&disc);
438:     PetscObjectGetClassId((PetscObject)disc,&classid);
439:     if (classid == PETSCFE_CLASSID) {
440:       DM      hocdm;
441:       PetscFE hodisc;
442:       Vec     vec;
443:       Mat     mat;
444:       char    name[32],fec_type[64];

446:       GLVisCreateFE(disc,name,&hodisc);
447:       DMClone(cdm,&hocdm);
448:       DMSetField(hocdm,0,NULL,(PetscObject)hodisc);
449:       PetscFEDestroy(&hodisc);
450:       DMCreateDS(hocdm);

452:       DMGetCoordinates(dm,&vec);
453:       DMCreateGlobalVector(hocdm,&hovec);
454:       DMCreateInterpolation(cdm,hocdm,&mat,NULL);
455:       MatInterpolate(mat,vec,hovec);
456:       MatDestroy(&mat);
457:       DMDestroy(&hocdm);

459:       PetscSNPrintf(fec_type,sizeof(fec_type),"FiniteElementCollection: %s", name);
460:       PetscObjectSetName((PetscObject)hovec,fec_type);
461:     }
462:   }

464:   DMPlexGetHeightStratum(dm,0,&cStart,&cEnd);
465:   DMPlexGetGhostCellStratum(dm,&p,NULL);
466:   if (p >= 0) cEnd = p;
467:   DMPlexGetDepthStratum(dm,0,&vStart,&vEnd);
468:   DMGetPeriodicity(dm,&periodic,NULL,NULL,NULL);
469:   DMGetCoordinatesLocalized(dm,&localized);
470:   if (periodic && !localized && !hovec) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_SUP,"Coordinates need to be localized");
471:   DMGetCoordinateSection(dm,&coordSection);
472:   DMGetCoordinateDim(dm,&sdim);
473:   DMGetCoordinatesLocal(dm,&coordinates);
474:   if (!coordinates && !hovec) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_SUP,"Missing local coordinates vector");

476:   /*
477:      a couple of sections of the mesh specification are disabled
478:        - boundary: the boundary is not needed for proper mesh visualization unless we want to visualize boundary attributes or we have high-order coordinates in 3D (topologically)
479:        - vertex_parents: used for non-conforming meshes only when we want to use MFEM as a discretization package
480:                          and be able to derefine the mesh (MFEM does not currently have to ability to read ncmeshes in parallel)
481:   */
482:   enable_boundary = PETSC_FALSE;
483:   enable_ncmesh   = PETSC_FALSE;
484:   enable_mfem     = PETSC_FALSE;
485:   enable_emark    = PETSC_FALSE;
486:   enable_bmark    = PETSC_FALSE;
487:   /* I'm tired of problems with negative values in the markers, disable them */
488:   PetscOptionsBegin(PetscObjectComm((PetscObject)dm),((PetscObject)dm)->prefix,"GLVis PetscViewer DMPlex Options","PetscViewer");
489:   PetscOptionsBool("-viewer_glvis_dm_plex_enable_boundary","Enable boundary section in mesh representation",NULL,enable_boundary,&enable_boundary,NULL);
490:   PetscOptionsBool("-viewer_glvis_dm_plex_enable_ncmesh","Enable vertex_parents section in mesh representation (allows derefinement)",NULL,enable_ncmesh,&enable_ncmesh,NULL);
491:   PetscOptionsBool("-viewer_glvis_dm_plex_enable_mfem","Dump a mesh that can be used with MFEM's FiniteElementSpaces",NULL,enable_mfem,&enable_mfem,NULL);
492:   PetscOptionsBool("-viewer_glvis_dm_plex_overlap","Include overlap region in local meshes",NULL,view_ovl,&view_ovl,NULL);
493:   PetscOptionsString("-viewer_glvis_dm_plex_emarker","String for the material id label",NULL,emark,emark,sizeof(emark),&enable_emark);
494:   PetscOptionsString("-viewer_glvis_dm_plex_bmarker","String for the boundary id label",NULL,bmark,bmark,sizeof(bmark),&enable_bmark);
495:   PetscOptionsEnd();
496:   if (enable_bmark) enable_boundary = PETSC_TRUE;

498:   MPI_Comm_size(PetscObjectComm((PetscObject)dm),&size);
499:   if (enable_ncmesh && size > 1) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_SUP,"Not supported in parallel");
500:   DMPlexGetDepth(dm,&depth);
501:   if (enable_boundary && depth >= 0 && dim != depth) SETERRQ(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "Mesh must be interpolated. "
502:                                                              "Alternatively, run with -viewer_glvis_dm_plex_enable_boundary 0");
503:   if (enable_ncmesh && depth >= 0 && dim != depth) SETERRQ(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "Mesh must be interpolated. "
504:                                                            "Alternatively, run with -viewer_glvis_dm_plex_enable_ncmesh 0");
505:   if (depth >=0 && dim != depth) { /* not interpolated, it assumes cell-vertex mesh */
506:     if (depth != 1) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"Unsupported depth %D. You should interpolate the mesh first",depth);
507:     cellvertex = PETSC_TRUE;
508:   }

510:   /* Identify possible cells in the overlap */
511:   novl = 0;
512:   pown = NULL;
513:   if (size > 1) {
514:     IS             globalNum = NULL;
515:     const PetscInt *gNum;
516:     PetscBool      ovl  = PETSC_FALSE;

518:     PetscObjectQuery((PetscObject)dm,"_glvis_plex_gnum",(PetscObject*)&globalNum);
519:     if (!globalNum) {
520:       if (view_ovl) {
521:         ISCreateStride(PetscObjectComm((PetscObject)dm),cEnd-cStart,0,1,&globalNum);
522:       } else {
523:         DMPlexCreateCellNumbering_Internal(dm,PETSC_TRUE,&globalNum);
524:       }
525:       PetscObjectCompose((PetscObject)dm,"_glvis_plex_gnum",(PetscObject)globalNum);
526:       PetscObjectDereference((PetscObject)globalNum);
527:     }
528:     ISGetIndices(globalNum,&gNum);
529:     for (p=cStart; p<cEnd; p++) {
530:       if (gNum[p-cStart] < 0) {
531:         ovl = PETSC_TRUE;
532:         novl++;
533:       }
534:     }
535:     if (ovl) {
536:       /* it may happen that pown get not destroyed, if the user closes the window while this function is running.
537:          TODO: garbage collector? attach pown to dm?  */
538:       PetscBTCreate(cEnd-cStart,&pown);
539:       for (p=cStart; p<cEnd; p++) {
540:         if (gNum[p-cStart] < 0) continue;
541:         else {
542:           PetscBTSet(pown,p-cStart);
543:         }
544:       }
545:     }
546:     ISRestoreIndices(globalNum,&gNum);
547:   }

549:   /* vertex_parents (Non-conforming meshes) */
550:   parentSection  = NULL;
551:   if (enable_ncmesh) {
552:     DMPlexGetTree(dm,&parentSection,NULL,NULL,NULL,NULL);
553:     enable_ncmesh = (PetscBool)(enable_ncmesh && parentSection);
554:   }
555:   /* return if this process is disabled */
556:   if (!enabled) {
557:     PetscViewerASCIIPrintf(viewer,"MFEM mesh %s\n",enable_ncmesh ? "v1.1" : "v1.0");
558:     PetscViewerASCIIPrintf(viewer,"\ndimension\n");
559:     PetscViewerASCIIPrintf(viewer,"%D\n",dim);
560:     PetscViewerASCIIPrintf(viewer,"\nelements\n");
561:     PetscViewerASCIIPrintf(viewer,"%D\n",0);
562:     PetscViewerASCIIPrintf(viewer,"\nboundary\n");
563:     PetscViewerASCIIPrintf(viewer,"%D\n",0);
564:     PetscViewerASCIIPrintf(viewer,"\nvertices\n");
565:     PetscViewerASCIIPrintf(viewer,"%D\n",0);
566:     PetscViewerASCIIPrintf(viewer,"%D\n",sdim);
567:     PetscBTDestroy(&pown);
568:     VecDestroy(&hovec);
569:     return(0);
570:   }

572:   if (enable_mfem) {
573:     if (periodic && !hovec) { /* we need to generate a vector of L2 coordinates, as this is how MFEM handles periodic meshes */
574:       PetscInt    vpc = 0;
575:       char        fec[64];
576:       PetscInt    vids[8] = {0,1,2,3,4,5,6,7};
577:       PetscInt    hexv[8] = {0,1,3,2,4,5,7,6}, tetv[4] = {0,1,2,3};
578:       PetscInt    quadv[8] = {0,1,3,2}, triv[3] = {0,1,2};
579:       PetscInt    *dof = NULL;
580:       PetscScalar *array,*ptr;

582:       PetscSNPrintf(fec,sizeof(fec),"FiniteElementCollection: L2_T1_%DD_P1",dim);
583:       if (cEnd-cStart) {
584:         PetscInt fpc;

586:         DMPlexGetConeSize(dm,cStart,&fpc);
587:         switch(dim) {
588:           case 1:
589:             vpc = 2;
590:             dof = hexv;
591:             break;
592:           case 2:
593:             switch (fpc) {
594:               case 3:
595:                 vpc = 3;
596:                 dof = triv;
597:                 break;
598:               case 4:
599:                 vpc = 4;
600:                 dof = quadv;
601:                 break;
602:               default:
603:                 SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"Unhandled case: faces per cell %D",fpc);
604:             }
605:             break;
606:           case 3:
607:             switch (fpc) {
608:               case 4: /* TODO: still need to understand L2 ordering for tets */
609:                 vpc = 4;
610:                 dof = tetv;
611:                 SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Unhandled tethraedral case");
612:               case 6:
613:                 if (cellvertex) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"Unhandled case: vertices per cell %D",fpc);
614:                 vpc = 8;
615:                 dof = hexv;
616:                 break;
617:               case 8:
618:                 if (!cellvertex) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"Unhandled case: faces per cell %D",fpc);
619:                 vpc = 8;
620:                 dof = hexv;
621:                 break;
622:               default:
623:                 SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"Unhandled case: faces per cell %D",fpc);
624:             }
625:             break;
626:           default:
627:             SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_SUP,"Unhandled dim");
628:         }
629:         DMPlexReorderCell(dm,cStart,vids);
630:       }
631:       if (!dof) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_PLIB,"Missing dofs");
632:       VecCreateSeq(PETSC_COMM_SELF,(cEnd-cStart-novl)*vpc*sdim,&hovec);
633:       PetscObjectSetName((PetscObject)hovec,fec);
634:       VecGetArray(hovec,&array);
635:       ptr  = array;
636:       for (p=cStart;p<cEnd;p++) {
637:         PetscInt    csize,v,d;
638:         PetscScalar *vals = NULL;

640:         if (PetscUnlikely(pown && !PetscBTLookup(pown,p-cStart))) continue;
641:         DMPlexVecGetClosure(dm,coordSection,coordinates,p,&csize,&vals);
642:         if (csize != vpc*sdim && csize != vpc*sdim*2) SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_SUP,"Unsupported closure size %D (vpc %D, sdim %D)",csize,vpc,sdim);
643:         for (v=0;v<vpc;v++) {
644:           for (d=0;d<sdim;d++) {
645:             ptr[sdim*dof[v]+d] = vals[sdim*vids[v]+d];
646:           }
647:         }
648:         ptr += vpc*sdim;
649:         DMPlexVecRestoreClosure(dm,coordSection,coordinates,p,&csize,&vals);
650:       }
651:       VecRestoreArray(hovec,&array);
652:     }
653:   }
654:   /* if we have high-order coordinates in 3D, we need to specify the boundary */
655:   if (hovec && dim == 3) enable_boundary = PETSC_TRUE;

657:   /* header */
658:   PetscViewerASCIIPrintf(viewer,"MFEM mesh %s\n",enable_ncmesh ? "v1.1" : "v1.0");

660:   /* topological dimension */
661:   PetscViewerASCIIPrintf(viewer,"\ndimension\n");
662:   PetscViewerASCIIPrintf(viewer,"%D\n",dim);

664:   /* elements */
665:   minl = 1;
666:   label = NULL;
667:   if (enable_emark) {
668:     PetscInt lminl = PETSC_MAX_INT;

670:     DMGetLabel(dm,emark,&label);
671:     if (label) {
672:       IS       vals;
673:       PetscInt ldef;

675:       DMLabelGetDefaultValue(label,&ldef);
676:       DMLabelGetValueIS(label,&vals);
677:       ISGetMinMax(vals,&lminl,NULL);
678:       ISDestroy(&vals);
679:       lminl = PetscMin(ldef,lminl);
680:     }
681:     MPIU_Allreduce(&lminl,&minl,1,MPIU_INT,MPI_MIN,PetscObjectComm((PetscObject)dm));
682:     if (minl == PETSC_MAX_INT) minl = 1;
683:   }
684:   PetscViewerASCIIPrintf(viewer,"\nelements\n");
685:   PetscViewerASCIIPrintf(viewer,"%D\n",cEnd-cStart-novl);
686:   for (p=cStart;p<cEnd;p++) {
687:     PetscInt       vids[8];
688:     PetscInt       i,nv = 0,cid = -1,mid = 1;

690:     if (PetscUnlikely(pown && !PetscBTLookup(pown,p-cStart))) continue;
691:     DMPlexGetPointMFEMCellID_Internal(dm,label,minl,p,&mid,&cid);
692:     DMPlexGetPointMFEMVertexIDs_Internal(dm,p,(localized && !hovec) ? coordSection : NULL,&nv,vids);
693:     DMPlexReorderCell(dm,p,vids);
694:     PetscViewerASCIIPrintf(viewer,"%D %D",mid,cid);
695:     for (i=0;i<nv;i++) {
696:       PetscViewerASCIIPrintf(viewer," %D",vids[i]);
697:     }
698:     PetscViewerASCIIPrintf(viewer,"\n");
699:   }

701:   /* boundary */
702:   PetscViewerASCIIPrintf(viewer,"\nboundary\n");
703:   if (!enable_boundary) {
704:     PetscViewerASCIIPrintf(viewer,"%D\n",0);
705:   } else {
706:     DMLabel  perLabel;
707:     PetscBT  bfaces;
708:     PetscInt fStart,fEnd,*fcells;

710:     DMPlexGetHeightStratum(dm,1,&fStart,&fEnd);
711:     PetscBTCreate(fEnd-fStart,&bfaces);
712:     DMPlexGetMaxSizes(dm,NULL,&p);
713:     PetscMalloc1(p,&fcells);
714:     DMGetLabel(dm,"glvis_periodic_cut",&perLabel);
715:     if (!perLabel && localized) { /* this periodic cut can be moved up to DMPlex setup */
716:       DMCreateLabel(dm,"glvis_periodic_cut");
717:       DMGetLabel(dm,"glvis_periodic_cut",&perLabel);
718:       DMLabelSetDefaultValue(perLabel,1);
719:       for (p=cStart;p<cEnd;p++) {
720:         DMPolytopeType cellType;
721:         PetscInt       dof;

723:         DMPlexGetCellType(dm,p,&cellType);
724:         PetscSectionGetDof(coordSection,p,&dof);
725:         if (dof) {
726:           PetscInt    uvpc, v,csize,cellClosureSize,*cellClosure = NULL,*vidxs = NULL;
727:           PetscScalar *vals = NULL;

729:           uvpc = DMPolytopeTypeGetNumVertices(cellType);
730:           if (dof%sdim) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_USER,"Incompatible number of cell dofs %D and space dimension %D",dof,sdim);
731:           DMPlexVecGetClosure(dm,coordSection,coordinates,p,&csize,&vals);
732:           DMPlexGetTransitiveClosure(dm,p,PETSC_TRUE,&cellClosureSize,&cellClosure);
733:           for (v=0;v<cellClosureSize;v++)
734:             if (cellClosure[2*v] >= vStart && cellClosure[2*v] < vEnd) {
735:               vidxs = cellClosure + 2*v;
736:               break;
737:             }
738:           if (!vidxs) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Missing vertices");
739:           for (v=0;v<uvpc;v++) {
740:             PetscInt s;

742:             for (s=0;s<sdim;s++) {
743:               if (PetscAbsScalar(vals[v*sdim+s]-vals[v*sdim+s+uvpc*sdim])>PETSC_MACHINE_EPSILON) {
744:                 DMLabelSetValue(perLabel,vidxs[2*v],2);
745:               }
746:             }
747:           }
748:           DMPlexRestoreTransitiveClosure(dm,p,PETSC_TRUE,&cellClosureSize,&cellClosure);
749:           DMPlexVecRestoreClosure(dm,coordSection,coordinates,p,&csize,&vals);
750:         }
751:       }
752:       if (dim > 1) {
753:         PetscInt eEnd,eStart;

755:         DMPlexGetDepthStratum(dm,1,&eStart,&eEnd);
756:         for (p=eStart;p<eEnd;p++) {
757:           const PetscInt *cone;
758:           PetscInt       coneSize,i;
759:           PetscBool      ispe = PETSC_TRUE;

761:           DMPlexGetCone(dm,p,&cone);
762:           DMPlexGetConeSize(dm,p,&coneSize);
763:           for (i=0;i<coneSize;i++) {
764:             PetscInt v;

766:             DMLabelGetValue(perLabel,cone[i],&v);
767:             ispe = (PetscBool)(ispe && (v==2));
768:           }
769:           if (ispe && coneSize) {
770:             PetscInt       ch, numChildren;
771:             const PetscInt *children;

773:             DMLabelSetValue(perLabel,p,2);
774:             DMPlexGetTreeChildren(dm,p,&numChildren,&children);
775:             for (ch = 0; ch < numChildren; ch++) {
776:               DMLabelSetValue(perLabel,children[ch],2);
777:             }
778:           }
779:         }
780:         if (dim > 2) {
781:           for (p=fStart;p<fEnd;p++) {
782:             const PetscInt *cone;
783:             PetscInt       coneSize,i;
784:             PetscBool      ispe = PETSC_TRUE;

786:             DMPlexGetCone(dm,p,&cone);
787:             DMPlexGetConeSize(dm,p,&coneSize);
788:             for (i=0;i<coneSize;i++) {
789:               PetscInt v;

791:               DMLabelGetValue(perLabel,cone[i],&v);
792:               ispe = (PetscBool)(ispe && (v==2));
793:             }
794:             if (ispe && coneSize) {
795:               PetscInt       ch, numChildren;
796:               const PetscInt *children;

798:               DMLabelSetValue(perLabel,p,2);
799:               DMPlexGetTreeChildren(dm,p,&numChildren,&children);
800:               for (ch = 0; ch < numChildren; ch++) {
801:                 DMLabelSetValue(perLabel,children[ch],2);
802:               }
803:             }
804:           }
805:         }
806:       }
807:     }
808:     for (p=fStart;p<fEnd;p++) {
809:       const PetscInt *support;
810:       PetscInt       supportSize;
811:       PetscBool      isbf = PETSC_FALSE;

813:       DMPlexGetSupportSize(dm,p,&supportSize);
814:       if (pown) {
815:         PetscBool has_owned = PETSC_FALSE, has_ghost = PETSC_FALSE;
816:         PetscInt  i;

818:         DMPlexGetSupport(dm,p,&support);
819:         for (i=0;i<supportSize;i++) {
820:           if (PetscLikely(PetscBTLookup(pown,support[i]-cStart))) has_owned = PETSC_TRUE;
821:           else has_ghost = PETSC_TRUE;
822:         }
823:         isbf = (PetscBool)((supportSize == 1 && has_owned) || (supportSize > 1 && has_owned && has_ghost));
824:       } else {
825:         isbf = (PetscBool)(supportSize == 1);
826:       }
827:       if (!isbf && perLabel) {
828:         const PetscInt *cone;
829:         PetscInt       coneSize,i;

831:         DMPlexGetCone(dm,p,&cone);
832:         DMPlexGetConeSize(dm,p,&coneSize);
833:         isbf = PETSC_TRUE;
834:         for (i=0;i<coneSize;i++) {
835:           PetscInt v,d;

837:           DMLabelGetValue(perLabel,cone[i],&v);
838:           DMLabelGetDefaultValue(perLabel,&d);
839:           isbf = (PetscBool)(isbf && v != d);
840:         }
841:       }
842:       if (isbf) {
843:         PetscBTSet(bfaces,p-fStart);
844:       }
845:     }
846:     /* count boundary faces */
847:     for (p=fStart,bf=0;p<fEnd;p++) {
848:       if (PetscUnlikely(PetscBTLookup(bfaces,p-fStart))) {
849:         const PetscInt *support;
850:         PetscInt       supportSize,c;

852:         DMPlexGetSupportSize(dm,p,&supportSize);
853:         DMPlexGetSupport(dm,p,&support);
854:         for (c=0;c<supportSize;c++) {
855:           const    PetscInt *cone;
856:           PetscInt cell,cl,coneSize;

858:           cell = support[c];
859:           if (pown && PetscUnlikely(!PetscBTLookup(pown,cell-cStart))) continue;
860:           DMPlexGetCone(dm,cell,&cone);
861:           DMPlexGetConeSize(dm,cell,&coneSize);
862:           for (cl=0;cl<coneSize;cl++) {
863:             if (cone[cl] == p) {
864:               bf += 1;
865:               break;
866:             }
867:           }
868:         }
869:       }
870:     }
871:     minl = 1;
872:     label = NULL;
873:     if (enable_bmark) {
874:       PetscInt lminl = PETSC_MAX_INT;

876:       DMGetLabel(dm,bmark,&label);
877:       if (label) {
878:         IS       vals;
879:         PetscInt ldef;

881:         DMLabelGetDefaultValue(label,&ldef);
882:         DMLabelGetValueIS(label,&vals);
883:         ISGetMinMax(vals,&lminl,NULL);
884:         ISDestroy(&vals);
885:         lminl = PetscMin(ldef,lminl);
886:       }
887:       MPIU_Allreduce(&lminl,&minl,1,MPIU_INT,MPI_MIN,PetscObjectComm((PetscObject)dm));
888:       if (minl == PETSC_MAX_INT) minl = 1;
889:     }
890:     PetscViewerASCIIPrintf(viewer,"%D\n",bf);
891:     for (p=fStart;p<fEnd;p++) {
892:       if (PetscUnlikely(PetscBTLookup(bfaces,p-fStart))) {
893:         const PetscInt *support;
894:         PetscInt       supportSize,c,nc = 0;

896:         DMPlexGetSupportSize(dm,p,&supportSize);
897:         DMPlexGetSupport(dm,p,&support);
898:         if (pown) {
899:           for (c=0;c<supportSize;c++) {
900:             if (PetscLikely(PetscBTLookup(pown,support[c]-cStart))) {
901:               fcells[nc++] = support[c];
902:             }
903:           }
904:         } else for (c=0;c<supportSize;c++) fcells[nc++] = support[c];
905:         for (c=0;c<nc;c++) {
906:           const DMPolytopeType *faceTypes;
907:           DMPolytopeType       cellType;
908:           const PetscInt       *faceSizes,*cone;
909:           PetscInt             vids[8],*faces,st,i,coneSize,cell,cl,nv,cid = -1,mid = -1;

911:           cell = fcells[c];
912:           DMPlexGetCone(dm,cell,&cone);
913:           DMPlexGetConeSize(dm,cell,&coneSize);
914:           for (cl=0;cl<coneSize;cl++)
915:             if (cone[cl] == p)
916:               break;
917:           if (cl == coneSize) continue;

919:           /* face material id and type */
920:           DMPlexGetPointMFEMCellID_Internal(dm,label,minl,p,&mid,&cid);
921:           PetscViewerASCIIPrintf(viewer,"%D %D",mid,cid);
922:           /* vertex ids */
923:           DMPlexGetCellType(dm,cell,&cellType);
924:           DMPlexGetPointMFEMVertexIDs_Internal(dm,cell,(localized && !hovec) ? coordSection : NULL,&nv,vids);
925:           DMPlexGetRawFaces_Internal(dm,cellType,vids,NULL,&faceTypes,&faceSizes,(const PetscInt**)&faces);
926:           st = 0;
927:           for (i=0;i<cl;i++) st += faceSizes[i];
928:           DMPlexInvertCell(faceTypes[cl],faces + st);
929:           for (i=0;i<faceSizes[cl];i++) {
930:             PetscViewerASCIIPrintf(viewer," %d",faces[st+i]);
931:           }
932:           PetscViewerASCIIPrintf(viewer,"\n");
933:           DMPlexRestoreRawFaces_Internal(dm,cellType,vids,NULL,&faceTypes,&faceSizes,(const PetscInt**)&faces);
934:           bf -= 1;
935:         }
936:       }
937:     }
938:     if (bf) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Remaining boundary faces %D",bf);
939:     PetscBTDestroy(&bfaces);
940:     PetscFree(fcells);
941:   }

943:   /* mark owned vertices */
944:   vown = NULL;
945:   if (pown) {
946:     PetscBTCreate(vEnd-vStart,&vown);
947:     for (p=cStart;p<cEnd;p++) {
948:       PetscInt i,closureSize,*closure = NULL;

950:       if (PetscUnlikely(!PetscBTLookup(pown,p-cStart))) continue;
951:       DMPlexGetTransitiveClosure(dm,p,PETSC_TRUE,&closureSize,&closure);
952:       for (i=0;i<closureSize;i++) {
953:         const PetscInt pp = closure[2*i];

955:         if (pp >= vStart && pp < vEnd) {
956:           PetscBTSet(vown,pp-vStart);
957:         }
958:       }
959:       DMPlexRestoreTransitiveClosure(dm,p,PETSC_TRUE,&closureSize,&closure);
960:     }
961:   }

963:   if (parentSection) {
964:     PetscInt vp,gvp;

966:     for (vp=0,p=vStart;p<vEnd;p++) {
967:       DMLabel  dlabel;
968:       PetscInt parent,depth;

970:       if (PetscUnlikely(vown && !PetscBTLookup(vown,p-vStart))) continue;
971:       DMPlexGetDepthLabel(dm,&dlabel);
972:       DMLabelGetValue(dlabel,p,&depth);
973:       DMPlexGetTreeParent(dm,p,&parent,NULL);
974:       if (parent != p) vp++;
975:     }
976:     MPIU_Allreduce(&vp,&gvp,1,MPIU_INT,MPI_SUM,PetscObjectComm((PetscObject)dm));
977:     if (gvp) {
978:       PetscInt  maxsupp;
979:       PetscBool *skip = NULL;

981:       PetscViewerASCIIPrintf(viewer,"\nvertex_parents\n");
982:       PetscViewerASCIIPrintf(viewer,"%D\n",vp);
983:       DMPlexGetMaxSizes(dm,NULL,&maxsupp);
984:       PetscMalloc1(maxsupp,&skip);
985:       for (p=vStart;p<vEnd;p++) {
986:         DMLabel  dlabel;
987:         PetscInt parent;

989:         if (PetscUnlikely(vown && !PetscBTLookup(vown,p-vStart))) continue;
990:         DMPlexGetDepthLabel(dm,&dlabel);
991:         DMPlexGetTreeParent(dm,p,&parent,NULL);
992:         if (parent != p) {
993:           PetscInt       vids[8] = { -1, -1, -1, -1, -1, -1, -1, -1 }; /* silent overzealous clang static analyzer */
994:           PetscInt       i,nv,ssize,n,numChildren,depth = -1;
995:           const PetscInt *children;

997:           DMPlexGetConeSize(dm,parent,&ssize);
998:           switch (ssize) {
999:             case 2: /* edge */
1000:               nv   = 0;
1001:               DMPlexGetPointMFEMVertexIDs_Internal(dm,parent,localized ? coordSection : NULL,&nv,vids);
1002:               PetscViewerASCIIPrintf(viewer,"%D",p-vStart);
1003:               for (i=0;i<nv;i++) {
1004:                 PetscViewerASCIIPrintf(viewer," %D",vids[i]);
1005:               }
1006:               PetscViewerASCIIPrintf(viewer,"\n");
1007:               vp--;
1008:               break;
1009:             case 4: /* face */
1010:               DMPlexGetTreeChildren(dm,parent,&numChildren,&children);
1011:               for (n=0;n<numChildren;n++) {
1012:                 DMLabelGetValue(dlabel,children[n],&depth);
1013:                 if (!depth) {
1014:                   const PetscInt *hvsupp,*hesupp,*cone;
1015:                   PetscInt       hvsuppSize,hesuppSize,coneSize;
1016:                   PetscInt       hv = children[n],he = -1,f;

1018:                   PetscArrayzero(skip,maxsupp);
1019:                   DMPlexGetSupportSize(dm,hv,&hvsuppSize);
1020:                   DMPlexGetSupport(dm,hv,&hvsupp);
1021:                   for (i=0;i<hvsuppSize;i++) {
1022:                     PetscInt ep;
1023:                     DMPlexGetTreeParent(dm,hvsupp[i],&ep,NULL);
1024:                     if (ep != hvsupp[i]) {
1025:                       he = hvsupp[i];
1026:                     } else {
1027:                       skip[i] = PETSC_TRUE;
1028:                     }
1029:                   }
1030:                   if (he == -1) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_SUP,"Vertex %D support size %D: hanging edge not found",hv,hvsuppSize);
1031:                   DMPlexGetCone(dm,he,&cone);
1032:                   vids[0] = (cone[0] == hv) ? cone[1] : cone[0];
1033:                   DMPlexGetSupportSize(dm,he,&hesuppSize);
1034:                   DMPlexGetSupport(dm,he,&hesupp);
1035:                   for (f=0;f<hesuppSize;f++) {
1036:                     PetscInt j;

1038:                     DMPlexGetCone(dm,hesupp[f],&cone);
1039:                     DMPlexGetConeSize(dm,hesupp[f],&coneSize);
1040:                     for (j=0;j<coneSize;j++) {
1041:                       PetscInt k;
1042:                       for (k=0;k<hvsuppSize;k++) {
1043:                         if (hvsupp[k] == cone[j]) {
1044:                           skip[k] = PETSC_TRUE;
1045:                           break;
1046:                         }
1047:                       }
1048:                     }
1049:                   }
1050:                   for (i=0;i<hvsuppSize;i++) {
1051:                     if (!skip[i]) {
1052:                       DMPlexGetCone(dm,hvsupp[i],&cone);
1053:                       vids[1] = (cone[0] == hv) ? cone[1] : cone[0];
1054:                     }
1055:                   }
1056:                   PetscViewerASCIIPrintf(viewer,"%D",hv-vStart);
1057:                   for (i=0;i<2;i++) {
1058:                     PetscViewerASCIIPrintf(viewer," %D",vids[i]-vStart);
1059:                   }
1060:                   PetscViewerASCIIPrintf(viewer,"\n");
1061:                   vp--;
1062:                 }
1063:               }
1064:               break;
1065:             default:
1066:               SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"Don't know how to deal with support size %D",ssize);
1067:           }
1068:         }
1069:       }
1070:       PetscFree(skip);
1071:     }
1072:     if (vp) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Unexpected %D hanging vertices",vp);
1073:   }
1074:   PetscBTDestroy(&pown);
1075:   PetscBTDestroy(&vown);

1077:   /* vertices */
1078:   if (hovec) { /* higher-order meshes */
1079:     const char *fec;
1080:     PetscInt   i,n,s;

1082:     PetscViewerASCIIPrintf(viewer,"\nvertices\n");
1083:     PetscViewerASCIIPrintf(viewer,"%D\n",vEnd-vStart);
1084:     PetscViewerASCIIPrintf(viewer,"nodes\n");
1085:     PetscObjectGetName((PetscObject)hovec,&fec);
1086:     PetscViewerASCIIPrintf(viewer,"FiniteElementSpace\n");
1087:     PetscViewerASCIIPrintf(viewer,"%s\n",fec);
1088:     PetscViewerASCIIPrintf(viewer,"VDim: %D\n",sdim);
1089:     PetscViewerASCIIPrintf(viewer,"Ordering: 1\n\n"); /*Ordering::byVDIM*/
1090:     VecGetArrayRead(hovec,&array);
1091:     VecGetLocalSize(hovec,&n);
1092:     if (n%sdim) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_USER,"Size of local coordinate vector %D incompatible with space dimension %D",n,sdim);
1093:     for (i=0;i<n/sdim;i++) {
1094:       for (s=0;s<sdim;s++) {
1095:         PetscViewerASCIIPrintf(viewer,fmt,PetscRealPart(array[i*sdim+s]));
1096:       }
1097:       PetscViewerASCIIPrintf(viewer,"\n");
1098:     }
1099:     VecRestoreArrayRead(hovec,&array);
1100:   } else {
1101:     VecGetLocalSize(coordinates,&nvert);
1102:     PetscViewerASCIIPrintf(viewer,"\nvertices\n");
1103:     PetscViewerASCIIPrintf(viewer,"%D\n",nvert/sdim);
1104:     PetscViewerASCIIPrintf(viewer,"%D\n",sdim);
1105:     VecGetArrayRead(coordinates,&array);
1106:     for (p=0;p<nvert/sdim;p++) {
1107:       PetscInt s;
1108:       for (s=0;s<sdim;s++) {
1109:         PetscReal v = PetscRealPart(array[p*sdim+s]);

1111:         PetscViewerASCIIPrintf(viewer,fmt,PetscIsInfOrNanReal(v) ? 0.0 : v);
1112:       }
1113:       PetscViewerASCIIPrintf(viewer,"\n");
1114:     }
1115:     VecRestoreArrayRead(coordinates,&array);
1116:   }
1117:   VecDestroy(&hovec);
1118:   return(0);
1119: }

1121: PetscErrorCode DMPlexView_GLVis(DM dm, PetscViewer viewer)
1122: {
1125:   DMView_GLVis(dm,viewer,DMPlexView_GLVis_ASCII);
1126:   return(0);
1127: }