void
p4est_wrap_destroy (p4est_wrap_t * pp)
{
if (pp->mesh_aux != NULL) {
p4est_mesh_destroy (pp->mesh_aux);
}
if (pp->ghost_aux != NULL) {
p4est_ghost_destroy (pp->ghost_aux);
}
if (!pp->hollow) {
p4est_mesh_destroy (pp->mesh);
p4est_ghost_destroy (pp->ghost);
}
P4EST_FREE (pp->flags);
P4EST_FREE (pp->temp_flags);
p4est_destroy (pp->p4est);
/* safety checks for connectivity ownership */
if (pp->conn_owner != NULL) {
/* we are a copy of a wrap and have borrowed its connectivity */
P4EST_ASSERT (!sc_refcount_is_active (&pp->conn_rc));
P4EST_EXECUTE_ASSERT_FALSE (sc_refcount_unref (&pp->conn_owner->conn_rc));
}
else {
/* we are the original wrap that owns the connectivity */
P4EST_EXECUTE_ASSERT_TRUE (sc_refcount_unref (&pp->conn_rc));
p4est_connectivity_destroy (pp->conn);
}
P4EST_FREE (pp);
}
static void
hack_test (mpi_context_t * mpi, p4est_connectivity_t * connectivity)
{
int i;
int8_t cc;
p4est_topidx_t tt;
p4est_locidx_t lnq, lng, lnc, lnco;
p4est_locidx_t li, qtc;
p4est_locidx_t co0, co1, coi, cq;
p4est_t *p4est;
p4est_ghost_t *ghost;
p4est_mesh_t *mesh;
p4est = p4est_new_ext (mpi->mpicomm, connectivity, 0,
refine_level, 1, 0, NULL, NULL);
p4est_vtk_write_file (p4est, NULL, "mesh_hack");
ghost = p4est_ghost_new (p4est, P4EST_CONNECT_FULL);
mesh = p4est_mesh_new_ext (p4est, ghost, 1, 1, P4EST_CONNECT_FULL);
lnq = mesh->local_num_quadrants;
lng = mesh->ghost_num_quadrants;
lnco = lnq + lng;
lnc = mesh->local_num_corners;
P4EST_LDEBUGF ("Local quads %lld corners %lld array %lld\n",
(long long) lnq, (long long) lnc,
(long long) mesh->corner_offset->elem_count);
for (li = 0; li < lnq; ++li) {
tt = mesh->quad_to_tree[li];
if (tt >= 2) {
/* break; */
}
for (i = 0; i < P4EST_CHILDREN; ++i) {
qtc = mesh->quad_to_corner[P4EST_CHILDREN * li + i];
if (qtc >= lnco) {
P4EST_LDEBUGF ("Quad %lld tree %lld Corner %d is %lld\n",
(long long) li, (long long) tt, i, (long long) qtc);
if (qtc >= lnco) {
qtc -= lnco;
co0 = *(p4est_locidx_t *) sc_array_index (mesh->corner_offset, qtc);
co1 =
*(p4est_locidx_t *) sc_array_index (mesh->corner_offset, qtc + 1);
for (coi = co0; coi < co1; ++coi) {
cq = *(p4est_locidx_t *) sc_array_index (mesh->corner_quad, coi);
cc = *(int8_t *) sc_array_index (mesh->corner_corner, coi);
P4EST_LDEBUGF (" Part %d quad %lld corner %d\n",
(int) (coi - co0), (long long) cq, (int) cc);
}
}
}
}
}
p4est_mesh_destroy (mesh);
p4est_ghost_destroy (ghost);
p4est_destroy (p4est);
}
void
p4est_wrap_complete (p4est_wrap_t * pp)
{
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 == 0);
p4est_mesh_destroy (pp->mesh_aux);
p4est_ghost_destroy (pp->ghost_aux);
pp->ghost_aux = NULL;
pp->mesh_aux = NULL;
}
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;
}
static void
mesh_run (mpi_context_t * mpi, p4est_connectivity_t * connectivity,
int uniform, int compute_tree_index, int compute_level_lists,
p4est_connect_type_t mesh_btype)
{
int mpiret;
unsigned crc;
long local_used[4], global_used[4];
p4est_t *p4est;
p4est_ghost_t *ghost;
p4est_mesh_t *mesh;
user_data_t *ghost_data;
p4est = p4est_new (mpi->mpicomm, connectivity,
sizeof (user_data_t), init_fn, NULL);
if (!uniform)
p4est_vtk_write_file (p4est, NULL, P4EST_STRING "_mesh_new");
/* refinement */
if (uniform) {
p4est_refine (p4est, 1, refine_uniform, init_fn);
}
else {
p4est_refine (p4est, 1, refine_normal, init_fn);
p4est_vtk_write_file (p4est, NULL, P4EST_STRING "_mesh_refined");
}
/* balance */
p4est_balance (p4est, P4EST_CONNECT_FULL, init_fn);
if (!uniform)
p4est_vtk_write_file (p4est, NULL, P4EST_STRING "_mesh_balanced");
/* partition */
p4est_partition (p4est, 0, NULL);
if (!uniform) {
p4est_vtk_write_file (p4est, NULL, P4EST_STRING "_mesh_partition");
}
crc = p4est_checksum (p4est);
/* print and verify forest checksum */
P4EST_GLOBAL_STATISTICSF ("Tree %s checksum 0x%08x\n",
uniform ? "uniform" : "adapted", crc);
/* create ghost layer and mesh */
ghost = p4est_ghost_new (p4est, P4EST_CONNECT_FULL);
ghost_data = P4EST_ALLOC (user_data_t, ghost->ghosts.elem_count);
p4est_ghost_exchange_data (p4est, ghost, ghost_data);
mesh = p4est_mesh_new_ext (p4est, ghost,
compute_tree_index, compute_level_lists,
mesh_btype);
test_mesh (p4est, ghost, mesh,
compute_tree_index, compute_level_lists, mesh_btype,
ghost_data, uniform);
/* compute memory used */
local_used[0] = (long) p4est_connectivity_memory_used (p4est->connectivity);
local_used[1] = (long) p4est_memory_used (p4est);
local_used[2] = (long) p4est_ghost_memory_used (ghost);
local_used[3] = (long) p4est_mesh_memory_used (mesh);
mpiret = sc_MPI_Allreduce (local_used, global_used, 4, sc_MPI_LONG,
sc_MPI_SUM, mpi->mpicomm);
SC_CHECK_MPI (mpiret);
P4EST_GLOBAL_PRODUCTIONF ("Total %s memory used %ld %ld %ld %ld\n",
uniform ? "uniform" : "adapted",
global_used[0], global_used[1],
global_used[2], global_used[3]);
/* destroy ghost layer and mesh */
P4EST_FREE (ghost_data);
p4est_mesh_destroy (mesh);
p4est_ghost_destroy (ghost);
/* destroy the p4est structure */
p4est_destroy (p4est);
}
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;
}