p4est_wrap_t *
p4est_wrap_new_copy (p4est_wrap_t * source, size_t data_size,
p4est_replace_t replace_fn, void *user_pointer)
{
p4est_wrap_t *pp;
P4EST_ASSERT (source != NULL);
pp = P4EST_ALLOC_ZERO (p4est_wrap_t, 1);
pp->hollow = 1;
sc_refcount_init_invalid (&pp->conn_rc);
pp->conn_owner = (source->conn_owner != NULL ? source->conn_owner : source);
pp->conn = pp->conn_owner->conn;
sc_refcount_ref (&pp->conn_owner->conn_rc);
pp->p4est_dim = P4EST_DIM;
pp->p4est_half = P4EST_HALF;
pp->p4est_faces = P4EST_FACES;
pp->p4est_children = P4EST_CHILDREN;
pp->btype = source->btype;
pp->replace_fn = replace_fn;
pp->p4est = p4est_copy (source->p4est, 0);
if (data_size > 0) {
p4est_reset_data (pp->p4est, data_size, NULL, NULL);
}
pp->weight_exponent = 0; /* keep this even though using ALLOC_ZERO */
pp->p4est->user_pointer = pp;
pp->user_pointer = user_pointer;
return pp;
}
int main(int argc,char *argv[]){
char *HDF5File;
int HDF5file_len;
/* p4est_t *p4est; */
p4est_connectivity_t *conn;
p4est_t *p4est;
p4est_geometry_t *geom;
char *vtkfilename,*vtkfilename_temp;
int mpiret;
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
if(argc>1) {
HDF5File=argv[1];
HDF5file_len=strlen(HDF5File);
ReadMeshFromHDF5_FC(HDF5File,HDF5file_len,&conn);
P4EST_ASSERT(p4est_connectivity_is_valid(conn));
p4est=p4est_new_ext(sc_MPI_COMM_WORLD,conn,0,2,1,0,NULL,NULL);
geom = P4EST_ALLOC_ZERO (p4est_geometry_t, 1);
geom->name = "hopest_readfromhdf5";
geom->X = p4_geometry_X;
vtkfilename_temp=P4EST_STRDUP(HDF5File);
vtkfilename=basename(vtkfilename_temp);
printf("%s\n",vtkfilename);
p4est_vtk_write_file (p4est,geom,vtkfilename);
P4EST_FREE(vtkfilename_temp);
p4est_geometry_destroy(geom);
p4est_destroy(p4est);
p4est_connectivity_destroy(conn);
}
else printf("no input file given.\n");
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
p4est_wrap_t *
p4est_wrap_new_p4est (p4est_t * p4est, int hollow, p4est_connect_type_t btype,
p4est_replace_t replace_fn, void *user_pointer)
{
p4est_wrap_t *pp;
P4EST_ASSERT (p4est_is_valid (p4est));
P4EST_ASSERT (p4est->user_pointer == NULL);
pp = P4EST_ALLOC_ZERO (p4est_wrap_t, 1);
pp->hollow = hollow;
sc_refcount_init (&pp->conn_rc, p4est_package_id);
pp->conn = p4est->connectivity;
pp->conn_owner = NULL;
pp->p4est_dim = P4EST_DIM;
pp->p4est_half = P4EST_HALF;
pp->p4est_faces = P4EST_FACES;
pp->p4est_children = P4EST_CHILDREN;
pp->btype = btype;
pp->replace_fn = replace_fn;
pp->p4est = p4est;
pp->weight_exponent = 0; /* keep this even though using ALLOC_ZERO */
if (!pp->hollow) {
pp->flags = P4EST_ALLOC_ZERO (uint8_t, pp->p4est->local_num_quadrants);
pp->ghost = p4est_ghost_new (pp->p4est, pp->btype);
pp->mesh = p4est_mesh_new_ext (pp->p4est, pp->ghost, 1, 1, pp->btype);
}
pp->p4est->user_pointer = pp;
pp->user_pointer = user_pointer;
return pp;
}
void
p4est_wrap_set_hollow (p4est_wrap_t * pp, int hollow)
{
/* Verify consistency */
if (!pp->hollow) {
P4EST_ASSERT (pp->flags != NULL);
P4EST_ASSERT (pp->ghost != NULL);
P4EST_ASSERT (pp->mesh != NULL);
}
else {
P4EST_ASSERT (pp->flags == NULL);
P4EST_ASSERT (pp->ghost == NULL);
P4EST_ASSERT (pp->mesh == NULL);
}
/* Make sure a full wrap is only set to hollow outside of adaptation cycle */
P4EST_ASSERT (!pp->match_aux);
P4EST_ASSERT (pp->temp_flags == NULL);
P4EST_ASSERT (pp->ghost_aux == NULL);
P4EST_ASSERT (pp->mesh_aux == NULL);
/* Do nothing if the status is right */
if (hollow == pp->hollow) {
return;
}
if (pp->hollow) {
/* Allocate the ghost, mesh, and flag members */
pp->flags = P4EST_ALLOC_ZERO (uint8_t, pp->p4est->local_num_quadrants);
pp->ghost = p4est_ghost_new (pp->p4est, pp->btype);
pp->mesh = p4est_mesh_new_ext (pp->p4est, pp->ghost, 1, 1, pp->btype);
}
else {
/* Free and nullify the ghost, mesh, and flag members */
p4est_mesh_destroy (pp->mesh);
p4est_ghost_destroy (pp->ghost);
P4EST_FREE (pp->flags);
pp->ghost = NULL;
pp->mesh = NULL;
pp->flags = NULL;
}
pp->num_refine_flags = pp->inside_counter = pp->num_replaced = 0;
pp->hollow = hollow;
}
p4est_t *
p4est_new_points (sc_MPI_Comm mpicomm, p4est_connectivity_t * connectivity,
int maxlevel, p4est_quadrant_t * points,
p4est_locidx_t num_points, p4est_locidx_t max_points,
size_t data_size, p4est_init_t init_fn, void *user_pointer)
{
int mpiret;
int num_procs, rank;
int i, isizet;
size_t lcount;
size_t *nmemb;
#ifdef P4EST_ENABLE_DEBUG
size_t zz;
#endif
p4est_topidx_t jt, num_trees;
p4est_topidx_t first_tree, last_tree, next_tree;
p4est_quadrant_t *first_quad, *next_quad, *quad;
p4est_quadrant_t a, b, c, f, l, n;
p4est_tree_t *tree;
p4est_t *p4est;
p4est_points_state_t ppstate;
P4EST_GLOBAL_PRODUCTIONF ("Into " P4EST_STRING
"_new_points with max level %d max points %lld\n",
maxlevel, (long long) max_points);
p4est_log_indent_push ();
P4EST_ASSERT (p4est_connectivity_is_valid (connectivity));
P4EST_ASSERT (max_points >= -1);
/* retrieve MPI information */
mpiret = sc_MPI_Comm_size (mpicomm, &num_procs);
SC_CHECK_MPI (mpiret);
mpiret = sc_MPI_Comm_rank (mpicomm, &rank);
SC_CHECK_MPI (mpiret);
/* This implementation runs in O(P/p * maxlevel)
* with P the total number of points, p the number of processors.
* Two optimizations are possible:
* 1. At startup remove points that lead to duplicate quadrants.
* 2. Use complete_region between successive points instead of
* the call to refine. This should give O(N/p) * maxlevel
* with N the total number of quadrants.
*/
/* parallel sort the incoming points */
lcount = (size_t) num_points;
nmemb = P4EST_ALLOC_ZERO (size_t, num_procs);
isizet = (int) sizeof (size_t);
mpiret = sc_MPI_Allgather (&lcount, isizet, sc_MPI_BYTE,
nmemb, isizet, sc_MPI_BYTE, mpicomm);
SC_CHECK_MPI (mpiret);
sc_psort (mpicomm, points, nmemb, sizeof (p4est_quadrant_t),
p4est_quadrant_compare_piggy);
P4EST_FREE (nmemb);
#ifdef P4EST_ENABLE_DEBUG
first_quad = points;
for (zz = 1; zz < lcount; ++zz) {
next_quad = points + zz;
P4EST_ASSERT (p4est_quadrant_compare_piggy (first_quad, next_quad) <= 0);
first_quad = next_quad;
}
#endif
/* create the p4est */
p4est = P4EST_ALLOC_ZERO (p4est_t, 1);
ppstate.points = points;
ppstate.num_points = num_points;
ppstate.max_points = max_points;
ppstate.current = 0;
ppstate.maxlevel = maxlevel;
/* assign some data members */
p4est->data_size = 2 * sizeof (p4est_locidx_t); /* temporary */
p4est->user_pointer = &ppstate;
p4est->connectivity = connectivity;
num_trees = connectivity->num_trees;
/* create parallel environment */
p4est_comm_parallel_env_create (p4est, mpicomm);
/* allocate memory pools */
p4est->user_data_pool = sc_mempool_new (p4est->data_size);
p4est->quadrant_pool = sc_mempool_new (sizeof (p4est_quadrant_t));
P4EST_GLOBAL_PRODUCTIONF ("New " P4EST_STRING
" with %lld trees on %d processors\n",
(long long) num_trees, num_procs);
/* allocate trees */
p4est->trees = sc_array_new (sizeof (p4est_tree_t));
sc_array_resize (p4est->trees, num_trees);
for (jt = 0; jt < num_trees; ++jt) {
tree = p4est_tree_array_index (p4est->trees, jt);
sc_array_init (&tree->quadrants, sizeof (p4est_quadrant_t));
P4EST_QUADRANT_INIT (&tree->first_desc);
P4EST_QUADRANT_INIT (&tree->last_desc);
tree->quadrants_offset = 0;
for (i = 0; i <= P4EST_QMAXLEVEL; ++i) {
tree->quadrants_per_level[i] = 0;
}
for (; i <= P4EST_MAXLEVEL; ++i) {
tree->quadrants_per_level[i] = -1;
}
tree->maxlevel = 0;
}
p4est->local_num_quadrants = 0;
p4est->global_num_quadrants = 0;
/* create point based partition */
P4EST_QUADRANT_INIT (&f);
p4est->global_first_position =
P4EST_ALLOC_ZERO (p4est_quadrant_t, num_procs + 1);
if (num_points == 0) {
P4EST_VERBOSE ("Empty processor");
first_tree = p4est->first_local_tree = -1;
first_quad = NULL;
}
else {
/* we are probably not empty */
if (rank == 0) {
first_tree = p4est->first_local_tree = 0;
p4est_quadrant_set_morton (&f, maxlevel, 0);
}
else {
first_tree = p4est->first_local_tree = points->p.which_tree;
p4est_node_to_quadrant (points, maxlevel, &f);
}
first_quad = &f;
}
last_tree = p4est->last_local_tree = -2;
p4est_comm_global_partition (p4est, first_quad);
first_quad = p4est->global_first_position + rank;
next_quad = p4est->global_first_position + (rank + 1);
next_tree = next_quad->p.which_tree;
if (first_tree >= 0 &&
p4est_quadrant_is_equal (first_quad, next_quad) &&
first_quad->p.which_tree == next_quad->p.which_tree) {
/* if all our points are consumed by the next processor we are empty */
first_tree = p4est->first_local_tree = -1;
}
if (first_tree >= 0) {
/* we are definitely not empty */
if (next_quad->x == 0 && next_quad->y == 0
#ifdef P4_TO_P8
&& next_quad->z == 0
#endif
) {
last_tree = p4est->last_local_tree = next_tree - 1;
}
else {
last_tree = p4est->last_local_tree = next_tree;
}
P4EST_ASSERT (first_tree <= last_tree);
}
/* fill the local trees */
P4EST_QUADRANT_INIT (&a);
P4EST_QUADRANT_INIT (&b);
P4EST_QUADRANT_INIT (&c);
P4EST_QUADRANT_INIT (&l);
n = *next_quad;
n.level = (int8_t) maxlevel;
for (jt = first_tree; jt <= last_tree; ++jt) {
int onlyone = 0;
int includeb = 0;
tree = p4est_tree_array_index (p4est->trees, jt);
/* determine first local quadrant of this tree */
if (jt == first_tree) {
a = *first_quad;
a.level = (int8_t) maxlevel;
first_quad = next_quad = NULL; /* free to use further down */
P4EST_ASSERT (p4est_quadrant_is_valid (&a));
}
else {
p4est_quadrant_set_morton (&a, maxlevel, 0);
P4EST_ASSERT (jt < next_tree || p4est_quadrant_compare (&a, &n) < 0);
}
/* enlarge first local quadrant if possible */
if (jt < next_tree) {
while (p4est_quadrant_child_id (&a) == 0 && a.level > 0) {
p4est_quadrant_parent (&a, &a);
}
P4EST_ASSERT (jt == first_tree || a.level == 0);
}
else {
for (c = a; p4est_quadrant_child_id (&c) == 0; a = c) {
p4est_quadrant_parent (&c, &c);
p4est_quadrant_last_descendant (&c, &l, maxlevel);
if (p4est_quadrant_compare (&l, &n) >= 0) {
break;
}
}
P4EST_ASSERT (a.level > 0);
P4EST_ASSERT ((p4est_quadrant_last_descendant (&a, &l, maxlevel),
p4est_quadrant_compare (&l, &n) < 0));
}
p4est_quadrant_first_descendant (&a, &tree->first_desc, P4EST_QMAXLEVEL);
/* determine largest possible last quadrant of this tree */
if (jt < next_tree) {
p4est_quadrant_last_descendant (&a, &l, maxlevel);
p4est_quadrant_set_morton (&b, 0, 0);
p4est_quadrant_last_descendant (&b, &b, maxlevel);
if (p4est_quadrant_is_equal (&l, &b)) {
onlyone = 1;
}
else {
includeb = 1;
for (c = b; p4est_quadrant_child_id (&c) == P4EST_CHILDREN - 1; b = c) {
p4est_quadrant_parent (&c, &c);
p4est_quadrant_first_descendant (&c, &f, maxlevel);
if (p4est_quadrant_compare (&l, &f) >= 0) {
break;
}
}
}
}
else {
b = n;
}
/* create a complete tree */
if (onlyone) {
quad = p4est_quadrant_array_push (&tree->quadrants);
*quad = a;
p4est_quadrant_init_data (p4est, jt, quad, p4est_points_init);
tree->maxlevel = a.level;
++tree->quadrants_per_level[a.level];
}
else {
p4est_complete_region (p4est, &a, 1, &b, includeb,
tree, jt, p4est_points_init);
quad = p4est_quadrant_array_index (&tree->quadrants,
tree->quadrants.elem_count - 1);
}
tree->quadrants_offset = p4est->local_num_quadrants;
p4est->local_num_quadrants += tree->quadrants.elem_count;
p4est_quadrant_last_descendant (quad, &tree->last_desc, P4EST_QMAXLEVEL);
/* verification */
#ifdef P4EST_ENABLE_DEBUG
first_quad = p4est_quadrant_array_index (&tree->quadrants, 0);
for (zz = 1; zz < tree->quadrants.elem_count; ++zz) {
next_quad = p4est_quadrant_array_index (&tree->quadrants, zz);
P4EST_ASSERT (((p4est_locidx_t *) first_quad->p.user_data)[1] ==
((p4est_locidx_t *) next_quad->p.user_data)[0]);
first_quad = next_quad;
}
#endif
}
if (last_tree >= 0) {
for (; jt < num_trees; ++jt) {
tree = p4est_tree_array_index (p4est->trees, jt);
tree->quadrants_offset = p4est->local_num_quadrants;
}
}
/* compute some member variables */
p4est->global_first_quadrant = P4EST_ALLOC (p4est_gloidx_t, num_procs + 1);
p4est_comm_count_quadrants (p4est);
/* print more statistics */
P4EST_VERBOSEF ("total local quadrants %lld\n",
(long long) p4est->local_num_quadrants);
P4EST_ASSERT (p4est_is_valid (p4est));
p4est_log_indent_pop ();
P4EST_GLOBAL_PRODUCTIONF ("Done " P4EST_STRING
"_new_points with %lld total quadrants\n",
(long long) p4est->global_num_quadrants);
/* refine to have one point per quadrant */
if (max_points >= 0) {
p4est_refine_ext (p4est, 1, maxlevel, p4est_points_refine,
p4est_points_init, NULL);
#ifdef P4EST_ENABLE_DEBUG
for (jt = first_tree; jt <= last_tree; ++jt) {
tree = p4est_tree_array_index (p4est->trees, jt);
first_quad = p4est_quadrant_array_index (&tree->quadrants, 0);
for (zz = 1; zz < tree->quadrants.elem_count; ++zz) {
next_quad = p4est_quadrant_array_index (&tree->quadrants, zz);
P4EST_ASSERT (((p4est_locidx_t *) first_quad->p.user_data)[1] ==
((p4est_locidx_t *) next_quad->p.user_data)[0]);
first_quad = next_quad;
}
}
#endif
}
/* initialize user pointer and data size */
p4est_reset_data (p4est, data_size, init_fn, user_pointer);
return p4est;
}
p6est_profile_t *
p6est_profile_new_local (p6est_t * p6est,
p6est_ghost_t * ghost,
p6est_profile_type_t ptype,
p8est_connect_type_t btype, int degree)
{
p6est_profile_t *profile = P4EST_ALLOC (p6est_profile_t, 1);
p4est_lnodes_t *lnodes;
p4est_locidx_t nln, nle;
p4est_topidx_t jt;
p4est_t *columns = p6est->columns;
p4est_tree_t *tree;
sc_array_t *tquadrants;
p4est_quadrant_t *col;
p4est_qcoord_t diff = P4EST_ROOT_LEN - p6est->root_len;
size_t first, last, count, zz, zy;
p4est_locidx_t *en, (*lr)[2];
sc_array_t *lc;
int i, j;
p2est_quadrant_t *layer;
sc_array_t *layers = p6est->layers;
p4est_locidx_t nidx, enidx;
p4est_connect_type_t hbtype;
int8_t *c;
sc_array_t *thisprof;
sc_array_t *selfprof;
sc_array_t *faceprof;
sc_array_t *cornerprof;
sc_array_t *work;
sc_array_t oldprof;
const int Nrp = degree + 1;
P4EST_ASSERT (degree > 1);
profile->ptype = ptype;
profile->btype = btype;
profile->lnode_changed[0] = NULL;
profile->lnode_changed[1] = NULL;
profile->enode_counts = NULL;
profile->diff = diff;
if (btype == P8EST_CONNECT_FACE) {
hbtype = P4EST_CONNECT_FACE;
}
else {
hbtype = P4EST_CONNECT_FULL;
}
if (ghost == NULL) {
profile->cghost = p4est_ghost_new (p6est->columns, P4EST_CONNECT_FULL);
profile->ghost_owned = 1;
}
else {
P4EST_ASSERT (ghost->column_ghost->btype == P4EST_CONNECT_FULL);
profile->cghost = ghost->column_ghost;
profile->ghost_owned = 0;
}
if (ptype == P6EST_PROFILE_UNION) {
P4EST_ASSERT (degree == 2);
}
profile->lnodes = lnodes = p4est_lnodes_new (p6est->columns,
profile->cghost, degree);
en = lnodes->element_nodes;
nln = lnodes->num_local_nodes;
nle = lnodes->num_local_elements;
profile->lnode_ranges = P4EST_ALLOC_ZERO (p4est_locidx_t, 2 * nln);
lr = (p4est_locidx_t (*)[2]) profile->lnode_ranges;
profile->lnode_columns = lc = sc_array_new (sizeof (int8_t));
selfprof = sc_array_new (sizeof (int8_t));
work = sc_array_new (sizeof (int8_t));
faceprof = sc_array_new (sizeof (int8_t));
cornerprof = sc_array_new (sizeof (int8_t));
if (ptype == P6EST_PROFILE_UNION) {
profile->lnode_changed[0] = P4EST_ALLOC (p4est_locidx_t, nln);
profile->lnode_changed[1] = P4EST_ALLOC (p4est_locidx_t, nln);
profile->enode_counts = P4EST_ALLOC (p4est_locidx_t, P4EST_INSUL * nle);
profile->evenodd = 0;
memset (profile->lnode_changed[0], -1, nln * sizeof (int));
}
/* create the profiles for each node: layers are reduced to just their level
* */
for (enidx = 0, jt = columns->first_local_tree;
jt <= columns->last_local_tree; ++jt) {
tree = p4est_tree_array_index (columns->trees, jt);
tquadrants = &tree->quadrants;
for (zz = 0; zz < tquadrants->elem_count; ++zz) {
col = p4est_quadrant_array_index (tquadrants, zz);
P6EST_COLUMN_GET_RANGE (col, &first, &last);
count = last - first;
sc_array_truncate (selfprof);
c = (int8_t *) sc_array_push_count (selfprof, count);
for (zy = first; zy < last; zy++) {
layer = p2est_quadrant_array_index (layers, zy);
*(c++) = layer->level;
}
if (ptype == P6EST_PROFILE_UNION) {
p6est_profile_balance_self (selfprof, work);
if (btype == P8EST_CONNECT_FACE) {
p6est_profile_balance_face (selfprof, faceprof, work, diff);
}
else {
p6est_profile_balance_full (selfprof, faceprof, work, diff);
}
if (btype == P8EST_CONNECT_EDGE) {
p6est_profile_balance_face (selfprof, cornerprof, work, diff);
}
else if (btype == P8EST_CONNECT_FULL) {
p6est_profile_balance_full (selfprof, cornerprof, work, diff);
}
}
for (j = 0; j < Nrp; j++) {
for (i = 0; i < Nrp; i++, enidx++) {
nidx = en[enidx];
if (ptype == P6EST_PROFILE_UNION) {
thisprof = NULL;
if (!(i % degree) && !(j % degree)) {
if (hbtype == P4EST_CONNECT_FACE) {
/* skip corners if we don't need to balance them */
P4EST_ASSERT (!lr[nidx][0]);
P4EST_ASSERT (!lr[nidx][1]);
continue;
}
else {
thisprof = cornerprof;
}
}
else if ((i % degree) && (j % degree)) {
thisprof = selfprof;
}
else {
thisprof = faceprof;
}
count = thisprof->elem_count;
profile->enode_counts[enidx] = count;
if (!lr[nidx][1]) {
/* if this node has not yet been initialized, initialize it */
lr[nidx][0] = lc->elem_count;
lr[nidx][1] = count;
c = (int8_t *) sc_array_push_count (lc, count);
memcpy (c, thisprof->array, count * sizeof (int8_t));
}
else {
/* if this node has been initialized, combine the two profiles,
* taking the finer layers from each */
sc_array_init_view (&oldprof, lc, lr[nidx][0], lr[nidx][1]);
p6est_profile_union (thisprof, &oldprof, work);
if (work->elem_count > oldprof.elem_count) {
lr[nidx][0] = lc->elem_count;
lr[nidx][1] = work->elem_count;
c = (int8_t *) sc_array_push_count (lc, work->elem_count);
memcpy (c, work->array, work->elem_count * work->elem_size);
}
}
}
else {
count = selfprof->elem_count;
if (!lr[nidx][1]) {
/* if this node has not yet been initialized, initialize it */
lr[nidx][0] = lc->elem_count;
lr[nidx][1] = count;
c = (int8_t *) sc_array_push_count (lc, count);
memcpy (c, selfprof->array, count * sizeof (int8_t));
}
else {
/* if this node has been initialized, combine the two profiles,
* taking the coarser layers from each */
sc_array_init_view (&oldprof, lc, lr[nidx][0], lr[nidx][1]);
p6est_profile_intersection (selfprof, &oldprof, work);
P4EST_ASSERT (work->elem_count <= oldprof.elem_count);
if (work->elem_count < oldprof.elem_count) {
lr[nidx][1] = work->elem_count;
memcpy (oldprof.array, work->array,
work->elem_count * work->elem_size);
}
}
}
}
}
}
}
p6est_profile_compress (profile);
sc_array_destroy (selfprof);
sc_array_destroy (faceprof);
sc_array_destroy (cornerprof);
sc_array_destroy (work);
return profile;
}
trilinear_mesh_t *
p8est_trilinear_mesh_new_from_nodes (p4est_t * p4est, p4est_nodes_t * nodes)
{
const int num_procs = p4est->mpisize;
const int rank = p4est->mpirank;
int mpiret;
int k, owner;
#ifdef P4EST_DEBUG
int prev_owner = 0;
int64_t prev_fvnid = -1;
#endif
int *sharers;
size_t current, zz, num_sharers;
int32_t e, n, local_owned_end;
int64_t global_borrowed, global_shared;
int64_t local_counts[5], global_counts[5];
int32link_t *lynk, **tail;
p4est_topidx_t which_tree;
p4est_locidx_t *local_node, *shared_offsets;
p4est_tree_t *tree;
p4est_quadrant_t *q;
p4est_indep_t *in;
p8est_hang4_t *fh;
p8est_hang2_t *eh;
trilinear_elem_t *elem;
trilinear_anode_t *anode;
trilinear_dnode_t *dnode;
trilinear_mesh_t *mesh;
trilinear_mesh_pid_t *elem_pids;
trilinear_mesh_pid_t *node_pids;
sc_recycle_array_t *rarr;
P4EST_GLOBAL_PRODUCTIONF
("Into trilinear_mesh_extract with %lld total elements\n",
(long long) p4est->global_num_quadrants);
/* Allocate output data structure. */
mesh = P4EST_ALLOC_ZERO (trilinear_mesh_t, 1);
memset (mesh, -1, sizeof (*mesh));
shared_offsets = nodes->shared_offsets;
/* Assign local counts. */
P4EST_ASSERT (nodes->num_local_quadrants == p4est->local_num_quadrants);
mesh->local_elem_num = p4est->local_num_quadrants;
mesh->local_anode_num = nodes->indep_nodes.elem_count;
mesh->local_dnode_num =
nodes->face_hangings.elem_count + nodes->edge_hangings.elem_count;
mesh->local_onode_num = nodes->num_owned_indeps;
mesh->local_owned_offset = nodes->offset_owned_indeps;
mesh->local_node_num = mesh->local_anode_num + mesh->local_dnode_num;
local_owned_end = mesh->local_owned_offset + mesh->local_onode_num;
/* Communicate global counts. */
local_counts[0] = mesh->local_elem_num;
local_counts[1] = mesh->local_anode_num;
local_counts[2] = mesh->local_onode_num;
local_counts[3] = mesh->local_dnode_num;
local_counts[4] = nodes->num_owned_shared;
mpiret = MPI_Allreduce (local_counts, global_counts, 5, MPI_LONG_LONG_INT,
MPI_SUM, p4est->mpicomm);
SC_CHECK_MPI (mpiret);
P4EST_ASSERT (global_counts[0] == p4est->global_num_quadrants);
mesh->total_elem_num = global_counts[0];
global_borrowed = global_counts[1] - global_counts[2];
mesh->total_anode_num = global_counts[2];
mesh->total_dnode_num = global_counts[3];
global_shared = global_counts[4];
mesh->total_node_num = mesh->total_anode_num + mesh->total_dnode_num;
/* Allocate the mesh memory. */
mesh->elem_table = P4EST_ALLOC (trilinear_elem_t, mesh->local_elem_num);
mesh->node_table = P4EST_ALLOC (trilinear_node_t, mesh->local_node_num);
mesh->fvnid_count_table = P4EST_ALLOC (int64_t, num_procs + 1);
mesh->fvnid_interval_table = P4EST_ALLOC (int64_t, num_procs + 1);
mesh->all_fvnid_start = mesh->fvnid_interval_table;
mesh->sharer_pool = sc_mempool_new (sizeof (int32link_t));
mesh->elem_pids = P4EST_ALLOC (trilinear_mesh_pid_t, mesh->local_node_num);
mesh->node_pids = P4EST_ALLOC (trilinear_mesh_pid_t, mesh->local_node_num);
/* Assign global free variable information. */
mesh->fvnid_interval_table[0] = 0;
for (k = 0; k < num_procs; ++k) {
mesh->fvnid_interval_table[k + 1] = mesh->fvnid_interval_table[k] +
(mesh->fvnid_count_table[k] = nodes->global_owned_indeps[k]);
}
mesh->fvnid_count_table[num_procs] = -1;
mesh->global_fvnid_num = mesh->fvnid_interval_table[num_procs];
mesh->global_fvnid_start = 0;
mesh->global_fvnid_end = mesh->global_fvnid_num - 1;
P4EST_ASSERT (mesh->global_fvnid_num == mesh->total_anode_num);
/* Assign element information. */
local_node = nodes->local_nodes;
which_tree = p4est->first_local_tree;
elem_pids = mesh->elem_pids;
if (which_tree >= 0) {
tree = p4est_tree_array_index (p4est->trees, which_tree);
current = 0;
for (e = 0; e < mesh->local_elem_num; ++e) {
if (current == tree->quadrants.elem_count) {
++which_tree;
tree = p4est_tree_array_index (p4est->trees, which_tree);
current = 0;
}
q = p4est_quadrant_array_index (&tree->quadrants, current);
elem = mesh->elem_table + e;
for (k = 0; k < P4EST_CHILDREN; ++k) {
elem->local_node_id[k] = *local_node++;
}
elem->lx = (tick_t) q->x;
elem->ly = (tick_t) q->y;
elem->lz = (tick_t) q->z;
elem->size = P4EST_QUADRANT_LEN (q->level);
elem->data = q->p.user_data;
elem_pids[e] = (trilinear_mesh_pid_t) which_tree;
++current;
}
P4EST_ASSERT (which_tree == p4est->last_local_tree);
P4EST_ASSERT (current == tree->quadrants.elem_count);
}
/* Assign anchored node information. */
mesh->anode_table = mesh->node_table;
mesh->onode_table = mesh->node_table + mesh->local_owned_offset;
mesh->dnode_table = mesh->node_table + mesh->local_anode_num;
node_pids = mesh->node_pids;
for (n = 0; n < mesh->local_anode_num; ++n) {
anode = &mesh->node_table[n].anchored;
in = (p4est_indep_t *) sc_array_index (&nodes->indep_nodes, (size_t) n);
anode->point.x = in->x;
anode->point.y = in->y;
anode->point.z = in->z;
node_pids[n] = (trilinear_mesh_pid_t) in->p.piggy3.which_tree;
if (n < mesh->local_owned_offset) {
owner = nodes->nonlocal_ranks[n];
P4EST_ASSERT (owner < rank && owner >= prev_owner);
}
else if (n >= local_owned_end) {
owner = nodes->nonlocal_ranks[n - mesh->local_onode_num];
P4EST_ASSERT (owner > rank && owner >= prev_owner);
}
else {
owner = rank;
}
anode->fvnid = mesh->all_fvnid_start[owner] + in->p.piggy3.local_num;
P4EST_ASSERT (anode->fvnid > prev_fvnid);
if (in->pad8 == 0) {
P4EST_ASSERT (in->pad16 == -1);
P4EST_ASSERT (shared_offsets == NULL || shared_offsets[n] == -1);
anode->share = NULL;
}
else {
P4EST_ASSERT (in->pad8 > 0);
num_sharers = (size_t) in->pad8;
rarr =
(sc_recycle_array_t *) sc_array_index (&nodes->shared_indeps,
num_sharers - 1);
if (nodes->shared_offsets == NULL) {
P4EST_ASSERT (in->pad16 >= 0);
zz = (size_t) in->pad16;
}
else {
P4EST_ASSERT (in->pad16 == -1);
zz = (size_t) shared_offsets[n];
}
sharers = (int *) sc_array_index (&rarr->a, zz);
tail = &anode->share;
for (zz = 0; zz < num_sharers; ++zz) {
*tail = lynk = (int32link_t *) sc_mempool_alloc (mesh->sharer_pool);
lynk->id = (int32_t) sharers[zz];
tail = &lynk->next;
}
*tail = NULL;
}
#ifdef P4EST_DEBUG
prev_owner = owner;
prev_fvnid = anode->fvnid;
#endif
}
/* Assign face hanging node information. */
for (zz = 0; zz < nodes->face_hangings.elem_count; ++n, ++zz) {
dnode = &mesh->node_table[n].dangling;
fh = (p8est_hang4_t *) sc_array_index (&nodes->face_hangings, zz);
dnode->point.x = fh->x;
dnode->point.y = fh->y;
dnode->point.z = fh->z;
dnode->type = 0; /* Not used in Rhea. */
dnode->local_anode_id[0] = fh->p.piggy.depends[0];
dnode->local_anode_id[1] = fh->p.piggy.depends[1];
dnode->local_anode_id[2] = fh->p.piggy.depends[2];
dnode->local_anode_id[3] = fh->p.piggy.depends[3];
node_pids[n] = (trilinear_mesh_pid_t) fh->p.piggy.which_tree;
}
/* Assign edge hanging node information. */
for (zz = 0; zz < nodes->edge_hangings.elem_count; ++n, ++zz) {
dnode = &mesh->node_table[n].dangling;
eh = (p8est_hang2_t *) sc_array_index (&nodes->edge_hangings, zz);
dnode->point.x = eh->x;
dnode->point.y = eh->y;
dnode->point.z = eh->z;
dnode->type = 0; /* Not used in Rhea. */
dnode->local_anode_id[0] = eh->p.piggy.depends[0];
dnode->local_anode_id[1] = eh->p.piggy.depends[1];
dnode->local_anode_id[2] = dnode->local_anode_id[3] = -1;
node_pids[n] = (trilinear_mesh_pid_t) eh->p.piggy.which_tree;
}
P4EST_ASSERT (n == mesh->local_node_num);
/* Assign the remaining variables. */
mesh->mpicomm = p4est->mpicomm;
mesh->mpisize = (int32_t) num_procs;
mesh->mpirank = (int32_t) rank;
mesh->recsize = (int32_t) p4est->data_size;
mesh->destructor = p8est_trilinear_mesh_destroy;
/* These members are incomplete and need to be filled later. */
memset (mesh->bounds, 0, 6 * sizeof (int));
memset (mesh->sizes, 0, 3 * sizeof (int));
mesh->minsize = mesh->maxsize = 0;
mesh->ticksize = 0.;
mesh->extra_info = NULL;
mesh->gid = -1;
/* We are done */
P4EST_GLOBAL_PRODUCTIONF ("Done trilinear_mesh_extract"
" with %lld anodes %lld %lld\n",
(long long) mesh->total_anode_num,
(long long) global_borrowed,
(long long) global_shared);
return mesh;
}
int
p4est_wrap_partition (p4est_wrap_t * pp, int weight_exponent,
p4est_locidx_t * unchanged_first,
p4est_locidx_t * unchanged_length,
p4est_locidx_t * unchanged_old_first)
{
int changed;
p4est_gloidx_t pre_me, pre_next;
p4est_gloidx_t post_me, post_next;
P4EST_ASSERT (!pp->hollow);
P4EST_ASSERT (pp->ghost != NULL);
P4EST_ASSERT (pp->mesh != NULL);
P4EST_ASSERT (pp->ghost_aux != NULL);
P4EST_ASSERT (pp->mesh_aux != NULL);
P4EST_ASSERT (pp->match_aux == 1);
p4est_mesh_destroy (pp->mesh);
p4est_ghost_destroy (pp->ghost);
pp->match_aux = 0;
/* Remember the window onto global quadrant sequence before partition */
pre_me = pp->p4est->global_first_quadrant[pp->p4est->mpirank];
pre_next = pp->p4est->global_first_quadrant[pp->p4est->mpirank + 1];
/* Initialize output for the case that the partition does not change */
if (unchanged_first != NULL) {
*unchanged_first = 0;
}
if (unchanged_length != NULL) {
*unchanged_length = pp->p4est->local_num_quadrants;
}
if (unchanged_old_first != NULL) {
*unchanged_old_first = 0;
}
/* In the future the flags could be used to pass partition weights */
/* We need to lift the restriction on 64 bits for the global weight sum */
P4EST_ASSERT (weight_exponent == 0 || weight_exponent == 1);
pp->weight_exponent = weight_exponent;
changed =
p4est_partition_ext (pp->p4est, 1,
weight_exponent ? partition_weight : NULL) > 0;
if (changed) {
P4EST_FREE (pp->flags);
pp->flags = P4EST_ALLOC_ZERO (uint8_t, pp->p4est->local_num_quadrants);
pp->ghost = p4est_ghost_new (pp->p4est, pp->btype);
pp->mesh = p4est_mesh_new_ext (pp->p4est, pp->ghost, 1, 1, pp->btype);
/* Query the window onto global quadrant sequence after partition */
if (unchanged_first != NULL || unchanged_length != NULL ||
unchanged_old_first != NULL) {
/* compute new windof of local quadrants */
post_me = pp->p4est->global_first_quadrant[pp->p4est->mpirank];
post_next = pp->p4est->global_first_quadrant[pp->p4est->mpirank + 1];
/* compute the range of quadrants that have stayed on this processor */
p4est_wrap_partition_unchanged (pre_me, pre_next, post_me, post_next,
unchanged_first, unchanged_length,
unchanged_old_first);
}
}
else {
memset (pp->flags, 0, sizeof (uint8_t) * pp->p4est->local_num_quadrants);
pp->ghost = pp->ghost_aux;
pp->mesh = pp->mesh_aux;
pp->ghost_aux = NULL;
pp->mesh_aux = NULL;
}
return changed;
}
int
p4est_wrap_adapt (p4est_wrap_t * pp)
{
int changed;
#ifdef P4EST_ENABLE_DEBUG
p4est_locidx_t jl, local_num;
#endif
p4est_gloidx_t global_num;
p4est_t *p4est = pp->p4est;
P4EST_ASSERT (!pp->hollow);
P4EST_ASSERT (pp->coarsen_delay >= 0);
P4EST_ASSERT (pp->mesh != NULL);
P4EST_ASSERT (pp->ghost != NULL);
P4EST_ASSERT (pp->mesh_aux == NULL);
P4EST_ASSERT (pp->ghost_aux == NULL);
P4EST_ASSERT (pp->match_aux == 0);
P4EST_ASSERT (pp->temp_flags == NULL);
P4EST_ASSERT (pp->num_refine_flags >= 0 &&
pp->num_refine_flags <= p4est->local_num_quadrants);
/* This allocation is optimistic when not all refine requests are honored */
pp->temp_flags = P4EST_ALLOC_ZERO (uint8_t, p4est->local_num_quadrants +
(P4EST_CHILDREN - 1) *
pp->num_refine_flags);
/* Execute refinement */
pp->inside_counter = pp->num_replaced = 0;
#ifdef P4EST_ENABLE_DEBUG
local_num = p4est->local_num_quadrants;
#endif
global_num = p4est->global_num_quadrants;
p4est_refine_ext (p4est, 0, -1, refine_callback, NULL, replace_on_refine);
P4EST_ASSERT (pp->inside_counter == local_num);
P4EST_ASSERT (p4est->local_num_quadrants - local_num ==
pp->num_replaced * (P4EST_CHILDREN - 1));
changed = global_num != p4est->global_num_quadrants;
/* Execute coarsening */
pp->inside_counter = pp->num_replaced = 0;
#ifdef P4EST_ENABLE_DEBUG
local_num = p4est->local_num_quadrants;
#endif
global_num = p4est->global_num_quadrants;
p4est_coarsen_ext (p4est, 0, 1, coarsen_callback, NULL,
pp->coarsen_delay ? replace_on_coarsen : pp->replace_fn);
P4EST_ASSERT (pp->inside_counter == local_num);
P4EST_ASSERT (local_num - p4est->local_num_quadrants ==
pp->num_replaced * (P4EST_CHILDREN - 1));
changed = changed || global_num != p4est->global_num_quadrants;
/* Free temporary flags */
P4EST_FREE (pp->temp_flags);
pp->temp_flags = NULL;
/* Only if refinement and/or coarsening happened do we need to balance */
if (changed) {
P4EST_FREE (pp->flags);
p4est_balance_ext (p4est, pp->btype, NULL, pp->coarsen_delay ?
replace_on_balance : pp->replace_fn);
pp->flags = P4EST_ALLOC_ZERO (uint8_t, p4est->local_num_quadrants);
pp->ghost_aux = p4est_ghost_new (p4est, pp->btype);
pp->mesh_aux = p4est_mesh_new_ext (p4est, pp->ghost_aux, 1, 1, pp->btype);
pp->match_aux = 1;
}
#ifdef P4EST_ENABLE_DEBUG
else {
for (jl = 0; jl < p4est->local_num_quadrants; ++jl) {
P4EST_ASSERT (pp->flags[jl] == 0);
}
}
#endif
pp->num_refine_flags = 0;
return changed;
}
p6est_lnodes_t *
p6est_lnodes_new (p6est_t * p6est, p6est_ghost_t * ghost, int degree)
{
p6est_lnodes_t *lnodes;
p6est_profile_t *profile;
p4est_lnodes_t *clnodes;
int nperelem = (degree + 1) * (degree + 1) * (degree + 1);
/* int nperface = (degree - 1) * (degree - 1); */
/* int nperedge = (degree - 1); */
p4est_locidx_t ncid, cid, enid, *en;
p4est_locidx_t nnodecols;
p4est_locidx_t nelemcols;
p4est_locidx_t nll;
p4est_locidx_t nlayers;
p4est_locidx_t *layernodecount;
p4est_locidx_t *layernodeoffsets;
p4est_locidx_t (*lr)[2];
p4est_locidx_t ncolnodes;
p4est_locidx_t *global_owned_count;
p4est_locidx_t num_owned, num_local;
p4est_gloidx_t gnum_owned, offset;
p4est_gloidx_t *owned_offsets;
int i, j, k;
int mpisize = p6est->mpisize;
int mpiret;
sc_array_t lnoview;
size_t zz, nsharers;
int Nrp = degree + 1;
if (degree == 1) {
p4est_locidx_t eid, nid, enid2, nid2;
p4est_locidx_t *newnum, newlocal, newowned;
P4EST_GLOBAL_PRODUCTION ("Into adapt p6est_lnodes_new for degree = 1\n");
p4est_log_indent_push ();
/* adapt 2 to 1 */
lnodes = p6est_lnodes_new (p6est, ghost, 2);
nll = p6est->layers->elem_count;
num_local = lnodes->num_local_nodes;
num_owned = lnodes->owned_count;
en = lnodes->element_nodes;
newnum = P4EST_ALLOC (p4est_locidx_t, P8EST_INSUL * nll);
memset (newnum, -1, P8EST_INSUL * nll * sizeof (p4est_locidx_t));
for (enid = 0, eid = 0; eid < nll; eid++) {
for (k = 0; k < 3; k++) {
for (j = 0; j < 3; j++) {
for (i = 0; i < 3; i++, enid++) {
if (k != 1 && j != 1 && i != 1) {
newnum[en[enid]] = 0;
}
}
}
}
}
newlocal = 0;
newowned = 0;
for (nid = 0; nid < num_local; nid++) {
if (newnum[nid] >= 0) {
newnum[nid] = newlocal++;
if (nid < num_owned) {
newowned++;
}
}
}
/* compress en */
enid2 = 0;
for (enid = 0, eid = 0; eid < nll; eid++) {
for (k = 0; k < 3; k++) {
for (j = 0; j < 3; j++) {
for (i = 0; i < 3; i++, enid++) {
if (k != 1 && j != 1 && i != 1) {
en[enid2++] = newnum[en[enid]];
}
}
}
}
}
P4EST_ASSERT (enid2 == P8EST_CHILDREN * nll);
lnodes->element_nodes =
P4EST_REALLOC (en, p4est_locidx_t, P8EST_CHILDREN * nll);
owned_offsets = P4EST_ALLOC (p4est_gloidx_t, mpisize + 1);
mpiret = sc_MPI_Allgather (&newowned, 1, P4EST_MPI_LOCIDX,
lnodes->global_owned_count, 1,
P4EST_MPI_LOCIDX, p6est->mpicomm);
owned_offsets[0] = 0;
for (i = 0; i < mpisize; i++) {
owned_offsets[i + 1] = owned_offsets[i] + lnodes->global_owned_count[i];
}
lnodes->global_offset = owned_offsets[p6est->mpirank];
lnodes->num_local_nodes = newlocal;
lnodes->owned_count = newowned;
lnodes->degree = 1;
lnodes->vnodes = P8EST_CHILDREN;
lnodes->nonlocal_nodes =
P4EST_REALLOC (lnodes->nonlocal_nodes, p4est_gloidx_t,
newlocal - newowned);
nsharers = lnodes->sharers->elem_count;
for (zz = 0; zz < nsharers; zz++) {
size_t nshared, zy, zw;
p6est_lnodes_rank_t *rank = p6est_lnodes_rank_array_index
(lnodes->sharers, zz);
if (rank->owned_count) {
if (rank->rank != p6est->mpirank) {
p4est_locidx_t newrankowned = 0;
p4est_locidx_t newrankoffset = -1;
for (nid = rank->owned_offset; nid < rank->owned_offset +
rank->owned_count; nid++) {
if (newnum[nid] >= 0) {
lnodes->nonlocal_nodes[newnum[nid] - newowned] =
owned_offsets[rank->rank];
newrankowned++;
if (newrankoffset < 0) {
newrankoffset = newnum[nid];
}
}
}
rank->owned_offset = newrankoffset;
rank->owned_count = newrankowned;
}
else {
rank->owned_offset = 0;
rank->owned_count = newowned;
}
}
rank->shared_mine_count = 0;
rank->shared_mine_offset = -1;
zw = 0;
nshared = rank->shared_nodes.elem_count;
for (zy = 0; zy < nshared; zy++) {
nid = *((p4est_locidx_t *) sc_array_index (&rank->shared_nodes, zy));
if (newnum[nid] >= 0) {
p4est_locidx_t *lp;
lp = (p4est_locidx_t *) sc_array_index (&rank->shared_nodes, zw++);
*lp = newnum[nid];
if (newnum[nid] < newowned) {
rank->shared_mine_count++;
if (rank->shared_mine_offset == -1) {
rank->shared_mine_offset = zw - 1;
}
}
}
}
sc_array_resize (&rank->shared_nodes, zw);
}
/* send local numbers to others */
{
sc_array_t view;
sc_array_init_data (&view, newnum, sizeof (p4est_locidx_t), newlocal);
p6est_lnodes_share_owned (&view, lnodes);
}
nid2 = 0;
for (nid = num_owned; nid < num_local; nid++) {
if (newnum[nid] >= 0) {
lnodes->nonlocal_nodes[nid2++] += (p4est_gloidx_t) newnum[nid];
}
}
P4EST_ASSERT (nid2 == newlocal - newowned);
P4EST_FREE (owned_offsets);
P4EST_FREE (newnum);
p4est_log_indent_pop ();
P4EST_GLOBAL_PRODUCTION ("Done adapt p6est_lnodes_new for degree = 1\n");
return lnodes;
}
P4EST_GLOBAL_PRODUCTION ("Into p6est_lnodes_new\n");
p4est_log_indent_push ();
P4EST_ASSERT (degree >= 1);
lnodes = P4EST_ALLOC (p6est_lnodes_t, 1);
/* first get the profile */
profile = p6est_profile_new_local (p6est, ghost, P6EST_PROFILE_INTERSECTION,
P8EST_CONNECT_FULL, degree);
p6est_profile_sync (profile);
lr = (p4est_locidx_t (*)[2]) profile->lnode_ranges;
clnodes = profile->lnodes;
nnodecols = clnodes->num_local_nodes;
nelemcols = clnodes->num_local_elements;
en = clnodes->element_nodes;
layernodecount = P4EST_ALLOC_ZERO (p4est_locidx_t, nnodecols);
layernodeoffsets = P4EST_ALLOC_ZERO (p4est_locidx_t, nnodecols + 1);
for (cid = 0, enid = 0; cid < nelemcols; cid++) {
for (j = 0; j < Nrp; j++) {
for (i = 0; i < Nrp; i++, enid++) {
ncid = en[enid];
nlayers = lr[ncid][1];
P4EST_ASSERT (nlayers);
ncolnodes = nlayers * degree + 1;
layernodecount[ncid] = ncolnodes;
}
}
}
num_owned = 0;
num_local = 0;
for (ncid = 0; ncid < nnodecols; ncid++) {
num_local += layernodecount[ncid];
if (ncid < clnodes->owned_count) {
num_owned += layernodecount[ncid];
}
}
P4EST_VERBOSEF ("p6est_lnodes: %d owned %d local\n", num_owned, num_local);
if (nnodecols) {
layernodeoffsets[0] = 0;
for (ncid = 0; ncid < nnodecols; ncid++) {
layernodeoffsets[ncid + 1] = layernodeoffsets[ncid] +
layernodecount[ncid];
}
}
gnum_owned = num_owned;
owned_offsets = P4EST_ALLOC (p4est_gloidx_t, mpisize + 1);
global_owned_count = P4EST_ALLOC (p4est_locidx_t, mpisize);
mpiret = sc_MPI_Allgather (&gnum_owned, 1, P4EST_MPI_GLOIDX,
owned_offsets, 1, P4EST_MPI_GLOIDX,
p6est->mpicomm);
SC_CHECK_MPI (mpiret);
offset = 0;
for (i = 0; i < mpisize; i++) {
global_owned_count[i] = (p4est_locidx_t) owned_offsets[i];
gnum_owned = owned_offsets[i];
owned_offsets[i] = offset;
offset += gnum_owned;
}
owned_offsets[mpisize] = offset;
nll = p6est->layers->elem_count;
nsharers = clnodes->sharers->elem_count;
lnodes->mpicomm = p6est->mpicomm;
lnodes->num_local_nodes = num_local;
lnodes->owned_count = num_owned;
lnodes->global_offset = owned_offsets[p6est->mpirank];
lnodes->nonlocal_nodes =
P4EST_ALLOC (p4est_gloidx_t, num_local - num_owned);
lnodes->sharers =
sc_array_new_size (sizeof (p6est_lnodes_rank_t), nsharers);
lnodes->global_owned_count = global_owned_count;
lnodes->degree = degree;
lnodes->vnodes = nperelem;
lnodes->num_local_elements = nll;
lnodes->face_code = P4EST_ALLOC (p6est_lnodes_code_t, nll);
lnodes->element_nodes = P4EST_ALLOC (p4est_locidx_t, nperelem * nll);
p6est_profile_element_to_node (p6est, profile, layernodeoffsets,
lnodes->element_nodes, lnodes->face_code);
for (zz = 0; zz < nsharers; zz++) {
p4est_lnodes_rank_t *crank = p4est_lnodes_rank_array_index
(clnodes->sharers, zz);
p6est_lnodes_rank_t *rank = p6est_lnodes_rank_array_index
(lnodes->sharers, zz);
size_t zy;
size_t nshared;
rank->rank = crank->rank;
sc_array_init (&rank->shared_nodes, sizeof (p4est_locidx_t));
nshared = crank->shared_nodes.elem_count;
rank->owned_offset = -1;
rank->owned_count = 0;
rank->shared_mine_count = 0;
rank->shared_mine_offset = -1;
for (zy = 0; zy < nshared; zy++) {
p4est_locidx_t cnid =
*((p4est_locidx_t *) sc_array_index (&crank->shared_nodes, zy));
p4est_locidx_t *lp;
p4est_locidx_t nthis, il;
p4est_locidx_t old_count = rank->shared_nodes.elem_count;
nthis = layernodecount[cnid];
lp =
(p4est_locidx_t *) sc_array_push_count (&rank->shared_nodes, nthis);
for (il = 0; il < nthis; il++) {
lp[il] = layernodeoffsets[cnid] + il;
if (zy >= (size_t) crank->shared_mine_offset
&& (p4est_locidx_t) zy - crank->shared_mine_offset <
crank->shared_mine_count) {
rank->shared_mine_count++;
if (rank->shared_mine_offset == -1) {
rank->shared_mine_offset = old_count + il;
}
}
if (cnid >= crank->owned_offset
&& cnid - crank->owned_offset < crank->owned_count) {
rank->owned_count++;
if (rank->owned_offset == -1) {
rank->owned_offset = lp[il];
}
}
}
}
if (rank->rank == p6est->mpirank) {
rank->owned_offset = 0;
rank->owned_count = num_owned;
}
}
memcpy (layernodecount, layernodeoffsets,
nnodecols * sizeof (p4est_locidx_t));
sc_array_init_data (&lnoview, layernodecount, sizeof (p4est_locidx_t),
(size_t) nnodecols);
p4est_lnodes_share_owned (&lnoview, clnodes);
for (zz = 0; zz < nsharers; zz++) {
p4est_lnodes_rank_t *crank = p4est_lnodes_rank_array_index
(clnodes->sharers, zz);
if (crank->rank == p6est->mpirank) {
continue;
}
for (ncid = crank->owned_offset;
ncid < crank->owned_offset + crank->owned_count; ncid++) {
p4est_gloidx_t owners_offset;
p4est_locidx_t nid;
P4EST_ASSERT (ncid >= clnodes->owned_count);
owners_offset = owned_offsets[crank->rank] + layernodecount[ncid];
for (nid = layernodeoffsets[ncid]; nid < layernodeoffsets[ncid + 1];
nid++) {
P4EST_ASSERT (nid >= num_owned);
P4EST_ASSERT (nid < num_local);
lnodes->nonlocal_nodes[nid - num_owned] = owners_offset++;
}
}
}
p6est_profile_destroy (profile);
P4EST_FREE (owned_offsets);
P4EST_FREE (layernodecount);
P4EST_FREE (layernodeoffsets);
p4est_log_indent_pop ();
P4EST_GLOBAL_PRODUCTION ("Done p6est_lnodes_new\n");
return lnodes;
}
p4est_mesh_t *
p4est_mesh_new_ext (p4est_t * p4est, p4est_ghost_t * ghost,
int compute_tree_index, int compute_level_lists,
p4est_connect_type_t btype)
{
int do_corner = 0;
int do_volume = 0;
int rank;
p4est_locidx_t lq, ng;
p4est_locidx_t jl;
p4est_mesh_t *mesh;
P4EST_ASSERT (p4est_is_balanced (p4est, btype));
mesh = P4EST_ALLOC_ZERO (p4est_mesh_t, 1);
lq = mesh->local_num_quadrants = p4est->local_num_quadrants;
ng = mesh->ghost_num_quadrants = (p4est_locidx_t) ghost->ghosts.elem_count;
if (btype == P4EST_CONNECT_FULL) {
do_corner = 1;
}
do_volume = (compute_tree_index || compute_level_lists ? 1 : 0);
/* Optional map of tree index for each quadrant */
if (compute_tree_index) {
mesh->quad_to_tree = P4EST_ALLOC (p4est_topidx_t, lq);
}
mesh->ghost_to_proc = P4EST_ALLOC (int, ng);
mesh->quad_to_quad = P4EST_ALLOC (p4est_locidx_t, P4EST_FACES * lq);
mesh->quad_to_face = P4EST_ALLOC (int8_t, P4EST_FACES * lq);
mesh->quad_to_half = sc_array_new (P4EST_HALF * sizeof (p4est_locidx_t));
/* Optional per-level lists of quadrants */
if (compute_level_lists) {
mesh->quad_level = P4EST_ALLOC (sc_array_t, P4EST_QMAXLEVEL + 1);
for (jl = 0; jl <= P4EST_QMAXLEVEL; ++jl) {
sc_array_init (mesh->quad_level + jl, sizeof (p4est_locidx_t));
}
}
/* Populate ghost information */
rank = 0;
for (jl = 0; jl < ng; ++jl) {
while (ghost->proc_offsets[rank + 1] <= jl) {
++rank;
P4EST_ASSERT (rank < p4est->mpisize);
}
mesh->ghost_to_proc[jl] = rank;
}
/* Fill face arrays with default values */
memset (mesh->quad_to_quad, -1, P4EST_FACES * lq * sizeof (p4est_locidx_t));
memset (mesh->quad_to_face, -25, P4EST_FACES * lq * sizeof (int8_t));
if (do_corner) {
/* Initialize corner information to a consistent state */
mesh->quad_to_corner = P4EST_ALLOC (p4est_locidx_t, P4EST_CHILDREN * lq);
memset (mesh->quad_to_corner, -1, P4EST_CHILDREN * lq *
sizeof (p4est_locidx_t));
mesh->corner_offset = sc_array_new (sizeof (p4est_locidx_t));
*(p4est_locidx_t *) sc_array_push (mesh->corner_offset) = 0;
mesh->corner_quad = sc_array_new (sizeof (p4est_locidx_t));
mesh->corner_corner = sc_array_new (sizeof (int8_t));
}
/* Call the forest iterator to collect face connectivity */
p4est_iterate (p4est, ghost, mesh,
(do_volume ? mesh_iter_volume : NULL), mesh_iter_face,
#ifdef P4_TO_P8
NULL,
#endif
do_corner ? mesh_iter_corner : NULL);
return mesh;
}