static void
check_all (sc_MPI_Comm mpicomm, p4est_connectivity_t * conn,
const char *vtkname, unsigned crc_expected, unsigned gcrc_expected)
{
int mpiret;
unsigned crc_computed, gcrc_computed;
long long lsize[3], gsize[3];
size_t size_conn, size_p4est, size_ghost;
p4est_t *p4est;
p4est_nodes_t *nodes;
p4est_ghost_t *ghost;
P4EST_GLOBAL_STATISTICSF ("Testing configuration %s\n", vtkname);
p4est = p4est_new_ext (mpicomm, conn, 0, 0, 0, 0, NULL, NULL);
p4est_refine (p4est, 1, refine_fn, NULL);
p4est_coarsen (p4est, 1, coarsen_fn, NULL);
p4est_balance (p4est, P4EST_CONNECT_FULL, NULL);
p4est_partition (p4est, 0, NULL);
p4est_vtk_write_file (p4est, NULL, vtkname);
crc_computed = p4est_checksum (p4est);
P4EST_GLOBAL_STATISTICSF ("Forest checksum 0x%08x\n", crc_computed);
if (p4est->mpisize == 2 && p4est->mpirank == 0) {
SC_CHECK_ABORT (crc_computed == crc_expected, "Forest checksum mismatch");
}
ghost = p4est_ghost_new (p4est, P4EST_CONNECT_FULL);
/* compute total size of forest storage */
size_conn = p4est_connectivity_memory_used (conn);
size_p4est = p4est_memory_used (p4est);
size_ghost = p4est_ghost_memory_used (ghost);
lsize[0] = (long long) size_conn;
lsize[1] = (long long) size_p4est;
lsize[2] = (long long) size_ghost;
mpiret = sc_MPI_Reduce (lsize, gsize, 3, sc_MPI_LONG_LONG_INT, sc_MPI_SUM,
0, mpicomm);
SC_CHECK_MPI (mpiret);
P4EST_GLOBAL_INFOF ("Global byte sizes: %lld %lld %lld\n",
gsize[0], gsize[1], gsize[2]);
gcrc_computed = p4est_ghost_checksum (p4est, ghost);
P4EST_GLOBAL_STATISTICSF ("Ghost checksum 0x%08x\n", gcrc_computed);
if (p4est->mpisize == 2 && p4est->mpirank == 0) {
SC_CHECK_ABORT (gcrc_computed == gcrc_expected,
"Ghost checksum mismatch");
}
nodes = p4est_nodes_new (p4est, ghost);
p4est_nodes_destroy (nodes);
p4est_ghost_destroy (ghost);
p4est_destroy (p4est);
p4est_connectivity_destroy (conn);
}
int
main (int argc, char **argv)
{
sc_MPI_Comm mpicomm;
int mpiret;
int mpisize, mpirank;
unsigned crc;
#ifndef P4_TO_P8
size_t kz;
int8_t l;
p4est_quadrant_t *q;
p4est_tree_t stree, *tree = &stree;
#endif
p4est_t *p4est;
p4est_connectivity_t *connectivity;
/* initialize MPI */
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpicomm = sc_MPI_COMM_WORLD;
mpiret = sc_MPI_Comm_size (mpicomm, &mpisize);
SC_CHECK_MPI (mpiret);
mpiret = sc_MPI_Comm_rank (mpicomm, &mpirank);
SC_CHECK_MPI (mpiret);
sc_init (mpicomm, 1, 1, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
#ifndef P4_TO_P8
connectivity = p4est_connectivity_new_star ();
#else
connectivity = p8est_connectivity_new_rotcubes ();
#endif
p4est = p4est_new_ext (mpicomm, connectivity, 0, 0, 0, 4, NULL, NULL);
#ifndef P4_TO_P8
/* build empty tree */
sc_array_init (&tree->quadrants, sizeof (p4est_quadrant_t));
for (l = 0; l <= P4EST_MAXLEVEL; ++l) {
tree->quadrants_per_level[l] = 0;
}
tree->maxlevel = 0;
/* insert two quadrants */
sc_array_resize (&tree->quadrants, 4);
q = p4est_quadrant_array_index (&tree->quadrants, 0);
p4est_quadrant_set_morton (q, 3, 13);
q = p4est_quadrant_array_index (&tree->quadrants, 1);
p4est_quadrant_set_morton (q, 1, 1);
q = p4est_quadrant_array_index (&tree->quadrants, 2);
p4est_quadrant_set_morton (q, 1, 2);
q = p4est_quadrant_array_index (&tree->quadrants, 3);
p4est_quadrant_set_morton (q, 1, 3);
for (kz = 0; kz < tree->quadrants.elem_count; ++kz) {
q = p4est_quadrant_array_index (&tree->quadrants, kz);
q->p.user_data = sc_mempool_alloc (p4est->user_data_pool);
++tree->quadrants_per_level[q->level];
tree->maxlevel = (int8_t) SC_MAX (tree->maxlevel, q->level);
}
/* balance the tree, print and destroy */
#if 0
p4est_balance_subtree (p4est, P4EST_CONNECT_FULL, 0, NULL);
p4est_tree_print (SC_LP_INFO, tree);
#endif
for (kz = 0; kz < tree->quadrants.elem_count; ++kz) {
q = p4est_quadrant_array_index (&tree->quadrants, kz);
sc_mempool_free (p4est->user_data_pool, q->p.user_data);
}
sc_array_reset (&tree->quadrants);
#endif /* !P4_TO_P8 */
/* check reset data function */
p4est_reset_data (p4est, 0, init_fn, NULL);
p4est_reset_data (p4est, 0, NULL, NULL);
/* refine and balance the forest */
SC_CHECK_ABORT (p4est_is_balanced (p4est, P4EST_CONNECT_FULL), "Balance 1");
p4est_refine (p4est, 1, refine_fn, NULL);
SC_CHECK_ABORT (!p4est_is_balanced (p4est, P4EST_CONNECT_FULL),
"Balance 2");
p4est_balance (p4est, P4EST_CONNECT_FULL, NULL);
SC_CHECK_ABORT (p4est_is_balanced (p4est, P4EST_CONNECT_FULL), "Balance 3");
/* check reset data function */
p4est_reset_data (p4est, 17, NULL, NULL);
p4est_reset_data (p4est, 8, init_fn, NULL);
/* checksum and partition */
crc = p4est_checksum (p4est);
p4est_partition (p4est, 0, NULL);
SC_CHECK_ABORT (p4est_checksum (p4est) == crc, "Partition");
SC_CHECK_ABORT (p4est_is_balanced (p4est, P4EST_CONNECT_FULL), "Balance 4");
/* check reset data function */
p4est_reset_data (p4est, 3, NULL, NULL);
p4est_reset_data (p4est, 3, NULL, NULL);
/* checksum and rebalance */
crc = p4est_checksum (p4est);
p4est_balance (p4est, P4EST_CONNECT_FULL, NULL);
SC_CHECK_ABORT (p4est_checksum (p4est) == crc, "Rebalance");
/* clean up and exit */
P4EST_ASSERT (p4est->user_data_pool->elem_count ==
(size_t) p4est->local_num_quadrants);
p4est_destroy (p4est);
p4est_connectivity_destroy (connectivity);
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
int
main (int argc, char **argv)
{
int mpiret;
sc_MPI_Comm mpicomm;
p4est_t *p4est;
p4est_connectivity_t *connectivity;
p4est_locidx_t save_local_count;
p4est_geometry_t *geom;
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpicomm = sc_MPI_COMM_WORLD;
sc_init (mpicomm, 1, 1, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
/* create connectivity and forest structures */
#ifdef P4_TO_P8
connectivity = p8est_connectivity_new_rotcubes ();
geom = NULL;
#else
connectivity = p4est_connectivity_new_star ();
geom = p4est_geometry_new_connectivity (connectivity);
#endif
p4est = p4est_new_ext (mpicomm, connectivity, 15, 0, 0, 0, NULL, NULL);
save_local_count = p4est->local_num_quadrants;
refine_callback_count = 0;
p4est_refine_ext (p4est, 0, 2, test_refine, NULL, NULL);
SC_CHECK_ABORT (refine_callback_count == save_local_count, "Refine count");
refine_callback_count = 0;
p4est_refine (p4est, 1, test_refine, NULL);
p4est_balance (p4est, P4EST_CONNECT_FULL, NULL);
coarsen_all = 1;
p4est_coarsen_both (p4est, 0, test_coarsen, NULL);
coarsen_all = 0;
p4est_coarsen_both (p4est, 1, test_coarsen, NULL);
p4est_balance (p4est, P4EST_CONNECT_FULL, NULL);
coarsen_all = 1;
p4est_coarsen_both (p4est, 1, test_coarsen, NULL);
p4est_vtk_write_file (p4est, geom, P4EST_STRING "_endcoarsen");
if (p4est->mpisize == 1) {
SC_CHECK_ABORT (p4est->global_num_quadrants ==
(p4est_gloidx_t) connectivity->num_trees, "Coarsen all");
}
p4est_destroy (p4est);
if (geom != NULL) {
p4est_geometry_destroy (geom);
}
p4est_connectivity_destroy (connectivity);
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
static void
run_load (sc_MPI_Comm mpicomm, p4est_connectivity_t * conn, int level)
{
int mpiret;
double elapsed_create, elapsed_partition, elapsed_balance;
#ifdef LOADCONN_VTK
char filename[BUFSIZ];
#endif
p4est_t *p4est;
P4EST_GLOBAL_PRODUCTIONF ("Run load on level %d\n", level);
/* create and refine the forest */
mpiret = sc_MPI_Barrier (mpicomm);
SC_CHECK_MPI (mpiret);
elapsed_create = -sc_MPI_Wtime ();
p4est = p4est_new_ext (mpicomm, conn, 0, level, 1, 0, NULL, NULL);
level_shift = 4;
refine_level = level + level_shift;
p4est_refine (p4est, 1, refine_fractal, NULL);
elapsed_create += sc_MPI_Wtime ();
#ifdef LOADCONN_VTK
snprintf (filename, BUFSIZ, "loadconn%d_%02d_C", P4EST_DIM, level);
p4est_vtk_write_file (p4est, NULL, filename);
#endif
/* partition the forest */
mpiret = sc_MPI_Barrier (mpicomm);
SC_CHECK_MPI (mpiret);
elapsed_partition = -sc_MPI_Wtime ();
p4est_partition (p4est, 0, NULL);
elapsed_partition += sc_MPI_Wtime ();
/* balance the forest */
mpiret = sc_MPI_Barrier (mpicomm);
SC_CHECK_MPI (mpiret);
elapsed_balance = -sc_MPI_Wtime ();
p4est_balance (p4est, P4EST_CONNECT_FULL, NULL);
elapsed_balance += sc_MPI_Wtime ();
#ifdef LOADCONN_VTK
snprintf (filename, BUFSIZ, "loadconn%d_%02d_B", P4EST_DIM, level);
p4est_vtk_write_file (p4est, NULL, filename);
#endif
/* report timings */
P4EST_GLOBAL_PRODUCTIONF ("Timings %d: %g %g %g\n", level, elapsed_create,
elapsed_partition, elapsed_balance);
p4est_destroy (p4est);
}
int
main (int argc, char **argv)
{
sc_MPI_Comm mpicomm;
int mpiret;
int size, rank;
unsigned crcF, crcC;
p4est_connectivity_t *connectivity;
p4est_t *p4est;
p4est_t *p4estF, *p4estC;
#ifdef P4_TO_P8
unsigned crcE;
p4est_t *p4estE;
#endif
/* initialize */
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpicomm = sc_MPI_COMM_WORLD;
mpiret = sc_MPI_Comm_size (mpicomm, &size);
SC_CHECK_MPI (mpiret);
mpiret = sc_MPI_Comm_rank (mpicomm, &rank);
SC_CHECK_MPI (mpiret);
sc_init (mpicomm, 1, 1, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
/* create forest and refine */
#ifndef P4_TO_P8
connectivity = p4est_connectivity_new_star ();
#else
connectivity = p8est_connectivity_new_rotcubes ();
#endif
p4est = p4est_new_ext (mpicomm, connectivity, 0, 0, 0, 0, NULL, NULL);
p4est_refine (p4est, 1, refine_fn, NULL);
/* test face balance */
p4estF = p4est_copy (p4est, 0);
#ifndef P4_TO_P8
p4est_balance (p4estF, P4EST_CONNECT_FACE, NULL);
#else
p4est_balance (p4estF, P8EST_CONNECT_FACE, NULL);
#endif
crcF = p4est_checksum (p4estF);
P4EST_GLOBAL_INFOF ("Face balance with %lld quadrants and crc 0x%08x\n",
(long long) p4estF->global_num_quadrants, crcF);
#ifdef P4_TO_P8
/* test edge balance */
p4estE = p4est_copy (p4est, 1);
p4est_balance (p4estF, P8EST_CONNECT_EDGE, NULL);
p4est_balance (p4estE, P8EST_CONNECT_EDGE, NULL);
crcE = p4est_checksum (p4estE);
SC_CHECK_ABORT (crcE == p4est_checksum (p4estF), "mismatch A");
P4EST_GLOBAL_INFOF ("Edge balance with %lld quadrants and crc 0x%08x\n",
(long long) p4estE->global_num_quadrants, crcE);
#endif
/* test corner balance */
p4estC = p4est_copy (p4est, 1);
#ifndef P4_TO_P8
p4est_balance (p4estF, P4EST_CONNECT_CORNER, NULL);
p4est_balance (p4estC, P4EST_CONNECT_CORNER, NULL);
#else
p4est_balance (p4estF, P8EST_CONNECT_CORNER, NULL);
p4est_balance (p4estC, P8EST_CONNECT_CORNER, NULL);
#endif
crcC = p4est_checksum (p4estC);
SC_CHECK_ABORT (crcC == p4est_checksum (p4estF), "mismatch B");
P4EST_GLOBAL_INFOF ("Corner balance with %lld quadrants and crc 0x%08x\n",
(long long) p4estC->global_num_quadrants, crcC);
/* destroy forests and connectivity */
p4est_destroy (p4est);
p4est_destroy (p4estF);
#ifdef P4_TO_P8
p4est_destroy (p4estE);
#endif
p4est_destroy (p4estC);
p4est_connectivity_destroy (connectivity);
/* clean up and exit */
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
int
main (int argc, char **argv)
{
int rank;
int mpiret;
sc_MPI_Comm mpicomm;
p4est_t *p4est;
p4est_connectivity_t *connectivity;
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpicomm = sc_MPI_COMM_WORLD;
mpiret = sc_MPI_Comm_rank (mpicomm, &rank);
SC_CHECK_MPI (mpiret);
sc_init (mpicomm, 1, 1, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
/* create connectivity and forest structures */
connectivity = p4est_connectivity_new_star ();
p4est = p4est_new_ext (mpicomm, connectivity, 15, 0, 0,
sizeof (user_data_t), init_fn, NULL);
/* refine to make the number of elements interesting */
p4est_refine (p4est, 1, refine_fn, init_fn);
/* balance the forest */
p4est_balance (p4est, P4EST_CONNECT_FULL, init_fn);
/* do a uniform partition, include the weight function for testing */
p4est_partition (p4est, 0, weight_one);
p4est_check_local_order (p4est, connectivity);
/* do a weighted partition with many zero weights */
weight_counter = 0;
weight_index = (rank == 1) ? 1342 : 0;
p4est_partition (p4est, 0, weight_once);
p4est_check_local_order (p4est, connectivity);
/* clean up */
p4est_destroy (p4est);
p4est_connectivity_destroy (connectivity);
/* create connectivity and forest structures */
connectivity = p4est_connectivity_new_periodic ();
p4est = p4est_new_ext (mpicomm, connectivity, 15, 0, 0,
sizeof (user_data_t), init_fn, NULL);
/* refine to make the number of elements interesting */
p4est_refine (p4est, 1, refine_fn, init_fn);
/* balance the forest */
p4est_balance (p4est, P4EST_CONNECT_FULL, init_fn);
/* do a uniform partition, include the weight function for testing */
p4est_partition (p4est, 0, weight_one);
p4est_check_local_order (p4est, connectivity);
/* clean up and exit */
p4est_destroy (p4est);
p4est_connectivity_destroy (connectivity);
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
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
main (int argc, char **argv)
{
sc_MPI_Comm mpicomm;
int mpiret;
int mpisize, mpirank;
p4est_t *p4est;
p4est_connectivity_t *conn;
sc_array_t *points_per_dim, *cone_sizes, *cones,
*cone_orientations, *coords,
*children, *parents, *childids, *leaves, *remotes;
p4est_locidx_t first_local_quad = -1;
/* initialize MPI */
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpicomm = sc_MPI_COMM_WORLD;
mpiret = sc_MPI_Comm_size (mpicomm, &mpisize);
SC_CHECK_MPI (mpiret);
mpiret = sc_MPI_Comm_rank (mpicomm, &mpirank);
SC_CHECK_MPI (mpiret);
sc_init (mpicomm, 1, 1, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
#ifndef P4_TO_P8
conn = p4est_connectivity_new_moebius ();
#else
conn = p8est_connectivity_new_rotcubes ();
#endif
p4est = p4est_new_ext (mpicomm, conn, 0, 1, 1, 0, NULL, NULL);
p4est_refine (p4est, 1, refine_fn, NULL);
p4est_balance (p4est, P4EST_CONNECT_FULL, NULL);
p4est_partition (p4est, 0, NULL);
points_per_dim = sc_array_new (sizeof (p4est_locidx_t));
cone_sizes = sc_array_new (sizeof (p4est_locidx_t));
cones = sc_array_new (sizeof (p4est_locidx_t));
cone_orientations = sc_array_new (sizeof (p4est_locidx_t));
coords = sc_array_new (3 * sizeof (double));
children = sc_array_new (sizeof (p4est_locidx_t));
parents = sc_array_new (sizeof (p4est_locidx_t));
childids = sc_array_new (sizeof (p4est_locidx_t));
leaves = sc_array_new (sizeof (p4est_locidx_t));
remotes = sc_array_new (2 * sizeof (p4est_locidx_t));
p4est_get_plex_data (p4est, P4EST_CONNECT_FULL, (mpisize > 1) ? 2 : 0,
&first_local_quad, points_per_dim, cone_sizes, cones,
cone_orientations, coords, children, parents, childids,
leaves, remotes);
#ifdef P4EST_WITH_PETSC
{
PetscErrorCode ierr;
DM plex, refTree;
PetscInt pStart, pEnd;
PetscSection parentSection;
PetscSF pointSF;
size_t zz, count;
locidx_to_PetscInt (points_per_dim);
locidx_to_PetscInt (cone_sizes);
locidx_to_PetscInt (cones);
locidx_to_PetscInt (cone_orientations);
coords_double_to_PetscScalar (coords);
locidx_to_PetscInt (children);
locidx_to_PetscInt (parents);
locidx_to_PetscInt (childids);
locidx_to_PetscInt (leaves);
locidx_pair_to_PetscSFNode (remotes);
P4EST_GLOBAL_PRODUCTION ("Begin PETSc routines\n");
ierr = PetscInitialize (&argc, &argv, 0, help);
CHKERRQ (ierr);
ierr = DMPlexCreate (mpicomm, &plex);
CHKERRQ (ierr);
ierr = DMSetDimension (plex, P4EST_DIM);
CHKERRQ (ierr);
ierr = DMSetCoordinateDim (plex, 3);
CHKERRQ (ierr);
ierr = DMPlexCreateFromDAG (plex, P4EST_DIM,
(PetscInt *) points_per_dim->array,
(PetscInt *) cone_sizes->array,
(PetscInt *) cones->array,
(PetscInt *) cone_orientations->array,
(PetscScalar *) coords->array);
CHKERRQ (ierr);
ierr = PetscSFCreate (mpicomm, &pointSF);
CHKERRQ (ierr);
ierr =
DMPlexCreateDefaultReferenceTree (mpicomm, P4EST_DIM, PETSC_FALSE,
&refTree);
CHKERRQ (ierr);
ierr = DMPlexSetReferenceTree (plex, refTree);
CHKERRQ (ierr);
ierr = DMDestroy (&refTree);
CHKERRQ (ierr);
ierr = PetscSectionCreate (mpicomm, &parentSection);
CHKERRQ (ierr);
ierr = DMPlexGetChart (plex, &pStart, &pEnd);
CHKERRQ (ierr);
ierr = PetscSectionSetChart (parentSection, pStart, pEnd);
CHKERRQ (ierr);
count = children->elem_count;
for (zz = 0; zz < count; zz++) {
PetscInt child =
*((PetscInt *) sc_array_index (children, zz));
ierr = PetscSectionSetDof (parentSection, child, 1);
CHKERRQ (ierr);
}
ierr = PetscSectionSetUp (parentSection);
CHKERRQ (ierr);
ierr =
DMPlexSetTree (plex, parentSection, (PetscInt *) parents->array,
(PetscInt *) childids->array);
CHKERRQ (ierr);
ierr = PetscSectionDestroy (&parentSection);
CHKERRQ (ierr);
ierr =
PetscSFSetGraph (pointSF, pEnd - pStart, (PetscInt) leaves->elem_count,
(PetscInt *) leaves->array, PETSC_COPY_VALUES,
(PetscSFNode *) remotes->array, PETSC_COPY_VALUES);
CHKERRQ (ierr);
ierr = DMViewFromOptions (plex, NULL, "-dm_view");
CHKERRQ (ierr);
/* TODO: test with rigid body modes as in plex ex3 */
ierr = DMDestroy (&plex);
CHKERRQ (ierr);
ierr = PetscFinalize ();
P4EST_GLOBAL_PRODUCTION ("End PETSc routines\n");
}
#endif
sc_array_destroy (points_per_dim);
sc_array_destroy (cone_sizes);
sc_array_destroy (cones);
sc_array_destroy (cone_orientations);
sc_array_destroy (coords);
sc_array_destroy (children);
sc_array_destroy (parents);
sc_array_destroy (childids);
sc_array_destroy (leaves);
sc_array_destroy (remotes);
p4est_destroy (p4est);
p4est_connectivity_destroy (conn);
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
static void
run_bricks (MPI_Comm mpicomm, int per, int l, int rlevel)
{
int mpiret;
int tcount;
double elapsed_create, elapsed_partition, elapsed_balance;
#ifdef BRICKS_VTK
char filename[BUFSIZ];
#endif
p4est_connectivity_t *conn;
p4est_t *p4est;
P4EST_GLOBAL_PRODUCTIONF ("Run bricks on level %d/%d\n", l, rlevel);
P4EST_ASSERT (l <= rlevel);
/* create and refine the forest */
mpiret = MPI_Barrier (mpicomm);
SC_CHECK_MPI (mpiret);
elapsed_create = -MPI_Wtime ();
tcount = 1 << l;
#ifndef P4_TO_P8
conn = p4est_connectivity_new_brick (tcount, tcount, per, per);
#else
conn = p8est_connectivity_new_brick (tcount, tcount, tcount, per, per, per);
#endif
p4est = p4est_new_ext (mpicomm, conn, 0, rlevel - l, 1, 0, NULL, NULL);
level_shift = 4;
refine_level = rlevel - l + level_shift;
p4est_refine (p4est, 1, refine_fractal, NULL);
elapsed_create += MPI_Wtime ();
/* partition the forest */
mpiret = MPI_Barrier (mpicomm);
SC_CHECK_MPI (mpiret);
elapsed_partition = -MPI_Wtime ();
p4est_partition (p4est, NULL);
elapsed_partition += MPI_Wtime ();
/* balance the forest */
mpiret = MPI_Barrier (mpicomm);
SC_CHECK_MPI (mpiret);
elapsed_balance = -MPI_Wtime ();
p4est_balance (p4est, P4EST_CONNECT_FULL, NULL);
elapsed_balance += MPI_Wtime ();
/* postprocessing */
P4EST_GLOBAL_PRODUCTIONF ("Timings %g %g %g\n", elapsed_create,
elapsed_partition, elapsed_balance);
#ifdef BRICKS_VTK
snprintf (filename, BUFSIZ, "brick_%02d_%02d_B", rlevel, l);
p4est_vtk_write_file (p4est, NULL, filename);
#endif
p4est_destroy (p4est);
p4est_connectivity_destroy (conn);
}
/** The main step 3 program.
*
* Setup of the example parameters; create the forest, with the state variable
* stored in the quadrant data; refine, balance, and partition the forest;
* timestep; clean up, and exit.
*/
int
main (int argc, char **argv)
{
int mpiret;
int recursive, partforcoarsen;
sc_MPI_Comm mpicomm;
p4est_t *p4est;
p4est_connectivity_t *conn;
step3_ctx_t ctx;
/* Initialize MPI; see sc_mpi.h.
* If configure --enable-mpi is given these are true MPI calls.
* Else these are dummy functions that simulate a single-processor run. */
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpicomm = sc_MPI_COMM_WORLD;
/* These functions are optional. If called they store the MPI rank as a
* static variable so subsequent global p4est log messages are only issued
* from processor zero. Here we turn off most of the logging; see sc.h. */
sc_init (mpicomm, 1, 1, NULL, SC_LP_ESSENTIAL);
p4est_init (NULL, SC_LP_PRODUCTION);
P4EST_GLOBAL_PRODUCTIONF
("This is the p4est %dD demo example/steps/%s_step3\n",
P4EST_DIM, P4EST_STRING);
ctx.bump_width = 0.1;
ctx.max_err = 2.e-2;
ctx.center[0] = 0.5;
ctx.center[1] = 0.5;
#ifdef P4_TO_P8
ctx.center[2] = 0.5;
#endif
#ifndef P4_TO_P8
/* randomly chosen advection direction */
ctx.v[0] = -0.445868402501118;
ctx.v[1] = -0.895098523991131;
#else
ctx.v[0] = 0.485191768970225;
ctx.v[1] = -0.427996381877778;
ctx.v[2] = 0.762501176669961;
#endif
ctx.refine_period = 2;
ctx.repartition_period = 4;
ctx.write_period = 8;
/* Create a forest that consists of just one periodic quadtree/octree. */
#ifndef P4_TO_P8
conn = p4est_connectivity_new_periodic ();
#else
conn = p8est_connectivity_new_periodic ();
#endif
/* *INDENT-OFF* */
p4est = p4est_new_ext (mpicomm, /* communicator */
conn, /* connectivity */
0, /* minimum quadrants per MPI process */
4, /* minimum level of refinement */
1, /* fill uniform */
sizeof (step3_data_t), /* data size */
step3_init_initial_condition, /* initializes data */
(void *) (&ctx)); /* context */
/* *INDENT-ON* */
/* refine and coarsen based on an interpolation error estimate */
recursive = 1;
p4est_refine (p4est, recursive, step3_refine_err_estimate,
step3_init_initial_condition);
p4est_coarsen (p4est, recursive, step3_coarsen_initial_condition,
step3_init_initial_condition);
/* Partition: The quadrants are redistributed for equal element count. The
* partition can optionally be modified such that a family of octants, which
* are possibly ready for coarsening, are never split between processors. */
partforcoarsen = 1;
/* If we call the 2:1 balance we ensure that neighbors do not differ in size
* by more than a factor of 2. This can optionally include diagonal
* neighbors across edges or corners as well; see p4est.h. */
p4est_balance (p4est, P4EST_CONNECT_FACE, step3_init_initial_condition);
p4est_partition (p4est, partforcoarsen, NULL);
/* time step */
step3_timestep (p4est, 0.1);
/* Destroy the p4est and the connectivity structure. */
p4est_destroy (p4est);
p4est_connectivity_destroy (conn);
/* Verify that allocations internal to p4est and sc do not leak memory.
* This should be called if sc_init () has been called earlier. */
sc_finalize ();
/* This is standard MPI programs. Without --enable-mpi, this is a dummy. */
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
void
problem_init
(
int argc,
char* argv [],
p4est_t* p4est,
p4est_geometry_t* p4est_geom,
dgmath_jit_dbase_t* dgmath_jit_dbase,
int proc_size,
sc_MPI_Comm mpicomm,
int load_from_checkpoint
)
{
mpi_assert((P4EST_DIM) == 2 || (P4EST_DIM) == 3);
int world_rank, world_size;
sc_MPI_Comm_rank(sc_MPI_COMM_WORLD, &world_rank);
sc_MPI_Comm_size(sc_MPI_COMM_WORLD, &world_size);
double* Au = P4EST_ALLOC_ZERO(double, 1);
double* rhs = P4EST_ALLOC_ZERO(double, 1);
double* u = P4EST_ALLOC_ZERO(double, 1);
double* f = P4EST_ALLOC_ZERO(double, 1);
double* u_analytic = P4EST_ALLOC_ZERO(double, 1);
int local_nodes = 1;
problem_input_t input = problem_input("options.input");
int endlevel = input.endlevel;
int degree = input.degree;
ip_flux_params_t ip_flux_params;
ip_flux_params.ip_flux_penalty_prefactor = input.ip_flux_penalty;
ip_flux_params.ip_flux_penalty_calculate_fcn = sipg_flux_vector_calc_penalty_maxp2_over_minh;
p4est_ghost_t* ghost = p4est_ghost_new (p4est, P4EST_CONNECT_FACE);
/* create space for storing the ghost data */
element_data_t* ghost_data = P4EST_ALLOC (element_data_t,
ghost->ghosts.elem_count);
p4est_partition(p4est, 0, NULL);
p4est_balance (p4est, P4EST_CONNECT_FACE, NULL);
grid_fcn_t boundary_flux_fcn = zero_fcn;
problem_data_t prob_vecs;
prob_vecs.rhs = rhs;
prob_vecs.Au = Au;
prob_vecs.u = u;
prob_vecs.f = f;
prob_vecs.local_nodes = local_nodes;
for (int level = 0; level < endlevel; ++level){
if (level != 0){
p4est_refine_ext(p4est,
0,
-1,
refine_function,
NULL,
NULL
);
p4est_balance_ext
(
p4est,
P4EST_CONNECT_FACE,
NULL,
NULL
);
p4est_ghost_destroy(ghost);
P4EST_FREE(ghost_data);
ghost = p4est_ghost_new(p4est, P4EST_CONNECT_FACE);
ghost_data = P4EST_ALLOC(element_data_t, ghost->ghosts.elem_count);
}
}
p4est_partition(p4est, 1, NULL);
p4est_balance_ext
(
p4est,
P4EST_CONNECT_FACE,
NULL,
NULL
);
p4est_ghost_destroy(ghost);
P4EST_FREE(ghost_data);
ghost = p4est_ghost_new(p4est, P4EST_CONNECT_FACE);
ghost_data = P4EST_ALLOC(element_data_t, ghost->ghosts.elem_count);
weakeqn_ptrs_t prob_fcns;
prob_fcns.apply_lhs = problem_apply_aij;
element_data_init(p4est, degree);
local_nodes = element_data_get_local_nodes(p4est);
printf("RANK %d: Nodes = %d\n", world_rank, local_nodes);
Au = P4EST_REALLOC(Au, double, local_nodes);
u = P4EST_REALLOC(u, double, local_nodes);
f = P4EST_REALLOC(f, double, local_nodes);
rhs = P4EST_REALLOC(rhs, double, local_nodes);
u_analytic = P4EST_REALLOC(u_analytic, double, local_nodes);
prob_vecs.Au = Au;
prob_vecs.u = u;
prob_vecs.f = f;
prob_vecs.rhs = rhs;
prob_vecs.local_nodes = local_nodes;
linalg_fill_vec(u, 0., local_nodes);
element_data_init_node_vec(p4est,f,f_fcn,dgmath_jit_dbase);
prob_vecs.vector_flux_fcn_data
= sipg_flux_vector_dirichlet_fetch_fcns
(
boundary_fcn,
&ip_flux_params
);
prob_vecs.scalar_flux_fcn_data
= sipg_flux_scalar_dirichlet_fetch_fcns
(
boundary_flux_fcn
);
problem_build_rhs
(
p4est,
&prob_vecs,
&prob_fcns,
ghost,
ghost_data,
dgmath_jit_dbase
);
clock_t begin = 0;
clock_t end = -1;
if (world_rank == 0){
begin = clock();
}
int vcycle_iter = 3;
double vcycle_rtol = 1e-3;
double vcycle_atol = 0.;
int smooth_iter = 8;
int cg_eigs_iter = 10;
double max_eig_factor = 1.1;
int max_eig_reuse = 1;
double lmax_lmin_rat = 30.;
int coarse_iter = 100;
double coarse_rtol = 1e-8;
int save_vtk_snapshot = 0;
int perform_checksum = 0;
multigrid_data_t* mg_data
= multigrid_data_init
(
world_rank,
endlevel,
vcycle_iter,
vcycle_rtol,
vcycle_atol,
smooth_iter,
cg_eigs_iter,
max_eig_factor,
max_eig_reuse,
lmax_lmin_rat,
CG,
coarse_iter,
coarse_rtol,
save_vtk_snapshot,
perform_checksum,
RES_AND_EIG_LOG,
dgmath_jit_dbase
);
multigrid_solve
(
p4est,
&prob_vecs,
&prob_fcns,
mg_data,
&ghost,
&ghost_data
);
multigrid_data_destroy(mg_data);
element_data_init_node_vec(p4est, u_analytic, analytic_solution_fcn, dgmath_jit_dbase);
linalg_vec_axpy(-1., u, u_analytic, local_nodes);
double local_l2_norm_sqr = element_data_compute_l2_norm_sqr_no_local
(
p4est,
u_analytic,
dgmath_jit_dbase
);
double local_nodes_dbl = (double)local_nodes;
double local_reduce [2];
local_reduce[0] = local_nodes_dbl;
local_reduce[1] = local_l2_norm_sqr;
double global_reduce [2];
sc_reduce
(
&local_reduce[0],
&global_reduce[0],
2,
sc_MPI_DOUBLE,
sc_MPI_SUM,
0,
sc_MPI_COMM_WORLD
);
double global_nodes_dbl = global_reduce[0];
double global_l2_norm_sqr = global_reduce[1];
if (world_rank == 0){
end = clock();
double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf
(
"\n\n[HP_AMR]: %d %d %d %.25f %f \n\n",
degree,
(int)p4est->global_num_quadrants,
(int)global_nodes_dbl,
sqrt(global_l2_norm_sqr),
/* info.iterations, */
/* info.residual_norm, */
time_spent
);
}
if (ghost) {
p4est_ghost_destroy (ghost);
P4EST_FREE (ghost_data);
ghost = NULL;
ghost_data = NULL;
}
P4EST_FREE(f);
P4EST_FREE(Au);
P4EST_FREE(rhs);
P4EST_FREE(u_analytic);
P4EST_FREE(u);
}
static void
test_loadsave (p4est_connectivity_t * connectivity, const char *prefix,
sc_MPI_Comm mpicomm, int mpirank)
{
int mpiret, retval;
unsigned csum, csum2;
double elapsed, wtime;
p4est_connectivity_t *conn2;
p4est_t *p4est, *p4est2;
sc_statinfo_t stats[STATS_COUNT];
char conn_name[BUFSIZ];
char p4est_name[BUFSIZ];
snprintf (conn_name, BUFSIZ, "%s.%s", prefix, P4EST_CONN_SUFFIX);
snprintf (p4est_name, BUFSIZ, "%s.%s", prefix, P4EST_FOREST_SUFFIX);
P4EST_GLOBAL_INFOF ("Using file names %s and %s\n", conn_name, p4est_name);
p4est = p4est_new_ext (mpicomm, connectivity, 0, 0, 0,
sizeof (int), init_fn, NULL);
p4est_refine (p4est, 1, refine_fn, init_fn);
test_deflate (p4est);
/* save, synchronize, load connectivity and compare */
if (mpirank == 0) {
retval = p4est_connectivity_save (conn_name, connectivity);
SC_CHECK_ABORT (retval == 0, "connectivity_save failed");
}
mpiret = sc_MPI_Barrier (mpicomm);
SC_CHECK_MPI (mpiret);
wtime = sc_MPI_Wtime ();
conn2 = p4est_connectivity_load (conn_name, NULL);
elapsed = sc_MPI_Wtime () - wtime;
sc_stats_set1 (stats + STATS_CONN_LOAD, elapsed, "conn load");
SC_CHECK_ABORT (p4est_connectivity_is_equal (connectivity, conn2),
"load/save connectivity mismatch A");
p4est_connectivity_destroy (conn2);
/* save, synchronize, load p4est and compare */
wtime = sc_MPI_Wtime ();
p4est_save (p4est_name, p4est, 1);
elapsed = sc_MPI_Wtime () - wtime;
sc_stats_set1 (stats + STATS_P4EST_SAVE1, elapsed, "p4est save 1");
wtime = sc_MPI_Wtime ();
p4est2 = p4est_load (p4est_name, mpicomm, sizeof (int), 1, NULL, &conn2);
elapsed = sc_MPI_Wtime () - wtime;
sc_stats_set1 (stats + STATS_P4EST_LOAD1a, elapsed, "p4est load 1a");
SC_CHECK_ABORT (p4est_connectivity_is_equal (connectivity, conn2),
"load/save connectivity mismatch Ba");
SC_CHECK_ABORT (p4est_is_equal (p4est, p4est2, 1),
"load/save p4est mismatch Ba");
p4est_destroy (p4est2);
p4est_connectivity_destroy (conn2);
wtime = sc_MPI_Wtime ();
p4est2 = p4est_load (p4est_name, mpicomm, 0, 0, NULL, &conn2);
elapsed = sc_MPI_Wtime () - wtime;
sc_stats_set1 (stats + STATS_P4EST_LOAD1b, elapsed, "p4est load 1b");
SC_CHECK_ABORT (p4est_connectivity_is_equal (connectivity, conn2),
"load/save connectivity mismatch Bb");
SC_CHECK_ABORT (p4est_is_equal (p4est, p4est2, 0),
"load/save p4est mismatch Bb");
test_deflate (p4est2);
p4est_destroy (p4est2);
p4est_connectivity_destroy (conn2);
/* partition and balance */
p4est_partition (p4est, 0, NULL);
p4est_balance (p4est, P4EST_CONNECT_FULL, init_fn);
csum = p4est_checksum (p4est);
sc_stats_set1 (stats + STATS_P4EST_ELEMS,
(double) p4est->local_num_quadrants, "p4est elements");
/* save, synchronize, load p4est and compare */
wtime = sc_MPI_Wtime ();
p4est_save (p4est_name, p4est, 0);
elapsed = sc_MPI_Wtime () - wtime;
sc_stats_set1 (stats + STATS_P4EST_SAVE2, elapsed, "p4est save 2");
wtime = sc_MPI_Wtime ();
p4est2 = p4est_load (p4est_name, mpicomm, sizeof (int), 0, NULL, &conn2);
elapsed = sc_MPI_Wtime () - wtime;
sc_stats_set1 (stats + STATS_P4EST_LOAD2, elapsed, "p4est load 2");
SC_CHECK_ABORT (p4est_connectivity_is_equal (connectivity, conn2),
"load/save connectivity mismatch C");
SC_CHECK_ABORT (p4est_is_equal (p4est, p4est2, 0),
"load/save p4est mismatch C");
p4est_destroy (p4est2);
p4est_connectivity_destroy (conn2);
/* save, synchronize, load p4est and compare */
wtime = sc_MPI_Wtime ();
p4est_save (p4est_name, p4est, 1);
elapsed = sc_MPI_Wtime () - wtime;
sc_stats_set1 (stats + STATS_P4EST_SAVE3, elapsed, "p4est save 3");
wtime = sc_MPI_Wtime ();
p4est2 = p4est_load (p4est_name, mpicomm, sizeof (int), 0, NULL, &conn2);
elapsed = sc_MPI_Wtime () - wtime;
sc_stats_set1 (stats + STATS_P4EST_LOAD3, elapsed, "p4est load 3");
SC_CHECK_ABORT (p4est_connectivity_is_equal (connectivity, conn2),
"load/save connectivity mismatch D");
SC_CHECK_ABORT (p4est_is_equal (p4est, p4est2, 0),
"load/save p4est mismatch D");
p4est_destroy (p4est2);
p4est_connectivity_destroy (conn2);
/* Test autopartition load feature */
wtime = sc_MPI_Wtime ();
p4est2 = p4est_load_ext (p4est_name, mpicomm, sizeof (int), 0,
1, 0, NULL, &conn2);
elapsed = sc_MPI_Wtime () - wtime;
csum2 = p4est_checksum (p4est2);
sc_stats_set1 (stats + STATS_P4EST_LOAD4, elapsed, "p4est load 4");
SC_CHECK_ABORT (p4est_connectivity_is_equal (connectivity, conn2),
"load/save connectivity mismatch E");
SC_CHECK_ABORT (mpirank != 0 || csum == csum2,
"load/save p4est mismatch E");
p4est_destroy (p4est2);
p4est_connectivity_destroy (conn2);
/* destroy data structures */
p4est_destroy (p4est);
/* compute and print timings */
sc_stats_compute (mpicomm, STATS_COUNT, stats);
sc_stats_print (p4est_package_id, SC_LP_STATISTICS,
STATS_COUNT, stats, 0, 1);
}
int
main (int argc, char *argv[])
{
MPI_Comm comm = MPI_COMM_WORLD;
p4est_t *p4est;
p4est_connectivity_t *conn;
p4est_ghost_t *ghost_layer;
p4est_lnodes_t *lnodes;
int rank;
const int degree = 1;
BFAM_MPI_CHECK(MPI_Init(&argc,&argv));
BFAM_MPI_CHECK(MPI_Comm_rank(comm, &rank));
bfam_log_init(rank, stdout, BFAM_LL_DEFAULT);
bfam_signal_handler_set();
sc_init(comm, 0, 0, NULL, SC_LP_DEFAULT);
p4est_init(NULL, SC_LP_DEFAULT);
conn = p4est_connectivity_new_corner();
p4est = p4est_new_ext(comm, conn, 0, 0, 0, 0, NULL, NULL);
refine_level = 1;
p4est_refine(p4est, 1, refine_fn, NULL);
p4est_balance(p4est, P4EST_CONNECT_FACE, NULL);
p4est_partition(p4est, 1, NULL);
p4est_vtk_write_file(p4est, NULL, "mesh");
ghost_layer = p4est_ghost_new(p4est, P4EST_CONNECT_FULL);
lnodes = p4est_lnodes_new(p4est, ghost_layer, degree);
/*
* Output the mesh. It can be read using something like following command:
*
* mpirun -np 3 ./bfam_exam_p4est | grep MESH | sort -n -k 2 | sort -n -k 5 | gvim -
*/
fflush(stdout);
BFAM_MPI_CHECK(MPI_Barrier(comm));
BFAM_ROOT_INFO("MESH 0 ------------ Mesh Begin ------------");
BFAM_ROOT_INFO("MESH 1 degree = %d", lnodes->degree);
BFAM_ROOT_INFO("MESH 2 vnodes = %d", lnodes->vnodes);
BFAM_INFO("MESH 3 num_local_elements = %jd", (intmax_t)lnodes->num_local_elements);
BFAM_INFO("MESH 4 num_local_nodes = %jd", (intmax_t)lnodes->num_local_nodes);
BFAM_INFO("MESH 5 owned_count = %jd", (intmax_t)lnodes->owned_count);
BFAM_INFO("MESH 6 global_offset = %jd", (intmax_t)lnodes->global_offset);
sc_array_t *global_nodes = sc_array_new(sizeof (p4est_gloidx_t));
sc_array_resize(global_nodes, lnodes->num_local_nodes);
for(size_t zz = 0; zz < global_nodes->elem_count; ++zz)
{
*((p4est_gloidx_t *) sc_array_index(global_nodes, zz)) =
p4est_lnodes_global_index(lnodes, zz);
}
p4est_lnodes_share_owned(global_nodes, lnodes);
for(size_t zz = 0; zz < global_nodes->elem_count; ++zz)
{
const p4est_gloidx_t gn =
*((p4est_gloidx_t *)sc_array_index(global_nodes, zz));
SC_CHECK_ABORT (gn == p4est_lnodes_global_index(lnodes, zz),
"Lnodes: bad global index across procesors");
BFAM_INFO("MESH 7 global_nodes[%zu] = %jd", zz, (intmax_t)gn);
}
sc_array_destroy(global_nodes);
p4est_topidx_t flt = p4est->first_local_tree;
p4est_topidx_t llt = p4est->last_local_tree;
p4est_locidx_t elid, elnid;
p4est_topidx_t t;
const double *v = conn->vertices;
const p4est_topidx_t *tree_to_vertex = conn->tree_to_vertex;
for(elid = 0, elnid = 0, t = flt; t <= llt; ++t)
{
p4est_tree_t *tree = p4est_tree_array_index(p4est->trees, t);
const size_t count = tree->quadrants.elem_count;
p4est_topidx_t vt[P4EST_CHILDREN];
for (int c = 0; c < P4EST_CHILDREN; ++c)
{
vt[c] = tree_to_vertex[t * P4EST_CHILDREN + c];
}
for (size_t zz = 0; zz < count; ++zz, ++elid)
{
p4est_quadrant_t *q = p4est_quadrant_array_index(&tree->quadrants, zz);
for(int jind = 0; jind < degree + 1; ++jind)
{
for(int iind = 0; iind < degree + 1; ++iind, ++elnid)
{
double xyz[3];
for (int j = 0; j < 3; ++j)
{
const p4est_qcoord_t len = P4EST_QUADRANT_LEN(q->level);
const double rlen = (double) P4EST_ROOT_LEN;
const double deg = (double) degree;
const double qlen = ((double) len) / rlen;
const double eta_x =
((double) q->x) / rlen + (((double) iind) / deg) * qlen;
const double eta_y =
((double) q->y) / rlen + (((double) jind) / deg) * qlen;
xyz[j] = ((1. - eta_y) * ((1. - eta_x) * v[3 * vt[0] + j] +
eta_x * v[3 * vt[1] + j]) +
eta_y * ((1. - eta_x) * v[3 * vt[2] + j] +
eta_x * v[3 * vt[3] + j]));
}
const p4est_locidx_t nid = lnodes->element_nodes[elnid];
BFAM_INFO(
"MESH 8 local_node[%03jd] = %03jd ( %25.16e %25.16e %25.16e )",
(intmax_t)elnid, (intmax_t)nid, xyz[0], xyz[1], xyz[2]);
}
}
}
}
BFAM_ROOT_INFO("MESH 9 ------------ Mesh End ------------");
p4est_lnodes_destroy(lnodes);
p4est_ghost_destroy(ghost_layer);
p4est_destroy(p4est);
p4est_connectivity_destroy(conn);
sc_finalize();
BFAM_MPI_CHECK(MPI_Finalize());
return EXIT_SUCCESS;
}
