MEdge_ptr MVs_CommonEdge(MVertex_ptr v1, MVertex_ptr v2) { List_ptr vedges; MEdge_ptr edge=0; MVertex_ptr ev; int i, found, nve; vedges = MV_Edges(v1); if (!vedges) return 0; nve = List_Num_Entries(vedges); for (i = 0, found = 0; i < nve; i++) { edge = List_Entry(vedges,i); ev = ME_Vertex(edge,0); if (ev == v2) { found = 1; break; } else { ev = ME_Vertex(edge,1); if (ev == v2) { found = 1; break; } } } List_Delete(vedges); return (found ? edge : 0); }
/* test if a vertex is on partition boundary, for surface mesh a vertex is on boundary if one of its incident edges has less than 2 neighboring faces */ static int vertex_on_boundary2D(MVertex_ptr mv) { int i, nve, ok = 0; MEdge_ptr me; List_ptr vedges = MV_Edges(mv); nve = List_Num_Entries(vedges); for(i = 0; (i < nve) &!ok; i++) { List_ptr efaces; me = List_Entry(vedges,i); efaces = ME_Faces(me); if(List_Num_Entries(efaces) <= 1) ok = 1; List_Delete(efaces); } List_Delete(vedges); return ok; }
MVertex_ptr ME_Collapse(MEdge_ptr e, MVertex_ptr vkeep_in, int topoflag, List_ptr *deleted_entities) { MVertex_ptr vdel, vkeep, ev00, ev01, ev10, ev11, vert; MEdge_ptr edge, edge2, oldedges[3], nuedges[2]; MFace_ptr face, face2, rface1, rface2; MRegion_ptr reg, reg2; List_ptr vedges, efaces, eregs, fedges, rfaces, fverts1, fverts2, vfaces; int idx1, idx2, idx3, dir, status, nfe, nrf, allfound, degenerate; int i, j, nfe2, nfv1, nfv2; status = 1; if (vkeep_in == NULL) { vdel = ME_Vertex(e,0); vkeep = ME_Vertex(e,1); } else { vkeep = vkeep_in; vdel = ME_OppVertex(e,vkeep); } int dimkeep, dimdel; dimkeep = MV_GEntDim(vkeep); /* Model entity dim of vertex to keep */ dimdel = MV_GEntDim(vdel); /* Model entity dim of vertex to delete */ if (topoflag == 1) { if (dimkeep == dimdel) { if (MV_GEntID(vkeep) != MV_GEntID(vdel)) status = 0; /* cannot allow since it will cause a dimensional reduction in mesh */ } else if (dimdel < dimkeep) { if (vkeep_in == NULL) { /* If no preference was indicated on which vertex to retain, we can collapse in the other direction */ MVertex_ptr vtemp = vdel; vdel = vkeep; vkeep = vtemp; } else status = 0; /* can't reverse order or vertices and boundary of mesh will get messed up if we go through as is */ } } else if (vkeep_in == NULL) { /* If no preference was indicated for the kept vertex and topological conformity with the underlying geometric model was not requested, we prefer to keep an external boundary vertex over an interior vertex or interior boundary vertex. This is because it is more likely that the external boundary vertex would have a boundary condition applied to it. If a preference was indicated, we just have to respect that. */ int vdel_external = 0; /* Check if any edges connected to vdel have only one connected face */ vedges = MV_Edges(vdel); idx1 = 0; while ((edge = (MEdge_ptr) List_Next_Entry(vedges,&idx1))) { List_ptr efaces = ME_Faces(edge); int nef = List_Num_Entries(efaces); List_Delete(efaces); if (nef < 2) { vdel_external = 1; break; } } List_Delete(vedges); /* check if any face connected to vdel has only one region connected to it */ if (!vdel_external) { vfaces = MV_Faces(vdel); idx1 = 0; while ((face = (MFace_ptr) List_Next_Entry(vfaces,&idx1))) { List_ptr fregs = MF_Regions(face); int nfr = fregs ? List_Num_Entries(fregs) : 0; if (fregs) List_Delete(fregs); if (nfr == 1) { vdel_external = 0; break; } } List_Delete(vfaces); } if (vdel_external) { /* swap the vertices in the hope that vkeep is not also on an external boundary. Since we have to go through with the collapse anyway, there is no use of doing a detailed check for whether vkeep is also on an external boundary */ MVertex_ptr vtemp = vdel; vdel = vkeep; vkeep = vtemp; } } if (status == 0) return NULL; /* Cannot collapse due to constraints of topological conformity with geometric model */ *deleted_entities = List_New(10); /* Need to collect this in advance because the info gets messed up later */ efaces = ME_Faces(e); eregs = ME_Regions(e); /* Replace vdel with vkeep in all edges connected to vdel */ vedges = MV_Edges(vdel); idx1 = 0; while ((edge = List_Next_Entry(vedges,&idx1))) { ME_Replace_Vertex(edge,vdel,vkeep); } List_Delete(vedges); /* Remove edge 'e' from all faces connected to e */ /* This part of the code is using some reliance on the internal implementation of MF_Edges. While unlikely, it _might_ break if the innards of MF_Edges are changed */ idx1 = 0; while ((face = List_Next_Entry(efaces,&idx1))) { fedges = MF_Edges(face,1,0); nfe = List_Num_Entries(fedges); /* Find the edge before and after e in the face */ oldedges[0] = oldedges[2] = NULL; for (i = 0; i < nfe; i++) { edge = List_Entry(fedges,i); if (edge == e) continue; dir = MF_EdgeDir_i(face,i); if (ME_Vertex(edge,dir) == vkeep) oldedges[0] = edge; else if (ME_Vertex(edge,!dir) == vkeep) oldedges[2] = edge; } oldedges[1] = e; nuedges[0] = oldedges[0]; nuedges[1] = oldedges[2]; /* Replace oldedges[0], oldedges[1] (=e), oldedges[2] with oldedges[0], oldedges[2] since e is degenerate */ MF_Replace_Edges(face,3,oldedges,2,nuedges); List_Delete(fedges); } /* Delete topologically degenerate regions */ /* Defined as two faces of the regions having the same vertices */ if (eregs) { idx1 = 0; while ((reg = List_Next_Entry(eregs,&idx1))) { rfaces = MR_Faces(reg); nrf = List_Num_Entries(rfaces); if (nrf == 4) { List_ptr rverts = MR_Vertices(reg); if (List_Num_Entries(rverts) == 4) { MR_Delete(reg,0); /* This is a tet - it will become degenerate */ } List_Delete(rverts); } else { degenerate = 0; for (i = 0; i < nrf; i++) { rface1 = List_Entry(rfaces,i); fverts1 = MF_Vertices(rface1,1,0); nfv1 = List_Num_Entries(fverts1); for (j = i+1; j < nrf; j++) { rface2 = List_Entry(rfaces,j); fverts2 = MF_Vertices(rface2,1,0); nfv2 = List_Num_Entries(fverts2); if (nfv1 != nfv2) { List_Delete(fverts2); continue; /* can't be exactly coincident */ } allfound = 1; idx2 = 0; while ((vert = List_Next_Entry(fverts2,&idx2))) { if (!List_Contains(fverts1,vert)) { allfound = 0; break; } } List_Delete(fverts2); if (allfound) { degenerate = 1; break; } } /* for (j = i+1 ... */ List_Delete(fverts1); if (degenerate) break; } /* for (i = 0; i < nrf;.... */ if (degenerate) { List_Add(*deleted_entities,reg); MR_Delete(reg,0); } } /* if (nrf == 4) .. else ... */ List_Delete(rfaces); } /* while ((reg = ...)) */ } /* Delete topologically degenerate faces */ if (efaces) { idx1 = 0; while ((face = List_Next_Entry(efaces,&idx1))) { fedges = MF_Edges(face,1,0); if (List_Num_Entries(fedges) == 2) { /* Disconnect the regions from the face before deleting */ List_ptr fregs = MF_Regions(face); if (fregs) { idx2 = 0; while ((reg = List_Next_Entry(fregs,&idx2))) MR_Rem_Face(reg,face); List_Delete(fregs); } List_Add(*deleted_entities,face); MF_Delete(face,0); } List_Delete(fedges); } List_Delete(efaces); } /* Now merge edges which have the same end vertices */ /* Prefer to preserve edges on external boundaries over internal edges */ vedges = MV_Edges(vkeep); idx1 = 0; while ((edge = List_Next_Entry(vedges,&idx1))) { if (edge == e) continue; ev00 = ME_Vertex(edge,0); ev01 = ME_Vertex(edge,1); idx2 = 0; while ((edge2 = List_Next_Entry(vedges,&idx2))) { if (edge == e || edge == edge2) continue; ev10 = ME_Vertex(edge2,0); ev11 = ME_Vertex(edge2,1); if ((ev00 == ev10 && ev01 == ev11) || (ev00 == ev11 && ev10 == ev01)) { int external_edge, external_edge2; int edim = 4; external_edge = 0; edim = ME_GEntDim(edge); if (edim == 1 || edim == 2 || edim == 4) { /* check if external edge */ efaces = ME_Faces(edge); int nef = List_Num_Entries(efaces); if (nef == 1) { external_edge = 1; } else { idx3 = 0; while ((face = List_Next_Entry(efaces,&idx2))) { List_ptr fregs = MF_Regions(face); int nfr = fregs ? List_Num_Entries(fregs) : 0; if (fregs) List_Delete(fregs); if (nfr == 1) { external_edge = 1; break; } } } List_Delete(efaces); } external_edge2 = 0; edim = ME_GEntDim(edge2); if (edim == 1 || edim == 2 || edim == 4) { /* check if external edge */ efaces = ME_Faces(edge2); int nef = List_Num_Entries(efaces); if (nef == 1) { external_edge2 = 1; } else { idx3 = 0; while ((face = List_Next_Entry(efaces,&idx2))) { List_ptr fregs = MF_Regions(face); int nfr = fregs ? List_Num_Entries(fregs) : 0; if (fregs) List_Delete(fregs); if (nfr == 1) { external_edge2 = 1; break; } } } List_Delete(efaces); } /* If edge2 is not external or both edges are external, go ahead and merge (edge2 will be deleted subject to topological checks if topoflag is 1) */ if (!external_edge2 || (external_edge && external_edge2)) { MEs_Merge(edge,edge2,topoflag); List_Rem(vedges,edge2); List_Add(*deleted_entities,edge2); break; } } } } List_Delete(vedges); /* Merge faces with the same set of edges */ vfaces = MV_Faces(vkeep); if (vfaces) { idx1 = 0; while ((face = List_Next_Entry(vfaces,&idx1))) { fedges = MF_Edges(face,1,0); nfe = List_Num_Entries(fedges); idx2 = 0; while ((face2 = List_Next_Entry(vfaces,&idx2))) { List_ptr fedges2; if (face2 == face) continue; fedges2 = MF_Edges(face2,1,0); nfe2 = List_Num_Entries(fedges2); if (nfe != nfe2) { List_Delete(fedges2); continue; } allfound = 1; for (i = 0; i < nfe2; i++) { edge = List_Entry(fedges2,i); if (!List_Contains(fedges,edge)) { allfound = 0; break; } } List_Delete(fedges2); if (allfound) { List_ptr fregs = MF_Regions(face); int external_face = fregs ? (List_Num_Entries(fregs) == 1) : 0; if (fregs) List_Delete(fregs); List_ptr fregs2 = MF_Regions(face2); int external_face2 = fregs2 ? (List_Num_Entries(fregs2) == 1) : 0; if (fregs2) List_Delete(fregs2); /* Proceed with merge (which will delete face2) only if face2 is not an external face or both face and face2 are external */ if (!external_face2 || (external_face && external_face2)) { MFs_Merge(face,face2,topoflag); List_Rem(vfaces,face2); List_Add(*deleted_entities,face2); break; } } } /* while (face2 = List_Next_Entry(vfaces,... */ List_Delete(fedges); } /* while (face = List_Next_Entry(vfaces,... */ List_Delete(vfaces); } /* Now actually delete the collapse edge and the to-be-merged vertex */ ME_Delete(e,0); List_Add(*deleted_entities,e); MV_Delete(vdel,0); List_Add(*deleted_entities,vdel); if (eregs) { idx1 = 0; while ((reg = List_Next_Entry(eregs,&idx1))) MR_Update_ElementType(reg); List_Delete(eregs); } return vkeep; }
void MESH_Renumber(Mesh_ptr mesh, int renum_type, MType mtype) { MVertex_ptr mv, v0=NULL; MEdge_ptr me, e0=NULL; MFace_ptr mf, f0=NULL; MRegion_ptr mr, r0=NULL; int idx, idx2, idx3; int i, j; int done; MAttrib_ptr vidatt; List_ptr vlist; double xyz[3]; double rval; int bandwidth, maxbandwidth1, maxbandwidth2; double avebandwidth1, avebandwidth2; void *pval; if (renum_type == 0) { if (mtype == MVERTEX || mtype == MALLTYPE) { int nv = 0; idx = 0; while ((mv = MESH_Next_Vertex(mesh,&idx))) MV_Set_ID(mv,++nv); } if (mtype == MEDGE || mtype == MALLTYPE) { int ne = 0; idx = 0; while ((me = MESH_Next_Edge(mesh,&idx))) ME_Set_ID(me,++ne); } if (mtype == MFACE || mtype == MALLTYPE) { int nf = 0; idx = 0; while ((mf = MESH_Next_Face(mesh,&idx))) MF_Set_ID(mf,++nf); } if (mtype == MREGION || mtype == MALLTYPE) { int nr = 0; idx = 0; while ((mr = MESH_Next_Region(mesh,&idx))) MR_Set_ID(mr,++nr); } } else if (renum_type == 1) { double minx, miny, minz; int minid, maxid; int *nadj, *newmap, *adj, *offset, nconn; int nalloc, depth, maxwidth; #ifdef MSTK_USE_MARKERS int mkid = MSTK_GetMarker(); #else MAttrib_ptr mkatt = MAttrib_New(mesh, "mkatt", INT, MALLTYPE); #endif if (mtype == MVERTEX || mtype == MALLTYPE) { int nv = MESH_Num_Vertices(mesh); /* Compute a graph of vertex connections across elements (faces for surface meshes, regions for solid meshes */ /* Start with the vertex in the lower leftmost corner */ minx = miny = minz = 1.0e+12; v0 = NULL; idx = 0; while ((mv = MESH_Next_Vertex(mesh,&idx))) { MV_Coords(mv,xyz); if (xyz[0] <= minx && xyz[1] <= miny && xyz[2] <= minz) { minx = xyz[0]; miny = xyz[1]; minz = xyz[2]; v0 = mv; } } nadj = (int *) malloc(nv*sizeof(int)); nalloc = nv*5; adj = (int *) malloc(nalloc*sizeof(int)); if (!MESH_Num_Regions(mesh)) { int nentries = 0; i = 0; idx = 0; while ((mv = MESH_Next_Vertex(mesh,&idx))) { List_ptr vfaces, adjvlist; MFace_ptr vf; MVertex_ptr adjv; adjvlist = List_New(0); vfaces = MV_Faces(mv); idx2 = 0; while ((vf = List_Next_Entry(vfaces,&idx2))) { List_ptr fverts = MF_Vertices(vf,1,0); idx3 = 0; while ((adjv = List_Next_Entry(fverts,&idx3))) { if (adjv != mv) { int vmarked; #ifdef MSTK_USE_MARKERS vmarked = MEnt_IsMarked(adjv,mkid); #else MEnt_Get_AttVal(adjv, mkatt, &vmarked, &rval, &pval); #endif if (!vmarked) { List_Add(adjvlist,adjv); #ifdef MSTK_USE_MARKERS MEnt_Mark(adjv,mkid); #else MEnt_Set_AttVal(adjv, mkatt, 1, 0.0, NULL); #endif } } } List_Delete(fverts); } List_Delete(vfaces); #ifdef MSTK_USE_MARKERS List_Unmark(adjvlist,mkid); #endif nadj[i] = List_Num_Entries(adjvlist); if (nentries+nadj[i] > nalloc) { nalloc *= 2; adj = (int *) realloc(adj,nalloc*sizeof(int)); } idx2 = 0; while ((adjv = List_Next_Entry(adjvlist,&idx2))) adj[nentries++] = MV_ID(adjv)-1; List_Delete(adjvlist); i++; } } else { int nentries = 0; i = 0; idx = 0; while ((mv = MESH_Next_Vertex(mesh,&idx))) { List_ptr vregions, adjvlist; MRegion_ptr vr; MVertex_ptr adjv; adjvlist = List_New(0); vregions = MV_Regions(mv); idx2 = 0; while ((vr = List_Next_Entry(vregions,&idx2))) { List_ptr rverts = MR_Vertices(vr); idx3 = 0; while ((adjv = List_Next_Entry(rverts,&idx3))) { if (adjv != mv) { int vmarked; #ifdef MSTK_USE_MARKERS vmarked = MEnt_IsMarked(adjv,mkid); #else MEnt_Get_AttVal(adjv, mkatt, &vmarked, &rval, &pval); #endif if (!vmarked) { List_Add(adjvlist,adjv); #ifdef MSTK_USE_MARKERS MEnt_Mark(adjv,mkid); #else MEnt_Set_AttVal(adjv, mkatt, 1, 0.0, NULL); #endif } } } List_Delete(rverts); } List_Delete(vregions); #ifdef MSTK_USE_MARKERS List_Unmark(adjvlist,mkid); #endif nadj[i] = List_Num_Entries(adjvlist); if (nentries+nadj[i] > nalloc) { nalloc *= 2; adj = (int *) realloc(adj,nalloc*sizeof(int)); } idx2 = 0; while ((adjv = List_Next_Entry(adjvlist,&idx2))) adj[nentries++] = MV_ID(adjv)-1; List_Delete(adjvlist); i++; } } /* Compute offsets into adj array */ offset = (int *) malloc(nv*sizeof(int)); offset[0] = 0; for (i = 1; i < nv; i++) offset[i] = offset[i-1] + nadj[i-1]; /* Compute maximum bandwidth before renumbering */ maxbandwidth1 = 0; avebandwidth1 = 0; for (i = 0; i < nv; i++) { int off = offset[i]; int curid = i; for (j = 0; j < nadj[i]; j++) { int adjid = adj[off+j]; int diff = abs(adjid-curid); maxbandwidth1 = (diff > maxbandwidth1) ? diff : maxbandwidth1; avebandwidth1 += diff; nconn++; } } nconn = offset[nv-1]+nadj[nv-1]; avebandwidth1 /= nconn; fprintf(stderr, "Ave vertex ID difference on elements before renumbering: %-lf\n", avebandwidth1); fprintf(stderr, "Max vertex ID difference on elements before renumbering: %-d\n", maxbandwidth1); fprintf(stderr,"\n"); newmap = (int *) malloc(nv*sizeof(int)); Graph_Renumber_GPS(nv, MV_ID(v0)-1, nadj, adj, newmap, &depth, &maxwidth); /* Compute bandwidth after renumbering */ maxbandwidth2 = 0; avebandwidth2 = 0; for (i = 0; i < nv; i++) { int off = offset[i]; int curid = newmap[i]; for (j = 0; j < nadj[i]; j++) { int adjid = newmap[adj[off+j]]; int diff = abs(adjid-curid); maxbandwidth2 = (diff > maxbandwidth2) ? diff : maxbandwidth2; avebandwidth2 += diff; nconn++; } } nconn = offset[nv-1]+nadj[nv-1]; avebandwidth2 /= nconn; if (maxbandwidth2 < maxbandwidth1 && avebandwidth2 < avebandwidth1) { /* Renumber */ idx = 0; i = 0; while ((mv = MESH_Next_Vertex(mesh,&idx))) { MV_Set_ID(mv,newmap[i]+1); i++; } fprintf(stderr, "Ave vertex ID difference on elements after renumbering: %-lf\n", avebandwidth2); fprintf(stderr, "Max vertex ID difference on elements after renumbering: %-d\n", maxbandwidth2); } else { nv = 0; idx = 0; while ((mv = MESH_Next_Vertex(mesh,&idx))) MV_Set_ID(mv,++nv); fprintf(stderr,"Bandwidth did not improve. Keeping old numbering with gaps eliminated\n"); } fprintf(stderr,"\n\n\n"); free(nadj); free(adj); free(offset); free(newmap); } /* Reorder edges according to a breadth first algorithm applied to edges (differs from RCM in that it does not add adjacent nodes in ascending order of their valence) */ if (mtype == MEDGE || mtype == MALLTYPE) { int ne = MESH_Num_Edges(mesh); MEdge_ptr ve; List_ptr elist; /************************* renumbering code ****************************/ ne = MESH_Num_Edges(mesh); if (mtype == MALLTYPE) { /* RCM algorithm already applied on the vertices. Use an edge connected to the starting vertex as the first edge */ List_ptr vedges = MV_Edges(v0); e0 = List_Entry(vedges,0); List_Delete(vedges); } else { /* Find the edge whose mid point is a minimum point */ minx = miny = minz = 1.0e+12; e0 = NULL; idx = 0; while ((me = MESH_Next_Edge(mesh,&idx))) { double exyz[2][3]; MV_Coords(ME_Vertex(me,0),exyz[0]); MV_Coords(ME_Vertex(me,1),exyz[1]); xyz[0] = (exyz[0][0]+exyz[1][0])/2.0; xyz[1] = (exyz[0][1]+exyz[1][1])/2.0; xyz[2] = (exyz[0][2]+exyz[1][2])/2.0; if (xyz[0] < minx && xyz[1] < miny && xyz[2] < minz) { minx = xyz[0]; miny = xyz[1]; minz = xyz[2]; e0 = me; } } } nadj = (int *) malloc(ne*sizeof(int)); nalloc = ne*5; adj = (int *) malloc(nalloc*sizeof(int)); if (!MESH_Num_Regions(mesh)) { int nentries = 0; i = 0; idx = 0; while ((me = MESH_Next_Edge(mesh,&idx))) { List_ptr efaces, adjelist; MFace_ptr ef; MEdge_ptr adje; adjelist = List_New(0); efaces = ME_Faces(me); idx2 = 0; while ((ef = List_Next_Entry(efaces,&idx2))) { List_ptr fedges = MF_Edges(ef,1,0); idx3 = 0; while ((adje = List_Next_Entry(fedges,&idx3))) { if (adje != me) { int emarked; #ifdef MSTK_USE_MARKERS emarked = MEnt_IsMarked(adje,mkid); #else MEnt_Get_AttVal(adje, mkatt, &emarked, &rval, &pval); #endif if (!emarked) { List_Add(adjelist,adje); #ifdef MSTK_USE_MARKERS MEnt_Mark(adje,mkid); #else MEnt_Set_AttVal(adje, mkatt, 1, 0.0, NULL); #endif } } } List_Delete(fedges); } List_Delete(efaces); #ifdef MSTK_USE_MARKERS List_Unmark(adjelist,mkid); #endif nadj[i] = List_Num_Entries(adjelist); if (nentries+nadj[i] > nalloc) { nalloc *= 2; adj = (int *) realloc(adj,nalloc*sizeof(int)); } idx2 = 0; while ((adje = List_Next_Entry(adjelist,&idx2))) adj[nentries++] = ME_ID(adje)-1; List_Delete(adjelist); i++; } } else { int nentries = 0; i = 0; idx = 0; while ((me = MESH_Next_Edge(mesh,&idx))) { List_ptr eregions, adjelist; MRegion_ptr er; MEdge_ptr adje; adjelist = List_New(0); eregions = ME_Regions(me); idx2 = 0; while ((er = List_Next_Entry(eregions,&idx2))) { List_ptr redges = MR_Edges(er); idx3 = 0; while ((adje = List_Next_Entry(redges,&idx3))) { if (adje != me) { int emarked; #ifdef MSTK_USE_MARKERS emarked = MEnt_IsMarked(adje,mkid); #else MEnt_Get_AttVal(adje, mkatt, &emarked, &rval, &pval); #endif if (!emarked) { List_Add(adjelist,adje); #ifdef MSTK_USE_MARKERS MEnt_Mark(adje,mkid); #else MEnt_Set_AttVal(adje, mkatt, 1, 0.0, NULL); #endif } } } List_Delete(redges); } List_Delete(eregions); #ifdef MSTK_USE_MARKERS List_Unmark(adjelist,mkid); #endif nadj[i] = List_Num_Entries(adjelist); if (nentries+nadj[i] > nalloc) { nalloc *= 2; adj = (int *) realloc(adj,nalloc*sizeof(int)); } idx2 = 0; while ((adje = List_Next_Entry(adjelist,&idx2))) adj[nentries++] = ME_ID(adje)-1; List_Delete(adjelist); i++; } } /* Compute offsets into adj array */ offset = (int *) malloc(ne*sizeof(int)); offset[0] = 0; for (i = 1; i < ne; i++) offset[i] = offset[i-1] + nadj[i-1]; /* Compute maximum bandwidth before renumbering */ maxbandwidth1 = 0; avebandwidth1 = 0; for (i = 0; i < ne; i++) { int off = offset[i]; int curid = i; for (j = 0; j < nadj[i]; j++) { int adjid = adj[off+j]; int diff = abs(adjid-curid); maxbandwidth1 = (diff > maxbandwidth1) ? diff : maxbandwidth1; avebandwidth1 += diff; nconn++; } } nconn = offset[ne-1]+nadj[ne-1]; avebandwidth1 /= nconn; fprintf(stderr, "Ave edge ID difference on elements before renumbering: %-lf\n", avebandwidth1); fprintf(stderr, "Max edge ID difference on elements before renumbering: %-d\n", maxbandwidth1); fprintf(stderr,"\n"); /* Call Graph Renumbering algorithm */ newmap = (int *) malloc(ne*sizeof(int)); Graph_Renumber_GPS(ne, ME_ID(e0)-1, nadj, adj, newmap, &depth, &maxwidth); /* Compute bandwidth after renumbering */ maxbandwidth2 = 0; avebandwidth2 = 0; for (i = 0; i < ne; i++) { int off = offset[i]; int curid = newmap[i]; for (j = 0; j < nadj[i]; j++) { int adjid = newmap[adj[off+j]]; int diff = abs(adjid-curid); maxbandwidth2 = (diff > maxbandwidth2) ? diff : maxbandwidth2; avebandwidth2 += diff; nconn++; } } nconn = offset[ne-1]+nadj[ne-1]; avebandwidth2 /= nconn; if (maxbandwidth2 < maxbandwidth1 && avebandwidth2 < avebandwidth1) { /* Renumber */ idx = 0; i = 0; while ((me = MESH_Next_Edge(mesh,&idx))) { ME_Set_ID(me,newmap[i]+1); i++; } fprintf(stderr, "Ave edge ID difference on elements after renumbering: %-lf\n", avebandwidth2); fprintf(stderr, "Max edge ID difference on elements after renumbering: %-d\n", maxbandwidth2); } else { ne = 0; idx = 0; while ((me = MESH_Next_Edge(mesh,&idx))) ME_Set_ID(me,++ne); fprintf(stderr,"Bandwidth did not improve. Keeping old numbering with gaps eliminated\n"); } fprintf(stderr,"\n\n\n"); free(nadj); free(adj); free(offset); free(newmap); } /* Reorder faces according to a breadth first algorithm applied to edges (differs from RCM in that it does not add adjacent graph nodes in ascending order of their valence) */ if (mtype == MFACE || mtype == MALLTYPE) { int nf = MESH_Num_Faces(mesh); if (mtype == MALLTYPE) { /* RCM algorithm already applied on the vertices. Use an edge connected to the starting vertex as the first edge */ List_ptr vfaces = MV_Faces(v0); f0 = List_Entry(vfaces,0); List_Delete(vfaces); } else { /* Find the face whose mid point is a minimum point */ minx = miny = minz = 1.0e+12; f0 = NULL; idx = 0; while ((mf = MESH_Next_Face(mesh,&idx))) { double fxyz[MAXPV2][3]; int nfv; MF_Coords(mf,&nfv,fxyz); xyz[0] = fxyz[0][0]; xyz[1] = fxyz[0][1]; xyz[2] = fxyz[0][2]; for (i = 1; i < nfv; i++) { xyz[0] += fxyz[i][0]; xyz[1] += fxyz[i][1]; xyz[2] += fxyz[i][2]; } xyz[0] /= nfv; xyz[1] /= nfv; xyz[2] /= nfv; if (xyz[0] < minx && xyz[1] < miny && xyz[2] < minz) { minx = xyz[0]; miny = xyz[1]; minz = xyz[2]; f0 = mf; } } } nadj = (int *) malloc(nf*sizeof(int)); nalloc = nf*5; adj = (int *) malloc(nalloc*sizeof(int)); if (!MESH_Num_Regions(mesh)) { int nentries = 0; i = 0; idx = 0; while ((mf = MESH_Next_Face(mesh,&idx))) { List_ptr vfaces, fverts, adjflist; MFace_ptr vf, adjf; MVertex_ptr fv; adjflist = List_New(0); fverts = MF_Vertices(mf,1,0); idx2 = 0; while ((fv = List_Next_Entry(fverts,&idx2))) { List_ptr vfaces = MV_Faces(fv); idx3 = 0; while ((adjf = List_Next_Entry(vfaces,&idx3))) { if (adjf != mf) { int fmarked; #ifdef MSTK_USE_MARKERS fmarked = MEnt_IsMarked(adjf,mkid); #else MEnt_Get_AttVal(adjf, mkatt, &fmarked, &rval, &pval); #endif if (fmarked) { List_Add(adjflist,adjf); #ifdef MSTK_USE_MARKERS MEnt_Mark(adjf,mkid); #else MEnt_Set_AttVal(adjf, mkatt, 1, 0.0, NULL); #endif } } } List_Delete(vfaces); } List_Delete(fverts); #ifdef MSTK_USE_MARKERS List_Unmark(adjflist,mkid); #endif nadj[i] = List_Num_Entries(adjflist); if (nentries+nadj[i] > nalloc) { nalloc *= 2; adj = (int *) realloc(adj,nalloc*sizeof(int)); } idx2 = 0; while ((adjf = List_Next_Entry(adjflist,&idx2))) adj[nentries++] = MF_ID(adjf)-1; List_Delete(adjflist); i++; } } else { int nentries = 0; i = 0; idx = 0; while ((mf = MESH_Next_Face(mesh,&idx))) { List_ptr fregions, adjflist; MRegion_ptr fr; MFace_ptr adjf; adjflist = List_New(0); fregions = MF_Regions(mf); idx2 = 0; while ((fr = List_Next_Entry(fregions,&idx2))) { List_ptr rfaces = MR_Faces(fr); idx3 = 0; while ((adjf = List_Next_Entry(rfaces,&idx3))) { if (adjf != mf) { int fmarked; #ifdef MSTK_USE_MARKERS fmarked = MEnt_IsMarked(adjf,mkid); #else MEnt_Get_AttVal(adjf, mkatt, &fmarked, &rval, &pval); #endif if (fmarked) { List_Add(adjflist,adjf); #ifdef MSTK_USE_MARKERS MEnt_Mark(adjf,mkid); #else MEnt_Set_AttVal(adjf, mkatt, 1, 0.0, NULL); #endif } } } List_Delete(rfaces); } List_Delete(fregions); #ifdef MSTK_USE_MARKERS List_Unmark(adjflist,mkid); #endif nadj[i] = List_Num_Entries(adjflist); if (nentries+nadj[i] > nalloc) { nalloc *= 2; adj = (int *) realloc(adj,nalloc*sizeof(int)); } idx2 = 0; while ((adjf = List_Next_Entry(adjflist,&idx2))) adj[nentries++] = MF_ID(adjf)-1; List_Delete(adjflist); i++; } } /* Compute offsets into adj array */ offset = (int *) malloc(nf*sizeof(int)); offset[0] = 0; for (i = 1; i < nf; i++) offset[i] = offset[i-1] + nadj[i-1]; /* Compute maximum bandwidth before renumbering */ maxbandwidth1 = 0; avebandwidth1 = 0; for (i = 0; i < nf; i++) { int off = offset[i]; int curid = i; for (j = 0; j < nadj[i]; j++) { int adjid = adj[off+j]; int diff = abs(adjid-curid); maxbandwidth1 = (diff > maxbandwidth1) ? diff : maxbandwidth1; avebandwidth1 += diff; nconn++; } } nconn = offset[nf-1]+nadj[nf-1]; avebandwidth1 /= nconn; if (MESH_Num_Regions(mesh)) { fprintf(stderr, "Ave face ID difference on elements before renumbering: %-lf\n", avebandwidth1); fprintf(stderr, "Max face ID difference on elements before renumbering: %-d\n", maxbandwidth1); } else { fprintf(stderr, "Ave face ID difference before renumbering: %-lf\n", avebandwidth1); fprintf(stderr, "Max face ID difference before renumbering: %-d\n", maxbandwidth1); } fprintf(stderr,"\n"); /* Call Graph Renumbering algorithm */ newmap = (int *) malloc(nf*sizeof(int)); Graph_Renumber_GPS(nf, MF_ID(f0)-1, nadj, adj, newmap, &depth, &maxwidth); /* Compute bandwidth after renumbering */ maxbandwidth2 = 0; avebandwidth2 = 0; for (i = 0; i < nf; i++) { int off = offset[i]; int curid = newmap[i]; for (j = 0; j < nadj[i]; j++) { int adjid = newmap[adj[off+j]]; int diff = abs(adjid-curid); maxbandwidth2 = (diff > maxbandwidth2) ? diff : maxbandwidth2; avebandwidth2 += diff; nconn++; } } nconn = offset[nf-1]+nadj[nf-1]; avebandwidth2 /= nconn; if (maxbandwidth2 < maxbandwidth1 && avebandwidth2 < avebandwidth1) { /* Renumber */ idx = 0; i = 0; while ((mf = MESH_Next_Face(mesh,&idx))) { MF_Set_ID(mf,newmap[i]+1); i++; } if (MESH_Num_Regions(mesh)) { fprintf(stderr, "Ave face ID difference on elements after renumbering: %-lf\n", avebandwidth2); fprintf(stderr, "Max face ID difference on elements after renumbering: %-d\n", maxbandwidth2); } else { fprintf(stderr, "Ave face ID difference after renumbering: %-lf\n", avebandwidth2); fprintf(stderr, "Max face ID difference after renumbering: %-d\n", maxbandwidth2); } } else { nf = 0; idx = 0; while ((mf = MESH_Next_Face(mesh,&idx))) MF_Set_ID(mf,++nf); fprintf(stderr,"Bandwidth did not improve. Keeping old numbering with gaps eliminated\n"); } fprintf(stderr,"\n\n\n"); free(nadj); free(adj); free(offset); free(newmap); } if (mtype == MREGION || mtype == MALLTYPE) { int nr = MESH_Num_Regions(mesh); if (nr) { if (mtype == MALLTYPE) { /* Renumbering algorithm already applied on the vertices. Use a region connected to the starting vertex as the first region */ List_ptr vregions = MV_Regions(v0); r0 = List_Entry(vregions,0); List_Delete(vregions); } else { /* Find the region whose center point is a minimum point */ minx = miny = minz = 1.0e+12; r0 = NULL; idx = 0; while ((mr = MESH_Next_Region(mesh,&idx))) { double rxyz[MAXPV3][3]; int nrv; MR_Coords(mr,&nrv,rxyz); xyz[0] = rxyz[0][0]; xyz[1] = rxyz[0][1]; xyz[2] = rxyz[0][2]; for (i = 1; i < nrv; i++) { xyz[0] += rxyz[i][0]; xyz[1] += rxyz[i][1]; xyz[2] += rxyz[i][2]; } xyz[0] /= nrv; xyz[1] /= nrv; xyz[2] /= nrv; if (xyz[0] < minx && xyz[1] < miny && xyz[2] < minz) { minx = xyz[0]; miny = xyz[1]; minz = xyz[2]; r0 = mr; } } } nadj = (int *) malloc(nr*sizeof(int)); nalloc = nr*5; adj = (int *) malloc(nalloc*sizeof(int)); int nentries = 0; i = 0; idx = 0; while ((mr = MESH_Next_Region(mesh,&idx))) { List_ptr vregions, rverts, adjrlist; MRegion_ptr vr, adjr; MVertex_ptr rv; adjrlist = List_New(0); rverts = MR_Vertices(mr); idx2 = 0; while ((rv = List_Next_Entry(rverts,&idx2))) { List_ptr vregions = MV_Regions(rv); idx3 = 0; while ((adjr = List_Next_Entry(vregions,&idx3))) { if (adjr != mr) { int rmarked; #ifdef MSTK_USE_MARKERS rmarked = MEnt_IsMarked(adjr,mkid); #else MEnt_Get_AttVal(adjr, mkatt, &rmarked, &rval, &pval); #endif List_Add(adjrlist,adjr); #ifdef MSTK_USE_MARKERS MEnt_Mark(adjr,mkid); #else MEnt_Set_AttVal(adjr, mkatt, 1, 0.0, NULL); #endif } } List_Delete(vregions); } List_Delete(rverts); #ifdef MSTK_USE_MARKERS List_Unmark(adjrlist,mkid); #endif nadj[i] = List_Num_Entries(adjrlist); if (nentries+nadj[i] > nalloc) { nalloc *= 2; adj = (int *) realloc(adj,nalloc*sizeof(int)); } idx2 = 0; while ((adjr = List_Next_Entry(adjrlist,&idx2))) adj[nentries++] = MR_ID(adjr)-1; List_Delete(adjrlist); i++; } /* Compute offsets into adj array */ offset = (int *) malloc(nr*sizeof(int)); offset[0] = 0; for (i = 1; i < nr; i++) offset[i] = offset[i-1] + nadj[i-1]; /* Compute maximum bandwidth before renumbering */ maxbandwidth1 = 0; avebandwidth1 = 0; for (i = 0; i < nr; i++) { int off = offset[i]; int curid = i; for (j = 0; j < nadj[i]; j++) { int adjid = adj[off+j]; int diff = abs(adjid-curid); maxbandwidth1 = (diff > maxbandwidth1) ? diff : maxbandwidth1; avebandwidth1 += diff; nconn++; } } nconn = offset[nr-1]+nadj[nr-1]; avebandwidth1 /= nconn; fprintf(stderr, "Ave region ID difference before renumbering: %-lf\n", avebandwidth1); fprintf(stderr, "Max region ID difference before renumbering: %-d\n", maxbandwidth1); fprintf(stderr,"\n"); /* Call Graph Renumbering algorithm */ newmap = (int *) malloc(nr*sizeof(int)); Graph_Renumber_GPS(nr, MR_ID(r0)-1, nadj, adj, newmap, &depth, &maxwidth); /* Compute bandwidth after renumbering */ maxbandwidth2 = 0; avebandwidth2 = 0; for (i = 0; i < nr; i++) { int off = offset[i]; int curid = newmap[i]; for (j = 0; j < nadj[i]; j++) { int adjid = newmap[adj[off+j]]; int diff = abs(adjid-curid); maxbandwidth2 = (diff > maxbandwidth2) ? diff : maxbandwidth2; avebandwidth2 += diff; nconn++; } } nconn = offset[nr-1]+nadj[nr-1]; avebandwidth2 /= nconn; if (maxbandwidth2 < maxbandwidth1 && avebandwidth2 < avebandwidth1) { /* Renumber */ idx = 0; i = 0; while ((mr = MESH_Next_Region(mesh,&idx))) { MR_Set_ID(mr,newmap[i]+1); i++; } fprintf(stderr, "Ave region ID difference after renumbering: %-lf\n", avebandwidth2); fprintf(stderr, "Max region ID difference after renumbering: %-d\n", maxbandwidth2); } else { nr = 0; idx = 0; while ((mr = MESH_Next_Region(mesh,&idx))) MR_Set_ID(mr,++nr); fprintf(stderr,"Bandwidth did not improve. Keeping old numbering with gaps eliminated\n"); } fprintf(stderr,"\n\n\n"); free(nadj); free(adj); free(offset); free(newmap); } } #ifdef MSTK_USE_MARKERS MSTK_FreeMarker(mkid); #endif } vidatt = MAttrib_New(mesh,"vidrcm",INT,MVERTEX); idx = 0; while ((mv = MESH_Next_Vertex(mesh,&idx))) { MEnt_Set_AttVal(mv,vidatt,MV_ID(mv),0.0,NULL); } /* We have to reset the max IDs stored in the mesh so that we can correctly assign IDs to new entities */ MESH_Reset_Cached_MaxIDs(mesh); return; }
int MESH_CheckTopo(Mesh_ptr mesh) { int valid = 1; char mesg[256], funcname[32] = "MESH_CheckTopo"; int idx1, idx2, idx3, idx4; MVertex_ptr mv; MEdge_ptr me, ve, fe, re; MFace_ptr mf, vf, ef, rf; MRegion_ptr mr, vr, er, fr; int found, done; int dir; int i, j, k; int nfe; int vid, eid, fid, rid; int gvid, geid, gfid, grid; int gvdim, gedim, gfdim, grdim; int maxiter = 1000; List_ptr vedges, vfaces, vregions; List_ptr efaces; List_ptr fverts, fedges, fregs, fregs1; List_ptr rverts, redges, rfaces; /*****************************************************************/ /* Vertices */ /*****************************************************************/ /* Check that edges connected to vertices reference the vertices */ /* Also check that the classification of the vertex is consistent with respect to the edge */ int first_unknown_classfn = 1; idx1 = 0; while ((mv = MESH_Next_Vertex(mesh,&idx1))) { #ifdef MSTK_HAVE_MPI if (MV_PType(mv) == PGHOST) continue; #endif vid = MV_ID(mv); gvdim = MV_GEntDim(mv); gvid = MV_GEntID(mv); if (gvdim == 4 && first_unknown_classfn) { sprintf(mesg, "Vertex %-d - classification unknown\n", vid); MSTK_Report(funcname, mesg, MSTK_WARN); first_unknown_classfn = 0; } vedges = MV_Edges(mv); if (!vedges) { sprintf(mesg,"Vertex %-d does not have any connected edges\n",vid); MSTK_Report(funcname,mesg,MSTK_WARN); continue; } idx2 = 0; while ((ve = List_Next_Entry(vedges,&idx2))) { eid = ME_ID(ve); if (ME_Vertex(ve,0) != mv && ME_Vertex(ve,1) != mv) { sprintf(mesg,"Vertex %-d connected to edge %-d but edge does not use vertex",vid,eid); MSTK_Report(funcname,mesg,MSTK_ERROR); valid = 0; } } if (gvdim == 1) { /* If vertex is classified on a model edge, then it should be connected to two and only two edges that are classified on the same model edge */ int ne = 0; idx2 = 0; while ((ve = List_Next_Entry(vedges,&idx2))) { gedim = ME_GEntDim(ve); geid = ME_GEntID(ve); if (gedim == 1 && geid == gvid) ne++; } if (ne != 2) { sprintf(mesg,"Vertex %-d classified on model edge %-d but it is not \n connected to two edges classified on this model edge",vid,gvid); MSTK_Report(funcname,mesg,MSTK_WARN); } } List_Delete(vedges); if (gvdim == 2) { MEdge_ptr e0, ecur, enxt; MFace_ptr fcur; int flipped = 0; /* If vertex is classified on a model face, then we should be able to find a ring of faces classified on that model face */ vfaces = MV_Faces(mv); found = 0; idx2 = 0; while ((vf = List_Next_Entry(vfaces,&idx2))) { if (MF_GEntDim(vf) == 2) { found = 1; break; } } List_Delete(vfaces); if (!found) { sprintf(mesg,"Vertex %-d classified on model face %-d but could not \n find connected face classified on this model face",vid,gvid); MSTK_Report(funcname,mesg,MSTK_WARN); valid = 0; } fcur = vf; fedges = MF_Edges(fcur,1,mv); nfe = List_Num_Entries(fedges); e0 = List_Entry(fedges,0); ecur = e0; enxt = List_Entry(fedges,nfe-1); List_Delete(fedges); done = 0; i = 0; while (!done) { ecur = enxt; efaces = ME_Faces(ecur); found = 0; idx3 = 0; while ((ef = List_Next_Entry(efaces,&idx3))) { if (ef != fcur && MF_GEntDim(ef) == 2 && MF_GEntID(ef) == gvid) { fcur = ef; found = 1; break; } } List_Delete(efaces); if (!found) { sprintf(mesg,"Could not find next boundary face connected to vertex %-d",vid); MSTK_Report(funcname,mesg,MSTK_WARN); valid = 0; break; } fedges = MF_Edges(fcur,1,mv); nfe = List_Num_Entries(fedges); if (List_Entry(fedges,0) == ecur) enxt = List_Entry(fedges,nfe-1); else if (List_Entry(fedges,nfe-1) == ecur) { enxt = List_Entry(fedges,0); flipped = 1; } else { sprintf(mesg,"Could not find next edge while traversing around vertex %-d on model face %-d",vid,gvid); MSTK_Report(funcname,mesg,MSTK_ERROR); } List_Delete(fedges); if (enxt == e0) done = 1; if (++i > maxiter) break; } if (!done) { sprintf(mesg,"Vertex %-d classified on model face %-d but could not find ring of faces classified on this model face",vid,gvid); MSTK_Report(funcname,mesg,MSTK_WARN); } if (done && flipped) { List_ptr fregs = MF_Regions(fcur); if (List_Num_Entries(fregs) < 2) { sprintf(mesg,"Inconsistent orientations of boundary faces around vertex %-d",vid); MSTK_Report(funcname,mesg,MSTK_WARN); } if (fregs) List_Delete(fregs); } } } /* while ((mv = MESH_Next_Vertex(mesh,&idx1))) */ /*****************************************************************/ /* Edges */ /*****************************************************************/ first_unknown_classfn = 1; idx1 = 0; while ((me = MESH_Next_Edge(mesh,&idx1))) { #ifdef MSTK_HAVE_MPI if (ME_PType(me) == PGHOST) continue; #endif eid = ME_ID(me); gedim = ME_GEntDim(me); geid = ME_GEntID(me); if (gedim == 4 && first_unknown_classfn) { sprintf(mesg, "Edge %-d - unknown classification", eid); MSTK_Report(funcname, mesg, MSTK_WARN); first_unknown_classfn = 0; } if (ME_Vertex(me,0) == ME_Vertex(me,1)) { sprintf(mesg,"Edge %-d has repeated vertices",eid); MSTK_Report(funcname,mesg,MSTK_ERROR); } for (i = 0; i < 2; i++) { MVertex_ptr ev = ME_Vertex(me,i); vid = MV_ID(ev); gvid = MV_GEntID(ev); gvdim = MV_GEntDim(ev); if (gvdim != 4 && gvdim != 4) { /* vertex and edge classifn is known */ if (gedim < gvdim) { sprintf(mesg,"Edge %-d classified on lower dimensional entity than connected vertex %-d",eid,vid); MSTK_Report(funcname,mesg,MSTK_WARN); valid = 0; } else if (gedim == gvdim && geid != gvid) { sprintf(mesg,"Edge %-d and its vertex %-d classified on different entities of the same dimension",eid,vid); MSTK_Report(funcname,mesg,MSTK_WARN); valid = 0; } } vedges = MV_Edges(ev); if (!List_Contains(vedges,me)) { sprintf(mesg,"Edge %-d sees vertex %-d but not vice versa",eid,vid); MSTK_Report(funcname,mesg,MSTK_ERROR); valid = 0; } List_Delete(vedges); if (gedim == 2) { MFace_ptr ebf[2], fcur, fnxt; MRegion_ptr rcur; int nf, nfr; List_ptr eregs; /* Edge is classified on model face - it should be connected to two and only two faces also classified on this model face */ ebf[0] = ebf[1] = NULL; nf = 0; efaces = ME_Faces(me); idx2 = 0; while ((ef = List_Next_Entry(efaces,&idx2))) { fid = MF_ID(ef); if (MF_GEntDim(ef) == 2) { nf++; if (gedim == 2 && MF_GEntID(ef) != geid) { sprintf(mesg,"Face %-d connected to edge %-d classified on different model face",fid,eid); MSTK_Report(funcname,mesg,MSTK_WARN); valid = 0; } if (ebf[0] == NULL) ebf[0] = ef; else ebf[1] = ef; } } List_Delete(efaces); if (nf != 2) { sprintf(mesg,"Boundary edge %-d is not connected to exactly two\n faces classified on the boundary",eid); MSTK_Report(funcname,mesg,MSTK_ERROR); valid = 0; } eregs = ME_Regions(me); if (!eregs) continue; else List_Delete(eregs); /* Can we go from f0 to f1 in one or two dirs? */ fcur = ebf[0]; fnxt = NULL; fregs = MF_Regions(fcur); if (!fregs) { fid = MF_ID(fcur); sprintf(mesg,"Edge %-d connected to regions but face %-d is not",eid,fid); MSTK_Report(funcname,mesg,MSTK_ERROR); valid = 0; } nfr = List_Num_Entries(fregs); for (i = 0; i < nfr; i++) { rcur = List_Entry(fregs,i); rfaces = MR_Faces(rcur); idx3 = 0; found = 0; while ((rf = List_Next_Entry(rfaces,&idx3))) { if (rf != fcur && MF_UsesEntity(rf,me,1)) { found = 1; fnxt = rf; break; } } List_Delete(rfaces); if (!found) { rid = MR_ID(rcur); sprintf(mesg,"Could not find second face in region %-d using edge %-d",rid,eid); } done = 0; j = 0; while (!done) { fcur = fnxt; fid = MF_ID(fcur); if (fnxt == ebf[1]) { done = 1; break; } fregs1 = MF_Regions(fcur); idx3 = 0; while ((fr = List_Next_Entry(fregs1,&idx3))) { if (fr != rcur) { rcur = fr; found = 1; break; } } List_Delete(fregs1); if (!found) { sprintf(mesg,"Could not find next region around edge %-d",eid); MSTK_Report(funcname,mesg,MSTK_ERROR); valid = 0; break; } rfaces = MR_Faces(rcur); idx3 = 0; found = 0; while ((rf = List_Next_Entry(rfaces,&idx3))) { if (rf != fcur && MF_UsesEntity(rf,me,1)) { found = 1; fnxt = rf; break; } } List_Delete(rfaces); if (!found) { rid = MR_ID(rcur); sprintf(mesg,"Could not find second face in region %-d using edge %-d",rid,eid); } if (++j > maxiter) break; } /* while (!done) */ if (!done) { sprintf(mesg,"Could not traverse around edge %-d from face %-d to face %-d",eid,MF_ID(ebf[0]),MF_ID(ebf[1])); MSTK_Report(funcname,mesg,MSTK_ERROR); valid = 0; } } /* for (i = 0; i < nfr; i++) */ List_Delete(fregs); } /* if (geid == 2) */ } /* for (i = 0; i < 2; i++) */ } /* while ((me = MESH_Next_Edge(mesh,&idx1))) */ /*****************************************************************/ /* Faces */ /*****************************************************************/ first_unknown_classfn = 1; idx1 = 0; while ((mf = MESH_Next_Face(mesh,&idx1))) { #ifdef MSTK_HAVE_MPI if (MF_PType(mf) == PGHOST) continue; #endif fid = MF_ID(mf); gfid = MF_GEntID(mf); gfdim = MF_GEntDim(mf); if (gfdim == 4 && first_unknown_classfn) { sprintf(mesg, "Face %-d - unknown classification", fid); MSTK_Report(funcname, mesg, MSTK_WARN); first_unknown_classfn = 0; } fedges = MF_Edges(mf,1,0); if (List_Num_Entries(fedges) < 3) { sprintf(mesg,"Face %-d has less than 3 edges",fid); MSTK_Report(funcname,mesg,MSTK_ERROR); } idx2 = 0; while ((fe = List_Next_Entry(fedges,&idx2))) { eid = ME_ID(fe); geid = ME_GEntID(fe); gedim = ME_GEntDim(fe); if (gedim != 4 && gfdim != 4) { /* Edge, Face classfn is known */ if (gfdim < gedim) { sprintf(mesg,"Face %-d classified on lower order entity than edge %-d",fid,ME_ID(fe)); MSTK_Report(funcname,mesg,MSTK_WARN); valid = 0; } else if (gedim == gfdim && geid != gfid) { sprintf(mesg,"Face %-d and edge %-d classified on different\n entities of the same dimension",fid,eid); MSTK_Report(funcname,mesg,MSTK_WARN); } } efaces = ME_Faces(fe); if (!List_Contains(efaces,mf)) { sprintf(mesg,"Face %-d refers to edge %-d but not vice versa",fid,ME_ID(fe)); MSTK_Report(funcname,mesg,MSTK_ERROR); valid = 0; } List_Delete(efaces); } List_Delete(fedges); fregs = MF_Regions(mf); if (gfdim == 3) { if (!fregs || List_Num_Entries(fregs) != 2) { sprintf(mesg,"Interior face %-d does not have two connected regions",fid); MSTK_Report(funcname,mesg,MSTK_ERROR); valid = 0; } } if (fregs) { if (List_Num_Entries(fregs) == 2) { if (MR_FaceDir(List_Entry(fregs,0),mf) == MR_FaceDir(List_Entry(fregs,1),mf)) { sprintf(mesg,"Both regions using face %-d in the same sense",fid); MSTK_Report(funcname,mesg,MSTK_ERROR); valid = 0; } } List_Delete(fregs); } } /* while ((mf = MESH_Next_Face(mesh,&idx1))) */ /*****************************************************************/ /* Regions */ /*****************************************************************/ idx1 = 0; while ((mr = MESH_Next_Region(mesh,&idx1))) { #ifdef MSTK_HAVE_MPI if (MR_PType(mr) == PGHOST) continue; #endif rid = MR_ID(mr); grid = MR_GEntID(mr); rfaces = MR_Faces(mr); int nrf = List_Num_Entries(rfaces); if (nrf < 4) { sprintf(mesg,"Region %-d has less than 4 faces",rid); MSTK_Report(funcname,mesg,MSTK_ERROR); } /* Check that face to region and region to face links are consistent with each other */ int *rfdirs = (int *) malloc(nrf*sizeof(int)); i = 0; idx2 = 0; while ((rf = List_Next_Entry(rfaces,&idx2))) { rfdirs[i] = MR_FaceDir_i(mr,i); if (mr != MF_Region(rf,!rfdirs[i])) { sprintf(mesg,"Region %-d to face %-d dir inconsistent with \n face to region dir",rid,MF_ID(rf)); MSTK_Report(funcname,mesg,MSTK_ERROR); valid = 0; } i++; } /* Check that faces of a region have consistent orientation in the region with respect to each other */ for (i = 0; i < nrf; i++) { MFace_ptr rf, rf2; rf = List_Entry(rfaces,i); fedges = MF_Edges(rf,1,0); nfe = List_Num_Entries(fedges); for (j = 0; j < nfe; j++) { fe = List_Entry(fedges,j); int fedir = MF_EdgeDir_i(rf,j); /* Find adjacent face in the region */ found = 0; for (k = 0; k < nrf; k++) { rf2 = List_Entry(rfaces,k); if (rf != rf2 && MF_UsesEntity(rf2,fe,MEDGE)) { found = 1; break; } } if (!found) { sprintf(mesg,"Cannot find another face in region %-d sharing edge %-d (ID = %-d) of face with ID = %-d",MR_ID(mr),j,ME_ID(fe),MF_ID(rf)); MSTK_Report(funcname,mesg,MSTK_ERROR); valid = 0; } int fedir_adj = MF_EdgeDir(rf2,fe); /* If the two faces use the edge in opposite directions then the region should use the faces in the same direction and vice versa */ if (((fedir_adj == fedir) && (rfdirs[i] == rfdirs[k])) || ((fedir_adj != fedir) && (rfdirs[i] != rfdirs[k]))) { sprintf(mesg,"Region %-d faces are inconsistently oriented",MR_ID(mr)); MSTK_Report(funcname,mesg,MSTK_ERROR); valid = 0; } } List_Delete(fedges); } List_Delete(rfaces); free(rfdirs); } return valid; } /* int MESH_CheckTopo */
int MESH_BuildEdgeClassfn(Mesh_ptr mesh, int use_geometry) { int i, j, k, idx, idx2, fnd, fnd2, geid, geid2, gdim; int ngedges, ngealloc, ngef, max_loc_gfids, *loc_gfids; int max_gedge_id; int nve, nbe, nef, nsub, *geids, **gefaceids; double PI=3.141592, cosang, COSSHARPANG; MVertex_ptr ev[2]; MEdge_ptr edge, subedge, adjedge; MFace_ptr eface; List_ptr efaces, vedges, vbedges, geedges, subedges; double rval; void *pval; COSSHARPANG = cos(5*PI/6); /* 165 degrees */ /* Verify that mesh edges on the boundary have classification information; if not, assign all edges to the same model edge */ ngedges = 0; ngealloc = 10; geids = (int *) malloc(ngealloc*sizeof(int)); /* model edge ids */ /* Number of model faces connected to edge followed by model face ids */ gefaceids = (int **) malloc(ngealloc*sizeof(int *)); /* Take stock of existing model edge information */ max_gedge_id = 0; idx = 0; while ((edge = MESH_Next_Edge(mesh,&idx))) { gdim = ME_GEntDim(edge); if (gdim != 1) continue; geid = ME_GEntID(edge); if (geid) { /* Has this model edge been encountered? If not, add it to list of model edges */ for (i = 0, fnd = 0; i < ngedges; i++) if (geids[i] == geid) { fnd = 1; break; } if (!fnd) { if (geid > max_gedge_id) max_gedge_id = geid; if (ngealloc == ngedges) { ngealloc *= 2; geids = (int *) realloc(geids,ngealloc*sizeof(int)); gefaceids = (int **)realloc(gefaceids,ngealloc*sizeof(int *)); } geids[ngedges] = geid; efaces = ME_Faces(edge); nef = List_Num_Entries(efaces); gefaceids[ngedges] = (int *) malloc((1+nef)*sizeof(int)); ngef = 0; for (i = 0; i < nef; i++) { eface = List_Entry(efaces,i); if (MF_GEntDim(eface) == 2) { gefaceids[ngedges][1+ngef] = MF_GEntID(eface); ngef++; } } gefaceids[ngedges][0] = ngef; ngedges++; List_Delete(efaces); } } } /* Build new model edge information based on adjacent model region info */ /* NOTE: The following cases involve some repetition and can be "cleverly" folded into a shorter piece of code, but then the method by which the individual cases are handled gets a littled obscured. So leave as is */ max_loc_gfids = 10; loc_gfids = (int *) malloc(max_loc_gfids*sizeof(int)); idx = 0; while ((edge = MESH_Next_Edge(mesh,&idx))) { gdim = ME_GEntDim(edge); geid = ME_GEntID(edge); /* Edge has no classification? Assign classification info */ /* Edge classified as face or interior edge? Verify */ efaces = ME_Faces(edge); nef = efaces ? List_Num_Entries(efaces) : 0; if (!nef) { /* Isolated edge (must be on model edge). Did we encounter such an edge before? */ ME_Set_GEntDim(edge,1); for (i = 0, fnd = 0; i < ngedges; i++) { if (gefaceids[i][0] == 0) { fnd = 1; break; } } if (fnd) ME_Set_GEntID(edge,geids[i]); else { max_gedge_id++; ME_Set_GEntID(edge,max_gedge_id); if (ngealloc == ngedges) { ngealloc *= 2; geids = (int *) realloc(geids,ngealloc*sizeof(int)); gefaceids = (int **) realloc(gefaceids,ngealloc*sizeof(int *)); } geids[ngedges] = max_gedge_id; gefaceids[ngedges] = malloc(1*sizeof(int *)); gefaceids[ngedges][0] = 0; } continue; /* nothing else to do */ } if (nef > max_loc_gfids) { loc_gfids = (int *) realloc(loc_gfids,nef*sizeof(int)); max_loc_gfids = nef; } ngef = 0; for (i = 0; i < nef; i++) { eface = List_Entry(efaces,i); if (MF_GEntDim(eface) == 2) { loc_gfids[ngef] = MF_GEntID(eface); ngef++; } } switch (ngef) { case 0: /* Interior edge - we took care of the case of the isolated edge b4 */ ME_Set_GEntDim(edge,3); eface = List_Entry(efaces,0); ME_Set_GEntID(edge,MF_GEntID(eface)); break; case 2: if (loc_gfids[0] == loc_gfids[1]) { if (gdim == 1) { /* Looks like during face classification, this was tagged as being a sharp edge. This means that it is a sharp edge on the interior of a model face (same model face on both sides) */ ME_Set_GEntDim(edge,1); /* Check if such an edge was encountered before */ for (i = 0, fnd = 0; i < ngedges; i++) { if (gefaceids[i][0] != 2) continue; if ((loc_gfids[0] == gefaceids[i][0]) && (gefaceids[i][0] == gefaceids[i][1])) { fnd = 1; break; } } if (fnd) ME_Set_GEntID(edge,geids[i]); else { max_gedge_id++; ME_Set_GEntID(edge,max_gedge_id); if (ngealloc == ngedges) { ngealloc *= 2; geids = (int *) realloc(geids,ngealloc*sizeof(int)); gefaceids = (int **) realloc(gefaceids,ngealloc*sizeof(int *)); } geids[ngedges] = max_gedge_id; gefaceids[ngedges] = malloc((1+ngef)*sizeof(int *)); gefaceids[ngedges][0] = ngef; for (i = 0; i < ngef; i++) gefaceids[ngedges][1+i] = loc_gfids[i]; ngedges++; } } else { /* edge must be on model face */ ME_Set_GEntDim(edge,2); ME_Set_GEntID(edge,loc_gfids[0]); } } else { /* edge is on model edge between two faces */ ME_Set_GEntDim(edge,1); /* Check if such an edge was encountered before */ for (i = 0, fnd = 0; i < ngedges; i++) { if (gefaceids[i][0] != 2) continue; if (((loc_gfids[0] == gefaceids[i][1]) && (loc_gfids[1] == gefaceids[i][2])) || ((loc_gfids[1] == gefaceids[i][1]) && (loc_gfids[0] == gefaceids[i][2]))) { fnd = 1; break; } } if (fnd) ME_Set_GEntID(edge,geids[i]); else { max_gedge_id++; ME_Set_GEntID(edge,max_gedge_id); if (ngealloc == ngedges) { ngealloc *= 2; geids = (int *) realloc(geids,ngealloc*sizeof(int)); gefaceids = (int **) realloc(gefaceids,ngealloc*sizeof(int *)); } geids[ngedges] = max_gedge_id; gefaceids[ngedges] = malloc((1+ngef)*sizeof(int *)); gefaceids[ngedges][0] = ngef; for (i = 0; i < ngef; i++) gefaceids[ngedges][1+i] = loc_gfids[i]; ngedges++; } } break; default: /* if ngef is 1, edge is on model edge of non-manifold model face if ngef is >= 3, edge is on model edge at junction of many model faces */ ME_Set_GEntDim(edge,1); /* Check if a previously encountered model edge has this combination of connected faces */ for (i = 0, fnd = 0; i < ngedges; i++) { if (ngef != gefaceids[i][0]) continue; /* number of connected model faces is different */ /* see if all the model faces of the current edge can be found in the i'th model edge's faces */ fnd2 = 0; for (j = 0; j < ngef; j++) { fnd2 = 0; for (k = 0; k < ngef; k++) { if (loc_gfids[j] == gefaceids[i][1+k]) { fnd2 = 1; break; } } /* Did not find loc_gfid[j] in the list gefaceids[i] */ if (!fnd2) break; } /* if a model face connected to this edge was not found in the model face list of the previously processed, then the two model edges are obviously different */ if (!fnd2) continue; else { fnd = 1; break; } } if (fnd) ME_Set_GEntID(edge,geids[i]); else { max_gedge_id++; ME_Set_GEntID(edge,max_gedge_id); if (ngealloc == ngedges) { ngealloc *= 2; geids = (int *) realloc(geids,ngealloc*sizeof(int)); gefaceids = (int **) realloc(gefaceids,ngealloc*sizeof(int *)); } geids[ngedges] = max_gedge_id; gefaceids[ngedges] = malloc((1+ngef)*sizeof(int *)); gefaceids[ngedges][0] = ngef; for (i = 0; i < ngef; i++) gefaceids[ngedges][1+i] = loc_gfids[i]; ngedges++; } break; } List_Delete(efaces); /* needed efaces in case 0 */ } free(loc_gfids); if (use_geometry == 1) { #ifdef MSTK_USE_MARKERS int processedmk = MSTK_GetMarker(); int submk = MSTK_GetMarker(); #else MAttrib_ptr processedatt = MAttrib_New(mesh, "processed", INT, MEDGE); MAttrib_ptr sublistatt = MAttrib_New(mesh, "sublist", INT, MEDGE); #endif /* Now assign model edge IDs based on whether a sharp set of edges enclose a set of edges */ for (i = 0; i < ngedges; i++) { /* Find all mesh edges with this model edge id */ geedges = List_New(10); idx = 0; while ((edge = MESH_Next_Edge(mesh,&idx))) { if (ME_GEntDim(edge) == 1 && ME_GEntID(edge) == geids[i]) List_Add(geedges,edge); } /* Process edges of this list and subdivide them into subedges */ /* The way we do that is 1) we put an unprocessed edge from the original list in a subedge list 2) we then add its neighboring edges to subedge list if they are of the same color (same model edge id) and do not have a sharp edge separating them from the current edge 3) we then process the next edge in the subedge list 4) we are done if we cannot find any more neighbors of edges in the subedge list to add to the subedge list 5) we then repeat steps 1 through 4 until we are left with no more edges to process from the original list */ nsub = 0; idx = 0; while ((edge = List_Next_Entry(geedges,&idx))) { int emarked; #ifdef MSTK_USE_MARKERS emarked = MEnt_IsMarked(edge,processedmk); #else MEnt_Get_AttVal(edge, processedatt, &emarked, &rval, &pval); #endif if (emarked) continue; /* Found a edge in geedges that has not been processed */ #ifdef MSTK_USE_MARKERS MEnt_Mark(edge,processedmk); #else MEnt_Set_AttVal(edge, processedatt, 1, 0.0, NULL); #endif subedges = List_New(10); List_Add(subedges,edge); #ifdef MSTK_USE_MARKERS MEnt_Mark(edge,submk); #else MEnt_Set_AttVal(edge, sublistatt, 1, 0.0, NULL); #endif idx2 = 0; while ((subedge = List_Next_Entry(subedges,&idx2))) { geid = ME_GEntID(subedge); ev[0] = ME_Vertex(subedge,0); ev[1] = ME_Vertex(subedge,1); for (j = 0; j < 2; j++) { vedges = MV_Edges(ev[j]); nve = List_Num_Entries(vedges); vbedges = List_New(nve); /* list of boundary edges cnctd 2 vert */ for (k = 0; k < nve; k++) { adjedge = List_Entry(vedges,k); if (ME_GEntDim(adjedge) == 1) List_Add(vbedges,adjedge); } nbe = List_Num_Entries(vbedges); if (nbe == 2) { /* we might be on a model vertex or on a model edge */ adjedge = List_Entry(vbedges,0); if (adjedge == subedge) adjedge = List_Entry(vbedges,1); geid2 = ME_GEntID(adjedge); if (geid == geid2) { /* The two edges are of the same ID. If the angle between them is not sharp they can be classified as being on the same subedge */ cosang = MEs_Angle(subedge,adjedge); if (cosang <= COSSHARPANG) { /* Add edge2 to subedge list unless its already there */ int adjemarked; #ifdef MSTK_USE_MARKERS adjemarked = MEnt_IsMarked(adjedge,submk); #else MEnt_Get_AttVal(adjedge, sublistatt, &adjemarked, &rval, &pval); #endif if (!adjemarked) { List_Add(subedges,adjedge); #ifdef MSTK_USE_MARKERS MEnt_Mark(adjedge,submk); #else MEnt_Set_AttVal(adjedge, sublistatt, 1, 0.0, NULL); #endif } } else { /* The two edges make a very sharp angle. We will consider the edge b/w them to be a model vertex */ /* Tag the edge as being on a model vertex (we don't know the model vertex ID as yet) and continue */ MV_Set_GEntDim(ev[j],0); MV_Set_GEntID(ev[j],0); } } else { /* we reached a model vertex */ /* Tag the edge as being on a model vertex (we don't know the model vertex ID as yet) and continue */ MV_Set_GEntDim(ev[j],0); MV_Set_GEntID(ev[j],0); } } else { /* we reached a a model vertex */ /* Tag the edge as being on a model vertex (we don't know the model vertex ID as yet) and continue */ ME_Set_GEntDim(ev[j],0); ME_Set_GEntID(ev[j],0); } List_Delete(vedges); List_Delete(vbedges); } /* Finished processing all neighbors of the edge */ } /* Now we have a list of edges which we believe constitutes a model edge by itself. If this is the first subedge (which means it could also be the entire model edge originally considered), leave the model edge tag as it is. If not, assign the edges in the subedge a new model edge ID */ if (nsub != 0) { max_gedge_id++; idx2 = 0; while ((subedge = List_Next_Entry(subedges,&idx2))) ME_Set_GEntID(subedge,max_gedge_id); } nsub++; /* Done with this subedge */ #ifdef MSTK_USE_MARKERS idx2 = 0; while ((subedge = List_Next_Entry(subedges,&idx2))) { MEnt_Mark(subedge,processedmk); MEnt_Unmark(subedge,submk); } #else idx2 = 0; while ((subedge = List_Next_Entry(subedges,&idx2))) { MEnt_Set_AttVal(subedge, processedatt, 1, 0.0, NULL); MEnt_Set_AttVal(subedge, sublistatt, 0, 0.0, NULL); } #endif List_Delete(subedges); } #ifdef MSTK_USE_MARKERS List_Unmark(geedges,processedmk); #else idx2 = 0; while ((edge = List_Next_Entry(geedges, &idx2))) MEnt_Set_AttVal(edge, processedatt, 1, 0.0, NULL); #endif List_Delete(geedges); } #ifdef MSTK_USE_MARKERS MSTK_FreeMarker(processedmk); MSTK_FreeMarker(submk); #else MAttrib_Delete(processedatt); MAttrib_Delete(sublistatt); #endif } /* if use_geometry == 1 */ free(geids); for (i = 0; i < ngedges; i++) free(gefaceids[i]); free(gefaceids); return 1; }