int MESH_ExportToSTL(Mesh_ptr mesh, const char *filename) {
List_ptr fverts;
MFace_ptr face;
char mesg[256];
int i, j, nfv, idx;
double fxyz[MAXPV2][3], normal[3], len, vec1[3], vec2[3];
FILE *fp;
if (!(fp = fopen(filename,"w"))) {
sprintf(mesg,"Couldn't open output file %s\n",filename);
MSTK_Report("MESH_ExportToSTL",mesg,MSTK_ERROR);
return 0;
}
if (MESH_Num_Regions(mesh)) {
MSTK_Report("MESH_ExportToSTL","Cannot export solid meshes\n",MSTK_ERROR);
return 0;
}
idx = 0;
while ((face = MESH_Next_Face(mesh,&idx))) {
if (MF_Num_Edges(face) != 3) {
MSTK_Report("MESH_ExportToSTL","Can only export triangular meshes to STL\n",MSTK_ERROR);
MSTK_Report("MESH_ExportToSTL","If you need polygonal meshes to be exported\n",MSTK_MESG);
MSTK_Report("MESH_ExportToSTL","as a triangulated surface mesh to STL, \n",MSTK_MESG);
MSTK_Report("MESH_ExportToSTL","please send a mail to [email protected]\n",MSTK_MESG);
return 0;
}
}
/* Opening line for STL file */
fprintf(fp,"solid\n");
idx = 0;
while ((face = MESH_Next_Face(mesh,&idx))) {
fverts = MF_Vertices(face,1,0);
nfv = List_Num_Entries(fverts);
for (i = 0; i < nfv; i++)
MV_Coords(List_Entry(fverts,i),fxyz[i]);
{
vec1[0] = fxyz[1][0]-fxyz[0][0];
vec1[1] = fxyz[1][1]-fxyz[0][1];
vec1[2] = fxyz[1][2]-fxyz[0][2];
vec2[0] = fxyz[2][0]-fxyz[0][0];
vec2[1] = fxyz[2][1]-fxyz[0][1];
vec2[2] = fxyz[2][2]-fxyz[0][2];
normal[0] = vec1[1]*vec2[2] - vec1[2]*vec2[1];
normal[1] = vec1[2]*vec2[0] - vec1[0]*vec2[2];
normal[2] = vec1[0]*vec2[1] - vec1[1]*vec2[0];
len = sqrt(normal[0]*normal[0]+normal[1]*normal[1]+normal[2]*normal[2]);
normal[0] /= len; normal[1] /= len; normal[2] /= len;
}
fprintf(fp,"facet normal %12.8lf %12.8lf %12.8lf\n",normal[0],normal[1],normal[2]);
fprintf(fp," outer loop\n");
for (j = 0; j < 3; j++)
fprintf(fp," vertex %20.10lf %20.10lf %20.10lf\n",fxyz[j][0],fxyz[j][1],fxyz[j][2]);
fprintf(fp,"endloop");
fprintf(fp,"endfacet");
}
fprintf(fp,"endsolid");
fclose(fp);
return 1;
}
List_ptr MR_Vertices_FNR3R4(MRegion_ptr r) {
int i, j, n, ne, nf, mkr, found, idx;
int diradj0=0, diropp=0, fdir, fdir0, fdir1, allquad, alltri;
int nquads, ntris, itri0, itri1, iquad0;
MFace_ptr face=NULL, face0=NULL, fadj0=NULL, fopp=NULL;
MFace_ptr quad0=NULL, tri0=NULL, tri1=NULL;
MEdge_ptr edge, fedge00, upedge;
MVertex_ptr vert, rv0, rvopp0=NULL;
List_ptr rvertices, fverts, fedges0, adjfedges;
MRegion_Adj_FN *adj;
adj = (MRegion_Adj_FN *) r->adj;
nf = List_Num_Entries(adj->rfaces);
switch (r->mrtype) {
case TET:
/* Add vertices of first face to list of region vertices */
face0 = List_Entry(adj->rfaces,0); /* first face */
fdir0 = MR_FaceDir_i(r,0); /* Sense in which face is used in region */
rvertices = MF_Vertices(face0,!fdir0,0);
face = List_Entry(adj->rfaces,1);
fverts = MF_Vertices(face,1,0);
for (i = 0; i < 3; i++) {
vert = List_Entry(fverts,i);
if (!List_Contains(rvertices,vert)) {
List_Add(rvertices,vert);
break;
}
}
List_Delete(fverts);
return rvertices;
break;
case PRISM:
tri0 = NULL; itri0 = -1;
tri1 = NULL; itri1 = -1;
for (i = 0; i < nf; i++) {
face = List_Entry(adj->rfaces,i);
ne = MF_Num_Edges(face);
if (ne == 3) {
if (!tri0) {
tri0 = face;
itri0 = i;
}
else {
tri1 = face;
itri1 = i;
}
}
}
fdir0 = MR_FaceDir_i(r,itri0); /* Sense in which face is used in region */
rvertices = MF_Vertices(tri0,!fdir0,0);
/* find the vertical edge between vertex 0 of bottom triangle and
top triangle */
fdir1 = MR_FaceDir_i(r,itri1);
fverts = MF_Vertices(tri1,fdir1,0);
rv0 = List_Entry(rvertices,0); /* first vtx of region & bottom face */
for (i = 0; i < 3; i++) {
vert = List_Entry(fverts,i);
if (MVs_CommonEdge(rv0,vert)) {
List_Add(rvertices,vert);
List_Add(rvertices,List_Entry(fverts,(i+1)%3));
List_Add(rvertices,List_Entry(fverts,(i+2)%3));
break;
}
}
List_Delete(fverts);
return rvertices;
break;
case PYRAMID:
quad0 = NULL; iquad0 = -1;
tri0 = NULL; itri0 = -1;
for (i = 0; i < nf; i++) {
face = List_Entry(adj->rfaces,i);
ne = MF_Num_Edges(face);
if (ne == 4) {
if (!quad0) {
quad0 = face;
iquad0 = i;
}
}
else if (ne == 3) {
if (!tri0) {
tri0 = face;
itri0 = i;
}
}
}
fdir0 = MR_FaceDir_i(r,iquad0); /* Sense in which face is used in region */
rvertices = MF_Vertices(quad0,!fdir0,0);
fverts = MF_Vertices(tri0,1,0);
for (i = 0; i < 3; i++) {
vert = List_Entry(fverts,i);
if (!List_Contains(rvertices,vert)) { /* found apex vtx of pyramid */
List_Add(rvertices,vert);
break;
}
}
List_Delete(fverts);
return rvertices;
break;
case HEX:
face0 = List_Entry(adj->rfaces,0); /* face 0 */
fdir0 = MR_FaceDir_i(r,0); /* dir of face w.r.t. region */
/* Add vertices of first face */
rvertices = MF_Vertices(face0,!fdir0,0);
/* vertex 0 of region and of face 0 */
rv0 = List_Entry(rvertices,0);
/* Edges of face 0 */
fedges0 = MF_Edges(face0,!fdir0,rv0);
/* edge 0 of face 0 (wrt face dir pointing into the region) */
fedge00 = List_Entry(fedges0,0);
/* Get the face adjacent to edge 0 of face 0 and also the
opposite face, a face that has no edge common face 0 */
fopp = NULL; fadj0 = NULL;
found = 0;
for (i = 1; i < nf; i++) {
face = List_Entry(adj->rfaces,i);
/* Check if face uses any edge of face 0 */
for (j = 0, found = 0; j < 4; j++) {
edge = List_Entry(fedges0,j);
if (MF_UsesEntity(face,edge,1)) {
if (edge == fedge00) {
/* face uses edge 0 of face 0 (w.r.t. face dir pointing
into region) */
fadj0 = face;
diradj0 = MR_FaceDir_i(r,i);
}
found = 1;
break;
}
}
if (!found) {
fopp = face;
diropp = MR_FaceDir_i(r,i);
}
if (fopp && fadj0)
break;
}
if (!fopp) {
MSTK_Report("MR_Vertices_FNR3R4","Could not find opposite face",MSTK_ERROR);
List_Delete(fedges0);
List_Delete(rvertices);
return (void *) NULL;
}
/* edges of face adjacent to edge 0 of face 0 */
adjfedges = MF_Edges(fadj0,1,rv0);
/* edge connecting rv0 and vertex on opposite face */
upedge = diradj0 ? List_Entry(adjfedges,3): List_Entry(adjfedges,0);
#ifdef DEBUG
if (!ME_UsesEntity(upedge,rv0,0))
MSTK_Report("MR_Vertices_FNR3R4","Cannot find correct vertical edge",
MSTK_ERROR);
#endif
if (ME_Vertex(upedge,0) == rv0)
rvopp0 = ME_Vertex(upedge,1);
else {
rvopp0 = ME_Vertex(upedge,0);
}
List_Delete(fedges0);
List_Delete(adjfedges);
fverts = MF_Vertices(fopp,diropp,rvopp0);
for (i = 0; i < 4; i++)
List_Add(rvertices,List_Entry(fverts,i));
List_Delete(fverts);
return rvertices;
break;
default:
/* General Polyhedra */
mkr = MSTK_GetMarker();
/* Add vertices of first face */
face = List_Entry(adj->rfaces,0); /* first face */
fdir = MR_FaceDir_i(r,0); /* Sense in which face is used in region */
rvertices = MF_Vertices(face,!fdir,0);
List_Mark(rvertices,mkr);
for (i = 1; i < nf-1; i++) {
face = List_Entry(adj->rfaces,i);
fverts = MF_Vertices(face,1,0);
n = List_Num_Entries(fverts);
for (j = 0; j < n; j++) {
vert = List_Entry(fverts,j);
if (!MEnt_IsMarked(vert,mkr)) {
List_Add(rvertices,vert);
MEnt_Mark(vert,mkr);
}
}
List_Delete(fverts);
}
List_Unmark(rvertices,mkr);
MSTK_FreeMarker(mkr);
return rvertices;
}
return NULL;
}
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 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;
}
