int MESH_ConcatSubMesh_Region(Mesh_ptr mesh, int num, Mesh_ptr *submeshes) {
int nrf, nre, nrv, nfe, i, j, k, num_parbndry_verts, num_parbndry_edges, num_parbndry_faces, ival;
MVertex_ptr mv, new_mv, sub_mv;
MEdge_ptr me, new_me, sub_me;
MFace_ptr mf, new_mf, sub_mf;
MRegion_ptr new_mr, sub_mr;
List_ptr mrfaces, mredges, mrverts, mfedges;
int add_region, 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);
List_ptr parbndry_faces = List_New(10);
MFace_ptr *rfaces = (MFace_ptr *) malloc(MAXPF3*sizeof(MFace_ptr));
int *rfdirs = (int *) malloc(MAXPF3*sizeof(int));
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 faces, edges and vertices on the partition boundary */
idx = 0; num_parbndry_faces = 0;
while ((mf = MESH_Next_Face(mesh,&idx)))
if (MF_PType(mf) != PINTERIOR) {
List_Add(parbndry_faces,mf);
num_parbndry_faces++;
}
idx = 0; num_parbndry_edges = 0;
while ((me = MESH_Next_Edge(mesh,&idx)))
if (ME_PType(me) != PINTERIOR) {
List_Add(parbndry_edges,me);
num_parbndry_edges++;
}
idx = 0; num_parbndry_verts = 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_faces,num_parbndry_faces,sizeof(MFace_ptr),compareGlobalID);
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));
int *parbndry_face_gids = (int *)malloc(num_parbndry_faces*sizeof(int));
/* store them in array for binary search */
for (i = 0; i < num_parbndry_faces; i++) {
mf = List_Entry(parbndry_faces,i);
parbndry_face_gids[i] = MF_GlobalID(mf);
}
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, max_fnew = 0;
for (i = 0; i < num; i++) {
max_vnew += MESH_Num_Vertices(submeshes[i]);
max_enew += MESH_Num_Edges(submeshes[i]);
max_fnew += MESH_Num_Faces(submeshes[i]);
}
int num_new_verts = 0, num_new_edges = 0, num_new_faces = 0;
int *new_vert_gids = (int *) malloc(max_vnew*sizeof(int));
int *new_edge_gids = (int *) malloc(max_enew*sizeof(int));
int *new_face_gids = (int *) malloc(max_fnew*sizeof(int));
List_ptr new_verts = List_New(max_vnew);
List_ptr new_edges = List_New(max_enew);
List_ptr new_faces = List_New(max_fnew);
/* 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);
MAttrib_ptr fidatt = MAttrib_New(submesh, "tempfid", POINTER, MFACE);
idx = 0;
while ((sub_mr = MESH_Next_Region(submesh, &idx))) {
add_region = 0;
/* Find matching vertices between submesh and main mesh */
mrverts = MR_Vertices(sub_mr);
nrv = List_Num_Entries(mrverts);
for (j = 0; j < nrv; j++) {
sub_mv = List_Entry(mrverts,j);
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_region = 1;
} else {
/* Does the global ID of this vertex of the sub mesh region
* match the global ID of a 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) {
add_region = 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(mrverts);
/* Find matching edges between submesh and main mesh */
mredges = MR_Edges(sub_mr);
nre = List_Num_Entries(mredges);
for (j = 0; j < nre; j++) {
sub_me = List_Entry(mredges,j);
/* Does the edge already have a counterpart in 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 region
* match the global ID of a 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) {
add_region = 1;
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);
}
}
}
List_Delete(mredges);
/* Find matching faces between submesh and main mesh */
mrfaces = MR_Faces(sub_mr);
nrf = List_Num_Entries(mrfaces);
for (j = 0; j < nrf; j++) {
sub_mf = List_Entry(mrfaces,j);
MEnt_Get_AttVal(sub_mf, fidatt, &ival, &rval, &mf);
if (!mf) {
/* Does the global ID of this face of the sub mesh region
* match the global ID of a boundary face in the main
* mesh? */
global_id = MF_GlobalID(sub_mf);
loc = (int *) bsearch(&global_id, parbndry_face_gids, num_parbndry_faces, sizeof(int),
compareINT);
if (loc) {
iloc = loc - parbndry_face_gids;
mf = List_Entry(parbndry_faces,iloc);
/* here set the ghost edge property, only necessary when the input submeshes are not consistent */
if (MF_PType(mf) == PGHOST && MF_PType(sub_mf) != PGHOST) {
MF_Set_GEntDim(mf,MF_GEntDim(sub_mf));
MF_Set_GEntID(mf,MF_GEntID(sub_mf));
}
MEnt_Set_AttVal(sub_mf, fidatt, 0, 0.0, mf);
}
}
}
if (!add_region) {
List_Delete(mrfaces);
continue;
}
new_mr = MR_New(mesh); /* add region */
MR_Set_GEntDim(new_mr,MR_GEntDim(sub_mr));
MR_Set_GEntID(new_mr,MR_GEntID(sub_mr));
MR_Set_PType(new_mr,PGHOST);
MR_Set_MasterParID(new_mr,MR_MasterParID(sub_mr));
MR_Set_GlobalID(new_mr,MR_GlobalID(sub_mr));
nrf = List_Num_Entries(mrfaces);
int i2;
for(i2 = 0; i2 < nrf; i2++) {
sub_mf = List_Entry(mrfaces,i2);
global_id = MF_GlobalID(sub_mf);
rfdirs[i2] = MR_FaceDir_i(sub_mr,i2) == 1 ? 1 : 0;
new_mf = NULL;
MEnt_Get_AttVal(sub_mf, fidatt, &ival, &rval, &new_mf);
if (!new_mf) {
/* search in the ghost layer if another face with
* this global ID has been added */
loc = (int *) bsearch(&global_id, new_face_gids, num_new_faces,
sizeof(int), compareINT);
if (loc) {
iloc = loc - new_face_gids;
new_mf = List_Entry(new_faces, iloc);
MEnt_Set_AttVal(sub_mf, fidatt, 0, 0.0, new_mf);
}
}
if (new_mf) {
List_ptr mfverts = MF_Vertices(sub_mf,1,0);
int fvgid0[2];
fvgid0[0] = MF_GlobalID(List_Entry(mfverts,0));
fvgid0[1] = MF_GlobalID(List_Entry(mfverts,1));
List_Delete(mfverts);
mfverts = MF_Vertices(new_mf,1,0);
int nfv = List_Num_Entries(mfverts);
int fvgid1[MAXPV2];
for (j = 0; j < nfv; j++)
fvgid1[j] = MF_GlobalID(List_Entry(mfverts,j));
List_Delete(mfverts);
for (j = 0; j < nfv; j++) {
if (fvgid1[j] == fvgid0[0]) {
if (fvgid1[(j+nfv-1)%nfv] == fvgid0[1]) /* reverse dir */
rfdirs[i2] = !rfdirs[i2];
break;
}
}
}
else { /* add a new face to main mesh */
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));
MEnt_Set_AttVal(sub_mf, fidatt, 0, 0.0, new_mf);
List_Add(new_faces, new_mf);
mfedges = MF_Edges(sub_mf,1,0);
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); /* add new edge and copy information */
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 new vertex to main mesh */
new_mv = MV_New(mesh); /* add new vertex and copy information */
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);
}
rfaces[i2] = new_mf;
}
MR_Set_Faces(new_mr,nrf,rfaces,rfdirs); /* set region-face */
List_Delete(mrfaces);
}
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);
idx = 0;
while ((sub_mf = MESH_Next_Face(submesh, &idx)))
MEnt_Rem_AttVal(sub_mf, fidatt);
MAttrib_Delete(fidatt);
/* Sort the added entity lists by GlobalID */
num_new_faces = List_Num_Entries(new_faces);
List_Sort(new_faces, num_new_faces, sizeof(MFace_ptr), compareGlobalID);
for (j = 0; j < num_new_faces; j++)
new_face_gids[j] = MF_GlobalID(List_Entry(new_faces, j));
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_faces);
List_Delete(parbndry_edges);
List_Delete(parbndry_verts);
List_Delete(new_faces);
List_Delete(new_edges);
List_Delete(new_verts);
free(parbndry_vert_gids);
free(parbndry_edge_gids);
free(parbndry_face_gids);
free(new_face_gids);
free(new_edge_gids);
free(new_vert_gids);
free(fedges);
free(fedirs);
free(rfaces);
free(rfdirs);
return 1;
}
MFace_ptr MR_Split_with_EdgeLoop(MRegion_ptr rsplit, int nfe, MEdge_ptr *fedges) {
Mesh_ptr mesh;
int i, j, idx1, idx2, fedirs[MAXPV2], rfdir_adj, curdir, edir, edir_adj;;
int gid, mkid, nrf1, nrf2, rfdirs1[MAXPF3], rfdirs2[MAXPF3];
MEdge_ptr fe;
MFace_ptr fnew, eface, rfarray1[MAXPF3], rfarray2[MAXPF3], curface;
MRegion_ptr rnew[2];
List_ptr felist, efaces;
#ifdef DEBUG
List_ptr redges;
#endif
gid = MR_GEntID(rsplit);
#ifdef DEBUG
/* check to make sure we got meaningful input */
redges = MR_Edges(rsplit);
for (i = 0; i < nfe; i++)
if (!List_Contains(redges,fedges[i]))
MSTK_Report("MR_Split","Input edges are not part of the region boundary",
MSTK_FATAL);
List_Delete(redges);
#endif
mesh = MR_Mesh(rsplit);
/* Fix a set of directions for the edges */
fedirs[0] = 1;
for (i = 1; i < nfe; i++) {
MVertex_ptr vprev, v0, v1;
vprev = ME_Vertex(fedges[i-1],fedirs[i-1]);
v0 = ME_Vertex(fedges[i],0);
v1 = ME_Vertex(fedges[i],1);
if (vprev == v0)
fedirs[i] = 1;
else if (vprev == v1)
fedirs[i] = 0;
else
MSTK_Report("MR_Split","Input edges do not form a loop as listed",
MSTK_FATAL);
}
/* Create the splitting face */
fnew = MF_New(mesh);
MF_Set_GEntDim(fnew,3);
MF_Set_GEntID(fnew,gid);
MF_Set_Edges(fnew,nfe,fedges,fedirs);
/* Collect info for the first region */
List_ptr processed_faces = List_New(0);
rfarray1[0] = fnew;
rfdirs1[0] = 1;
nrf1 = 1;
List_Add(processed_faces,rfarray1[0]);
i = 0;
while (i < nrf1) {
curface = rfarray1[i];
curdir = rfdirs1[i];
i++;
/* Get adjacent faces in region of current face and if they are
not already in the new region face list (not marked), then add
them */
felist = MF_Edges(curface,1,0);
idx1 = 0; j = 0;
while ((fe = List_Next_Entry(felist,&idx1))) {
edir = MF_EdgeDir_i(curface,j);
j++;
efaces = ME_Faces(fe);
if (curface != fnew && List_Contains(efaces,fnew)) {
/* we have come back to the starting or splitting face - don't
go across this edge */
List_Delete(efaces);
continue;
}
/* Add an adjacent unprocessed face of the region to the list of
faces for the new region */
idx2 = 0;
while ((eface = List_Next_Entry(efaces,&idx2))) {
if (eface == curface) continue;
if (List_Contains(processed_faces,eface)) continue;
if (!MR_UsesEntity(rsplit,eface,MFACE)) continue; /* does not belong to region */
edir_adj = MF_EdgeDir(eface,fe);
rfdir_adj = MR_FaceDir(rsplit,eface);
/* add adjacent face based on the check that if two adjacent faces of
region are used by the region in the same sense, then their common
edge should be used by the two faces in opposite senses (or the opposite
of both the conditions should be true) */
if ((edir != edir_adj && curdir == rfdir_adj) ||
(edir == edir_adj && curdir != rfdir_adj)) {
rfarray1[nrf1] = eface;
rfdirs1[nrf1] = rfdir_adj;
List_Add(processed_faces,rfarray1[nrf1]);
nrf1++;
break;
}
}
List_Delete(efaces);
}
List_Delete(felist);
}
/* collect info for the second region */
rfarray2[0] = fnew;
rfdirs2[0] = !rfdirs1[0];
nrf2 = 1;
List_Add(processed_faces,rfarray2[0]);
i = 0;
while (i < nrf2) {
curface = rfarray2[i];
curdir = rfdirs2[i];
i++;
/* Get adjacent faces in region of current face and if they are
not already in the new region face list (not marked), then add
them */
felist = MF_Edges(curface,1,0);
idx1 = 0; j = 0;
while ((fe = List_Next_Entry(felist,&idx1))) {
edir = MF_EdgeDir_i(curface,j);
j++;
efaces = ME_Faces(fe);
if (curface != fnew && List_Contains(efaces,fnew)) {
/* we have come back to the starting or splitting face - don't
go across this edge */
List_Delete(efaces);
continue;
}
/* Add an adjacent unprocessed face of the region to the list of
faces for the new region */
idx2 = 0;
while ((eface = List_Next_Entry(efaces,&idx2))) {
if (eface == curface) continue;
if (List_Contains(processed_faces,eface)) continue;
if (!MR_UsesEntity(rsplit,eface,MFACE)) continue; /* does not belong to region */
edir_adj = MF_EdgeDir(eface,fe);
rfdir_adj = MR_FaceDir(rsplit,eface);
/* add adjacent face based on the check that if two adjacent faces of
region are used by the region in the same sense, then their common
edge should be used by the two faces in opposite senses (or the opposite
of both the conditions should be true) */
if ((edir != edir_adj && curdir == rfdir_adj) ||
(edir == edir_adj && curdir != rfdir_adj)) {
rfarray2[nrf2] = eface;
rfdirs2[nrf2] = rfdir_adj;
List_Add(processed_faces,rfarray2[nrf2]);
nrf2++;
break;
}
}
List_Delete(efaces);
}
List_Delete(felist);
}
/* Delete the original region */
MR_Delete(rsplit,0);
/* Make the two new regions */
rnew[0] = MR_New(mesh);
MR_Set_GEntDim(rnew[0],3);
MR_Set_GEntID(rnew[0],gid);
MR_Set_Faces(rnew[0],nrf1,rfarray1,rfdirs1);
rnew[1] = MR_New(mesh);
MR_Set_GEntDim(rnew[1],3);
MR_Set_GEntID(rnew[1],gid);
MR_Set_Faces(rnew[1],nrf2,rfarray2,rfdirs2);
List_Delete(processed_faces);
return fnew;
}
