MVertex_ptr MVs_Merge_R1R2(MVertex_ptr v1, MVertex_ptr v2, int topoflag) {
int i, idx, gdim, gid;
MFace_ptr face;
MRegion_ptr region;
Mesh_ptr mesh;
List_ptr vfaces2, vregions2;
mesh = MV_Mesh(v1);
gid = MV_GEntID(v1);
gdim = MV_GEntDim(v1);
if (mesh != MF_Mesh(v2)) {
MSTK_Report("MVs_Join","Vertices not from same mesh",MSTK_ERROR);
return 0;
}
else if (topoflag) { /* make sure geometric model topology is not violated */
if (gid != MV_GEntID(v2) || gdim != MV_GEntDim(v2)) {
MSTK_Report("MFs_Join","Faces not from same geometric entity",MSTK_ERROR);
return 0;
}
}
vfaces2 = MV_Faces(v2);
if (vfaces2) {
idx = 0;
while ((face = List_Next_Entry(vfaces2,&idx)))
MF_Replace_Vertex(face,v2,v1);
List_Delete(vfaces2);
}
vregions2 = MV_Regions(v2);
if (vregions2) {
idx = 0;
while ((region = List_Next_Entry(vregions2,&idx)))
MR_Replace_Vertex(region,v2,v1);
List_Delete(vregions2);
}
MV_Delete(v2,0);
return v1;
}
MVertex_ptr MVs_Merge_R3R4(MVertex_ptr v1, MVertex_ptr v2, int topoflag) {
int idx, gdim, gid, nsets;
MFace_ptr face;
Mesh_ptr mesh;
List_ptr vfaces2;
MSet_ptr mset;
mesh = MV_Mesh(v1);
gid = MV_GEntID(v1);
gdim = MV_GEntDim(v1);
if (mesh != MF_Mesh(v2)) {
MSTK_Report("MVs_Join","Vertices not from same mesh",MSTK_ERROR);
return 0;
}
else if (topoflag) { /* Make sure model topology is not violated */
if (gid != MV_GEntID(v2) || gdim != MV_GEntDim(v2)) {
MSTK_Report("MFs_Join","Faces not from same geometric entity",MSTK_ERROR);
return 0;
}
}
vfaces2 = MV_Faces(v2);
if (vfaces2) {
idx = 0;
while ((face = List_Next_Entry(vfaces2,&idx)))
MF_Replace_Vertex(face,v2,v1);
List_Delete(vfaces2);
}
nsets = MESH_Num_MSets(mesh);
if(nsets) {
idx = 0;
while ((mset = (MSet_ptr) MESH_Next_MSet(mesh,&idx))) {
if (MSet_Contains(mset, v2)) {
if(MSet_Contains(mset, v1))
MSet_Rem(mset, v2);
else
MSet_Replace(mset, v2, v1);
}
}
}
MV_Delete(v2,1);
return v1;
}
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;
}
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_ConcatSubMesh_Face(Mesh_ptr mesh, int num, Mesh_ptr *submeshes) {
int nfv, nfe, i, j, k, ival;
MVertex_ptr mv, new_mv, sub_mv;
MEdge_ptr me, new_me, sub_me;
MFace_ptr new_mf, sub_mf;
List_ptr mfverts, mfedges;
int add_face, idx, global_id, iloc, *loc;
double coor[3], rval;
void *pval;
Mesh_ptr submesh;
List_ptr parbndry_verts = List_New(10);
List_ptr parbndry_edges = List_New(10);
MEdge_ptr *fedges = (MEdge_ptr *) malloc(MAXPV2*sizeof(MEdge_ptr));
int *fedirs = (int *) malloc(MAXPV2*sizeof(int));
MAttrib_ptr parbndryatt = MAttrib_New(mesh, "on_parbndry", INT, MVERTEX);
/* collect edges and vertices on the partition boundary */
int num_parbndry_edges = 0;
idx = 0;
while ((me = MESH_Next_Edge(mesh,&idx)))
if (ME_PType(me) != PINTERIOR) {
List_Add(parbndry_edges,me);
num_parbndry_edges++;
}
int num_parbndry_verts = 0;
idx = 0;
while ((mv = MESH_Next_Vertex(mesh,&idx)))
if (MV_PType(mv) != PINTERIOR) {
List_Add(parbndry_verts,mv);
MEnt_Set_AttVal(mv, parbndryatt, 1, 0.0, NULL);
num_parbndry_verts++;
}
/* sort based on global ID */
List_Sort(parbndry_edges,num_parbndry_edges,sizeof(MEdge_ptr),compareGlobalID);
List_Sort(parbndry_verts,num_parbndry_verts,sizeof(MVertex_ptr),compareGlobalID);
int *parbndry_vert_gids = (int *) malloc(num_parbndry_verts*sizeof(int));
int *parbndry_edge_gids = (int *) malloc(num_parbndry_edges*sizeof(int));
/* store them in array for binary search */
for (i = 0; i < num_parbndry_edges; i++) {
me = List_Entry(parbndry_edges,i);
parbndry_edge_gids[i] = ME_GlobalID(me);
}
for (i = 0; i < num_parbndry_verts; i++) {
mv = List_Entry(parbndry_verts,i);
parbndry_vert_gids[i] = MV_GlobalID(mv);
}
/* Make list of new edges and vertices which will be updated
with each mesh that is concatenated */
int max_vnew = 0, max_enew = 0;
for (i = 0; i < num; i++) {
max_vnew += MESH_Num_Vertices(submeshes[i]);
max_enew += MESH_Num_Edges(submeshes[i]);
}
int num_new_verts = 0, num_new_edges = 0;
int *new_vert_gids = (int *) malloc(max_vnew*sizeof(int));
int *new_edge_gids = (int *) malloc(max_enew*sizeof(int));
List_ptr new_verts = List_New(max_vnew);
List_ptr new_edges = List_New(max_enew);
/* Now process each mesh and add a layer of ghost elements from
each of them to the main partition */
for (i = 0; i < num; i++) {
submesh = submeshes[i];
MAttrib_ptr vidatt = MAttrib_New(submesh, "tempvid", POINTER, MVERTEX);
MAttrib_ptr eidatt = MAttrib_New(submesh, "tempeid", POINTER, MEDGE);
idx = 0;
while ((sub_mf = MESH_Next_Face(submesh, &idx))) {
add_face = 0;
/* Find matching vertices between the submesh and main mesh */
mfverts = MF_Vertices(sub_mf,1,0);
nfv = List_Num_Entries(mfverts);
for (j = 0; j < nfv; j++) {
sub_mv = List_Entry(mfverts,j);
/* Does the vertex have a known counterpart on the partition
* boundary of the main mesh? */
MEnt_Get_AttVal(sub_mv, vidatt, &ival, &rval, &mv);
if (mv) {
int on_parbndry=0;
MEnt_Get_AttVal(mv, parbndryatt, &on_parbndry, &rval, &pval);
if (on_parbndry)
add_face = 1;
} else {
/* Does the global ID of this vertex of the sub mesh face
* match the global ID of a partition boundary vertex in
* the main mesh? */
global_id = MV_GlobalID(sub_mv);
loc = (int *) bsearch(&global_id, parbndry_vert_gids, num_parbndry_verts, sizeof(int),
compareINT);
if (loc) { /* found a match */
add_face = 1;
iloc = loc - parbndry_vert_gids;
mv = List_Entry(parbndry_verts,iloc);
/* here set the ghost vertex property, only necessary when the input submeshes are not consistent */
if (MV_PType(mv) == PGHOST && MV_PType(sub_mv) != PGHOST) {
MV_Set_GEntDim(mv,MV_GEntDim(sub_mv));
MV_Set_GEntID(mv,MV_GEntID(sub_mv));
}
MEnt_Set_AttVal(sub_mv, vidatt, 0, 0.0, mv);
}
}
}
List_Delete(mfverts);
/* Find matching edges between the submesh and main mesh */
mfedges = MF_Edges(sub_mf,1,0);
nfe = List_Num_Entries(mfedges);
for (j = 0; j < nfe; j++) {
sub_me = List_Entry(mfedges,j);
/* Does the edge have a known counterpart on the partition
* boundary of the main mesh */
MEnt_Get_AttVal(sub_me, eidatt, &ival, &rval, &me);
if (!me) {
/* Does the global ID of this edge of the sub mesh face
* match the global ID of a partition boundary edge in the
* main mesh? */
global_id = ME_GlobalID(sub_me);
loc = (int *) bsearch(&global_id, parbndry_edge_gids, num_parbndry_edges, sizeof(int),
compareINT);
if (loc) {
iloc = loc - parbndry_edge_gids;
me = List_Entry(parbndry_edges,iloc);
/* here set the ghost edge property, only necessary when the input submeshes are not consistent */
if (ME_PType(me) == PGHOST && ME_PType(sub_me) != PGHOST) {
ME_Set_GEntDim(me,ME_GEntDim(sub_me));
ME_Set_GEntID(me,ME_GEntID(sub_me));
}
MEnt_Set_AttVal(sub_me, eidatt, 0, 0.0, me);
}
}
}
if (!add_face) {
List_Delete(mfedges);
continue;
}
new_mf = MF_New(mesh); /* add face */
MF_Set_GEntDim(new_mf,MF_GEntDim(sub_mf));
MF_Set_GEntID(new_mf,MF_GEntID(sub_mf));
MF_Set_PType(new_mf,PGHOST);
MF_Set_MasterParID(new_mf,MF_MasterParID(sub_mf));
MF_Set_GlobalID(new_mf,MF_GlobalID(sub_mf));
nfe = List_Num_Entries(mfedges);
for (j = 0; j < nfe; j++) {
sub_me = List_Entry(mfedges,j);
global_id = ME_GlobalID(sub_me);
fedirs[j] = MF_EdgeDir_i(sub_mf,j) == 1 ? 1 : 0;
new_me = NULL;
MEnt_Get_AttVal(sub_me, eidatt, &ival, &rval, &new_me);
if (!new_me) {
/* search in the ghost layer if another edge with
* this global ID has been added */
loc = (int *) bsearch(&global_id, new_edge_gids, num_new_edges,
sizeof(int), compareINT);
if (loc) {
iloc = loc - new_edge_gids;
new_me = List_Entry(new_edges, iloc);
MEnt_Set_AttVal(sub_me, eidatt, 0, 0.0, new_me);
}
}
if (new_me) {
if (MV_GlobalID(ME_Vertex(new_me,0)) != MV_GlobalID(ME_Vertex(sub_me,0)))
fedirs[j] = 1 - fedirs[j]; /* if the edge dir is not the same, reverse the edge dir */
} else { /* add a new edge to main mesh */
new_me = ME_New(mesh);
ME_Set_GEntDim(new_me,ME_GEntDim(sub_me));
ME_Set_GEntID(new_me,ME_GEntID(sub_me));
ME_Set_PType(new_me,PGHOST);
ME_Set_MasterParID(new_me,ME_MasterParID(sub_me));
ME_Set_GlobalID(new_me,ME_GlobalID(sub_me));
MEnt_Set_AttVal(sub_me, eidatt, 0, 0.0, new_me);
List_Add(new_edges, new_me);
for (k = 0; k < 2; k++) {
sub_mv = ME_Vertex(sub_me,k);
global_id = MV_GlobalID(sub_mv);
new_mv = NULL;
MEnt_Get_AttVal(sub_mv, vidatt, &ival, &rval, &new_mv);
if (!new_mv) {
/* search in the ghost layer if another vertex with
* this global ID has been added */
loc = (int *) bsearch(&global_id, new_vert_gids, num_new_verts,
sizeof(int), compareINT);
if (loc) {
iloc = loc - new_vert_gids;
new_mv = List_Entry(new_verts, iloc);
MEnt_Set_AttVal(sub_mv, vidatt, 0, 0.0, new_mv);
}
}
if (!new_mv) { /* add a new vertex to main mesh */
new_mv = MV_New(mesh);
MV_Set_GEntDim(new_mv,MV_GEntDim(sub_mv));
MV_Set_GEntID(new_mv,MV_GEntID(sub_mv));
MV_Set_PType(new_mv,PGHOST);
MV_Set_MasterParID(new_mv,MV_MasterParID(sub_mv));
MV_Set_GlobalID(new_mv,MV_GlobalID(sub_mv));
MV_Coords(sub_mv,coor);
MV_Set_Coords(new_mv,coor);
MEnt_Set_AttVal(sub_mv, vidatt, 0, 0.0, new_mv);
List_Add(new_verts, new_mv);
}
ME_Set_Vertex(new_me,k,new_mv); /* set edge-vertex */
}
}
fedges[j] = new_me;
}
MF_Set_Edges(new_mf,nfe,fedges,fedirs); /* set face-edge */
List_Delete(mfedges);
}
idx = 0;
while ((sub_mv = MESH_Next_Vertex(submesh, &idx)))
MEnt_Rem_AttVal(sub_mv, vidatt);
MAttrib_Delete(vidatt);
idx = 0;
while ((sub_me = MESH_Next_Edge(submesh, &idx)))
MEnt_Rem_AttVal(sub_me, eidatt);
MAttrib_Delete(eidatt);
/* Sort the added entity lists by GlobalID */
num_new_edges = List_Num_Entries(new_edges);
List_Sort(new_edges, num_new_edges, sizeof(MEdge_ptr), compareGlobalID);
for (j = 0; j < num_new_edges; j++)
new_edge_gids[j] = ME_GlobalID(List_Entry(new_edges, j));
num_new_verts = List_Num_Entries(new_verts);
List_Sort(new_verts, num_new_verts, sizeof(MVertex_ptr), compareGlobalID);
for (j = 0; j < num_new_verts; j++)
new_vert_gids[j] = MV_GlobalID(List_Entry(new_verts, j));
}
idx = 0;
while ((mv = List_Next_Entry(parbndry_verts, &idx)))
MEnt_Rem_AttVal(mv, parbndryatt);
MAttrib_Delete(parbndryatt);
List_Delete(parbndry_edges);
List_Delete(parbndry_verts);
List_Delete(new_edges);
List_Delete(new_verts);
free(parbndry_vert_gids);
free(parbndry_edge_gids);
free(new_vert_gids);
free(new_edge_gids);
free(fedges);
free(fedirs);
return 1;
}
int ME_Set_GInfo_Auto(MEdge_ptr e) {
MVertex_ptr v0, v1;
int gdim0, gdim1, gid0, gid1, egdim, egid;
v0 = e->vertex[0];
gdim0 = MV_GEntDim(v0); gid0 = MV_GEntID(v0);
v1 = e->vertex[1];
gdim1 = MV_GEntDim(v1); gid1 = MV_GEntID(v1);
egdim = 4;
egid = -1;
if (gdim0 == gdim1) {
if (gid0 == gid1) {
egdim = gdim0;
egid = gid0;
}
else { /* Unknown classification */
egdim = 4;
egid = -1;
}
}
else {
if (gdim0 > gdim1) {
egdim = gdim0;
egid = gid0;
}
else {
egdim = gdim1;
egid = gid1;
}
}
/* if the classification could not be determined, look at
higher-dimensional entities connected to the edge to see if we
can at least find the dimension of the model entity on which it
is classified */
if (egdim == 4) {
List_ptr efaces;
MFace_ptr eface;
efaces = ME_Faces(e);
if (!efaces) {
egdim = 2;
egid = -1;
}
else {
int allinterior, allsame, idx, gfid0;
/* First check if all faces connected to edge are interior faces */
idx = 0;
allinterior = 1;
while ((eface = List_Next_Entry(efaces,&idx))) {
if (MEnt_GEntDim((MEntity_ptr) eface) != 3) {
allinterior = 0;
break;
}
}
if (allinterior) {
egdim = 3;
egid = MEnt_GEntID((MEntity_ptr) List_Entry(efaces,0));
}
else {
/* edge has some boundary faces connected to it. If all the
boundary faces are classified on the same model face,
then the edge is on that model face. If boundary faces
are on different model faces, the edge is on a model
edge, although we don't know which one */
gfid0 = -1;
allsame = 1;
idx = 0;
while ((eface = List_Next_Entry(efaces,&idx))) {
if (MEnt_GEntDim((MEntity_ptr) eface) != 2) continue;
if (gfid0 == -1) { /* first boundary face */
gfid0 = MEnt_GEntID((MEntity_ptr) eface);
}
else {
if (MEnt_GEntID((MEntity_ptr) eface) != gfid0) {
allsame = 0;
break;
}
}
}
if (allsame && gfid0 != -1) {
egdim = 2;
egid = gfid0;
}
else {
egdim = 1;
egid = -1;
}
}
List_Delete(efaces);
}
}
MEnt_Set_GEntDim((MEntity_ptr) e,egdim);
MEnt_Set_GEntID((MEntity_ptr) e,egid);
if (egdim == 4)
return 0;
else
return 1;
}
int MESH_WriteToFile(Mesh_ptr mesh, const char *filename, RepType rtype, MSTK_Comm comm) {
FILE *fp;
char mesg[80], attname[256];
int i, j, k, idx;
int gdim, gid;
int mvid, mvid0, mvid1, mvid2, mrid2, meid, mfid, mrid;
int nav, nar, nfe, nfv, nrf, nrv, dir=0;
int nv, ne, nf, nr;
int natt, ncomp, ival, nent;
double xyz[3], rval, rdummy, *rval_arr;
void *pval, *pdummy;
MVertex_ptr mv, mv0, mv1, mv2;
MEdge_ptr me;
MFace_ptr mf;
MRegion_ptr mr, mr2;
List_ptr adjverts, mfedges, mfverts, mrfaces, mrverts, adjregs;
RepType reptype;
MAttrib_ptr attrib, vidatt, eidatt, fidatt, ridatt;
MType attentdim;
MAttType atttype;
char modfilename[256];
strcpy(modfilename, filename);
int rank = 0, numprocs = 1;
#ifdef MSTK_HAVE_MPI
if (comm) {
MPI_Comm_size((MPI_Comm)comm, &numprocs);
MPI_Comm_rank((MPI_Comm)comm, &rank);
}
if (numprocs > 1) {
int ndigits = 0;
int div = 1;
while (numprocs/div) {div *= 10; ndigits++;}
sprintf(modfilename,"%s.%d.%0*d",filename,numprocs,ndigits,rank);
}
#endif
if (!(fp = fopen(modfilename,"w"))) {
sprintf(mesg,"Cannot open file %-s for writing",modfilename);
MSTK_Report("MESH_WriteToFile",mesg,MSTK_ERROR);
return 0;
}
if (rtype != UNKNOWN_REP) {
reptype = rtype;
}
else {
reptype = MESH_RepType(mesh);
}
nv = MESH_Num_Vertices(mesh);
ne = MESH_Num_Edges(mesh);
nf = MESH_Num_Faces(mesh);
nr = MESH_Num_Regions(mesh);
fprintf(fp,"MSTK %-2.1lf\n",MSTK_FILE_VER);
fprintf(fp,"%s %d %d %d %d\n",
MESH_rtype_str[reptype],
nv,
(reptype >= R1 && reptype <= R4)?0:ne,
(reptype >= R1 && reptype <= R2 && nr)?0:nf,
nr);
vidatt = MAttrib_New(mesh,"vidatt",INT,MVERTEX);
eidatt = MAttrib_New(mesh,"eidatt",INT,MEDGE);
fidatt = MAttrib_New(mesh,"fidatt",INT,MFACE);
ridatt = MAttrib_New(mesh,"ridatt",INT,MREGION);
idx = 0; i = 0;
while ((mv = MESH_Next_Vertex(mesh,&idx)))
MEnt_Set_AttVal(mv,vidatt,++i,0.0,NULL);
idx = 0; i = 0;
while ((me = MESH_Next_Edge(mesh,&idx)))
MEnt_Set_AttVal(me,eidatt,++i,0.0,NULL);
idx = 0; i = 0;
while ((mf = MESH_Next_Face(mesh,&idx)))
MEnt_Set_AttVal(mf,fidatt,++i,0.0,NULL);
idx = 0; i = 0;
while ((mr = MESH_Next_Region(mesh,&idx)))
MEnt_Set_AttVal(mr,ridatt,++i,0.0,NULL);
fprintf(fp,"vertices\n");
idx = 0;
while ((mv = MESH_Next_Vertex(mesh,&idx))) {
MV_Coords(mv,xyz);
gdim = MV_GEntDim(mv);
gid = MV_GEntID(mv);
fprintf(fp,"%24.16lf %24.16lf %24.16lf %d %d\n",
xyz[0],xyz[1],xyz[2],gdim,gid);
}
if (reptype == R2 || reptype == R4) {
fprintf(fp,"adjvertices\n");
idx = 0;
while ((mv = MESH_Next_Vertex(mesh,&idx))) {
nav = MV_Num_AdjVertices(mv);
fprintf(fp,"%d ",nav);
adjverts = MV_AdjVertices(mv);
for (j = 0; j < nav; j++) {
mv2 = List_Entry(adjverts,j);
MEnt_Get_AttVal(mv2,vidatt,&mvid2,&rval,&pval);
fprintf(fp,"%d ",mvid2);
}
fprintf(fp,"\n");
List_Delete(adjverts);
}
}
if (reptype <= F4 && ne) {
fprintf(fp,"edges\n");
idx = 0;
while ((me = MESH_Next_Edge(mesh,&idx))) {
mv0 = ME_Vertex(me,0);
MEnt_Get_AttVal(mv0,vidatt,&mvid0,&rval,&pval);
mv1 = ME_Vertex(me,1);
MEnt_Get_AttVal(mv1,vidatt,&mvid1,&rval,&pval);
gdim = ME_GEntDim(me);
gid = ME_GEntID(me);
fprintf(fp,"%d %d \t%d %d\n",mvid0,mvid1,gdim,gid);
}
}
if (reptype <= F4) {
/* For full representations, always write out faces in terms of edges */
fprintf(fp,"faces edge\n");
idx = 0;
while ((mf = MESH_Next_Face(mesh,&idx))) {
nfe = MF_Num_Edges(mf);
fprintf(fp,"%d ",nfe);
mfedges = MF_Edges(mf,1,0);
for (j = 0; j < nfe; j++) {
me = List_Entry(mfedges,j);
dir = MF_EdgeDir_i(mf,j);
MEnt_Get_AttVal(me,eidatt,&meid,&rval,&pval);
if (dir != 1) meid = -meid;
fprintf(fp,"%d ",meid);
}
List_Delete(mfedges);
gdim = MF_GEntDim(mf);
/*
gent = MF_GEntity(mf);
gid = gent ? -99 : 0;
*/
gid = MF_GEntID(mf);
fprintf(fp,"\t%d %d\n",gdim,gid);
}
}
else {
/* For reduced representations, R3 and R4 always write out faces
in terms of vertices. For reduced representations, R1 and R2
write out faces in terms of vertices only when there are no
regions (i.e. faces are the highest level mesh entities) */
if ((reptype > R2) || (nr == 0)) {
fprintf(fp,"faces vertex\n");
idx = 0;
while ((mf = MESH_Next_Face(mesh,&idx))) {
nfv = MF_Num_Edges(mf);
fprintf(fp,"%d ",nfv);
mfverts = MF_Vertices(mf,1,0);
for (j = 0; j < nfv; j++) {
mv = List_Entry(mfverts,j);
MEnt_Get_AttVal(mv,vidatt,&mvid,&rval,&pval);
fprintf(fp,"%d ",mvid);
}
List_Delete(mfverts);
gdim = MF_GEntDim(mf);
gid = MF_GEntID(mf);
fprintf(fp,"\t%d %d\n",gdim,gid);
}
}
}
if (nr) {
if (reptype <= F4 || reptype >= R2) {
fprintf(fp,"regions face\n");
idx = 0;
while ((mr = MESH_Next_Region(mesh,&idx))) {
nrf = MR_Num_Faces(mr);
fprintf(fp,"%d ",nrf);
mrfaces = MR_Faces(mr);
for (j = 0; j < nrf; j++) {
mf = List_Entry(mrfaces,j);
dir = MR_FaceDir_i(mr,j);
MEnt_Get_AttVal(mf,fidatt,&mfid,&rval,&pval);
if (dir != 1) mfid = -mfid;
fprintf(fp,"%d ",mfid);
}
List_Delete(mrfaces);
gdim = MF_GEntDim(mr);
gid = MR_GEntID(mr);
fprintf(fp,"\t%d %d\n",gdim,gid);
}
}
else {
fprintf(fp,"regions vertex\n");
idx = 0;
while ((mr = MESH_Next_Region(mesh,&idx))) {
nrv = MR_Num_Vertices(mr);
fprintf(fp,"%d ",nrv);
mrverts = MR_Vertices(mr);
for (j = 0; j < nrv; j++) {
mv = List_Entry(mrverts,j);
MEnt_Get_AttVal(mv,vidatt,&mvid,&rval,&pval);
fprintf(fp,"%d ",mvid);
}
List_Delete(mrverts);
gdim = MR_GEntDim(mr);
gid = MR_GEntID(mr);
fprintf(fp,"\t%d %d\n",gdim,gid);
}
}
if (reptype == R2 || reptype == R4) {
fprintf(fp,"adjregions\n");
idx = 0;
while ((mr = MESH_Next_Region(mesh,&idx))) {
nar = MR_Num_Faces(mr);
fprintf(fp,"%d ",nar);
adjregs = MR_AdjRegions(mr);
for (j = 0; j < nar; j++) {
mr2 = List_Entry(adjregs,j);
if ((long) mr2 == -1)
fprintf(fp,"%d ",0);
else {
MEnt_Get_AttVal(mr2,ridatt,&mrid2,&rval,&pval);
fprintf(fp,"%d ",mrid2);
}
}
fprintf(fp,"\n");
List_Delete(adjregs);
}
}
}
/* Write out attributes if there are more than the 4 that we created
in this routine */
if ((natt = MESH_Num_Attribs(mesh)) > 4) {
fprintf(fp,"attributes\n");
for (i = 0; i < natt; i++) {
attrib = MESH_Attrib(mesh,i);
/* Don't write out attribs we created for the internal use of
this routine */
if (attrib == vidatt || attrib == eidatt || attrib == fidatt ||
attrib == ridatt) continue;
MAttrib_Get_Name(attrib,attname);
atttype = MAttrib_Get_Type(attrib);
if (atttype == POINTER) continue; /* cannot write it out */
ncomp = MAttrib_Get_NumComps(attrib);
attentdim = MAttrib_Get_EntDim(attrib);
/* First count how many entities actually have the attribute assigned */
nent = 0;
switch(attentdim) {
case MVERTEX:
idx = 0;
while ((mv = MESH_Next_Vertex(mesh,&idx)))
if (MEnt_Get_AttVal(mv,attrib,&ival,&rval,&pval)) nent++;
break;
case MEDGE:
idx = 0;
while ((me = MESH_Next_Edge(mesh,&idx)))
if (MEnt_Get_AttVal(me,attrib,&ival,&rval,&pval)) nent++;
break;
case MFACE:
idx = 0;
while ((mf = MESH_Next_Face(mesh,&idx)))
if (MEnt_Get_AttVal(mf,attrib,&ival,&rval,&pval)) nent++;
break;
case MREGION:
idx = 0;
while ((mr = MESH_Next_Region(mesh,&idx)))
if (MEnt_Get_AttVal(mr,attrib,&ival,&rval,&pval)) nent++;
break;
case MALLTYPE:
idx = 0;
while ((mv = MESH_Next_Vertex(mesh,&idx)))
if (MEnt_Get_AttVal(mv,attrib,&ival,&rval,&pval)) nent++;
idx = 0;
while ((me = MESH_Next_Edge(mesh,&idx)))
if (MEnt_Get_AttVal(me,attrib,&ival,&rval,&pval)) nent++;
idx = 0;
while ((mf = MESH_Next_Face(mesh,&idx)))
if (MEnt_Get_AttVal(mf,attrib,&ival,&rval,&pval)) nent++;
idx = 0;
while ((mr = MESH_Next_Region(mesh,&idx)))
if (MEnt_Get_AttVal(mr,attrib,&ival,&rval,&pval)) nent++;
break;
default:
break;
} /* switch (attentdim) */
/* No point in writing out attribute if no entity uses it! Or is there? */
if (!nent) continue;
fprintf(fp,"%-s\n",attname);
switch(atttype) {
case INT:
fprintf(fp,"INT\n");
break;
case DOUBLE:
fprintf(fp,"DOUBLE\n");
break;
case VECTOR:
fprintf(fp,"VECTOR\n");
break;
case TENSOR:
fprintf(fp,"TENSOR\n");
break;
default:
MSTK_Report("MESH_WriteToFile",
"Unrecognizable or unprintable attribute type\n",MSTK_WARN);
continue;
}
fprintf(fp,"%-d\n",ncomp);
switch(attentdim) {
case MVERTEX:
fprintf(fp,"MVERTEX\n");
break;
case MEDGE:
fprintf(fp,"MEDGE\n");
break;
case MFACE:
fprintf(fp,"MFACE\n");
break;
case MREGION:
fprintf(fp,"MREGION\n");
break;
case MALLTYPE:
fprintf(fp,"MALLTYPE\n");
break;
default:
MSTK_Report("Mesh_WriteToFile","Unrecognized entity type",MSTK_WARN);
break;
}
fprintf(fp,"%-d\n",nent);
switch(attentdim) {
case MVERTEX:
idx = 0;
while ((mv = MESH_Next_Vertex(mesh,&idx))) {
if (MEnt_Get_AttVal(mv,attrib,&ival,&rval,&pval)) {
MEnt_Get_AttVal(mv,vidatt,&mvid,&rdummy,&pdummy);
fprintf(fp,"0 %-d ",mvid);
switch (atttype) {
case INT:
fprintf(fp," %-d",ival);
break;
case DOUBLE:
fprintf(fp," %-lf ",rval);
break;
case VECTOR: case TENSOR:
rval_arr = (double *) pval;
for (k = 0; k < ncomp; k++)
fprintf(fp," %-lf ",rval_arr[k]);
break;
default:
break;
}
fprintf(fp,"\n");
}
}
break;
case MEDGE:
idx = 0;
while ((me = MESH_Next_Edge(mesh,&idx))) {
if (MEnt_Get_AttVal(me,attrib,&ival,&rval,&pval)) {
MEnt_Get_AttVal(me,eidatt,&meid,&rdummy,&pdummy);
fprintf(fp,"1 %-d ",meid);
switch (atttype) {
case INT:
fprintf(fp," %-d",ival);
break;
case DOUBLE:
fprintf(fp," %-lf ",rval);
break;
case VECTOR: case TENSOR:
rval_arr = (double *) pval;
for (k = 0; k < ncomp; k++)
fprintf(fp," %-lf ",rval_arr[k]);
break;
default:
break;
}
fprintf(fp,"\n");
}
}
break;
case MFACE:
idx = 0;
while ((mf = MESH_Next_Face(mesh,&idx))) {
if (MEnt_Get_AttVal(mf,attrib,&ival,&rval,&pval)) {
MEnt_Get_AttVal(mf,fidatt,&mfid,&rdummy,&pdummy);
fprintf(fp,"2 %-d ",mfid);
switch (atttype) {
case INT:
fprintf(fp," %-d",ival);
break;
case DOUBLE:
fprintf(fp," %-lf ",rval);
break;
case VECTOR: case TENSOR:
rval_arr = (double *) pval;
for (k = 0; k < ncomp; k++)
fprintf(fp," %-lf ",rval_arr[k]);
break;
default:
break;
}
fprintf(fp,"\n");
}
}
break;
case MREGION:
idx = 0;
while ((mr = MESH_Next_Region(mesh,&idx))) {
if (MEnt_Get_AttVal(mr,attrib,&ival,&rval,&pval)) {
MEnt_Get_AttVal(mr,ridatt,&mrid,&rdummy,&pdummy);
fprintf(fp,"3 %-d ",mrid);
switch (atttype) {
case INT:
fprintf(fp," %-d",ival);
break;
case DOUBLE:
fprintf(fp," %-lf ",rval);
break;
case VECTOR: case TENSOR:
rval_arr = (double *) pval;
for (k = 0; k < ncomp; k++)
fprintf(fp," %-lf ",rval_arr[k]);
break;
default:
break;
}
fprintf(fp,"\n");
}
}
break;
case MALLTYPE:
idx = 0;
while ((mv = MESH_Next_Vertex(mesh,&idx))) {
if (MEnt_Get_AttVal(mv,attrib,&ival,&rval,&pval)) {
MEnt_Get_AttVal(mv,vidatt,&mvid,&rdummy,&pdummy);
fprintf(fp,"0 %-d ",mvid);
switch (atttype) {
case INT:
fprintf(fp," %-d",ival);
break;
case DOUBLE:
fprintf(fp," %-lf ",rval);
break;
case VECTOR: case TENSOR:
rval_arr = (double *) pval;
for (k = 0; k < ncomp; k++)
fprintf(fp," %-lf ",rval_arr[k]);
break;
default:
break;
}
fprintf(fp,"\n");
}
}
idx = 0;
while ((me = MESH_Next_Edge(mesh,&idx))) {
if (MEnt_Get_AttVal(me,attrib,&ival,&rval,&pval)) {
MEnt_Get_AttVal(me,eidatt,&meid,&rdummy,&pdummy);
fprintf(fp,"1 %-d ",meid);
switch (atttype) {
case INT:
fprintf(fp," %-d",ival);
break;
case DOUBLE:
fprintf(fp," %-lf ",rval);
break;
case VECTOR: case TENSOR:
rval_arr = (double *) pval;
for (k = 0; k < ncomp; k++)
fprintf(fp," %-lf ",rval_arr[k]);
break;
default:
break;
}
fprintf(fp,"\n");
}
}
idx = 0;
while ((mf = MESH_Next_Face(mesh,&idx))) {
if (MEnt_Get_AttVal(mf,attrib,&ival,&rval,&pval)) {
MEnt_Get_AttVal(mf,fidatt,&mfid,&rdummy,&pdummy);
fprintf(fp,"2 %-d ",mfid);
switch (atttype) {
case INT:
fprintf(fp," %-d",ival);
break;
case DOUBLE:
fprintf(fp," %-lf ",rval);
break;
case VECTOR: case TENSOR:
rval_arr = (double *) pval;
for (k = 0; k < ncomp; k++)
fprintf(fp," %-lf ",rval_arr[k]);
break;
default:
break;
}
fprintf(fp,"\n");
}
}
idx = 0;
while ((mr = MESH_Next_Region(mesh,&idx))) {
if (MEnt_Get_AttVal(mr,attrib,&ival,&rval,&pval)) {
MEnt_Get_AttVal(mr,ridatt,&mrid,&rdummy,&pdummy);
fprintf(fp,"3 %-d ",mrid);
switch (atttype) {
case INT:
fprintf(fp," %-d",ival);
break;
case DOUBLE:
fprintf(fp," %-lf ",rval);
break;
case VECTOR: case TENSOR:
rval_arr = (double *) pval;
for (k = 0; k < ncomp; k++)
fprintf(fp," %-lf ",rval_arr[k]);
break;
default:
break;
}
fprintf(fp,"\n");
}
}
break;
default:
break;
} /* switch (attentdim) */
} /* for (i = 0; i < natt) */
} /* if (Mesh_Num_Attribs(mesh)) */
idx = 0; i = 0;
while ((mv = MESH_Next_Vertex(mesh,&idx)))
MEnt_Rem_AttVal(mv,vidatt);
idx = 0; i = 0;
while ((me = MESH_Next_Edge(mesh,&idx)))
MEnt_Rem_AttVal(me,eidatt);
idx = 0; i = 0;
while ((mf = MESH_Next_Face(mesh,&idx)))
MEnt_Rem_AttVal(mf,fidatt);
idx = 0; i = 0;
while ((mr = MESH_Next_Region(mesh,&idx)))
MEnt_Rem_AttVal(mr,ridatt);
MAttrib_Delete(vidatt);
MAttrib_Delete(eidatt);
MAttrib_Delete(fidatt);
MAttrib_Delete(ridatt);
fclose(fp);
return 1;
}
int MF_Set_GInfo_Auto_R2(MFace_ptr f) {
int i, same, nv, fgdim, fgid, vgdim, vgid, vgdim0, vgid0;
MVertex_ptr v;
MFace_Adj_R2 *adj;
adj = (MFace_Adj_R2 *) f->adj;
nv = List_Num_Entries(adj->fvertices);
same = 1;
fgdim = -1;
fgid = -1;
vgid = -1;
v = List_Entry(adj->fvertices,0);
vgid0 = MV_GEntID(v);
vgdim0 = MV_GEntDim(v);
for (i = 1; i < nv; i++) {
v = List_Entry(adj->fvertices,i);
vgid = MV_GEntID(v);
vgdim = MV_GEntDim(v);
if (vgdim == vgdim0 && vgid == vgid0)
continue; /* all vertices have same classification so far */
else {
same = 0;
break;
}
}
if (same) {
fgdim = vgdim0;
fgid = vgid;
}
if (fgdim == -1 || fgdim < 2) {
List_ptr fregions;
/* We are unable to find proper classification info from the
vertices. Lets look at the number of regions connected to the
face and their classification */
fregions = MF_Regions(f);
if (fregions == NULL || List_Num_Entries(fregions) == 1) {
/* In a complete mesh, this face must be on a model face */
fgdim = 2;
}
else {
MRegion_ptr fregion0, fregion1;
int rgid0, rgid1;
/* Internal face. Check if it is a mesh region or on an
interior interface */
fregion0 = List_Entry(fregions,0); rgid0 = MEnt_GEntID(fregion0);
fregion1 = List_Entry(fregions,1); rgid1 = MEnt_GEntID(fregion1);
if (rgid0 == -1 || rgid1 == -1) {
/* One of the regions is not classified properly. Just
assume this is an internal face */
fgdim = 3;
}
else {
fgdim = (rgid0 == rgid1) ? 3 : 2;
}
}
if (fregions) List_Delete(fregions);
}
MEnt_Set_GEntDim((MEntity_ptr) f,fgdim);
MEnt_Set_GEntID((MEntity_ptr) f,fgid);
if (fgdim == 4)
return 0;
else
return 1;
}
int MESH_Send_Vertices(Mesh_ptr mesh, int torank, MSTK_Comm comm,
int *numreq, int *maxreq, MPI_Request **requests,
int *numptrs2free, int *maxptrs2free,
void ***ptrs2free) {
int i, j, nv;
MVertex_ptr mv;
double coor[3];
MPI_Request mpirequest;
if (requests == NULL)
MSTK_Report("MESH_Surf_SendMesh","MPI requests array is NULL",MSTK_FATAL);
if (*maxreq == 0) {
*maxreq = 25;
*requests = (MPI_Request *) malloc(*maxreq*sizeof(MPI_Request));
*numreq = 0;
}
else if (*maxreq < (*numreq) + 11) {
*maxreq = 2*(*maxreq) + 11;
*requests = (MPI_Request *) realloc(*requests,*maxreq*sizeof(MPI_Request));
}
/* Now send out detailed vertex info */
nv = MESH_Num_Vertices(mesh);
int *list_vertex = (int *) malloc(3*nv*sizeof(int));
/* Store the 3 auxilliary data fields - would be nice if we didn't
* have to send the data in such an error prone way (with bit
* shifting) that requires knowledge of the internal structure of
* MEntity */
for(i = 0; i < nv; i++) {
mv = MESH_Vertex(mesh,i);
list_vertex[3*i] = (MV_GEntID(mv)<<3) | (MV_GEntDim(mv));
list_vertex[3*i+1] = (MV_MasterParID(mv) <<3) | MV_OnParBoundary(mv)<<2 | (MV_PType(mv));
list_vertex[3*i+2] = MV_GlobalID(mv);
}
/* send vertices */
MPI_Isend(list_vertex,3*nv,MPI_INT,torank,torank,comm,&mpirequest);
(*requests)[*numreq] = mpirequest;
(*numreq)++;;
int nptrs = 1;
if (*maxptrs2free == 0) {
*maxptrs2free = 25;
*ptrs2free = (void **) malloc(*maxptrs2free*sizeof(void *));
*numptrs2free = 0;
}
else if (*maxptrs2free < (*numptrs2free) + nptrs) {
*maxptrs2free = 2*(*maxptrs2free) + nptrs;
*ptrs2free = (void **) realloc(*ptrs2free,(*maxptrs2free)*sizeof(void *));
}
(*ptrs2free)[(*numptrs2free)++] = list_vertex;
return 1;
}