int
main (int argc, char **argv)
{
int mpiret;
p4est_connectivity_t *conn_in, *conn_out;
p4est_t *p4est;
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
conn_in = p4est_connectivity_new_cubed ();
#else
conn_in = p8est_connectivity_new_rotcubes ();
#endif
conn_out = p4est_connectivity_refine (conn_in, 5);
p4est_connectivity_destroy (conn_in);
p4est = p4est_new (sc_MPI_COMM_WORLD, conn_out, 0, NULL, NULL);
p4est_vtk_write_file (p4est, NULL, P4EST_STRING "_test_connrefine");
p4est_destroy (p4est);
p4est_connectivity_destroy (conn_out);
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
int main(int argc,char *argv[]){
char *HDF5File;
int HDF5file_len;
/* p4est_t *p4est; */
p4est_connectivity_t *conn;
p4est_t *p4est;
p4est_geometry_t *geom;
char *vtkfilename,*vtkfilename_temp;
int mpiret;
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
if(argc>1) {
HDF5File=argv[1];
HDF5file_len=strlen(HDF5File);
ReadMeshFromHDF5_FC(HDF5File,HDF5file_len,&conn);
P4EST_ASSERT(p4est_connectivity_is_valid(conn));
p4est=p4est_new_ext(sc_MPI_COMM_WORLD,conn,0,2,1,0,NULL,NULL);
geom = P4EST_ALLOC_ZERO (p4est_geometry_t, 1);
geom->name = "hopest_readfromhdf5";
geom->X = p4_geometry_X;
vtkfilename_temp=P4EST_STRDUP(HDF5File);
vtkfilename=basename(vtkfilename_temp);
printf("%s\n",vtkfilename);
p4est_vtk_write_file (p4est,geom,vtkfilename);
P4EST_FREE(vtkfilename_temp);
p4est_geometry_destroy(geom);
p4est_destroy(p4est);
p4est_connectivity_destroy(conn);
}
else printf("no input file given.\n");
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
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);
}
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;
mpi_context_t mpi_context, *mpi = &mpi_context;
p4est_t *p4est;
p4est_connectivity_t *connectivity;
p4est_ghost_t *ghost;
/* initialize MPI and p4est internals */
mpiret = MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpi->mpicomm = MPI_COMM_WORLD; /* your favourite comm here */
mpiret = MPI_Comm_size (mpi->mpicomm, &mpi->mpisize);
SC_CHECK_MPI (mpiret);
mpiret = MPI_Comm_rank (mpi->mpicomm, &mpi->mpirank);
SC_CHECK_MPI (mpiret);
/* this should alwaps be MPI_COMM_WORLD (no effect on p4est) */
sc_init (MPI_COMM_WORLD, 0, 0, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
/* create 2D connectivity and forest structures */
connectivity = p4est_connectivity_new_unitsquare ();
p4est = p4est_new_ext (mpi->mpicomm, connectivity, 0, 0, 1, 0, NULL, NULL);
/* refine and partition */
p4est_refine (p4est, 1, refine_fn, NULL);
p4est_partition (p4est, NULL);
/* write vtk output */
p4est_vtk_write_file (p4est, NULL, "p4est_ptest2");
/* create and destroy ghost layer */
ghost = p4est_ghost_new (p4est, P4EST_CONNECT_FULL);
p4est_ghost_destroy (ghost);
/* destroy the p4est and its connectivity structure */
p4est_destroy (p4est);
p4est_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;
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 found_total;
p4est_locidx_t jt, Al, Bl;
p4est_locidx_t local_count;
p4est_connectivity_t *conn;
p4est_quadrant_t *A, *B;
p4est_geometry_t *geom;
p4est_t *p4est;
sc_array_t *points;
test_point_t *p;
const char *vtkname;
/* Initialize MPI */
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpicomm = sc_MPI_COMM_WORLD;
/* Initialize packages */
sc_init (mpicomm, 1, 1, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
/* Create forest */
#ifndef P4_TO_P8
conn = p4est_connectivity_new_star ();
geom = NULL;
vtkname = "test_search2";
#else
conn = p8est_connectivity_new_sphere ();
geom = p8est_geometry_new_sphere (conn, 1., 0.191728, 0.039856);
vtkname = "test_search3";
#endif
p4est = p4est_new_ext (mpicomm, conn, 0, 0, 0, 0, NULL, &local_count);
p4est_refine (p4est, 1, refine_fn, NULL);
p4est_partition (p4est, 0, NULL);
p4est_vtk_write_file (p4est, geom, vtkname);
/* The following code should really be in a separate function. */
/* Prepare a point search -- fix size so the memory is not relocated */
points = sc_array_new_size (sizeof (test_point_t), 2);
/* A */
p = (test_point_t *) sc_array_index (points, 0);
p->name = "A";
A = &p->quad;
P4EST_QUADRANT_INIT (A);
p4est_quadrant_set_morton (A, 3, 23);
A->p.piggy3.which_tree = 0;
A->p.piggy3.local_num = -1;
Al = -1;
/* B */
p = (test_point_t *) sc_array_index (points, 1);
p->name = "B";
B = &p->quad;
P4EST_QUADRANT_INIT (B);
p4est_quadrant_set_morton (B, 2, 13);
B->p.piggy3.which_tree = conn->num_trees / 2;
B->p.piggy3.local_num = -1;
Bl = -1;
/* Find quadrant numbers if existing */
for (jt = p4est->first_local_tree; jt <= p4est->last_local_tree; ++jt) {
size_t zz;
p4est_tree_t *tree = p4est_tree_array_index (p4est->trees, jt);
p4est_quadrant_t *quad;
sc_array_t *tquadrants = &tree->quadrants;
for (zz = 0; zz < tquadrants->elem_count; ++zz) {
quad = p4est_quadrant_array_index (tquadrants, zz);
if (A->p.piggy3.which_tree == jt && !p4est_quadrant_compare (quad, A)) {
Al = tree->quadrants_offset + (p4est_locidx_t) zz;
P4EST_VERBOSEF ("Searching for A at %lld\n", (long long) Al);
}
if (B->p.piggy3.which_tree == jt && !p4est_quadrant_compare (quad, B)) {
Bl = tree->quadrants_offset + (p4est_locidx_t) zz;
P4EST_VERBOSEF ("Searching for B at %lld\n", (long long) Bl);
}
}
}
/* Go */
found_count = 0;
p4est_search_local (p4est, 0, NULL, search_callback, points);
mpiret = sc_MPI_Allreduce (&found_count, &found_total,
1, sc_MPI_INT, sc_MPI_SUM, mpicomm);
SC_CHECK_MPI (mpiret);
SC_CHECK_ABORT (found_total == (int) points->elem_count, "Point search");
SC_CHECK_ABORT (A->p.piggy3.local_num == Al, "Search A");
SC_CHECK_ABORT (B->p.piggy3.local_num == Bl, "Search B");
/* Use another search to count local quadrants */
local_count = 0;
p4est_search_local (p4est, 0, count_callback, NULL, NULL);
SC_CHECK_ABORT (local_count == p4est->local_num_quadrants, "Count search");
/* Clear memory */
sc_array_destroy (points);
p4est_destroy (p4est);
if (geom != NULL) {
p4est_geometry_destroy (geom);
}
p4est_connectivity_destroy (conn);
/* Test the build_local function and friends */
test_build_local (mpicomm);
/* Finalize */
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);
}
/**
* Runs all tests.
*/
int
main (int argc, char **argv)
{
const char *this_fn_name = P4EST_STRING "_test_subcomm";
/* options */
const p4est_locidx_t min_quadrants = 15;
const int min_level = 4;
const int fill_uniform = 0;
/* parallel environment */
sc_MPI_Comm mpicomm = sc_MPI_COMM_WORLD;
int mpisize, submpisize;
int mpiret;
#ifdef P4EST_ENABLE_DEBUG
int rank;
#endif
/* p4est */
p4est_connectivity_t *connectivity;
p4est_t *p4est;
p4est_locidx_t *partition;
/* initialize MPI */
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
/* exit if MPI communicator cannot be reduced */
mpiret = sc_MPI_Comm_size (mpicomm, &mpisize);
SC_CHECK_MPI (mpiret);
if (mpisize == 1) {
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
/* initialize p4est */
sc_init (mpicomm, 1, 1, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
/* create connectivity */
#ifdef P4_TO_P8
connectivity = p8est_connectivity_new_unitcube ();
#else
connectivity = p4est_connectivity_new_unitsquare ();
#endif
/* create p4est object */
p4est = p4est_new_ext (mpicomm, connectivity,
min_quadrants, min_level, fill_uniform,
0, NULL, NULL);
/* write vtk: new */
p4est_vtk_write_file (p4est, NULL, P4EST_STRING "_subcomm_new");
/* set variables pertaining to the parallel environment */
#ifdef P4EST_ENABLE_DEBUG
rank = p4est->mpirank;
#endif
submpisize = mpisize / 2;
P4EST_ASSERT (submpisize <= p4est->global_num_quadrants);
/* construct partitioning with empty ranks */
{
p4est_locidx_t n_quads_per_proc, n_quads_leftover;
int p;
partition = P4EST_ALLOC (p4est_locidx_t, mpisize);
n_quads_per_proc = p4est->global_num_quadrants / submpisize;
n_quads_leftover = p4est->global_num_quadrants -
(n_quads_per_proc * submpisize);
for (p = 0; p < mpisize; p++) {
if (p % 2) { /* if this rank will get quadrants */
partition[p] = n_quads_per_proc;
}
else { /* if this rank will be empty */
partition[p] = 0;
}
}
partition[1] += n_quads_leftover;
/* check partitioning */
#ifdef P4EST_ENABLE_DEBUG
{
p4est_gloidx_t sum = 0;
for (p = 0; p < mpisize; p++) {
sum += (p4est_gloidx_t) partition[p];
}
P4EST_ASSERT (sum == p4est->global_num_quadrants);
}
#endif
}
/*
* Test 1: Reduce MPI communicator to non-empty ranks
*/
P4EST_GLOBAL_INFOF ("%s: Into test 1\n", this_fn_name);
{
p4est_t *p4est_subcomm;
int is_nonempty;
/* create p4est copy and re-partition */
p4est_subcomm = p4est_copy_ext (p4est, 1, 1);
(void) p4est_partition_given (p4est_subcomm, partition);
/* write vtk: partitioned */
p4est_vtk_write_file (p4est_subcomm, NULL, P4EST_STRING "_subcomm_part");
/* reduce MPI communicator to non-empty ranks */
is_nonempty = p4est_comm_parallel_env_reduce (&p4est_subcomm);
P4EST_ASSERT ((is_nonempty && 0 < partition[rank]) ||
(!is_nonempty && 0 == partition[rank]));
if (is_nonempty) {
/* write vtk: reduced communicator */
p4est_vtk_write_file (p4est_subcomm, NULL,
P4EST_STRING "_subcomm_sub1");
/* destroy the p4est that has a reduced MPI communicator */
p4est_destroy (p4est_subcomm);
}
}
mpiret = sc_MPI_Barrier (mpicomm);
SC_CHECK_MPI (mpiret);
P4EST_GLOBAL_INFOF ("%s: Done test 1\n", this_fn_name);
/*
* Test 2: Reduce MPI communicator to non-empty ranks, but now the MPI
* communicator is not owned
*/
P4EST_GLOBAL_INFOF ("%s: Into test 2\n", this_fn_name);
{
p4est_t *p4est_subcomm;
int is_nonempty;
/* create p4est copy and re-partition */
p4est_subcomm = p4est_copy_ext (p4est, 1, 0 /* don't dup. comm. */ );
(void) p4est_partition_given (p4est_subcomm, partition);
/* reduce MPI communicator to non-empty ranks */
is_nonempty = p4est_comm_parallel_env_reduce (&p4est_subcomm);
P4EST_ASSERT ((is_nonempty && 0 < partition[rank]) ||
(!is_nonempty && 0 == partition[rank]));
if (is_nonempty) {
/* destroy the p4est that has a reduced MPI communicator */
p4est_destroy (p4est_subcomm);
}
}
mpiret = sc_MPI_Barrier (mpicomm);
SC_CHECK_MPI (mpiret);
P4EST_GLOBAL_INFOF ("%s: Done test 2\n", this_fn_name);
/*
* Test 3: Reduce MPI communicator to non-empty ranks, but keep rank 0
*/
P4EST_GLOBAL_INFOF ("%s: Into test 3\n", this_fn_name);
{
p4est_t *p4est_subcomm;
int sub_exists;
sc_MPI_Group group, group_reserve;
int reserve_range[1][3];
/* create group of full MPI communicator */
mpiret = sc_MPI_Comm_group (mpicomm, &group);
SC_CHECK_MPI (mpiret);
/* create sub-group containing only rank 0 */
reserve_range[0][0] = 0;
reserve_range[0][1] = 0;
reserve_range[0][2] = 1;
mpiret =
sc_MPI_Group_range_incl (group, 1, reserve_range, &group_reserve);
SC_CHECK_MPI (mpiret);
/* create p4est copy and re-partition */
p4est_subcomm = p4est_copy_ext (p4est, 1, 1);
(void) p4est_partition_given (p4est_subcomm, partition);
/* reduce MPI communicator to non-empty ranks, but keep rank 0 */
sub_exists = p4est_comm_parallel_env_reduce_ext (&p4est_subcomm,
group_reserve, 1, NULL);
P4EST_ASSERT ((sub_exists && (0 < partition[rank] || rank == 0)) ||
(!sub_exists && 0 == partition[rank]));
if (sub_exists) {
/* write vtk: reduced communicator */
p4est_vtk_write_file (p4est_subcomm, NULL,
P4EST_STRING "_subcomm_sub3");
/* destroy the p4est that has a reduced MPI communicator */
p4est_destroy (p4est_subcomm);
}
}
mpiret = sc_MPI_Barrier (mpicomm);
SC_CHECK_MPI (mpiret);
P4EST_GLOBAL_INFOF ("%s: Done test 3\n", this_fn_name);
/*
* Test 4: Reduce MPI communicator to non-empty ranks, but keep last 2 ranks
*/
P4EST_GLOBAL_INFOF ("%s: Into test 4\n", this_fn_name);
{
p4est_t *p4est_subcomm;
int sub_exists;
sc_MPI_Group group, group_reserve;
int reserve_range[1][3];
/* create group of full MPI communicator */
mpiret = sc_MPI_Comm_group (mpicomm, &group);
SC_CHECK_MPI (mpiret);
/* create sub-group containing only last 2 ranks */
reserve_range[0][0] = SC_MAX (0, mpisize - 2);
reserve_range[0][1] = mpisize - 1;
reserve_range[0][2] = 1;
mpiret =
sc_MPI_Group_range_incl (group, 1, reserve_range, &group_reserve);
SC_CHECK_MPI (mpiret);
/* create p4est copy and re-partition */
p4est_subcomm = p4est_copy_ext (p4est, 1, 1);
(void) p4est_partition_given (p4est_subcomm, partition);
/* reduce MPI communicator to non-empty ranks, but keep last 2 ranks */
sub_exists = p4est_comm_parallel_env_reduce_ext (&p4est_subcomm,
group_reserve, 0, NULL);
P4EST_ASSERT ((sub_exists && (0 < partition[rank] || mpisize - 2 <= rank))
|| (!sub_exists && 0 == partition[rank]));
if (sub_exists) {
/* write vtk: reduced communicator */
p4est_vtk_write_file (p4est_subcomm, NULL,
P4EST_STRING "_subcomm_sub4");
/* destroy the p4est that has a reduced MPI communicator */
p4est_destroy (p4est_subcomm);
}
}
mpiret = sc_MPI_Barrier (mpicomm);
SC_CHECK_MPI (mpiret);
P4EST_GLOBAL_INFOF ("%s: Done test 4\n", this_fn_name);
/* destroy */
P4EST_FREE (partition);
p4est_destroy (p4est);
p4est_connectivity_destroy (connectivity);
/* finalize */
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);
}
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;
}
/* main */
int
main (int argc, char **argv)
{
int rank, num_procs, mpiret, i;
sc_MPI_Comm mpicomm = sc_MPI_COMM_WORLD;
p4est_t *p4est_1tree, *p4est_ntrees;
p4est_connectivity_t *connectivity_1tree, *connectivity_ntrees;
/* initialize MPI and p4est internals */
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpiret = sc_MPI_Comm_size (mpicomm, &num_procs);
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 connectivity */
#ifdef P4_TO_P8
connectivity_1tree = p8est_connectivity_new_unitcube ();
connectivity_ntrees = p8est_connectivity_new_twocubes ();
#else
connectivity_1tree = p4est_connectivity_new_unitsquare ();
connectivity_ntrees = p4est_connectivity_new_corner ();
#endif
/* create p4est structure */
p4est_1tree = p4est_new_ext (mpicomm, connectivity_1tree, 15, 0, 0,
sizeof (user_data_t), init_fn, NULL);
p4est_ntrees = p4est_new_ext (mpicomm, connectivity_ntrees, 15, 0, 0,
sizeof (user_data_t), init_fn, NULL);
/* write output: new */
p4est_vtk_write_file (p4est_1tree, NULL,
P4EST_STRING "_partition_corr_1tree_new");
p4est_vtk_write_file (p4est_ntrees, NULL,
P4EST_STRING "_partition_corr_ntrees_new");
/* refine */
p4est_refine (p4est_1tree, 1, refine_fn, init_fn);
p4est_refine (p4est_ntrees, 1, refine_fn, init_fn);
/* write output: refined */
p4est_vtk_write_file (p4est_1tree, NULL,
P4EST_STRING "_partition_corr_1tree_refined");
p4est_vtk_write_file (p4est_ntrees, NULL,
P4EST_STRING "_partition_corr_ntrees_refined");
/* run partition and coarsen till one quadrant per tree remains */
i = 0;
while (p4est_1tree->global_num_quadrants > 1 && i <= P4EST_MAXLEVEL) {
(void) p4est_partition_ext (p4est_1tree, 1, NULL);
p4est_coarsen (p4est_1tree, 0, coarsen_fn, init_fn);
i++;
}
SC_CHECK_ABORT (p4est_1tree->global_num_quadrants == 1,
"coarsest forest with one tree was not achieved");
i = 0;
while (p4est_ntrees->global_num_quadrants > connectivity_ntrees->num_trees
&& i <= P4EST_MAXLEVEL) {
(void) p4est_partition_ext (p4est_ntrees, 1, NULL);
p4est_coarsen (p4est_ntrees, 0, coarsen_fn, init_fn);
i++;
}
SC_CHECK_ABORT (p4est_ntrees->global_num_quadrants
== connectivity_ntrees->num_trees,
"coarsest forest with multiple trees was not achieved");
/* run partition on coarse forest (one quadrant per tree) once again */
(void) p4est_partition_ext (p4est_1tree, 1, NULL);
(void) p4est_partition_ext (p4est_ntrees, 1, NULL);
/* write output: coarsened */
p4est_vtk_write_file (p4est_1tree, NULL,
P4EST_STRING "_partition_corr_1tree_coarsened");
p4est_vtk_write_file (p4est_ntrees, NULL,
P4EST_STRING "_partition_corr_ntrees_coarsened");
/* destroy the p4est and its connectivity structure */
p4est_destroy (p4est_1tree);
p4est_destroy (p4est_ntrees);
p4est_connectivity_destroy (connectivity_1tree);
p4est_connectivity_destroy (connectivity_ntrees);
/* clean up and exit */
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
