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_AssignGlobalIDs_Vertex(Mesh_ptr submesh, int have_GIDs, MSTK_Comm comm) {
int i, j, nv, nbv, ne, nf, nr, mesh_info[10];
MVertex_ptr mv;
List_ptr boundary_verts;
RepType rtype;
int index_nbv, max_nbv, iloc, num_ghost_verts, global_id;
int *global_mesh_info, *vertex_ov_label, *vertex_ov_global_id, *id_on_ov_list;
int rank, num;
MPI_Comm_rank(comm,&rank);
MPI_Comm_size(comm,&num);
for (i = 0; i < 10; i++) mesh_info[i] = 0;
rtype = MESH_RepType(submesh);
nv = MESH_Num_Vertices(submesh);
ne = MESH_Num_Edges(submesh);
nf = MESH_Num_Faces(submesh);
nr = MESH_Num_Regions(submesh);
mesh_info[0] = rtype;
mesh_info[1] = nv;
mesh_info[2] = ne;
mesh_info[3] = nf;
mesh_info[4] = nr;
/* calculate number of boundary vertices */
nbv = 0; boundary_verts = List_New(10);
if (nr) {
for(i = 0; i < nv; i++) {
mv = MESH_Vertex(submesh,i);
if (vertex_on_boundary3D(mv)) {
MV_Flag_OnParBoundary(mv);
List_Add(boundary_verts,mv);
nbv++;
}
}
}
else {
for(i = 0; i < nv; i++) {
mv = MESH_Vertex(submesh,i);
if (vertex_on_boundary2D(mv)) {
MV_Flag_OnParBoundary(mv);
List_Add(boundary_verts,mv);
nbv++;
}
}
}
mesh_info[5] = nbv;
/*
gather submeshes information
right now we only need nv and nbv, and later num_ghost_verts, but we gather all mesh_info
*/
global_mesh_info = (int *)malloc(10*num*sizeof(int));
MPI_Allgather(mesh_info,10,MPI_INT,global_mesh_info,10,MPI_INT,comm);
/* get largest number of boundary vertices of all the processors */
max_nbv = 0;
for(i = 0; i < num; i++)
if(max_nbv < global_mesh_info[10*i+5])
max_nbv = global_mesh_info[10*i+5];
if (have_GIDs) {
int *list_boundary_vertex_gid = (int *)malloc(max_nbv*sizeof(int));
int *recv_list_vertex_gid = (int *)malloc(num*max_nbv*sizeof(int));
/* sort boundary vertices based on Global ID, for binary search */
List_Sort(boundary_verts,nbv,sizeof(MVertex_ptr),compareGlobalID);
/* only global ids are sent */
index_nbv = 0;
for(i = 0; i < nbv; i++) {
mv = List_Entry(boundary_verts,i);
list_boundary_vertex_gid[index_nbv] = MV_GlobalID(mv);
index_nbv++;
}
MPI_Allgather(list_boundary_vertex_gid,max_nbv,MPI_INT,recv_list_vertex_gid,max_nbv,MPI_INT,comm);
/* indicate if a vertex is overlapped */
vertex_ov_label = (int *)malloc(num*max_nbv*sizeof(int));
/*
store the local boundary id on ov processor
it is used to assign global id of local ghost vertices
no need to store master partition id, MV_MasterParID(mv) is already assigned
*/
id_on_ov_list = (int *)malloc(max_nbv*sizeof(int));
for (i = 0; i < num*max_nbv; i++)
vertex_ov_label[i] = 0;
num_ghost_verts = 0;
/* for processor other than 0 */
if(rank > 0) {
for(i = 0; i < nbv; i++) {
mv = List_Entry(boundary_verts,i);
int gid = MV_GlobalID(mv);
/* check which previous processor has a vertex with same Global ID*/
for(j = 0; j < rank; j++) {
/* since each processor has sorted the boundary vertices, use binary search */
int *loc = (int *)bsearch(&gid,
&recv_list_vertex_gid[max_nbv*j],
global_mesh_info[10*j+5],
sizeof(int),
compareINT);
/* if found the vertex on previous processors */
if(loc) {
/* here the location iloc is relative to the beginning of the jth processor */
iloc = (int)(loc - &recv_list_vertex_gid[max_nbv*j]);
MV_Set_PType(mv,PGHOST);
MV_Set_MasterParID(mv,j);
num_ghost_verts++;
/* label the original vertex as overlapped */
vertex_ov_label[max_nbv*j+iloc] |= 1;
id_on_ov_list[i] = iloc;
/* if found on processor j, no need to test for j+1,j+2...*/
break;
}
}
}
}
free(list_boundary_vertex_gid);
free(recv_list_vertex_gid);
}
else {
double coor[3];
int *list_boundary_vertex = (int *)malloc(max_nbv*sizeof(int));
double *list_boundary_coor = (double *)malloc(3*max_nbv*sizeof(double));
int *recv_list_vertex = (int *)malloc(num*max_nbv*sizeof(int));
double *recv_list_coor = (double *)malloc(3*num*max_nbv*sizeof(double));
/* sort boundary vertices based on coordinate value, for binary search */
List_Sort(boundary_verts,nbv,sizeof(MVertex_ptr),compareVertexCoor);
/* only local id and coordinate values are sent */
index_nbv = 0;
for(i = 0; i < nbv; i++) {
mv = List_Entry(boundary_verts,i);
list_boundary_vertex[index_nbv] = MV_ID(mv);
MV_Coords(mv,coor);
list_boundary_coor[index_nbv*3] = coor[0];
list_boundary_coor[index_nbv*3+1] = coor[1];
list_boundary_coor[index_nbv*3+2] = coor[2];
index_nbv++;
}
MPI_Allgather(list_boundary_vertex,max_nbv,MPI_INT,recv_list_vertex,max_nbv,MPI_INT,comm);
MPI_Allgather(list_boundary_coor,3*max_nbv,MPI_DOUBLE,recv_list_coor,3*max_nbv,MPI_DOUBLE,comm);
/* indicate if a vertex is overlapped */
vertex_ov_label = (int *)malloc(num*max_nbv*sizeof(int));
/*
store the local boundary id on ov processor
it is used to assign global id of local ghost vertices
no need to store master partition id, MV_MasterParID(mv) is already assigned
*/
id_on_ov_list = (int *)malloc(max_nbv*sizeof(int));
for (i = 0; i < num*max_nbv; i++)
vertex_ov_label[i] = 0;
num_ghost_verts = 0;
/* for processor other than 0 */
if(rank > 0) {
for(i = 0; i < nbv; i++) {
mv = List_Entry(boundary_verts,i);
MV_Coords(mv,coor);
/* check which previous processor has the same coordinate vertex */
for(j = 0; j < rank; j++) {
/* since each processor has sorted the boundary vertices, use binary search */
double *loc = (double *)bsearch(&coor,
&recv_list_coor[3*max_nbv*j],
global_mesh_info[10*j+5],
3*sizeof(double),
compareCoorDouble);
/* if found the vertex on previous processors */
if(loc) {
/* here the location iloc is relative to the beginning of the jth processor */
iloc = (int)(loc - &recv_list_coor[3*max_nbv*j])/3;
MV_Set_PType(mv,PGHOST);
MV_Set_MasterParID(mv,j);
num_ghost_verts++;
/* label the original vertex as overlapped */
vertex_ov_label[max_nbv*j+iloc] |= 1;
id_on_ov_list[i] = iloc;
/* if found on processor j, no need to test for j+1,j+2...*/
break;
}
}
}
}
free(list_boundary_coor);
free(recv_list_coor);
free(list_boundary_vertex);
free(recv_list_vertex);
}
/* num of ghost verts */
mesh_info[9] = num_ghost_verts;
/* update ghost verts number */
MPI_Allgather(mesh_info,10,MPI_INT,global_mesh_info,10,MPI_INT,comm);
/* since this is a OR reduction, we can use MPI_IN_PLACE, send buffer same as recv buffer */
MPI_Allreduce(MPI_IN_PLACE,vertex_ov_label,num*max_nbv,MPI_INT,MPI_LOR,comm);
/* calculate starting global id number for vertices*/
if (!have_GIDs) {
global_id = 1;
for(i = 0; i < rank; i++)
global_id = global_id + global_mesh_info[10*i+1] - global_mesh_info[10*i+9];
for(i = 0; i < nv; i++) {
mv = MESH_Vertex(submesh,i);
if (MV_PType(mv) == PGHOST)
continue;
MV_Set_GlobalID(mv,global_id++);
MV_Set_MasterParID(mv,rank);
}
}
/* store overlapped vertices IDs and broadast */
vertex_ov_global_id = (int *)malloc(num*max_nbv*sizeof(int));
for(i = 0; i < num*max_nbv; i++)
vertex_ov_global_id[i] = 0;
for(i = 0; i < nbv; i++) {
if(vertex_ov_label[rank*max_nbv+i]) {
mv = List_Entry(boundary_verts,i);
MV_Set_PType(mv,POVERLAP);
vertex_ov_global_id[rank*max_nbv+i] = MV_GlobalID(mv);
}
}
MPI_Allreduce(MPI_IN_PLACE,vertex_ov_global_id,num*max_nbv,MPI_INT,MPI_MAX,comm);
for(i = 0; i < nbv; i++) {
mv = List_Entry(boundary_verts,i);
if(MV_PType(mv) == PGHOST)
MV_Set_GlobalID(mv,vertex_ov_global_id[MV_MasterParID(mv)*max_nbv+id_on_ov_list[i]]);
}
List_Delete(boundary_verts);
free(global_mesh_info);
free(vertex_ov_label);
free(vertex_ov_global_id);
free(id_on_ov_list);
return 1;
}
UBasicVolume::VolumeType* ImportMagicaVoxel(FArchive& Ar)
{
// https://voxel.codeplex.com/wikipage?title=Sample%20Codes
//auto* Result = new RawVolume(region);
//return Result;
const int MV_VERSION = 150;
const int ID_VOX = MV_ID('V', 'O', 'X', ' ');
const int ID_MAIN = MV_ID('M', 'A', 'I', 'N');
const int ID_SIZE = MV_ID('S', 'I', 'Z', 'E');
const int ID_XYZI = MV_ID('X', 'Y', 'Z', 'I');
const int ID_RGBA = MV_ID('R', 'G', 'B', 'A');
int32 magic;
int32 version;
// magic number
Ar << magic;
if (magic != ID_VOX)
{
UE_LOG(LogVoreealVolumeImporter, Warning, TEXT("magic number does not match"));
return nullptr;
}
// version
Ar << version;
if (version != MV_VERSION)
{
UE_LOG(LogVoreealVolumeImporter, Warning, TEXT("version does not match"));
return nullptr;
}
// main chunk
vox_chunk_t mainChunk;
ReadChunk(Ar, mainChunk);
if (mainChunk.id != ID_MAIN)
{
UE_LOG(LogVoreealVolumeImporter, Warning, TEXT("main chunk is not found"));
return nullptr;
}
bool isCustomPalette;
MV_RGBA palette[256];
MV_Voxel* voxels = nullptr;
int32 sizex = 0, sizey = 0, sizez = 0, numVoxels = 0;
while (!Ar.AtEnd())
{
// read chunk header
vox_chunk_t sub;
ReadChunk(Ar, sub);
if (sub.id == ID_SIZE)
{
// size
Ar << sizex << sizey << sizez;
}
else if (sub.id == ID_XYZI)
{
// numVoxels
Ar << numVoxels;
if (numVoxels < 0)
{
UE_LOG(LogVoreealVolumeImporter, Warning, TEXT("negative number of voxels"));
return nullptr;
}
// voxels
if (numVoxels > 0)
{
voxels = new MV_Voxel[numVoxels];
Ar.Serialize(voxels, sizeof(MV_Voxel) * numVoxels);
}
}
else if (sub.id == ID_RGBA)
{
// last color is not used, so we only need to read 255 colors
isCustomPalette = true;
Ar.Serialize(palette + 1, sizeof(MV_RGBA) * 255);
// NOTICE : skip the last reserved color
MV_RGBA reserved;
Ar.Serialize(&reserved, sizeof(MV_RGBA));
}
}
PolyVox::Region region;
region.setLowerCorner(PolyVox::Vector3DInt32(0, 0, 0));
region.setUpperCorner(PolyVox::Vector3DInt32(sizex, sizey, sizez));
auto* Result = new UBasicVolume::VolumeType(region);
for (int32 i = 0; i < numVoxels; i++)
{
auto voxel = voxels[i];
auto color = palette[voxel.colorIndex];
uint32 data =
(color.r) |
(color.g) << 8 |
(color.b) << 16 |
(color.a) << 24;
Result->setVoxel(voxel.x, voxel.y, voxel.z, data);
}
delete[] voxels;
//// print model info
//printf("[Log] MV_VoxelModel :: Model : %d %d %d : %d\n",
// sizex, sizey, sizez, numVoxels
// );
return Result;
}
int MESH_Send_NonVertexEntities_FN(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, ne, nf, nr;
int nevs, nfes, nrfs, nfe, nrv, nrf, dir;
int maxnfe, maxnrf;
int *mesh_info;
int *list_edge=NULL, *list_face=NULL, *list_region=NULL;
MVertex_ptr mv;
MEdge_ptr me;
MFace_ptr mf;
MRegion_ptr mr;
List_ptr mfedges, mrfaces, mrverts;
RepType rtype;
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) + 13) {
*maxreq = 2*(*maxreq) + 11;
*requests = (MPI_Request *) realloc(*requests,*maxreq*sizeof(MPI_Request));
}
ne = MESH_Num_Edges(mesh);
nf = MESH_Num_Faces(mesh);
nr = MESH_Num_Regions(mesh);
/* some other known quantitites - 5 items per edge (2 for verts
and 3 for extra data), maxnfe+4 items per face (1 for number of
edges, maxnfe for edge indices, anad 3 for extra data),
maxnrf+4 items per region (1 for number of faces, maxnrf for
face indices and 3 for extra data */
maxnfe = 0;
for (i = 0; i < nf; i++) {
mf = MESH_Face(mesh,i);
nfe = MF_Num_Edges(mf);
if (nfe > maxnfe)
maxnfe = nfe;
}
maxnrf = 0;
for (i = 0; i < nr; i++) {
mr = MESH_Region(mesh,i);
nrf = MR_Num_Faces(mr);
if (nrf > maxnrf)
maxnrf = nrf;
}
// The amount of extra info we are sending and their meaning is obviously
// known on the receiving side too. So nevs, nfes and nrfs can be
// calculated without us sending it
nevs = (2+3)*ne;
nfes = (1 + maxnfe + 3)*nf;
nrfs = (1 + maxnrf + 3)*nr;
/* Reserve nevs spots for each edge */
list_edge = (int *) malloc(5*ne*sizeof(int));
nevs = 0;
/* Store the vertex ids, then the 3 auxilliary data fields */
for(i = 0; i < ne; i++) {
me = MESH_Edge(mesh,i);
list_edge[nevs] = MV_ID(ME_Vertex(me,0));
list_edge[nevs+1] = MV_ID(ME_Vertex(me,1));
list_edge[nevs+2] = (ME_GEntID(me)<<3) | (ME_GEntDim(me));
list_edge[nevs+3] = (ME_MasterParID(me) <<3) | (ME_OnParBoundary(me)<<2) | (ME_PType(me));
list_edge[nevs+4] = ME_GlobalID(me);
nevs += 5;
}
/* send detailed edge info */
MPI_Isend(list_edge,nevs,MPI_INT,torank,torank,comm,&mpirequest);
(*requests)[*numreq] = mpirequest;
(*numreq)++;
/* Reserve nfes spots for each face */
list_face = (int *) malloc(nfes*sizeof(int));
nfes = 0;
/* first store nfe, then the edge ids, then the 3 auxilliary data fields */
for(i = 0; i < nf; i++) {
mf = MESH_Face(mesh,i);
mfedges = MF_Edges(mf,1,0);
nfe = List_Num_Entries(mfedges);
list_face[nfes] = nfe;
for(j = 0; j < nfe; j++) {
dir = MF_EdgeDir_i(mf,j) ? 1 : -1;
list_face[nfes+j+1] = dir*ME_ID(List_Entry(mfedges,j));
}
list_face[nfes+nfe+1] = (MF_GEntID(mf)<<3) | (MF_GEntDim(mf));
list_face[nfes+nfe+2] = (MF_MasterParID(mf)<<3) | (MF_OnParBoundary(mf)<<2) | (MF_PType(mf));
list_face[nfes+nfe+3] = MF_GlobalID(mf);
nfes += (nfe + 4);
List_Delete(mfedges);
}
/* send detailed face info */
MPI_Isend(list_face,nfes,MPI_INT,torank,torank,comm,&mpirequest);
(*requests)[*numreq] = mpirequest;
(*numreq)++;
if (nr) {
list_region = (int *) malloc(nrfs*sizeof(int));
nrfs = 0;
/* first store nrf, then the face ids, then the 3 auxilliary data fields */
for(i = 0; i < nr; i++) {
mr = MESH_Region(mesh,i);
mrfaces = MR_Faces(mr);
nrf = List_Num_Entries(mrfaces);
list_region[nrfs] = nrf;
for(j = 0; j < nrf; j++) {
dir = MR_FaceDir_i(mr,j) == 1 ? 1 : -1;
list_region[nrfs+j+1] = dir*MF_ID(List_Entry(mrfaces,j));
}
list_region[nrfs+nrf+1] = (MR_GEntID(mr)<<3) | (MR_GEntDim(mr));
list_region[nrfs+nrf+2] = (MR_MasterParID(mr)<<3) | (MR_PType(mr)); /* MR_PType is 2 bits; 3 bit is 0 */
list_region[nrfs+nrf+3] = MR_GlobalID(mr);
nrfs += (nrf + 4);
List_Delete(mrfaces);
}
/* send detailed region info */
MPI_Isend(list_region,nrfs,MPI_INT,torank,torank,comm,&mpirequest);
(*requests)[*numreq] = mpirequest;
(*numreq)++;
}
/* collect allocated memory so it can be freed in a higher level
routine after MPI_Waitall or MPI_Test has ensured that the send
has been completed */
if (ptrs2free == NULL)
MSTK_Report("MESH_Surf_SendMesh_FN","ptrs2free array is NULL",MSTK_FATAL);
int nptrs = 3;
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 *));
}
if (ne)
(*ptrs2free)[(*numptrs2free)++] = list_edge;
if (nf)
(*ptrs2free)[(*numptrs2free)++] = list_face;
if (nr)
(*ptrs2free)[(*numptrs2free)++] = list_region;
return 1;
}