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)
{
int mpiret;
int wrongusage;
unsigned crc;
const char *usage;
mpi_context_t mpi_context, *mpi = &mpi_context;
p8est_t *p8est;
p8est_connectivity_t *connectivity;
p8est_geometry_t *geom;
p8est_refine_t refine_fn;
p8est_coarsen_t coarsen_fn;
simple_config_t config;
const simple_regression_t *r;
/* initialize MPI and p4est internals */
mpiret = MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpi->mpicomm = MPI_COMM_WORLD;
mpiret = MPI_Comm_size (mpi->mpicomm, &mpi->mpisize);
SC_CHECK_MPI (mpiret);
mpiret = MPI_Comm_rank (mpi->mpicomm, &mpi->mpirank);
SC_CHECK_MPI (mpiret);
sc_init (mpi->mpicomm, 1, 1, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
/* process command line arguments */
usage =
"Arguments: <configuration> <level>\n"
" Configuration can be any of\n"
" unit|periodic|rotwrap|twocubes|twowrap|rotcubes|shell|sphere\n"
" Level controls the maximum depth of refinement\n";
wrongusage = 0;
config = P8EST_CONFIG_NULL;
if (!wrongusage && argc != 3) {
wrongusage = 1;
}
if (!wrongusage) {
if (!strcmp (argv[1], "unit")) {
config = P8EST_CONFIG_UNIT;
}
else if (!strcmp (argv[1], "periodic")) {
config = P8EST_CONFIG_PERIODIC;
}
else if (!strcmp (argv[1], "rotwrap")) {
config = P8EST_CONFIG_ROTWRAP;
}
else if (!strcmp (argv[1], "twocubes")) {
config = P8EST_CONFIG_TWOCUBES;
}
else if (!strcmp (argv[1], "twowrap")) {
config = P8EST_CONFIG_TWOWRAP;
}
else if (!strcmp (argv[1], "rotcubes")) {
config = P8EST_CONFIG_ROTCUBES;
}
else if (!strcmp (argv[1], "shell")) {
config = P8EST_CONFIG_SHELL;
}
else if (!strcmp (argv[1], "sphere")) {
config = P8EST_CONFIG_SPHERE;
}
else {
wrongusage = 1;
}
}
if (wrongusage) {
P4EST_GLOBAL_LERROR (usage);
sc_abort_collective ("Usage error");
}
/* assign variables based on configuration */
refine_level = atoi (argv[2]);
refine_fn = refine_normal_fn;
coarsen_fn = NULL;
/* create connectivity and forest structures */
geom = NULL;
if (config == P8EST_CONFIG_PERIODIC) {
connectivity = p8est_connectivity_new_periodic ();
}
else if (config == P8EST_CONFIG_ROTWRAP) {
connectivity = p8est_connectivity_new_rotwrap ();
}
else if (config == P8EST_CONFIG_TWOCUBES) {
connectivity = p8est_connectivity_new_twocubes ();
refine_fn = refine_sparse_fn;
}
else if (config == P8EST_CONFIG_TWOWRAP) {
connectivity = p8est_connectivity_new_twowrap ();
refine_fn = refine_sparse_fn;
}
else if (config == P8EST_CONFIG_ROTCUBES) {
connectivity = p8est_connectivity_new_rotcubes ();
}
else if (config == P8EST_CONFIG_SHELL) {
connectivity = p8est_connectivity_new_shell ();
geom = p8est_geometry_new_shell (1., .55);
}
else if (config == P8EST_CONFIG_SPHERE) {
connectivity = p8est_connectivity_new_sphere ();
geom = p8est_geometry_new_sphere (1., 0.191728, 0.039856);
}
else {
connectivity = p8est_connectivity_new_unitcube ();
}
p8est = p8est_new_ext (mpi->mpicomm, connectivity, 1, 0, 0,
sizeof (user_data_t), init_fn, NULL);
#ifdef VTK_OUTPUT
p8est_vtk_write_file (p8est, geom, "simple3_new");
#endif
/* refinement and coarsening */
p8est_refine (p8est, 1, refine_fn, init_fn);
if (coarsen_fn != NULL) {
p8est_coarsen (p8est, 1, coarsen_fn, init_fn);
}
#ifdef VTK_OUTPUT
p8est_vtk_write_file (p8est, geom, "simple3_refined");
#endif
/* balance */
p8est_balance (p8est, P8EST_CONNECT_FULL, init_fn);
#ifdef VTK_OUTPUT
p8est_vtk_write_file (p8est, geom, "simple3_balanced");
#endif
crc = p8est_checksum (p8est);
/* partition */
p8est_partition (p8est, NULL);
#ifdef VTK_OUTPUT
p8est_vtk_write_file (p8est, geom, "simple3_partition");
#endif
#ifdef P4EST_DEBUG
/* rebalance should not change checksum */
p8est_balance (p8est, P8EST_CONNECT_FULL, init_fn);
P4EST_ASSERT (p8est_checksum (p8est) == crc);
#endif
/* print and verify forest checksum */
P4EST_GLOBAL_STATISTICSF ("Tree checksum 0x%08x\n", crc);
if (mpi->mpirank == 0) {
for (r = regression; r->config != P8EST_CONFIG_NULL; ++r) {
if (r->config != config || r->mpisize != mpi->mpisize
|| r->level != refine_level)
continue;
SC_CHECK_ABORT (crc == r->checksum, "Checksum mismatch");
P4EST_GLOBAL_INFO ("Checksum regression OK\n");
break;
}
}
/* destroy the p8est and its connectivity structure */
p8est_destroy (p8est);
P4EST_FREE (geom);
p8est_connectivity_destroy (connectivity);
/* clean up and exit */
sc_finalize ();
mpiret = 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)
{
int mpiret, retval;
int mpirank;
const char *argbasename;
char afilename[BUFSIZ];
p4est_topidx_t tnum_flips;
p8est_tets_t *ptg;
p8est_connectivity_t *connectivity;
p8est_t *p8est;
MPI_Comm mpicomm;
mpiret = MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpicomm = MPI_COMM_WORLD;
mpiret = MPI_Comm_rank (mpicomm, &mpirank);
sc_init (MPI_COMM_WORLD, 1, 1, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
if (argc != 2) {
SC_GLOBAL_LERRORF ("Usage: %s <tetgen file base name>\n", argv[0]);
sc_abort ();
}
argbasename = argv[1];
/* read tetgen nodes and tetrahedra from files */
ptg = p8est_tets_read (argbasename);
SC_CHECK_ABORTF (ptg != NULL, "Failed to read tetgen %s", argbasename);
P4EST_GLOBAL_STATISTICSF ("Read %d nodes and %d tets %s attributes\n",
(int) ptg->nodes->elem_count / 3,
(int) ptg->tets->elem_count / 4,
ptg->tet_attributes != NULL ? "with" : "without");
/* flip orientation to right-handed */
tnum_flips = p8est_tets_make_righthanded (ptg);
P4EST_GLOBAL_STATISTICSF ("Performed %ld orientation flip(s)\n",
(long) tnum_flips);
/* create a connectivity from the tet mesh and save it */
connectivity = p8est_connectivity_new_tets (ptg);
if (mpirank == 0) {
snprintf (afilename, BUFSIZ, "%s", "read_tetgen.p8c");
retval = p8est_connectivity_save (afilename, connectivity);
SC_CHECK_ABORT (retval == 0, "Failed connectivity_save");
}
/* create a forest and visualize */
p8est = p8est_new (mpicomm, connectivity, 0, NULL, NULL);
snprintf (afilename, BUFSIZ, "%s", "read_tetgen");
p8est_vtk_write_file (p8est, NULL, afilename);
/* clean up */
p8est_destroy (p8est);
p8est_connectivity_destroy (connectivity);
p8est_tets_destroy (ptg);
sc_finalize ();
mpiret = MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
