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_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_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;
}
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;
}
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;
}
p4est_mesh_t *
p4est_mesh_new (p4est_t * p4est, p4est_ghost_t * ghost,
p4est_connect_type_t btype)
{
return p4est_mesh_new_ext (p4est, ghost, 0, 0, btype);
}
