int
main (int argc, char **argv)
{
sc_MPI_Comm mpicomm;
int mpiret;
int size, rank;
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);
(void) check_backward_compatibility ();
check_int_types ();
#ifndef P4_TO_P8
check_all (mpicomm, p4est_connectivity_new_unitsquare (),
"test_unitsquare", 0xef45243bU, 0xbc5d0907U);
check_all (mpicomm, p4est_connectivity_new_rotwrap (),
"test_rotwrap2", 0x266d2739U, 0x29a31248U);
check_all (mpicomm, p4est_connectivity_new_corner (),
"test_corner", 0x9dad92ccU, 0x937b27afU);
check_all (mpicomm, p4est_connectivity_new_moebius (),
"test_moebius", 0xbbc10f7fU, 0x09b6319eU);
check_all (mpicomm, p4est_connectivity_new_star (),
"test_star", 0xfb28233fU, 0x8e8a32b3);
#else
check_all (mpicomm, p8est_connectivity_new_unitcube (),
"test_unitcube", 0x2574801fU, 0x312559a7U);
check_all (mpicomm, p8est_connectivity_new_periodic (),
"test_periodic3", 0xdc7e8a93U, 0x0787ca2dU);
check_all (mpicomm, p8est_connectivity_new_rotwrap (),
"test_rotwrap", 0xa675888dU, 0x626cbe90U);
check_all (mpicomm, p8est_connectivity_new_twocubes (),
"test_twocubes", 0x7188978aU, 0x4124bcabU);
check_all (mpicomm, p8est_connectivity_new_twowrap (),
"test_twowrap", 0x8e3f994cU, 0x9dd49e94);
check_all (mpicomm, p8est_connectivity_new_rotcubes (),
"test_rotcubes", 0xc0e1b235U, 0x974af07a);
check_all (mpicomm, p8est_connectivity_new_shell (),
"test_shell", 0x558723a2U, 0x4dedf35eU);
check_all (mpicomm,
p8est_connectivity_new_brick (2, 3, 4, 0, 0, 1),
"test_brick", 0x82174e14U, 0x211da6c5);
#endif
/* clean up and exit */
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
int
main (int argc, char *argv[])
{
int mpiret;
/* initialize MPI and p4est internals */
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
sc_init (sc_MPI_COMM_WORLD, 1, 1, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
#ifndef P4_TO_P8
test_reduce (p4est_connectivity_new_unitsquare (), "unitsquare");
test_reduce (p4est_connectivity_new_periodic (), "periodic");
test_reduce (p4est_connectivity_new_rotwrap (), "rotwrap");
test_reduce (p4est_connectivity_new_corner (), "corner");
test_reduce (p4est_connectivity_new_pillow (), "pillow");
test_reduce (p4est_connectivity_new_moebius (), "moebius");
test_reduce (p4est_connectivity_new_star (), "star");
test_reduce (p4est_connectivity_new_cubed (), "cubed");
test_reduce (p4est_connectivity_new_disk (), "disk");
test_reduce (p4est_connectivity_new_brick (3, 2, 0, 0), "brick00");
test_reduce (p4est_connectivity_new_brick (3, 2, 0, 1), "brick01");
test_reduce (p4est_connectivity_new_brick (3, 2, 1, 0), "brick10");
test_reduce (p4est_connectivity_new_brick (3, 2, 1, 1), "brick11");
#else
test_reduce (p8est_connectivity_new_unitcube (), "unitcube");
test_reduce (p8est_connectivity_new_periodic (), "periodic");
test_reduce (p8est_connectivity_new_rotwrap (), "rotwrap");
test_reduce (p8est_connectivity_new_twocubes (), "twocubes");
test_reduce (p8est_connectivity_new_twowrap (), "twowrap");
test_reduce (p8est_connectivity_new_rotcubes (), "rotcubes");
test_reduce (p8est_connectivity_new_brick (4, 3, 2, 0, 0, 0), "brick000");
test_reduce (p8est_connectivity_new_brick (4, 3, 2, 0, 0, 1), "brick001");
test_reduce (p8est_connectivity_new_brick (4, 3, 2, 0, 1, 0), "brick010");
test_reduce (p8est_connectivity_new_brick (4, 3, 2, 0, 1, 1), "brick011");
test_reduce (p8est_connectivity_new_brick (4, 3, 2, 1, 0, 0), "brick100");
test_reduce (p8est_connectivity_new_brick (4, 3, 2, 1, 0, 1), "brick101");
test_reduce (p8est_connectivity_new_brick (4, 3, 2, 1, 1, 1), "brick111");
#endif
/* clean up and exit */
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
int
main (int argc, char **argv)
{
int mpiret;
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
sc_init (sc_MPI_COMM_WORLD, 1, 1, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
#ifndef P4_TO_P8
test_complete (p4est_connectivity_new_unitsquare (), "unitsquare", 1);
test_complete (p4est_connectivity_new_periodic (), "2D periodic", 0);
test_complete (p4est_connectivity_new_rotwrap (), "rotwrap", 0);
test_complete (p4est_connectivity_new_corner (), "corner", 1);
test_complete (p4est_connectivity_new_moebius (), "moebius", 1);
test_complete (p4est_connectivity_new_star (), "star", 1);
test_complete (p4est_connectivity_new_brick (3, 18, 0, 1),
"2D periodic brick", 0);
test_complete (p4est_connectivity_new_brick (3, 18, 0, 0), "2D brick", 1);
#else
test_complete (p8est_connectivity_new_unitcube (), "unitcube", 1);
test_complete (p8est_connectivity_new_periodic (), "3D periodic", 0);
test_complete (p8est_connectivity_new_rotwrap (), "rotwrap", 0);
test_complete (p8est_connectivity_new_twowrap (), "twowrap", 1);
test_complete (p8est_connectivity_new_twocubes (), "twocubes", 1);
test_complete (p8est_connectivity_new_rotcubes (), "rotcubes", 1);
test_complete (p8est_connectivity_new_brick (3, 2, 8, 1, 0, 1),
"3D periodic brick", 0);
test_complete (p8est_connectivity_new_brick (3, 2, 8, 0, 0, 0),
"3D brick", 1);
#endif
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
/*
* Purpose of this program is to verify that
* p8est_find_edge_transform and p8est_find_corner_transform
* work as expected for several periodic connectivities.
*/
int
main (int argc, char **argv)
{
p8est_connectivity_t *conn;
sc_init (sc_MPI_COMM_NULL, 1, 1, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
conn = p8est_connectivity_new_periodic ();
test_periodic (conn);
p8est_connectivity_destroy (conn);
conn = p8est_connectivity_new_rotwrap ();
test_rotwrap (conn);
p8est_connectivity_destroy (conn);
test_weird ();
sc_finalize ();
return 0;
}
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;
}
int
main (int argc, char **argv)
{
int mpiret;
int wrongusage;
const char *usage;
mpi_context_t mpi_context, *mpi = &mpi_context;
p4est_connectivity_t *connectivity;
simple_config_t config;
/* initialize MPI and p4est internals */
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpi->mpicomm = sc_MPI_COMM_WORLD;
mpiret = sc_MPI_Comm_size (mpi->mpicomm, &mpi->mpisize);
SC_CHECK_MPI (mpiret);
mpiret = sc_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"
#ifndef P4_TO_P8
" unit|three|moebius|star|periodic|rotwrap|cubed|disk\n"
#else
" unit|periodic|rotwrap|twocubes|twowrap|rotcubes|shell|sphere\n"
#endif
" Level controls the maximum depth of refinement\n";
wrongusage = 0;
config = P4EST_CONFIG_NULL;
if (!wrongusage && argc != 3) {
wrongusage = 1;
}
if (!wrongusage) {
if (!strcmp (argv[1], "unit")) {
#ifndef P4_TO_P8
config = P4EST_CONFIG_UNIT;
#else
config = P8EST_CONFIG_UNIT;
#endif
}
#ifndef P4_TO_P8
else if (!strcmp (argv[1], "three")) {
config = P4EST_CONFIG_THREE;
}
else if (!strcmp (argv[1], "moebius")) {
config = P4EST_CONFIG_MOEBIUS;
}
else if (!strcmp (argv[1], "star")) {
config = P4EST_CONFIG_STAR;
}
else if (!strcmp (argv[1], "periodic")) {
config = P4EST_CONFIG_PERIODIC;
}
else if (!strcmp (argv[1], "rotwrap")) {
config = P4EST_CONFIG_ROTWRAP;
}
else if (!strcmp (argv[1], "cubed")) {
config = P4EST_CONFIG_CUBED;
}
else if (!strcmp (argv[1], "disk")) {
config = P4EST_CONFIG_DISK;
}
#else
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;
}
#endif
else {
wrongusage = 1;
}
}
if (wrongusage) {
P4EST_GLOBAL_LERROR (usage);
sc_abort_collective ("Usage error");
}
/* assign variables based on configuration */
refine_level = atoi (argv[2]);
/* create connectivity and forest structures */
if (0) {
}
#ifndef P4_TO_P8
else if (config == P4EST_CONFIG_THREE) {
connectivity = p4est_connectivity_new_corner ();
}
else if (config == P4EST_CONFIG_MOEBIUS) {
connectivity = p4est_connectivity_new_moebius ();
}
else if (config == P4EST_CONFIG_STAR) {
connectivity = p4est_connectivity_new_star ();
}
else if (config == P4EST_CONFIG_PERIODIC) {
connectivity = p4est_connectivity_new_periodic ();
}
else if (config == P4EST_CONFIG_ROTWRAP) {
connectivity = p4est_connectivity_new_rotwrap ();
}
else if (config == P4EST_CONFIG_CUBED) {
connectivity = p4est_connectivity_new_cubed ();
}
else if (config == P4EST_CONFIG_DISK) {
connectivity = p4est_connectivity_new_disk ();
}
#else
else 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 ();
}
else if (config == P8EST_CONFIG_TWOWRAP) {
connectivity = p8est_connectivity_new_twowrap ();
}
else if (config == P8EST_CONFIG_ROTCUBES) {
connectivity = p8est_connectivity_new_rotcubes ();
}
else if (config == P8EST_CONFIG_SHELL) {
connectivity = p8est_connectivity_new_shell ();
}
else if (config == P8EST_CONFIG_SPHERE) {
connectivity = p8est_connectivity_new_sphere ();
}
#endif
else {
#ifndef P4_TO_P8
connectivity = p4est_connectivity_new_unitsquare ();
#else
connectivity = p8est_connectivity_new_unitcube ();
#endif
}
#if 0
/* hack test */
hack_test (mpi, connectivity);
#else
/* run mesh tests */
mesh_run (mpi, connectivity, 1, 0, 1, P4EST_CONNECT_FULL);
mesh_run (mpi, connectivity, 0, 1, 0, P4EST_CONNECT_FULL);
mesh_run (mpi, connectivity, 0, 0, 0, P4EST_CONNECT_FACE);
mesh_run (mpi, connectivity, 1, 1, 1, P4EST_CONNECT_FACE);
#endif
/* clean up and exit */
p4est_connectivity_destroy (connectivity);
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
/** 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;
}