void each_proc_make_face_on_proc_boundary()
{
unsigned id = get_bulk().parallel_rank()+1;
stk::mesh::Entity elem = get_bulk().get_entity(stk::topology::ELEM_RANK, id);
stk::mesh::EntityVector nodes_of_face = get_nodes_of_face_for_this_proc();
create_faces(elem, nodes_of_face);
}
/* create mesh from a vector of nodes, element list in format =>
* {nuber of nodes, node0, node1, ..., material}, {REPEAT}, ..., 0 (end of list); and surface colors in format =>
* global surface, {number of nodes, node0, node1, ..., surface}, {REPEAT}, ..., 0 (end of list); */
MESH_DATA* MESH_Create (REAL (*nodes) [3], int *elements, int *surfaces)
{
int maximal_node,
minimal_node,
elements_count,
faces_count,
temp, *eleptr, n;
REAL (*node) [3];
MEM *elemem,
facmem,
mapmem;
ELEMENT *ele, *enx, *elist;
FACE *fac, *cac, *gac, *flist;
MAP *faces, *smap;
MESH_DATA *msh;
maximal_node = 0;
minimal_node = INT_MAX;
elements_count = 0;
faces_count = 0;
/* create mesh storage */
ERRMEM (msh = static_cast<MESH_DATA*>(MEM_CALLOC (sizeof (MESH_DATA))));
elemem = &msh->elemem;
/* calculate elements */
for (eleptr = elements; eleptr [0]; eleptr += (eleptr [0]+2)) elements_count ++;
MEM_Init (elemem, sizeof (ELEMENT), elements_count);
MEM_Init (&facmem, sizeof (FACE), MEMCHUNK);
MEM_Init (&mapmem, sizeof (MAP), MEMCHUNK);
MEM_Init (&msh->mapmem, sizeof (MAP), MIN (elements_count, MEMCHUNK));
elist = NULL;
flist = NULL;
faces = NULL;
/* create elements list & face adjacency map */
for (eleptr = elements; eleptr [0]; eleptr += (eleptr [0]+2))
{
ASSERT (
eleptr [0] == 4 || /* tetrahedron */
eleptr [0] == 5 || /* pyramid */
eleptr [0] == 6 || /* wedge */
eleptr [0] == 8, /* hexahedron */
"ERROR: unsupported element type");
ele = create_element (elemem, eleptr);
flist = create_faces (&facmem, &mapmem, &faces, ele, flist);
ele->next = elist;
elist = ele;
/* node number extrema */
temp = maximal (eleptr);
if (temp > maximal_node)
maximal_node = temp;
temp = minimal (eleptr);
if (temp < minimal_node)
minimal_node = temp;
}
/* calculate faces */
for (fac = flist; fac; fac = fac->next)
if (fac->ele) faces_count ++;
/* alocate additional storage */
MEM_Init (&msh->facmem, sizeof (FACE), faces_count);
msh->nodes_count = (maximal_node - minimal_node + 1);
ERRMEM (msh->nodes = static_cast<REAL(*)[3]>(malloc (sizeof (REAL [3]) * (msh->nodes_count))));
msh->surfeles_count = msh->bulkeles_count = 0;
msh->surfeles = msh->bulkeles = NULL;
/* set up elements */
for (ele = elist; ele; ele = enx)
{
enx = ele->next;
if (minimal_node > 0) /* impose 0-based indexing */
{
for (temp = 0; temp < ele->type; temp ++)
ele->nodes [temp] -= minimal_node;
}
ele->prev = NULL;
if (ele->neighs < neighs (ele->type)) /* surface element */
{
msh->surfeles_count ++;
ele->next = msh->surfeles;
if (msh->surfeles) msh->surfeles->prev = ele;
msh->surfeles = ele;
}
else /* bulk element */
{
msh->bulkeles_count ++;
ele->next = msh->bulkeles;
if (msh->bulkeles) msh->bulkeles->prev = ele;
msh->bulkeles = ele;
}
}
/* create surfaces map => skip first element of 'surfaces' == the global surface kind */
for (eleptr = (surfaces + 1), smap = NULL, temp = 0;
eleptr [0]; eleptr += (eleptr [0]+2), temp ++)
{
fac = static_cast<FACE*>(MEM_Alloc (&facmem));
ASSERT (
eleptr [0] == 3 || /* triangle */
eleptr [0] == 4, /* quad */
"ERROR: unsupported face type");
fac->type = eleptr [0];
for (n = 0; n < eleptr [0]; n ++)
fac->nodes [n] = eleptr [n+1];
sort (fac->nodes, fac->nodes+fac->type-1);
fac->color = eleptr [eleptr [0] + 1];
MAP_Insert (&mapmem, &smap, fac, /* map by the type/nodes key */
fac, face_compare);
}
/* set up nodes */
for (temp = minimal_node,
node = msh->nodes;
temp <= maximal_node;
temp ++, node ++)
{
COPY (nodes [temp], *node);
}
/* set up faces */
for (fac = flist; fac; fac = fac->next)
{
if (fac->ele) /* see (***) */
{
ele = fac->ele;
cac = static_cast<FACE*>(MEM_Alloc (&msh->facmem));
setup_face (ele, fac->index, cac, 0); /* setup face nodes without sorting them */
cac->index = fac->index;
cac->ele = fac->ele;
setup_normal (msh->nodes, cac); /* calculate outer spatial normal */
cac->next = ele->faces; /* append element face list */
ele->faces = cac;
/* set the mapped surface kind if possible => otherwise the global one */
gac = static_cast<FACE*>(MAP_Find (smap, fac, face_compare));
cac->color = (gac ? gac->color : surfaces [0]);
}
}
/* create mesh face list */
for (ele = msh->surfeles; ele; ele = ele->next)
{
for (fac = ele->faces; fac; fac = fac->next)
{
fac->n = msh->faces;
msh->faces = fac;
}
}
/* clean up */
MEM_Release (&facmem);
MEM_Release (&mapmem);
return msh;
}
