p6est_lnodes_t *
p6est_lnodes_new (p6est_t * p6est, p6est_ghost_t * ghost, int degree)
{
p6est_lnodes_t *lnodes;
p6est_profile_t *profile;
p4est_lnodes_t *clnodes;
int nperelem = (degree + 1) * (degree + 1) * (degree + 1);
/* int nperface = (degree - 1) * (degree - 1); */
/* int nperedge = (degree - 1); */
p4est_locidx_t ncid, cid, enid, *en;
p4est_locidx_t nnodecols;
p4est_locidx_t nelemcols;
p4est_locidx_t nll;
p4est_locidx_t nlayers;
p4est_locidx_t *layernodecount;
p4est_locidx_t *layernodeoffsets;
p4est_locidx_t (*lr)[2];
p4est_locidx_t ncolnodes;
p4est_locidx_t *global_owned_count;
p4est_locidx_t num_owned, num_local;
p4est_gloidx_t gnum_owned, offset;
p4est_gloidx_t *owned_offsets;
int i, j, k;
int mpisize = p6est->mpisize;
int mpiret;
sc_array_t lnoview;
size_t zz, nsharers;
int Nrp = degree + 1;
if (degree == 1) {
p4est_locidx_t eid, nid, enid2, nid2;
p4est_locidx_t *newnum, newlocal, newowned;
P4EST_GLOBAL_PRODUCTION ("Into adapt p6est_lnodes_new for degree = 1\n");
p4est_log_indent_push ();
/* adapt 2 to 1 */
lnodes = p6est_lnodes_new (p6est, ghost, 2);
nll = p6est->layers->elem_count;
num_local = lnodes->num_local_nodes;
num_owned = lnodes->owned_count;
en = lnodes->element_nodes;
newnum = P4EST_ALLOC (p4est_locidx_t, P8EST_INSUL * nll);
memset (newnum, -1, P8EST_INSUL * nll * sizeof (p4est_locidx_t));
for (enid = 0, eid = 0; eid < nll; eid++) {
for (k = 0; k < 3; k++) {
for (j = 0; j < 3; j++) {
for (i = 0; i < 3; i++, enid++) {
if (k != 1 && j != 1 && i != 1) {
newnum[en[enid]] = 0;
}
}
}
}
}
newlocal = 0;
newowned = 0;
for (nid = 0; nid < num_local; nid++) {
if (newnum[nid] >= 0) {
newnum[nid] = newlocal++;
if (nid < num_owned) {
newowned++;
}
}
}
/* compress en */
enid2 = 0;
for (enid = 0, eid = 0; eid < nll; eid++) {
for (k = 0; k < 3; k++) {
for (j = 0; j < 3; j++) {
for (i = 0; i < 3; i++, enid++) {
if (k != 1 && j != 1 && i != 1) {
en[enid2++] = newnum[en[enid]];
}
}
}
}
}
P4EST_ASSERT (enid2 == P8EST_CHILDREN * nll);
lnodes->element_nodes =
P4EST_REALLOC (en, p4est_locidx_t, P8EST_CHILDREN * nll);
owned_offsets = P4EST_ALLOC (p4est_gloidx_t, mpisize + 1);
mpiret = sc_MPI_Allgather (&newowned, 1, P4EST_MPI_LOCIDX,
lnodes->global_owned_count, 1,
P4EST_MPI_LOCIDX, p6est->mpicomm);
owned_offsets[0] = 0;
for (i = 0; i < mpisize; i++) {
owned_offsets[i + 1] = owned_offsets[i] + lnodes->global_owned_count[i];
}
lnodes->global_offset = owned_offsets[p6est->mpirank];
lnodes->num_local_nodes = newlocal;
lnodes->owned_count = newowned;
lnodes->degree = 1;
lnodes->vnodes = P8EST_CHILDREN;
lnodes->nonlocal_nodes =
P4EST_REALLOC (lnodes->nonlocal_nodes, p4est_gloidx_t,
newlocal - newowned);
nsharers = lnodes->sharers->elem_count;
for (zz = 0; zz < nsharers; zz++) {
size_t nshared, zy, zw;
p6est_lnodes_rank_t *rank = p6est_lnodes_rank_array_index
(lnodes->sharers, zz);
if (rank->owned_count) {
if (rank->rank != p6est->mpirank) {
p4est_locidx_t newrankowned = 0;
p4est_locidx_t newrankoffset = -1;
for (nid = rank->owned_offset; nid < rank->owned_offset +
rank->owned_count; nid++) {
if (newnum[nid] >= 0) {
lnodes->nonlocal_nodes[newnum[nid] - newowned] =
owned_offsets[rank->rank];
newrankowned++;
if (newrankoffset < 0) {
newrankoffset = newnum[nid];
}
}
}
rank->owned_offset = newrankoffset;
rank->owned_count = newrankowned;
}
else {
rank->owned_offset = 0;
rank->owned_count = newowned;
}
}
rank->shared_mine_count = 0;
rank->shared_mine_offset = -1;
zw = 0;
nshared = rank->shared_nodes.elem_count;
for (zy = 0; zy < nshared; zy++) {
nid = *((p4est_locidx_t *) sc_array_index (&rank->shared_nodes, zy));
if (newnum[nid] >= 0) {
p4est_locidx_t *lp;
lp = (p4est_locidx_t *) sc_array_index (&rank->shared_nodes, zw++);
*lp = newnum[nid];
if (newnum[nid] < newowned) {
rank->shared_mine_count++;
if (rank->shared_mine_offset == -1) {
rank->shared_mine_offset = zw - 1;
}
}
}
}
sc_array_resize (&rank->shared_nodes, zw);
}
/* send local numbers to others */
{
sc_array_t view;
sc_array_init_data (&view, newnum, sizeof (p4est_locidx_t), newlocal);
p6est_lnodes_share_owned (&view, lnodes);
}
nid2 = 0;
for (nid = num_owned; nid < num_local; nid++) {
if (newnum[nid] >= 0) {
lnodes->nonlocal_nodes[nid2++] += (p4est_gloidx_t) newnum[nid];
}
}
P4EST_ASSERT (nid2 == newlocal - newowned);
P4EST_FREE (owned_offsets);
P4EST_FREE (newnum);
p4est_log_indent_pop ();
P4EST_GLOBAL_PRODUCTION ("Done adapt p6est_lnodes_new for degree = 1\n");
return lnodes;
}
P4EST_GLOBAL_PRODUCTION ("Into p6est_lnodes_new\n");
p4est_log_indent_push ();
P4EST_ASSERT (degree >= 1);
lnodes = P4EST_ALLOC (p6est_lnodes_t, 1);
/* first get the profile */
profile = p6est_profile_new_local (p6est, ghost, P6EST_PROFILE_INTERSECTION,
P8EST_CONNECT_FULL, degree);
p6est_profile_sync (profile);
lr = (p4est_locidx_t (*)[2]) profile->lnode_ranges;
clnodes = profile->lnodes;
nnodecols = clnodes->num_local_nodes;
nelemcols = clnodes->num_local_elements;
en = clnodes->element_nodes;
layernodecount = P4EST_ALLOC_ZERO (p4est_locidx_t, nnodecols);
layernodeoffsets = P4EST_ALLOC_ZERO (p4est_locidx_t, nnodecols + 1);
for (cid = 0, enid = 0; cid < nelemcols; cid++) {
for (j = 0; j < Nrp; j++) {
for (i = 0; i < Nrp; i++, enid++) {
ncid = en[enid];
nlayers = lr[ncid][1];
P4EST_ASSERT (nlayers);
ncolnodes = nlayers * degree + 1;
layernodecount[ncid] = ncolnodes;
}
}
}
num_owned = 0;
num_local = 0;
for (ncid = 0; ncid < nnodecols; ncid++) {
num_local += layernodecount[ncid];
if (ncid < clnodes->owned_count) {
num_owned += layernodecount[ncid];
}
}
P4EST_VERBOSEF ("p6est_lnodes: %d owned %d local\n", num_owned, num_local);
if (nnodecols) {
layernodeoffsets[0] = 0;
for (ncid = 0; ncid < nnodecols; ncid++) {
layernodeoffsets[ncid + 1] = layernodeoffsets[ncid] +
layernodecount[ncid];
}
}
gnum_owned = num_owned;
owned_offsets = P4EST_ALLOC (p4est_gloidx_t, mpisize + 1);
global_owned_count = P4EST_ALLOC (p4est_locidx_t, mpisize);
mpiret = sc_MPI_Allgather (&gnum_owned, 1, P4EST_MPI_GLOIDX,
owned_offsets, 1, P4EST_MPI_GLOIDX,
p6est->mpicomm);
SC_CHECK_MPI (mpiret);
offset = 0;
for (i = 0; i < mpisize; i++) {
global_owned_count[i] = (p4est_locidx_t) owned_offsets[i];
gnum_owned = owned_offsets[i];
owned_offsets[i] = offset;
offset += gnum_owned;
}
owned_offsets[mpisize] = offset;
nll = p6est->layers->elem_count;
nsharers = clnodes->sharers->elem_count;
lnodes->mpicomm = p6est->mpicomm;
lnodes->num_local_nodes = num_local;
lnodes->owned_count = num_owned;
lnodes->global_offset = owned_offsets[p6est->mpirank];
lnodes->nonlocal_nodes =
P4EST_ALLOC (p4est_gloidx_t, num_local - num_owned);
lnodes->sharers =
sc_array_new_size (sizeof (p6est_lnodes_rank_t), nsharers);
lnodes->global_owned_count = global_owned_count;
lnodes->degree = degree;
lnodes->vnodes = nperelem;
lnodes->num_local_elements = nll;
lnodes->face_code = P4EST_ALLOC (p6est_lnodes_code_t, nll);
lnodes->element_nodes = P4EST_ALLOC (p4est_locidx_t, nperelem * nll);
p6est_profile_element_to_node (p6est, profile, layernodeoffsets,
lnodes->element_nodes, lnodes->face_code);
for (zz = 0; zz < nsharers; zz++) {
p4est_lnodes_rank_t *crank = p4est_lnodes_rank_array_index
(clnodes->sharers, zz);
p6est_lnodes_rank_t *rank = p6est_lnodes_rank_array_index
(lnodes->sharers, zz);
size_t zy;
size_t nshared;
rank->rank = crank->rank;
sc_array_init (&rank->shared_nodes, sizeof (p4est_locidx_t));
nshared = crank->shared_nodes.elem_count;
rank->owned_offset = -1;
rank->owned_count = 0;
rank->shared_mine_count = 0;
rank->shared_mine_offset = -1;
for (zy = 0; zy < nshared; zy++) {
p4est_locidx_t cnid =
*((p4est_locidx_t *) sc_array_index (&crank->shared_nodes, zy));
p4est_locidx_t *lp;
p4est_locidx_t nthis, il;
p4est_locidx_t old_count = rank->shared_nodes.elem_count;
nthis = layernodecount[cnid];
lp =
(p4est_locidx_t *) sc_array_push_count (&rank->shared_nodes, nthis);
for (il = 0; il < nthis; il++) {
lp[il] = layernodeoffsets[cnid] + il;
if (zy >= (size_t) crank->shared_mine_offset
&& (p4est_locidx_t) zy - crank->shared_mine_offset <
crank->shared_mine_count) {
rank->shared_mine_count++;
if (rank->shared_mine_offset == -1) {
rank->shared_mine_offset = old_count + il;
}
}
if (cnid >= crank->owned_offset
&& cnid - crank->owned_offset < crank->owned_count) {
rank->owned_count++;
if (rank->owned_offset == -1) {
rank->owned_offset = lp[il];
}
}
}
}
if (rank->rank == p6est->mpirank) {
rank->owned_offset = 0;
rank->owned_count = num_owned;
}
}
memcpy (layernodecount, layernodeoffsets,
nnodecols * sizeof (p4est_locidx_t));
sc_array_init_data (&lnoview, layernodecount, sizeof (p4est_locidx_t),
(size_t) nnodecols);
p4est_lnodes_share_owned (&lnoview, clnodes);
for (zz = 0; zz < nsharers; zz++) {
p4est_lnodes_rank_t *crank = p4est_lnodes_rank_array_index
(clnodes->sharers, zz);
if (crank->rank == p6est->mpirank) {
continue;
}
for (ncid = crank->owned_offset;
ncid < crank->owned_offset + crank->owned_count; ncid++) {
p4est_gloidx_t owners_offset;
p4est_locidx_t nid;
P4EST_ASSERT (ncid >= clnodes->owned_count);
owners_offset = owned_offsets[crank->rank] + layernodecount[ncid];
for (nid = layernodeoffsets[ncid]; nid < layernodeoffsets[ncid + 1];
nid++) {
P4EST_ASSERT (nid >= num_owned);
P4EST_ASSERT (nid < num_local);
lnodes->nonlocal_nodes[nid - num_owned] = owners_offset++;
}
}
}
p6est_profile_destroy (profile);
P4EST_FREE (owned_offsets);
P4EST_FREE (layernodecount);
P4EST_FREE (layernodeoffsets);
p4est_log_indent_pop ();
P4EST_GLOBAL_PRODUCTION ("Done p6est_lnodes_new\n");
return lnodes;
}
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)
{
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;
}
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;
}
void
sc_init (MPI_Comm mpicomm,
int catch_signals, int print_backtrace,
sc_log_handler_t log_handler, int log_threshold)
{
int w;
const char *trace_file_name;
const char *trace_file_prio;
sc_identifier = -1;
sc_mpicomm = MPI_COMM_NULL;
sc_print_backtrace = print_backtrace;
if (mpicomm != MPI_COMM_NULL) {
int mpiret;
sc_mpicomm = mpicomm;
mpiret = MPI_Comm_rank (sc_mpicomm, &sc_identifier);
SC_CHECK_MPI (mpiret);
}
sc_set_signal_handler (catch_signals);
sc_package_id = sc_package_register (log_handler, log_threshold,
"libsc", "The SC Library");
trace_file_name = getenv ("SC_TRACE_FILE");
if (trace_file_name != NULL) {
char buffer[BUFSIZ];
if (sc_identifier >= 0) {
snprintf (buffer, BUFSIZ, "%s.%d.log", trace_file_name, sc_identifier);
}
else {
snprintf (buffer, BUFSIZ, "%s.log", trace_file_name);
}
SC_CHECK_ABORT (sc_trace_file == NULL, "Trace file not NULL");
sc_trace_file = fopen (buffer, "wb");
SC_CHECK_ABORT (sc_trace_file != NULL, "Trace file open");
trace_file_prio = getenv ("SC_TRACE_LP");
if (trace_file_prio != NULL) {
if (!strcmp (trace_file_prio, "SC_LP_TRACE")) {
sc_trace_prio = SC_LP_TRACE;
}
else if (!strcmp (trace_file_prio, "SC_LP_DEBUG")) {
sc_trace_prio = SC_LP_DEBUG;
}
else if (!strcmp (trace_file_prio, "SC_LP_VERBOSE")) {
sc_trace_prio = SC_LP_VERBOSE;
}
else if (!strcmp (trace_file_prio, "SC_LP_INFO")) {
sc_trace_prio = SC_LP_INFO;
}
else if (!strcmp (trace_file_prio, "SC_LP_STATISTICS")) {
sc_trace_prio = SC_LP_STATISTICS;
}
else if (!strcmp (trace_file_prio, "SC_LP_PRODUCTION")) {
sc_trace_prio = SC_LP_PRODUCTION;
}
else if (!strcmp (trace_file_prio, "SC_LP_ESSENTIAL")) {
sc_trace_prio = SC_LP_ESSENTIAL;
}
else if (!strcmp (trace_file_prio, "SC_LP_ERROR")) {
sc_trace_prio = SC_LP_ERROR;
}
else {
SC_ABORT ("Invalid trace priority");
}
}
}
w = 24;
SC_GLOBAL_ESSENTIALF ("This is %s\n", SC_PACKAGE_STRING);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "CC", SC_CC);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "C_VERSION", SC_C_VERSION);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "CFLAGS", SC_CFLAGS);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "CPP", SC_CPP);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "CPPFLAGS", SC_CPPFLAGS);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "F77", SC_F77);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "FFLAGS", SC_FFLAGS);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "LDFLAGS", SC_LDFLAGS);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "BLAS_LIBS", SC_BLAS_LIBS);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "LAPACK_LIBS", SC_LAPACK_LIBS);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "LIBS", SC_LIBS);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "FLIBS", SC_FLIBS);
}
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;
}
int
p6est_comm_parallel_env_reduce_ext (p6est_t ** p6est_supercomm,
sc_MPI_Group group_add,
int add_to_beginning, int **ranks_subcomm)
{
p6est_t *p6est = *p6est_supercomm;
int mpisize = p6est->mpisize;
int mpiret;
p4est_gloidx_t *global_first_layer = p6est->global_first_layer;
p4est_gloidx_t *n_quadrants;
int submpisize;
sc_MPI_Comm submpicomm;
int *ranks;
int i;
int is_nonempty;
/* reduce MPI communicator of column layout */
is_nonempty =
p4est_comm_parallel_env_reduce_ext (&(p6est->columns), group_add,
add_to_beginning, &ranks);
/* destroy p4est and exit if this rank is empty */
if (!is_nonempty) {
p6est->columns = NULL;
p6est_destroy (p6est);
*p6est_supercomm = NULL;
if (ranks_subcomm) {
*ranks_subcomm = NULL;
}
P4EST_ASSERT (ranks == NULL);
return 0;
}
/* get sub-communicator */
submpicomm = p6est->columns->mpicomm;
/* update size of new MPI communicator */
mpiret = sc_MPI_Comm_size (submpicomm, &submpisize);
SC_CHECK_MPI (mpiret);
if (submpisize == p6est->mpisize) {
P4EST_ASSERT (ranks == NULL);
return 1;
}
/* set new parallel environment */
p6est_comm_parallel_env_release (p6est);
p6est_comm_parallel_env_assign (p6est, submpicomm);
if (p6est->columns->mpicomm_owned) {
p6est->columns->mpicomm_owned = 0;
p6est->mpicomm_owned = 1;
}
P4EST_ASSERT (p6est->mpisize == submpisize);
/* create array of non-empty processes that will be included to sub-comm */
n_quadrants = P4EST_ALLOC (p4est_gloidx_t, mpisize);
for (i = 0; i < mpisize; i++) {
n_quadrants[i] = global_first_layer[i + 1] - global_first_layer[i];
}
/* allocate and set global layer count */
P4EST_FREE (p6est->global_first_layer);
p6est->global_first_layer = P4EST_ALLOC (p4est_gloidx_t, submpisize + 1);
p6est->global_first_layer[0] = 0;
for (i = 0; i < submpisize; i++) {
P4EST_ASSERT (ranks[i] != sc_MPI_UNDEFINED);
P4EST_ASSERT (group_add != sc_MPI_GROUP_NULL
|| 0 < n_quadrants[ranks[i]]);
p6est->global_first_layer[i + 1] =
p6est->global_first_layer[i] + n_quadrants[ranks[i]];
}
P4EST_FREE (n_quadrants);
if (ranks_subcomm) {
*ranks_subcomm = ranks;
}
else {
P4EST_FREE (ranks);
}
/* return that p6est exists on this rank */
return 1;
}
END_TEST
int main(int argc, char *argv[])
{
int mpiret;
sc_MPI_Comm mpicomm;
int proc_size;
int nf;
p4est_connectivity_t *conn;
p4est_t* p4est;
/* MPI init */
mpiret = sc_MPI_Init(&argc, &argv);
SC_CHECK_MPI(mpiret);
mpicomm = sc_MPI_COMM_WORLD;
/* sc_init (mpicomm, 1, 1, NULL, SC_LP_ESSENTIAL); */
mpiret = MPI_Comm_size(mpicomm, &proc_size);
SC_CHECK_MPI (mpiret);
/* pXest init */
p4est_init(NULL, SC_LP_PRODUCTION);
#if (P4EST_DIM)==3
conn = p8est_connectivity_new_unitcube();
#else
conn = p4est_connectivity_new_unitsquare();
#endif
p4est = p4est_new(mpicomm, conn, 0, NULL, NULL);
global_p4est_pointer = p4est;
/* start just-in-time dg-math */
dgmath_jit_init();
/* run tests */
Suite *s1 = suite_create("Test Plotting Functions");
SRunner *sr = srunner_create(s1);
TCase *tc1 = tcase_create("Test Surface and Contour plotting");
TCase *tc2 = tcase_create("Test Error Plotting");
tcase_add_test(tc1, test_surface_plot);
tcase_add_test(tc2, test_error_plot);
tcase_set_timeout(tc2, 100);
/* suite_add_tcase(s1,tc1); */
suite_add_tcase(s1,tc2);
srunner_run_all(sr, CK_ENV);
nf = srunner_ntests_failed(sr);
/* free pointers */
dgmath_jit_destroy();
/* free pXest */
p4est_destroy(p4est);
p4est_connectivity_destroy(conn);
/* finalize mpi stuff */
/* sc_finalize(); */
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI(mpiret);
srunner_free(sr);
return nf == 0 ? 0 : 1;
}
int
main (int argc, char **argv)
{
p4est_quadrant_t root;
p4est_quadrant_t p;
p4est_quadrant_t q;
p4est_quadrant_t desc;
int face, corner;
#ifndef P4_TO_P8
int maxlevel = 9;
#else
int edge;
int maxlevel = 6;
#endif
int mpiret, mpisize, mpirank;
sc_MPI_Comm mpicomm;
uint64_t i, ifirst, ilast;
int level;
sc_array_t *seeds, *seeds_check;
int testval;
int checkval;
int j, nrand = 1000;
/* 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);
srandom (9212007);
sc_init (mpicomm, 1, 1, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
seeds = sc_array_new (sizeof (p4est_quadrant_t));
seeds_check = sc_array_new (sizeof (p4est_quadrant_t));
memset (&root, 0, sizeof (p4est_quadrant_t));
root.level = 2;
root.x = P4EST_QUADRANT_LEN (2);
root.y = P4EST_QUADRANT_LEN (2);
#ifdef P4_TO_P8
root.z = P4EST_QUADRANT_LEN (2);
#endif
P4EST_QUADRANT_INIT (&p);
P4EST_QUADRANT_INIT (&q);
#if 1
for (face = 0; face < P4EST_FACES; face++) {
p4est_quadrant_face_neighbor (&root, face ^ 1, &p);
P4EST_GLOBAL_VERBOSEF ("Testing face %d\n", face);
for (level = 4; level <= maxlevel; level++) {
P4EST_GLOBAL_VERBOSEF (" level %d\n", level);
p4est_quadrant_first_descendant (&root, &desc, level);
ifirst = p4est_quadrant_linear_id (&desc, level);
p4est_quadrant_last_descendant (&root, &desc, level);
ilast = p4est_quadrant_linear_id (&desc, level);
for (i = ifirst; i <= ilast; i += P4EST_CHILDREN) {
p4est_quadrant_set_morton (&q, level, i);
#ifndef P4_TO_P8
testval = p4est_balance_seeds_face (&q, &p, face, P4EST_CONNECT_FACE,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P4EST_CONNECT_FACE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p4est_balance_seeds_face error");
compare_seeds (seeds, seeds_check);
#else
testval = p4est_balance_seeds_face (&q, &p, face, P8EST_CONNECT_FACE,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P8EST_CONNECT_FACE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p8est_balance_seeds_face error");
compare_seeds (seeds, seeds_check);
testval = p4est_balance_seeds_face (&q, &p, face, P8EST_CONNECT_EDGE,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P8EST_CONNECT_EDGE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p8est_balance_seeds_face error");
compare_seeds (seeds, seeds_check);
#endif
testval = p4est_balance_seeds_face (&q, &p, face, P4EST_CONNECT_FULL,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P4EST_CONNECT_FULL,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p4est_balance_seeds_face error");
compare_seeds (seeds, seeds_check);
}
}
if (!face) {
P4EST_GLOBAL_VERBOSE (" random levels\n");
for (j = 0; j < (int) nrand; j++) {
level = ((random ()) % (P4EST_QMAXLEVEL - maxlevel)) + maxlevel + 1;
p4est_quadrant_first_descendant (&root, &desc, level);
ifirst = p4est_quadrant_linear_id (&desc, level);
p4est_quadrant_last_descendant (&root, &desc, level);
ilast = p4est_quadrant_linear_id (&desc, level);
i = ((random ()) % (ilast + 1 - ifirst)) + ifirst;
p4est_quadrant_set_morton (&q, level, i);
#ifndef P4_TO_P8
testval = p4est_balance_seeds_face (&q, &p, face, P4EST_CONNECT_FACE,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P4EST_CONNECT_FACE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p4est_balance_seeds_face error");
compare_seeds (seeds, seeds_check);
#else
testval = p4est_balance_seeds_face (&q, &p, face, P8EST_CONNECT_FACE,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P8EST_CONNECT_FACE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p8est_balance_seeds_face error");
compare_seeds (seeds, seeds_check);
testval = p4est_balance_seeds_face (&q, &p, face, P8EST_CONNECT_EDGE,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P8EST_CONNECT_EDGE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p8est_balance_seeds_face error");
compare_seeds (seeds, seeds_check);
#endif
testval = p4est_balance_seeds_face (&q, &p, face, P4EST_CONNECT_FULL,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P4EST_CONNECT_FULL,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p4est_balance_seeds_face error");
compare_seeds (seeds, seeds_check);
}
}
}
#ifdef P4_TO_P8
for (edge = 0; edge < P8EST_EDGES; edge++) {
p8est_quadrant_edge_neighbor (&root, edge ^ 3, &p);
P4EST_GLOBAL_VERBOSEF ("Testing edge %d\n", edge);
for (level = 4; level <= maxlevel; level++) {
P4EST_GLOBAL_VERBOSEF (" level %d\n", level);
p4est_quadrant_first_descendant (&root, &desc, level);
ifirst = p4est_quadrant_linear_id (&desc, level);
p4est_quadrant_last_descendant (&root, &desc, level);
ilast = p4est_quadrant_linear_id (&desc, level);
for (i = ifirst; i <= ilast; i += P4EST_CHILDREN) {
p4est_quadrant_set_morton (&q, level, i);
testval = p8est_balance_seeds_edge (&q, &p, edge, P8EST_CONNECT_FACE,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P8EST_CONNECT_FACE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p8est_balance_seeds_edge error");
compare_seeds (seeds, seeds_check);
testval = p8est_balance_seeds_edge (&q, &p, edge, P8EST_CONNECT_EDGE,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P8EST_CONNECT_EDGE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p8est_balance_seeds_edge error");
compare_seeds (seeds, seeds_check);
testval = p8est_balance_seeds_edge (&q, &p, edge, P8EST_CONNECT_FULL,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P8EST_CONNECT_FULL,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p8est_balance_seeds_edge error");
compare_seeds (seeds, seeds_check);
}
}
if (!edge) {
P4EST_GLOBAL_VERBOSE (" random levels\n");
for (j = 0; j < (int) nrand; j++) {
level = ((random ()) % (P4EST_QMAXLEVEL - maxlevel)) + maxlevel + 1;
p4est_quadrant_first_descendant (&root, &desc, level);
ifirst = p4est_quadrant_linear_id (&desc, level);
p4est_quadrant_last_descendant (&root, &desc, level);
ilast = p4est_quadrant_linear_id (&desc, level);
i = ((random ()) % (ilast + 1 - ifirst)) + ifirst;
p4est_quadrant_set_morton (&q, level, i);
testval = p8est_balance_seeds_edge (&q, &p, edge, P8EST_CONNECT_FACE,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P8EST_CONNECT_FACE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p8est_balance_seeds_edge error");
compare_seeds (seeds, seeds_check);
testval = p8est_balance_seeds_edge (&q, &p, edge, P8EST_CONNECT_EDGE,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P8EST_CONNECT_EDGE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p8est_balance_seeds_edge error");
compare_seeds (seeds, seeds_check);
testval = p8est_balance_seeds_edge (&q, &p, edge, P8EST_CONNECT_FULL,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P8EST_CONNECT_FULL,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p8est_balance_seeds_edge error");
compare_seeds (seeds, seeds_check);
}
}
}
#endif
#endif
for (corner = 0; corner < P4EST_FACES; corner++) {
p4est_quadrant_corner_neighbor (&root, corner ^ (P4EST_CHILDREN - 1), &p);
P4EST_GLOBAL_VERBOSEF ("Testing corner %d\n", corner);
for (level = 4; level <= maxlevel; level++) {
P4EST_GLOBAL_VERBOSEF (" level %d\n", level);
p4est_quadrant_first_descendant (&root, &desc, level);
ifirst = p4est_quadrant_linear_id (&desc, level);
p4est_quadrant_last_descendant (&root, &desc, level);
ilast = p4est_quadrant_linear_id (&desc, level);
for (i = ifirst; i <= ilast; i += P4EST_CHILDREN) {
p4est_quadrant_set_morton (&q, level, i);
#ifndef P4_TO_P8
testval =
p4est_balance_seeds_corner (&q, &p, corner, P4EST_CONNECT_FACE,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P4EST_CONNECT_FACE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p4est_balance_seeds_corner error");
compare_seeds (seeds, seeds_check);
#else
testval = p4est_balance_seeds_corner (&q, &p, corner,
P8EST_CONNECT_FACE, seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P8EST_CONNECT_FACE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p8est_balance_seeds_corner error");
compare_seeds (seeds, seeds_check);
testval =
p4est_balance_seeds_corner (&q, &p, corner, P8EST_CONNECT_EDGE,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P8EST_CONNECT_EDGE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p8est_balance_seeds_corner error");
compare_seeds (seeds, seeds_check);
#endif
testval =
p4est_balance_seeds_corner (&q, &p, corner, P4EST_CONNECT_FULL,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P4EST_CONNECT_FULL,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p4est_balance_seeds_corner error");
compare_seeds (seeds, seeds_check);
}
}
if (!corner) {
P4EST_GLOBAL_VERBOSE (" random levels\n");
for (j = 0; j < (int) nrand; j++) {
level = ((random ()) % (P4EST_QMAXLEVEL - maxlevel)) + maxlevel + 1;
p4est_quadrant_first_descendant (&root, &desc, level);
ifirst = p4est_quadrant_linear_id (&desc, level);
p4est_quadrant_last_descendant (&root, &desc, level);
ilast = p4est_quadrant_linear_id (&desc, level);
i = ((random ()) % (ilast + 1 - ifirst)) + ifirst;
p4est_quadrant_set_morton (&q, level, i);
#ifndef P4_TO_P8
testval =
p4est_balance_seeds_corner (&q, &p, corner, P4EST_CONNECT_FACE,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P4EST_CONNECT_FACE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p4est_balance_seeds_corner error");
compare_seeds (seeds, seeds_check);
#else
testval = p4est_balance_seeds_corner (&q, &p, corner,
P8EST_CONNECT_FACE, seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P8EST_CONNECT_FACE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p8est_balance_seeds_corner error");
compare_seeds (seeds, seeds_check);
testval =
p4est_balance_seeds_corner (&q, &p, corner, P8EST_CONNECT_EDGE,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P8EST_CONNECT_EDGE,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p8est_balance_seeds_corner error");
compare_seeds (seeds, seeds_check);
#endif
testval =
p4est_balance_seeds_corner (&q, &p, corner, P4EST_CONNECT_FULL,
seeds);
standard_seeds (seeds);
checkval = check_balance_seeds (&q, &p, P4EST_CONNECT_FULL,
seeds_check);
SC_CHECK_ABORT (testval == checkval,
"p4est_balance_seeds_corner error");
compare_seeds (seeds, seeds_check);
}
}
}
sc_array_destroy (seeds);
sc_array_destroy (seeds_check);
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
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;
int mpirank, mpisize;
int i, j;
char cvalue, cresult;
int ivalue, iresult;
unsigned short usvalue, usresult;
long lvalue, lresult;
float fvalue[3], fresult[3], fexpect[3];
double dvalue, dresult;
sc_MPI_Comm mpicomm;
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);
/* test allreduce int max */
ivalue = mpirank;
sc_allreduce (&ivalue, &iresult, 1, sc_MPI_INT, sc_MPI_MAX, mpicomm);
SC_CHECK_ABORT (iresult == mpisize - 1, "Allreduce mismatch");
/* test reduce float max */
fvalue[0] = (float) mpirank;
fexpect[0] = (float) (mpisize - 1);
fvalue[1] = (float) (mpirank % 9 - 4);
fexpect[1] = (float) (mpisize >= 9 ? 4 : (mpisize - 1) % 9 - 4);
fvalue[2] = (float) (mpirank % 6);
fexpect[2] = (float) (mpisize >= 6 ? 5 : (mpisize - 1) % 6);
for (i = 0; i < mpisize; ++i) {
sc_reduce (fvalue, fresult, 3, sc_MPI_FLOAT, sc_MPI_MAX, i, mpicomm);
if (i == mpirank) {
for (j = 0; j < 3; ++j) {
SC_CHECK_ABORTF (fresult[j] == fexpect[j], /* ok */
"Reduce mismatch in %d", j);
}
}
}
/* test allreduce char min */
cvalue = (char) (mpirank % 127);
sc_allreduce (&cvalue, &cresult, 1, sc_MPI_CHAR, sc_MPI_MIN, mpicomm);
SC_CHECK_ABORT (cresult == 0, "Allreduce mismatch");
/* test reduce unsigned short min */
usvalue = (unsigned short) (mpirank % 32767);
for (i = 0; i < mpisize; ++i) {
sc_reduce (&usvalue, &usresult, 1, sc_MPI_UNSIGNED_SHORT, sc_MPI_MIN, i,
mpicomm);
if (i == mpirank) {
SC_CHECK_ABORT (usresult == 0, "Reduce mismatch");
}
}
/* test allreduce long sum */
lvalue = (long) mpirank;
sc_allreduce (&lvalue, &lresult, 1, sc_MPI_LONG, sc_MPI_SUM, mpicomm);
SC_CHECK_ABORT (lresult == ((long) (mpisize - 1)) * mpisize / 2,
"Allreduce mismatch");
/* test reduce double sum */
dvalue = (double) mpirank;
for (i = 0; i < mpisize; ++i) {
sc_reduce (&dvalue, &dresult, 1, sc_MPI_DOUBLE, sc_MPI_SUM, i, mpicomm);
if (i == mpirank) {
SC_CHECK_ABORT (dresult == ((double) (mpisize - 1)) * mpisize / 2., /* ok */
"Reduce mismatch");
}
}
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
/**
* 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);
}
p4est_gloidx_t *
p6est_lnodes_get_column_labels (p6est_t * p6est, p8est_lnodes_t * lnodes)
{
p4est_gloidx_t *labels;
p4est_gloidx_t num_cols = 0;
p4est_gloidx_t global_num_cols = 0;
p4est_topidx_t jt;
p4est_tree_t *tree;
sc_array_t *tquadrants;
p4est_quadrant_t *col;
size_t zz, first, last;
p4est_locidx_t lfirst, llast, lk;
int stride = lnodes->degree + 1;
int vnodes = lnodes->vnodes;
int mpiret, i;
labels = P4EST_ALLOC (p4est_gloidx_t, lnodes->owned_count);
memset (labels, -1, lnodes->owned_count * sizeof (*labels));
for (jt = p6est->columns->first_local_tree;
jt <= p6est->columns->last_local_tree; ++jt) {
tree = p4est_tree_array_index (p6est->columns->trees, jt);
tquadrants = &tree->quadrants;
for (zz = 0; zz < tquadrants->elem_count; ++zz) {
col = p4est_quadrant_array_index (tquadrants, zz);
P6EST_COLUMN_GET_RANGE (col, &first, &last);
lfirst = (p4est_locidx_t) first;
llast = (p4est_locidx_t) last;
for (i = 0; i < vnodes; i += stride) {
p4est_locidx_t fnid = lnodes->element_nodes[vnodes * lfirst + i];
p4est_locidx_t lnid =
lnodes->element_nodes[vnodes * (llast - 1) + i + (stride - 1)];
P4EST_ASSERT (lnid >= 0);
P4EST_ASSERT (lnid >= fnid);
P4EST_ASSERT (fnid < lnodes->num_local_nodes);
if (lnid < lnodes->owned_count) {
P4EST_ASSERT (fnid < lnodes->owned_count);
if (labels[fnid] < 0) {
for (lk = fnid; lk <= lnid; lk++) {
labels[lk] = num_cols;
}
num_cols++;
}
}
}
}
}
mpiret =
sc_MPI_Exscan (&num_cols, &global_num_cols, 1, P4EST_MPI_GLOIDX,
sc_MPI_SUM, lnodes->mpicomm);
SC_CHECK_MPI (mpiret);
if (!p6est->mpirank) {
global_num_cols = 0;
}
for (lk = 0; lk < lnodes->owned_count; lk++) {
labels[lk] += global_num_cols;
}
#if 0
{
sc_array_t view;
sc_array_init_data (&view, labels, sizeof (*labels),
(size_t) lnodes->num_local_nodes);
p6est_lnodes_share_owned (&view, lnodes);
}
#endif
for (lk = 0; lk < lnodes->owned_count; lk++) {
P4EST_ASSERT (labels[lk] >= 0);
}
return labels;
}
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;
}
int
main (int argc, char **argv)
{
sc_MPI_Comm mpicomm;
int mpiret, mpisize;
int retval, nargs;
int minpoints;
int d, p, n;
double x, y;
sc_dmatrix_t *points, *knots, *works;
sc_bspline_t *bs;
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpicomm = sc_MPI_COMM_WORLD;
sc_init (mpicomm, 1, 1, NULL, SC_LP_DEFAULT);
mpiret = sc_MPI_Comm_size (mpicomm, &mpisize);
SC_CHECK_MPI (mpiret);
if (mpisize != 1)
sc_abort_collective ("This program runs in serial only");
nargs = 2;
if (argc != nargs) {
SC_LERRORF ("Usage: %s <degree>\n", argv[0]);
SC_ABORT ("Usage error");
}
n = atoi (argv[1]);
SC_CHECK_ABORT (n >= 0, "Degree must be non-negative");
minpoints = sc_bspline_min_number_points (n);
SC_INFOF ("Degree %d will require at least %d points\n", n, minpoints);
d = 2;
points = sc_dmatrix_new (0, d);
p = -1;
for (;;) {
retval = scanf ("%lg %lg", &x, &y);
if (retval == d) {
++p;
sc_dmatrix_resize (points, p + 1, d);
points->e[p][0] = x;
points->e[p][1] = y;
}
else
break;
}
SC_CHECK_ABORT (p + 1 >= minpoints, "Not enough points");
SC_INFOF ("Points read %d\n", p + 1);
works = sc_bspline_workspace_new (n, d);
knots = sc_bspline_knots_new (n, points);
bs = sc_bspline_new (n, points, knots, works);
create_plot ("uniform", bs);
sc_bspline_destroy (bs);
sc_dmatrix_destroy (knots);
if (n > 0) {
knots = sc_bspline_knots_new_length (n, points);
bs = sc_bspline_new (n, points, knots, works);
create_plot ("length", bs);
check_derivatives (bs);
sc_bspline_destroy (bs);
sc_dmatrix_destroy (knots);
}
sc_dmatrix_destroy (works);
sc_dmatrix_destroy (points);
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
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;
}
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;
}
int
main (int argc, char **argv)
{
const p4est_qcoord_t qone = 1;
int mpiret;
int k;
int level, mid, cid;
int id0, id1, id2, id3;
int64_t index1, index2;
size_t iz, jz, incount;
p4est_qcoord_t mh = P4EST_QUADRANT_LEN (P4EST_QMAXLEVEL);
p4est_connectivity_t *connectivity;
p4est_t *p4est1;
p4est_t *p4est2;
p4est_tree_t *t1, *t2, tree;
p4est_quadrant_t *p, *q1, *q2;
p4est_quadrant_t r, s;
p4est_quadrant_t c0, c1, c2, c3;
p4est_quadrant_t cv[P4EST_CHILDREN], *cp[P4EST_CHILDREN];
p4est_quadrant_t A, B, C, D, E, F, G, H, I, P, Q;
p4est_quadrant_t a, f, g, h;
uint64_t Aid, Fid;
/* initialize MPI */
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
/* create connectivity and forest structures */
connectivity = p4est_connectivity_new_unitsquare ();
p4est1 = p4est_new_ext (sc_MPI_COMM_SELF, connectivity, 15, 0, 0,
0, NULL, NULL);
p4est2 = p4est_new_ext (sc_MPI_COMM_SELF, connectivity, 15, 0, 0,
8, NULL, NULL);
/* refine the second tree to a uniform level */
p4est_refine (p4est1, 1, refine_none, NULL);
p4est_refine (p4est2, 1, refine_some, NULL);
t1 = p4est_tree_array_index (p4est1->trees, 0);
t2 = p4est_tree_array_index (p4est2->trees, 0);
SC_CHECK_ABORT (p4est_tree_is_sorted (t1), "is_sorted");
SC_CHECK_ABORT (p4est_tree_is_sorted (t2), "is_sorted");
/* run a bunch of cross-tests */
p = NULL;
for (iz = 0; iz < t1->quadrants.elem_count; ++iz) {
q1 = p4est_quadrant_array_index (&t1->quadrants, iz);
/* test the index conversion */
index1 = p4est_quadrant_linear_id (q1, (int) q1->level);
p4est_quadrant_set_morton (&r, (int) q1->level, index1);
index2 = p4est_quadrant_linear_id (&r, (int) r.level);
SC_CHECK_ABORT (index1 == index2, "index conversion");
level = (int) q1->level - 1;
if (level >= 0) {
index1 = p4est_quadrant_linear_id (q1, level);
p4est_quadrant_set_morton (&r, level, index1);
index2 = p4est_quadrant_linear_id (&r, level);
SC_CHECK_ABORT (index1 == index2, "index conversion");
}
/* test the is_next function */
if (p != NULL) {
SC_CHECK_ABORT (p4est_quadrant_is_next (p, q1), "is_next");
}
p = q1;
/* test the is_family function */
p4est_quadrant_children (q1, &c0, &c1, &c2, &c3);
SC_CHECK_ABORT (p4est_quadrant_is_family (&c0, &c1, &c2, &c3),
"is_family");
SC_CHECK_ABORT (!p4est_quadrant_is_family (&c1, &c0, &c2, &c3),
"is_family");
SC_CHECK_ABORT (!p4est_quadrant_is_family (&c0, &c0, &c1, &c2),
"is_family");
p4est_quadrant_childrenv (q1, cv);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&c0, &cv[0]), "is_family");
SC_CHECK_ABORT (p4est_quadrant_is_equal (&c1, &cv[1]), "is_family");
SC_CHECK_ABORT (p4est_quadrant_is_equal (&c2, &cv[2]), "is_family");
SC_CHECK_ABORT (p4est_quadrant_is_equal (&c3, &cv[3]), "is_family");
SC_CHECK_ABORT (p4est_quadrant_is_family (&cv[0], &cv[1], &cv[2], &cv[3]),
"is_family");
cp[0] = &cv[0];
cp[1] = &cv[1];
cp[2] = &cv[2];
cp[3] = &cv[3];
SC_CHECK_ABORT (p4est_quadrant_is_familypv (cp), "is_family");
cv[1] = cv[0];
SC_CHECK_ABORT (!p4est_quadrant_is_familyv (cv), "is_family");
cp[1] = &c1;
SC_CHECK_ABORT (p4est_quadrant_is_familypv (cp), "is_family");
cp[2] = &c3;
SC_CHECK_ABORT (!p4est_quadrant_is_familypv (cp), "is_family");
/* test the sibling function */
mid = p4est_quadrant_child_id (q1);
for (cid = 0; cid < 4; ++cid) {
p4est_quadrant_sibling (q1, &r, cid);
if (cid != mid) {
SC_CHECK_ABORT (p4est_quadrant_is_sibling (q1, &r), "sibling");
}
else {
SC_CHECK_ABORT (p4est_quadrant_is_equal (q1, &r), "sibling");
}
}
/* test t1 against itself */
for (jz = 0; jz < t1->quadrants.elem_count; ++jz) {
q2 = p4est_quadrant_array_index (&t1->quadrants, jz);
/* test the comparison function */
SC_CHECK_ABORT (p4est_quadrant_compare (q1, q2) ==
-p4est_quadrant_compare (q2, q1), "compare");
SC_CHECK_ABORT ((p4est_quadrant_compare (q1, q2) == 0) ==
p4est_quadrant_is_equal (q1, q2), "is_equal");
/* test the descriptive versions of functions */
SC_CHECK_ABORT (p4est_quadrant_is_sibling_D (q1, q2) ==
p4est_quadrant_is_sibling (q1, q2), "is_sibling");
SC_CHECK_ABORT (p4est_quadrant_is_parent_D (q1, q2) ==
p4est_quadrant_is_parent (q1, q2), "is_parent");
SC_CHECK_ABORT (p4est_quadrant_is_parent_D (q2, q1) ==
p4est_quadrant_is_parent (q2, q1), "is_parent");
SC_CHECK_ABORT (p4est_quadrant_is_ancestor_D (q1, q2) ==
p4est_quadrant_is_ancestor (q1, q2), "is_ancestor");
SC_CHECK_ABORT (p4est_quadrant_is_ancestor_D (q2, q1) ==
p4est_quadrant_is_ancestor (q2, q1), "is_ancestor");
SC_CHECK_ABORT (p4est_quadrant_is_next_D (q1, q2) ==
p4est_quadrant_is_next (q1, q2), "is_next");
SC_CHECK_ABORT (p4est_quadrant_is_next_D (q2, q1) ==
p4est_quadrant_is_next (q2, q1), "is_next");
p4est_nearest_common_ancestor_D (q1, q2, &r);
p4est_nearest_common_ancestor (q1, q2, &s);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&r, &s), "common_ancestor");
p4est_nearest_common_ancestor_D (q2, q1, &r);
p4est_nearest_common_ancestor (q2, q1, &s);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&r, &s), "common_ancestor");
}
/* test t1 against t2 */
for (jz = 0; jz < t2->quadrants.elem_count; ++jz) {
q2 = p4est_quadrant_array_index (&t2->quadrants, jz);
/* test the comparison function */
SC_CHECK_ABORT (p4est_quadrant_compare (q1, q2) ==
-p4est_quadrant_compare (q2, q1), "compare");
SC_CHECK_ABORT ((p4est_quadrant_compare (q1, q2) == 0) ==
p4est_quadrant_is_equal (q1, q2), "is_equal");
/* test the descriptive versions of functions */
SC_CHECK_ABORT (p4est_quadrant_is_sibling_D (q1, q2) ==
p4est_quadrant_is_sibling (q1, q2), "is_sibling");
SC_CHECK_ABORT (p4est_quadrant_is_parent_D (q1, q2) ==
p4est_quadrant_is_parent (q1, q2), "is_parent");
SC_CHECK_ABORT (p4est_quadrant_is_parent_D (q2, q1) ==
p4est_quadrant_is_parent (q2, q1), "is_parent");
SC_CHECK_ABORT (p4est_quadrant_is_ancestor_D (q1, q2) ==
p4est_quadrant_is_ancestor (q1, q2), "is_ancestor");
SC_CHECK_ABORT (p4est_quadrant_is_ancestor_D (q2, q1) ==
p4est_quadrant_is_ancestor (q2, q1), "is_ancestor");
SC_CHECK_ABORT (p4est_quadrant_is_next_D (q1, q2) ==
p4est_quadrant_is_next (q1, q2), "is_next");
SC_CHECK_ABORT (p4est_quadrant_is_next_D (q2, q1) ==
p4est_quadrant_is_next (q2, q1), "is_next");
p4est_nearest_common_ancestor_D (q1, q2, &r);
p4est_nearest_common_ancestor (q1, q2, &s);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&r, &s), "common_ancestor");
p4est_nearest_common_ancestor_D (q2, q1, &r);
p4est_nearest_common_ancestor (q2, q1, &s);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&r, &s), "common_ancestor");
}
}
p = NULL;
for (iz = 0; iz < t2->quadrants.elem_count; ++iz) {
q1 = p4est_quadrant_array_index (&t2->quadrants, iz);
/* test the is_next function */
if (p != NULL) {
SC_CHECK_ABORT (p4est_quadrant_is_next (p, q1), "is_next");
}
p = q1;
}
/* test the coarsen function */
p4est_coarsen (p4est1, 1, coarsen_none, NULL);
p4est_coarsen (p4est1, 1, coarsen_all, NULL);
p4est_coarsen (p4est2, 1, coarsen_some, NULL);
/* test the linearize algorithm */
incount = t2->quadrants.elem_count;
(void) p4est_linearize_tree (p4est2, t2);
SC_CHECK_ABORT (incount == t2->quadrants.elem_count, "linearize");
/* this is user_data neutral only when p4est1->data_size == 0 */
sc_array_init (&tree.quadrants, sizeof (p4est_quadrant_t));
sc_array_resize (&tree.quadrants, 18);
q1 = p4est_quadrant_array_index (&tree.quadrants, 0);
q2 = p4est_quadrant_array_index (&t2->quadrants, 0);
*q1 = *q2;
q2 = p4est_quadrant_array_index (&t2->quadrants, 1);
for (k = 0; k < 3; ++k) {
q1 = p4est_quadrant_array_index (&tree.quadrants, (size_t) (k + 1));
*q1 = *q2;
q1->level = (int8_t) (q1->level + k);
}
for (k = 0; k < 10; ++k) {
q1 = p4est_quadrant_array_index (&tree.quadrants, (size_t) (k + 4));
q2 = p4est_quadrant_array_index (&t2->quadrants, (size_t) (k + 3));
*q1 = *q2;
q1->level = (int8_t) (q1->level + k);
}
for (k = 0; k < 4; ++k) {
q1 = p4est_quadrant_array_index (&tree.quadrants, (size_t) (k + 14));
q2 = p4est_quadrant_array_index (&t2->quadrants, (size_t) (k + 12));
*q1 = *q2;
q1->level = (int8_t) (q1->level + 10 + k);
}
tree.maxlevel = 0;
for (k = 0; k <= P4EST_QMAXLEVEL; ++k) {
tree.quadrants_per_level[k] = 0;
}
for (; k <= P4EST_MAXLEVEL; ++k) {
tree.quadrants_per_level[k] = -1;
}
incount = tree.quadrants.elem_count;
for (iz = 0; iz < incount; ++iz) {
q1 = p4est_quadrant_array_index (&tree.quadrants, iz);
++tree.quadrants_per_level[q1->level];
tree.maxlevel = (int8_t) SC_MAX (tree.maxlevel, q1->level);
}
SC_CHECK_ABORT (!p4est_tree_is_linear (&tree), "is_linear");
(void) p4est_linearize_tree (p4est1, &tree);
SC_CHECK_ABORT (incount - 3 == tree.quadrants.elem_count, "linearize");
sc_array_reset (&tree.quadrants);
/* create a partial tree and check overlap */
sc_array_resize (&tree.quadrants, 3);
q1 = p4est_quadrant_array_index (&tree.quadrants, 0);
p4est_quadrant_set_morton (q1, 1, 1);
q1 = p4est_quadrant_array_index (&tree.quadrants, 1);
p4est_quadrant_set_morton (q1, 2, 8);
q1 = p4est_quadrant_array_index (&tree.quadrants, 2);
p4est_quadrant_set_morton (q1, 2, 9);
for (k = 0; k <= P4EST_QMAXLEVEL; ++k) {
tree.quadrants_per_level[k] = 0;
}
for (; k <= P4EST_MAXLEVEL; ++k) {
tree.quadrants_per_level[k] = -1;
}
tree.quadrants_per_level[1] = 1;
tree.quadrants_per_level[2] = 2;
tree.maxlevel = 2;
p4est_quadrant_first_descendant (p4est_quadrant_array_index
(&tree.quadrants, 0), &tree.first_desc,
P4EST_QMAXLEVEL);
p4est_quadrant_last_descendant (p4est_quadrant_array_index
(&tree.quadrants,
tree.quadrants.elem_count - 1),
&tree.last_desc, P4EST_QMAXLEVEL);
SC_CHECK_ABORT (p4est_tree_is_complete (&tree), "is_complete");
p4est_quadrant_set_morton (&D, 0, 0);
SC_CHECK_ABORT (p4est_quadrant_overlaps_tree (&tree, &D), "overlaps 0");
p4est_quadrant_set_morton (&A, 1, 0);
SC_CHECK_ABORT (!p4est_quadrant_overlaps_tree (&tree, &A), "overlaps 1");
p4est_quadrant_set_morton (&A, 1, 1);
SC_CHECK_ABORT (p4est_quadrant_overlaps_tree (&tree, &A), "overlaps 2");
p4est_quadrant_set_morton (&A, 1, 2);
SC_CHECK_ABORT (p4est_quadrant_overlaps_tree (&tree, &A), "overlaps 3");
p4est_quadrant_set_morton (&A, 1, 3);
SC_CHECK_ABORT (!p4est_quadrant_overlaps_tree (&tree, &A), "overlaps 4");
p4est_quadrant_set_morton (&B, 3, 13);
SC_CHECK_ABORT (!p4est_quadrant_overlaps_tree (&tree, &B), "overlaps 5");
p4est_quadrant_set_morton (&B, 3, 25);
SC_CHECK_ABORT (p4est_quadrant_overlaps_tree (&tree, &B), "overlaps 6");
p4est_quadrant_set_morton (&B, 3, 39);
SC_CHECK_ABORT (p4est_quadrant_overlaps_tree (&tree, &B), "overlaps 7");
p4est_quadrant_set_morton (&B, 3, 40);
SC_CHECK_ABORT (!p4est_quadrant_overlaps_tree (&tree, &B), "overlaps 8");
p4est_quadrant_set_morton (&C, 4, 219);
SC_CHECK_ABORT (!p4est_quadrant_overlaps_tree (&tree, &C), "overlaps 9");
sc_array_reset (&tree.quadrants);
/* destroy the p4est and its connectivity structure */
p4est_destroy (p4est1);
p4est_destroy (p4est2);
p4est_connectivity_destroy (connectivity);
/* This will test the ability to address negative quadrants */
P4EST_QUADRANT_INIT (&A);
P4EST_QUADRANT_INIT (&B);
P4EST_QUADRANT_INIT (&C);
P4EST_QUADRANT_INIT (&D);
P4EST_QUADRANT_INIT (&E);
P4EST_QUADRANT_INIT (&F);
P4EST_QUADRANT_INIT (&G);
P4EST_QUADRANT_INIT (&H);
P4EST_QUADRANT_INIT (&I);
P4EST_QUADRANT_INIT (&P);
P4EST_QUADRANT_INIT (&Q);
A.x = -qone << P4EST_MAXLEVEL;
A.y = -qone << P4EST_MAXLEVEL;
A.level = 0;
B.x = qone << P4EST_MAXLEVEL;
B.y = -qone << P4EST_MAXLEVEL;
B.level = 0;
C.x = -qone << P4EST_MAXLEVEL;
C.y = qone << P4EST_MAXLEVEL;
C.level = 0;
D.x = qone << P4EST_MAXLEVEL;
D.y = qone << P4EST_MAXLEVEL;
D.level = 0;
/* this one is outside the 3x3 box */
E.x = -qone << (P4EST_MAXLEVEL + 1);
E.y = -qone;
E.level = 0;
F.x = P4EST_ROOT_LEN + (P4EST_ROOT_LEN - mh);
F.y = P4EST_ROOT_LEN + (P4EST_ROOT_LEN - mh);
F.level = P4EST_QMAXLEVEL;
G.x = -mh;
G.y = -mh;
G.level = P4EST_QMAXLEVEL;
H.x = -qone << (P4EST_MAXLEVEL - 1);
H.y = -qone << (P4EST_MAXLEVEL - 1);
H.level = 1;
I.x = -qone << P4EST_MAXLEVEL;
I.y = -qone << (P4EST_MAXLEVEL - 1);
I.level = 1;
check_linear_id (&A, &A);
check_linear_id (&A, &B);
check_linear_id (&A, &C);
check_linear_id (&A, &D);
/* check_linear_id (&A, &E); */
check_linear_id (&A, &F);
check_linear_id (&A, &G);
check_linear_id (&A, &H);
check_linear_id (&A, &I);
check_linear_id (&B, &A);
check_linear_id (&B, &B);
check_linear_id (&B, &C);
check_linear_id (&B, &D);
/* check_linear_id (&B, &E); */
check_linear_id (&B, &F);
check_linear_id (&B, &G);
check_linear_id (&B, &H);
check_linear_id (&B, &I);
check_linear_id (&D, &A);
check_linear_id (&D, &B);
check_linear_id (&D, &C);
check_linear_id (&D, &D);
/* check_linear_id (&D, &E); */
check_linear_id (&D, &F);
check_linear_id (&D, &G);
check_linear_id (&D, &H);
check_linear_id (&D, &I);
check_linear_id (&G, &A);
check_linear_id (&G, &B);
check_linear_id (&G, &C);
check_linear_id (&G, &D);
/* check_linear_id (&G, &E); */
check_linear_id (&G, &F);
check_linear_id (&G, &G);
check_linear_id (&G, &H);
check_linear_id (&G, &I);
check_linear_id (&I, &A);
check_linear_id (&I, &B);
check_linear_id (&I, &C);
check_linear_id (&I, &D);
/* check_linear_id (&I, &E); */
check_linear_id (&I, &F);
check_linear_id (&I, &G);
check_linear_id (&I, &H);
check_linear_id (&I, &I);
SC_CHECK_ABORT (p4est_quadrant_is_extended (&A) == 1, "is_extended A");
SC_CHECK_ABORT (p4est_quadrant_is_extended (&B) == 1, "is_extended B");
SC_CHECK_ABORT (p4est_quadrant_is_extended (&C) == 1, "is_extended C");
SC_CHECK_ABORT (p4est_quadrant_is_extended (&D) == 1, "is_extended D");
SC_CHECK_ABORT (!p4est_quadrant_is_extended (&E) == 1, "!is_extended E");
SC_CHECK_ABORT (p4est_quadrant_is_extended (&F) == 1, "is_extended F");
SC_CHECK_ABORT (p4est_quadrant_is_extended (&G) == 1, "is_extended G");
SC_CHECK_ABORT (p4est_quadrant_compare (&A, &A) == 0, "compare");
SC_CHECK_ABORT (p4est_quadrant_compare (&A, &B) > 0, "compare");
SC_CHECK_ABORT (p4est_quadrant_compare (&B, &A) < 0, "compare");
SC_CHECK_ABORT (p4est_quadrant_compare (&F, &F) == 0, "compare");
SC_CHECK_ABORT (p4est_quadrant_compare (&G, &F) > 0, "compare");
SC_CHECK_ABORT (p4est_quadrant_compare (&F, &G) < 0, "compare");
A.p.which_tree = 0;
B.p.piggy1.which_tree = 0;
SC_CHECK_ABORT (p4est_quadrant_compare_piggy (&A, &A) == 0,
"compare_piggy");
SC_CHECK_ABORT (p4est_quadrant_compare_piggy (&A, &B) > 0, "compare_piggy");
SC_CHECK_ABORT (p4est_quadrant_compare_piggy (&B, &A) < 0, "compare_piggy");
F.p.piggy2.which_tree = 0;
G.p.which_tree = 0;
SC_CHECK_ABORT (p4est_quadrant_compare_piggy (&F, &F) == 0,
"compare_piggy");
SC_CHECK_ABORT (p4est_quadrant_compare_piggy (&G, &F) > 0, "compare_piggy");
SC_CHECK_ABORT (p4est_quadrant_compare_piggy (&F, &G) < 0, "compare_piggy");
F.p.piggy1.which_tree = (p4est_topidx_t) P4EST_TOPIDX_MAX - 3;
G.p.piggy2.which_tree = (p4est_topidx_t) P4EST_TOPIDX_MAX / 2;
SC_CHECK_ABORT (p4est_quadrant_compare_piggy (&F, &F) == 0,
"compare_piggy");
SC_CHECK_ABORT (p4est_quadrant_compare_piggy (&G, &F) < 0, "compare_piggy");
SC_CHECK_ABORT (p4est_quadrant_compare_piggy (&F, &G) > 0, "compare_piggy");
SC_CHECK_ABORT (p4est_quadrant_is_equal (&A, &A) == 1, "is_equal");
SC_CHECK_ABORT (p4est_quadrant_is_equal (&F, &F) == 1, "is_equal");
SC_CHECK_ABORT (p4est_quadrant_is_equal (&G, &G) == 1, "is_equal");
/* Not sure if these make sense because D, O and A are all level 0 */
#if 0
SC_CHECK_ABORT (p4est_quadrant_is_sibling (&D, &O) == 1, "is_sibling");
SC_CHECK_ABORT (p4est_quadrant_is_sibling (&D, &A) == 0, "is_sibling");
SC_CHECK_ABORT (p4est_quadrant_is_sibling_D (&D, &O) == 1, "is_sibling_D");
SC_CHECK_ABORT (p4est_quadrant_is_sibling_D (&D, &A) == 0, "is_sibling_D");
#endif
SC_CHECK_ABORT (p4est_quadrant_is_sibling (&I, &H) == 1, "is_sibling");
SC_CHECK_ABORT (p4est_quadrant_is_sibling (&I, &G) == 0, "is_sibling");
SC_CHECK_ABORT (p4est_quadrant_is_sibling_D (&I, &H) == 1, "is_sibling_D");
SC_CHECK_ABORT (p4est_quadrant_is_sibling_D (&I, &G) == 0, "is_sibling_D");
SC_CHECK_ABORT (p4est_quadrant_is_parent (&A, &H) == 1, "is_parent");
SC_CHECK_ABORT (p4est_quadrant_is_parent (&H, &A) == 0, "is_parent");
SC_CHECK_ABORT (p4est_quadrant_is_parent (&A, &D) == 0, "is_parent");
SC_CHECK_ABORT (p4est_quadrant_is_parent_D (&A, &H) == 1, "is_parent_D");
SC_CHECK_ABORT (p4est_quadrant_is_ancestor (&A, &G) == 1, "is_ancestor");
SC_CHECK_ABORT (p4est_quadrant_is_ancestor (&G, &A) == 0, "is_ancestor");
SC_CHECK_ABORT (p4est_quadrant_is_ancestor_D (&A, &G) == 1,
"is_ancestor_D");
SC_CHECK_ABORT (p4est_quadrant_is_ancestor_D (&G, &A) == 0,
"is_ancestor_D");
/* SC_CHECK_ABORT (p4est_quadrant_is_next (&F, &E) == 1, "is_next"); */
SC_CHECK_ABORT (p4est_quadrant_is_next (&A, &H) == 0, "is_next");
/* SC_CHECK_ABORT (p4est_quadrant_is_next_D (&F, &E) == 1, "is_next_D"); */
SC_CHECK_ABORT (p4est_quadrant_is_next_D (&A, &H) == 0, "is_next_D");
p4est_quadrant_parent (&H, &a);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&A, &a) == 1, "parent");
p4est_quadrant_sibling (&I, &h, 3);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&H, &h) == 1, "sibling");
p4est_quadrant_children (&A, &c0, &c1, &c2, &c3);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&c2, &I) == 1, "children");
SC_CHECK_ABORT (p4est_quadrant_is_equal (&c3, &H) == 1, "children");
SC_CHECK_ABORT (p4est_quadrant_is_equal (&c3, &G) == 0, "children");
SC_CHECK_ABORT (p4est_quadrant_is_family (&c0, &c1, &c2, &c3) == 1,
"is_family");
id0 = p4est_quadrant_child_id (&c0);
id1 = p4est_quadrant_child_id (&c1);
id2 = p4est_quadrant_child_id (&c2);
id3 = p4est_quadrant_child_id (&c3);
SC_CHECK_ABORT (id0 == 0 && id1 == 1 && id2 == 2 && id3 == 3, "child_id");
SC_CHECK_ABORT (p4est_quadrant_child_id (&G) == 3, "child_id");
p4est_quadrant_first_descendant (&A, &c1, 1);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&c0, &c1) == 1,
"first_descendant");
p4est_quadrant_last_descendant (&A, &g, P4EST_QMAXLEVEL);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&G, &g) == 1, "last_descendant");
Fid = p4est_quadrant_linear_id (&F, P4EST_QMAXLEVEL);
p4est_quadrant_set_morton (&f, P4EST_QMAXLEVEL, Fid);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&F, &f) == 1,
"set_morton/linear_id");
Aid = p4est_quadrant_linear_id (&A, 0);
p4est_quadrant_set_morton (&a, 0, Aid);
SC_CHECK_ABORT (Aid == 15, "linear_id");
SC_CHECK_ABORT (p4est_quadrant_is_equal (&A, &a) == 1,
"set_morton/linear_id");
p4est_nearest_common_ancestor (&I, &H, &a);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&A, &a) == 1, "ancestor");
p4est_nearest_common_ancestor_D (&I, &H, &a);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&A, &a) == 1, "ancestor_D");
for (k = 0; k < 16; ++k) {
if (k != 4 && k != 6 && k != 8 && k != 9 && k != 12 && k != 13 && k != 14) {
p4est_quadrant_set_morton (&E, 0, (uint64_t) k);
}
}
p4est_quadrant_set_morton (&P, 0, 10);
p4est_quadrant_set_morton (&Q, 0, 11);
SC_CHECK_ABORT (p4est_quadrant_is_next (&P, &Q), "is_next");
SC_CHECK_ABORT (!p4est_quadrant_is_next (&A, &Q), "is_next");
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
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;
}
int main(int argc, char *argv[])
{
int mpiret;
sc_MPI_Comm mpicomm;
int proc_size;
p4est_connectivity_t *conn;
p4est_geometry_t *geom;
p4est_t* p4est;
int seed = time(NULL);
srand(seed);
/* MPI init */
mpiret = sc_MPI_Init(&argc, &argv);
SC_CHECK_MPI(mpiret);
mpicomm = sc_MPI_COMM_WORLD;
sc_init (mpicomm, 1, 1, NULL, SC_LP_ESSENTIAL);
mpiret = MPI_Comm_size(mpicomm, &proc_size);
SC_CHECK_MPI (mpiret);
/* pXest init */
p4est_init(NULL, SC_LP_PRODUCTION);
conn = p4est_connectivity_new_disk();
/* geom = p4est_geometry_new_connectivity(conn); */
geom = p4est_geometry_new_disk(conn,1.,2.);
p4est = p4est_new_ext (mpicomm, conn, -1, 0, 1,
sizeof(curved_element_data_t), NULL, NULL);
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);
/* start just-in-time dg-math */
dgmath_jit_dbase_t* dgmath_jit_dbase = dgmath_jit_dbase_init();
geometric_factors_t* geometric_factors = geometric_factors_init(p4est);
curved_element_data_init(p4est, geometric_factors, dgmath_jit_dbase, geom, 4);
/* int local_nodes = curved_element_data_get_local_nodes(p4est); */
/* double* u = P4EST_ALLOC(double, local_nodes); */
/* for (int i = 0; i < local_nodes; i++){ */
/* /\* u = x *\/ */
/* u[i] = geometric_factors->xyz[i]; */
/* } */
int num_of_refinements = 2;
/* p4est_vtk_write_all */
/* (p4est, */
/* geom, */
/* 0.99, */
/* 1, */
/* 1, */
/* 1, */
/* 0, */
/* 0, */
/* 0, */
/* "disk0" */
/* ); */
for (int i = 0; i < num_of_refinements; i++){
p4est_refine_ext (p4est, 0, -1, random_h_refine, NULL, refine_uniform_replace_callback);
p4est_balance_ext(p4est, P4EST_CONNECT_FACE, NULL, refine_uniform_replace_callback);
/* p4est_vtk_write_all */
/* (p4est, */
/* geom, */
/* 0.99, */
/* 1, */
/* 1, */
/* 1, */
/* 0, */
/* 0, */
/* 0, */
/* "disk" */
/* ); */
}
curved_element_data_init(p4est, geometric_factors, dgmath_jit_dbase, geom, -1);
int local_nodes = curved_element_data_get_local_nodes(p4est);
double* u = P4EST_ALLOC(double, local_nodes);
for (int i = 0; i < local_nodes; i++){
/* u = x */
u[i] = geometric_factors->xyz[i];
}
/* curved_element_data_init(p4est, geometric_factors, dgmath_jit_dbase, geom, -1); */
/* store vector */
curved_element_data_copy_from_vec_to_storage
(
p4est,
u
);
test_curved_data_t test_curved_data;
test_curved_data.mortar_err = 0.;
test_curved_data.hanging_proj_err = 0.;
test_curved_data.full_proj_err = 0.;
test_curved_data.print_data = 1;
test_curved_data.no_reorient = 0;
test_curved_data.geom = geom;
p4est_ghost_t* ghost = p4est_ghost_new (p4est, P4EST_CONNECT_FACE);
/* create space for storing the ghost data */
curved_element_data_t* ghost_data = P4EST_ALLOC (curved_element_data_t,
ghost->ghosts.elem_count);
p4est_ghost_exchange_data (p4est, ghost, ghost_data);
curved_compute_flux_user_data_t curved_compute_flux_user_data;
curved_compute_flux_user_data.dgmath_jit_dbase = dgmath_jit_dbase;
curved_flux_fcn_ptrs_t flux_fcns = (test_curved_data_fetch_fcns(&test_curved_data));
curved_compute_flux_user_data.flux_fcn_ptrs = &flux_fcns;
p4est->user_pointer = &curved_compute_flux_user_data;
p4est_iterate (p4est,
ghost,
(void *) ghost_data,
NULL,
curved_compute_flux_on_local_elements,
#if (P4EST_DIM)==3
NULL,
#endif
NULL);
test_curved_data.mortar_err = 0.;
if (world_rank == 0)
printf("mortar_err = %.20f\n",
test_curved_data.mortar_err
);
p4est_ghost_destroy (ghost);
P4EST_FREE (ghost_data);
ghost = NULL;
ghost_data = NULL;
/* curved_hp_amr(p4est, */
/* &u, */
/* test_nonconform_random_hp, */
/* NULL, */
/* NULL, */
/* NULL, */
/* dgmath_jit_dbase */
/* ); */
/* curved_element_data_init(p4est, geometric_factors, dgmath_jit_dbase, geom, -1); */
/* double* u_vertex = P4EST_ALLOC(double, p4est->local_num_quadrants*(P4EST_CHILDREN)); */
/* element_data_store_nodal_vec_in_vertex_array */
/* ( */
/* p4est, */
/* u, */
/* u_vertex */
/* ); */
/* char sol_save_as [500]; */
/* sprintf(sol_save_as, "%s_test_nonconform_sym_level_%d_u", P4EST_STRING, i); */
/* curved_hacked_p4est_vtk_write_all */
/* (p4est, */
/* NULL, */
/* 0.99, */
/* 0, */
/* 1, */
/* 1, */
/* 0, */
/* 1, */
/* 0, */
/* sol_save_as, */
/* "u", */
/* u_vertex */
/* ); */
/* P4EST_FREE(u_vertex); */
/* ip_flux_params_t ip_flux_params; */
/* ip_flux_params.ip_flux_penalty_prefactor = atoi(argv[6]); */
/* ip_flux_params.ip_flux_penalty_calculate_fcn = sipg_flux_vector_calc_penalty_maxp2_over_minh; */
/* problem_data_t vecs; */
/* vecs.u = u; */
/* vecs.local_nodes = element_data_get_local_nodes(p4est); */
/* vecs.vector_flux_fcn_data = sipg_flux_vector_dirichlet_fetch_fcns */
/* ( */
/* zero_fcn, */
/* &ip_flux_params */
/* ); */
/* vecs.scalar_flux_fcn_data = sipg_flux_scalar_dirichlet_fetch_fcns(zero_fcn); */
/* weakeqn_ptrs_t fcns; */
/* fcns.apply_lhs = poisson_apply_aij; */
/* matrix_sym_tester */
/* ( */
/* p4est, */
/* &vecs, /\* only needed for # of nodes *\/ */
/* &fcns, */
/* .000000000000001, */
/* dgmath_jit_dbase, */
/* 0, */
/* 0 */
/* ); */
/* } */
P4EST_FREE(u);
geometric_factors_destroy(geometric_factors);
/* free pointers */
dgmath_jit_dbase_destroy(dgmath_jit_dbase);
/* free pXest */
p4est_destroy(p4est);
/* p4est_destroy(p4est); */
if (geom != NULL) {
p4est_geometry_destroy (geom);
}
p4est_connectivity_destroy(conn);
/* finalize mpi stuff */
sc_finalize();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI(mpiret);
}
int
main (int argc, char **argv)
{
sc_MPI_Comm mpicomm;
int mpiret;
int mpisize, mpirank;
p4est_t *p4est;
p4est_connectivity_t *connectivity;
sc_dmatrix_t *vtkvec;
p4est_tree_t *tree;
sc_array_t *quadrants;
size_t zz, count;
p4est_quadrant_t *q;
int i;
#ifndef P4_TO_P8
char filename[] = "p4est_balance_face";
#else
char filename[] = "p8est_balance_edge";
#endif
p4est_vtk_context_t *context;
sc_array_t *level;
int retval;
/* 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_unitsquare ();
#else
connectivity = p8est_connectivity_new_unitcube ();
#endif
p4est = p4est_new_ext (mpicomm, connectivity, 0, 2, 1,
sizeof (balance_seeds_elem_t), init_fn, NULL);
p4est_refine (p4est, 1, refine_fn, init_fn);
context = p4est_vtk_context_new (p4est, filename);
p4est_vtk_context_set_scale (context, 1. - 2. * SC_EPS);
context = p4est_vtk_write_header (context);
SC_CHECK_ABORT (context != NULL, P4EST_STRING "_vtk: Error writing header");
vtkvec = sc_dmatrix_new (p4est->local_num_quadrants, P4EST_CHILDREN);
tree = p4est_tree_array_index (p4est->trees, 0);
quadrants = &(tree->quadrants);
count = quadrants->elem_count;
for (zz = 0; zz < count; zz++) {
q = p4est_quadrant_array_index (quadrants, zz);
for (i = 0; i < P4EST_CHILDREN; i++) {
vtkvec->e[zz][i] = (double)
((balance_seeds_elem_t *) (q->p.user_data))->flag;
}
}
level =
sc_array_new_data ((void *) vtkvec->e[0], sizeof (double),
count * P4EST_CHILDREN);
context =
p4est_vtk_write_point_dataf (context, 1, 0, "level", level, context);
SC_CHECK_ABORT (context != NULL,
P4EST_STRING "_vtk: Error writing point data");
sc_array_destroy (level);
retval = p4est_vtk_write_footer (context);
SC_CHECK_ABORT (!retval, P4EST_STRING "_vtk: Error writing footer");
sc_dmatrix_destroy (vtkvec);
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 num_failed_tests = 0;
int mpiret;
sc_keyvalue_t *args;
sc_keyvalue_t *args2;
const char *dummy = "I am a dummy string";
const char *wrong = "I am the wrong string";
const char *again = "Try this all over again";
int intTest;
double doubleTest;
const char *stringTest;
void *pointerTest;
/* Initialization stuff */
mpiret = MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
sc_init (MPI_COMM_WORLD, 1, 1, NULL, SC_LP_DEFAULT);
/* Print some funny stuff */
SC_GLOBAL_LDEBUGF ("Hash of empty string: %x\n",
sc_hash_function_string ("", NULL));
SC_GLOBAL_LDEBUGF ("Hash of ABCDEFGHIJKL: %x\n",
sc_hash_function_string ("ABCDEFGHIJKL", NULL));
SC_GLOBAL_LDEBUGF ("Hash of dummy: %x\n",
sc_hash_function_string (dummy, NULL));
SC_GLOBAL_LDEBUGF ("Hash of dummy: %x\n",
sc_hash_function_string (wrong, NULL));
SC_GLOBAL_LDEBUGF ("Hash of dummy: %x\n",
sc_hash_function_string (again, NULL));
/* Create a new argument set */
args = sc_keyvalue_newf (0,
"i:intTest", -17,
"g:doubleTest", 3.14159,
"s:stringTest", "Hello Test!",
"p:pointerTest", (void *) dummy, NULL);
intTest = sc_keyvalue_get_int (args, "intTest", 0);
doubleTest = sc_keyvalue_get_double (args, "doubleTest", 0.0);
stringTest = sc_keyvalue_get_string (args, "stringTest", wrong);
pointerTest = sc_keyvalue_get_pointer (args, "pointerTest", NULL);
if (intTest != -17) {
SC_VERBOSE ("Test 1 failure on int\n");
num_failed_tests++;
}
if (doubleTest != 3.14159) {
SC_VERBOSE ("Test 1 failure on double\n");
num_failed_tests++;
}
if (strcmp (stringTest, "Hello Test!")) {
SC_VERBOSE ("Test 1 failure on string\n");
num_failed_tests++;
}
if (pointerTest != (void *) dummy) {
SC_VERBOSE ("Test 1 failure on pointer\n");
num_failed_tests++;
}
sc_keyvalue_destroy (args);
args = NULL;
/* Create a new argument set using the sc_keyvalue_set functions */
args2 = sc_keyvalue_new ();
sc_keyvalue_set_int (args2, "intTest", -17);
sc_keyvalue_set_double (args2, "doubleTest", 3.14159);
sc_keyvalue_set_string (args2, "stringTest", "Hello Test!");
sc_keyvalue_set_pointer (args2, "pointerTest", (void *) dummy);
/* Direct verification that these objects now exist */
if (sc_keyvalue_exists (args2, "intTest") != SC_KEYVALUE_ENTRY_INT) {
SC_VERBOSE ("Test exist failure on int\n");
num_failed_tests++;
}
if (sc_keyvalue_exists (args2, "doubleTest") != SC_KEYVALUE_ENTRY_DOUBLE) {
SC_VERBOSE ("Test exist failure on double\n");
num_failed_tests++;
}
if (sc_keyvalue_exists (args2, "stringTest") != SC_KEYVALUE_ENTRY_STRING) {
SC_VERBOSE ("Test exist failure on string\n");
num_failed_tests++;
}
if (sc_keyvalue_exists (args2, "pointerTest") != SC_KEYVALUE_ENTRY_POINTER) {
SC_VERBOSE ("Test exist failure on pointer\n");
num_failed_tests++;
}
intTest = sc_keyvalue_get_int (args2, "intTest", 0);
doubleTest = sc_keyvalue_get_double (args2, "doubleTest", 0.0);
stringTest = sc_keyvalue_get_string (args2, "stringTest", wrong);
pointerTest = sc_keyvalue_get_pointer (args2, "pointerTest", NULL);
if (intTest != -17) {
SC_VERBOSE ("Test 2 failure on int\n");
num_failed_tests++;
}
if (doubleTest != 3.14159) {
SC_VERBOSE ("Test 2 failure on double\n");
num_failed_tests++;
}
if (strcmp (stringTest, "Hello Test!")) {
SC_VERBOSE ("Test 2 failure on string\n");
num_failed_tests++;
}
if (pointerTest != (void *) dummy) {
SC_VERBOSE ("Test 2 failure on pointer\n");
num_failed_tests++;
}
/* Test the unset functionality */
if (sc_keyvalue_unset (args2, "intTest") != SC_KEYVALUE_ENTRY_INT) {
SC_VERBOSE ("Test unset failure on int\n");
num_failed_tests++;
}
if (sc_keyvalue_unset (args2, "doubleTest") != SC_KEYVALUE_ENTRY_DOUBLE) {
SC_VERBOSE ("Test unset failure on double\n");
num_failed_tests++;
}
if (sc_keyvalue_unset (args2, "stringTest") != SC_KEYVALUE_ENTRY_STRING) {
SC_VERBOSE ("Test unset failure on string\n");
num_failed_tests++;
}
if (sc_keyvalue_unset (args2, "pointerTest") != SC_KEYVALUE_ENTRY_POINTER) {
SC_VERBOSE ("Test unset failure on pointer\n");
num_failed_tests++;
}
intTest = sc_keyvalue_get_int (args2, "intTest", 12);
doubleTest = sc_keyvalue_get_double (args2, "doubleTest", 2.71828);
stringTest =
sc_keyvalue_get_string (args2, "stringTest", "Another test string?");
pointerTest =
sc_keyvalue_get_pointer (args2, "pointerTest", (void *) again);
if (intTest != 12) {
SC_VERBOSE ("Test 3 failure on int\n");
num_failed_tests++;
}
if (doubleTest != 2.71828) {
SC_VERBOSE ("Test 3 failure on double\n");
num_failed_tests++;
}
if (strcmp (stringTest, "Another test string?")) {
SC_VERBOSE ("Test 3 failure on string\n");
num_failed_tests++;
}
if (pointerTest != again) {
SC_VERBOSE ("Test 3 failure on pointer\n");
num_failed_tests++;
}
/* Direct verification that these objects no longer exist */
if (sc_keyvalue_exists (args2, "intTest")) {
SC_VERBOSE ("Test 4 failure on int\n");
num_failed_tests++;
}
if (sc_keyvalue_exists (args2, "doubleTest")) {
SC_VERBOSE ("Test 4 failure on double\n");
num_failed_tests++;
}
if (sc_keyvalue_exists (args2, "stringTest")) {
SC_VERBOSE ("Test 4 failure on string\n");
num_failed_tests++;
}
if (sc_keyvalue_exists (args2, "pointerTest")) {
SC_VERBOSE ("Test 4 failure on pointer\n");
num_failed_tests++;
}
/* Test empty cases for exists and unset */
if (sc_keyvalue_exists (args2, "notakey") != SC_KEYVALUE_ENTRY_NONE) {
SC_VERBOSE ("Test failure on nonexist 1\n");
num_failed_tests++;
}
if (sc_keyvalue_unset (args2, "notanotherkey") != SC_KEYVALUE_ENTRY_NONE) {
SC_VERBOSE ("Test failure on nonexist 2\n");
num_failed_tests++;
}
sc_keyvalue_destroy (args2);
/* Shutdown procedures */
sc_finalize ();
mpiret = MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return num_failed_tests ? 1 : 0;
}
trilinear_mesh_t *
p8est_trilinear_mesh_new_from_nodes (p4est_t * p4est, p4est_nodes_t * nodes)
{
const int num_procs = p4est->mpisize;
const int rank = p4est->mpirank;
int mpiret;
int k, owner;
#ifdef P4EST_DEBUG
int prev_owner = 0;
int64_t prev_fvnid = -1;
#endif
int *sharers;
size_t current, zz, num_sharers;
int32_t e, n, local_owned_end;
int64_t global_borrowed, global_shared;
int64_t local_counts[5], global_counts[5];
int32link_t *lynk, **tail;
p4est_topidx_t which_tree;
p4est_locidx_t *local_node, *shared_offsets;
p4est_tree_t *tree;
p4est_quadrant_t *q;
p4est_indep_t *in;
p8est_hang4_t *fh;
p8est_hang2_t *eh;
trilinear_elem_t *elem;
trilinear_anode_t *anode;
trilinear_dnode_t *dnode;
trilinear_mesh_t *mesh;
trilinear_mesh_pid_t *elem_pids;
trilinear_mesh_pid_t *node_pids;
sc_recycle_array_t *rarr;
P4EST_GLOBAL_PRODUCTIONF
("Into trilinear_mesh_extract with %lld total elements\n",
(long long) p4est->global_num_quadrants);
/* Allocate output data structure. */
mesh = P4EST_ALLOC_ZERO (trilinear_mesh_t, 1);
memset (mesh, -1, sizeof (*mesh));
shared_offsets = nodes->shared_offsets;
/* Assign local counts. */
P4EST_ASSERT (nodes->num_local_quadrants == p4est->local_num_quadrants);
mesh->local_elem_num = p4est->local_num_quadrants;
mesh->local_anode_num = nodes->indep_nodes.elem_count;
mesh->local_dnode_num =
nodes->face_hangings.elem_count + nodes->edge_hangings.elem_count;
mesh->local_onode_num = nodes->num_owned_indeps;
mesh->local_owned_offset = nodes->offset_owned_indeps;
mesh->local_node_num = mesh->local_anode_num + mesh->local_dnode_num;
local_owned_end = mesh->local_owned_offset + mesh->local_onode_num;
/* Communicate global counts. */
local_counts[0] = mesh->local_elem_num;
local_counts[1] = mesh->local_anode_num;
local_counts[2] = mesh->local_onode_num;
local_counts[3] = mesh->local_dnode_num;
local_counts[4] = nodes->num_owned_shared;
mpiret = MPI_Allreduce (local_counts, global_counts, 5, MPI_LONG_LONG_INT,
MPI_SUM, p4est->mpicomm);
SC_CHECK_MPI (mpiret);
P4EST_ASSERT (global_counts[0] == p4est->global_num_quadrants);
mesh->total_elem_num = global_counts[0];
global_borrowed = global_counts[1] - global_counts[2];
mesh->total_anode_num = global_counts[2];
mesh->total_dnode_num = global_counts[3];
global_shared = global_counts[4];
mesh->total_node_num = mesh->total_anode_num + mesh->total_dnode_num;
/* Allocate the mesh memory. */
mesh->elem_table = P4EST_ALLOC (trilinear_elem_t, mesh->local_elem_num);
mesh->node_table = P4EST_ALLOC (trilinear_node_t, mesh->local_node_num);
mesh->fvnid_count_table = P4EST_ALLOC (int64_t, num_procs + 1);
mesh->fvnid_interval_table = P4EST_ALLOC (int64_t, num_procs + 1);
mesh->all_fvnid_start = mesh->fvnid_interval_table;
mesh->sharer_pool = sc_mempool_new (sizeof (int32link_t));
mesh->elem_pids = P4EST_ALLOC (trilinear_mesh_pid_t, mesh->local_node_num);
mesh->node_pids = P4EST_ALLOC (trilinear_mesh_pid_t, mesh->local_node_num);
/* Assign global free variable information. */
mesh->fvnid_interval_table[0] = 0;
for (k = 0; k < num_procs; ++k) {
mesh->fvnid_interval_table[k + 1] = mesh->fvnid_interval_table[k] +
(mesh->fvnid_count_table[k] = nodes->global_owned_indeps[k]);
}
mesh->fvnid_count_table[num_procs] = -1;
mesh->global_fvnid_num = mesh->fvnid_interval_table[num_procs];
mesh->global_fvnid_start = 0;
mesh->global_fvnid_end = mesh->global_fvnid_num - 1;
P4EST_ASSERT (mesh->global_fvnid_num == mesh->total_anode_num);
/* Assign element information. */
local_node = nodes->local_nodes;
which_tree = p4est->first_local_tree;
elem_pids = mesh->elem_pids;
if (which_tree >= 0) {
tree = p4est_tree_array_index (p4est->trees, which_tree);
current = 0;
for (e = 0; e < mesh->local_elem_num; ++e) {
if (current == tree->quadrants.elem_count) {
++which_tree;
tree = p4est_tree_array_index (p4est->trees, which_tree);
current = 0;
}
q = p4est_quadrant_array_index (&tree->quadrants, current);
elem = mesh->elem_table + e;
for (k = 0; k < P4EST_CHILDREN; ++k) {
elem->local_node_id[k] = *local_node++;
}
elem->lx = (tick_t) q->x;
elem->ly = (tick_t) q->y;
elem->lz = (tick_t) q->z;
elem->size = P4EST_QUADRANT_LEN (q->level);
elem->data = q->p.user_data;
elem_pids[e] = (trilinear_mesh_pid_t) which_tree;
++current;
}
P4EST_ASSERT (which_tree == p4est->last_local_tree);
P4EST_ASSERT (current == tree->quadrants.elem_count);
}
/* Assign anchored node information. */
mesh->anode_table = mesh->node_table;
mesh->onode_table = mesh->node_table + mesh->local_owned_offset;
mesh->dnode_table = mesh->node_table + mesh->local_anode_num;
node_pids = mesh->node_pids;
for (n = 0; n < mesh->local_anode_num; ++n) {
anode = &mesh->node_table[n].anchored;
in = (p4est_indep_t *) sc_array_index (&nodes->indep_nodes, (size_t) n);
anode->point.x = in->x;
anode->point.y = in->y;
anode->point.z = in->z;
node_pids[n] = (trilinear_mesh_pid_t) in->p.piggy3.which_tree;
if (n < mesh->local_owned_offset) {
owner = nodes->nonlocal_ranks[n];
P4EST_ASSERT (owner < rank && owner >= prev_owner);
}
else if (n >= local_owned_end) {
owner = nodes->nonlocal_ranks[n - mesh->local_onode_num];
P4EST_ASSERT (owner > rank && owner >= prev_owner);
}
else {
owner = rank;
}
anode->fvnid = mesh->all_fvnid_start[owner] + in->p.piggy3.local_num;
P4EST_ASSERT (anode->fvnid > prev_fvnid);
if (in->pad8 == 0) {
P4EST_ASSERT (in->pad16 == -1);
P4EST_ASSERT (shared_offsets == NULL || shared_offsets[n] == -1);
anode->share = NULL;
}
else {
P4EST_ASSERT (in->pad8 > 0);
num_sharers = (size_t) in->pad8;
rarr =
(sc_recycle_array_t *) sc_array_index (&nodes->shared_indeps,
num_sharers - 1);
if (nodes->shared_offsets == NULL) {
P4EST_ASSERT (in->pad16 >= 0);
zz = (size_t) in->pad16;
}
else {
P4EST_ASSERT (in->pad16 == -1);
zz = (size_t) shared_offsets[n];
}
sharers = (int *) sc_array_index (&rarr->a, zz);
tail = &anode->share;
for (zz = 0; zz < num_sharers; ++zz) {
*tail = lynk = (int32link_t *) sc_mempool_alloc (mesh->sharer_pool);
lynk->id = (int32_t) sharers[zz];
tail = &lynk->next;
}
*tail = NULL;
}
#ifdef P4EST_DEBUG
prev_owner = owner;
prev_fvnid = anode->fvnid;
#endif
}
/* Assign face hanging node information. */
for (zz = 0; zz < nodes->face_hangings.elem_count; ++n, ++zz) {
dnode = &mesh->node_table[n].dangling;
fh = (p8est_hang4_t *) sc_array_index (&nodes->face_hangings, zz);
dnode->point.x = fh->x;
dnode->point.y = fh->y;
dnode->point.z = fh->z;
dnode->type = 0; /* Not used in Rhea. */
dnode->local_anode_id[0] = fh->p.piggy.depends[0];
dnode->local_anode_id[1] = fh->p.piggy.depends[1];
dnode->local_anode_id[2] = fh->p.piggy.depends[2];
dnode->local_anode_id[3] = fh->p.piggy.depends[3];
node_pids[n] = (trilinear_mesh_pid_t) fh->p.piggy.which_tree;
}
/* Assign edge hanging node information. */
for (zz = 0; zz < nodes->edge_hangings.elem_count; ++n, ++zz) {
dnode = &mesh->node_table[n].dangling;
eh = (p8est_hang2_t *) sc_array_index (&nodes->edge_hangings, zz);
dnode->point.x = eh->x;
dnode->point.y = eh->y;
dnode->point.z = eh->z;
dnode->type = 0; /* Not used in Rhea. */
dnode->local_anode_id[0] = eh->p.piggy.depends[0];
dnode->local_anode_id[1] = eh->p.piggy.depends[1];
dnode->local_anode_id[2] = dnode->local_anode_id[3] = -1;
node_pids[n] = (trilinear_mesh_pid_t) eh->p.piggy.which_tree;
}
P4EST_ASSERT (n == mesh->local_node_num);
/* Assign the remaining variables. */
mesh->mpicomm = p4est->mpicomm;
mesh->mpisize = (int32_t) num_procs;
mesh->mpirank = (int32_t) rank;
mesh->recsize = (int32_t) p4est->data_size;
mesh->destructor = p8est_trilinear_mesh_destroy;
/* These members are incomplete and need to be filled later. */
memset (mesh->bounds, 0, 6 * sizeof (int));
memset (mesh->sizes, 0, 3 * sizeof (int));
mesh->minsize = mesh->maxsize = 0;
mesh->ticksize = 0.;
mesh->extra_info = NULL;
mesh->gid = -1;
/* We are done */
P4EST_GLOBAL_PRODUCTIONF ("Done trilinear_mesh_extract"
" with %lld anodes %lld %lld\n",
(long long) mesh->total_anode_num,
(long long) global_borrowed,
(long long) global_shared);
return mesh;
}
p4est_t *
p4est_new_points (sc_MPI_Comm mpicomm, p4est_connectivity_t * connectivity,
int maxlevel, p4est_quadrant_t * points,
p4est_locidx_t num_points, p4est_locidx_t max_points,
size_t data_size, p4est_init_t init_fn, void *user_pointer)
{
int mpiret;
int num_procs, rank;
int i, isizet;
size_t lcount;
size_t *nmemb;
#ifdef P4EST_ENABLE_DEBUG
size_t zz;
#endif
p4est_topidx_t jt, num_trees;
p4est_topidx_t first_tree, last_tree, next_tree;
p4est_quadrant_t *first_quad, *next_quad, *quad;
p4est_quadrant_t a, b, c, f, l, n;
p4est_tree_t *tree;
p4est_t *p4est;
p4est_points_state_t ppstate;
P4EST_GLOBAL_PRODUCTIONF ("Into " P4EST_STRING
"_new_points with max level %d max points %lld\n",
maxlevel, (long long) max_points);
p4est_log_indent_push ();
P4EST_ASSERT (p4est_connectivity_is_valid (connectivity));
P4EST_ASSERT (max_points >= -1);
/* retrieve MPI information */
mpiret = sc_MPI_Comm_size (mpicomm, &num_procs);
SC_CHECK_MPI (mpiret);
mpiret = sc_MPI_Comm_rank (mpicomm, &rank);
SC_CHECK_MPI (mpiret);
/* This implementation runs in O(P/p * maxlevel)
* with P the total number of points, p the number of processors.
* Two optimizations are possible:
* 1. At startup remove points that lead to duplicate quadrants.
* 2. Use complete_region between successive points instead of
* the call to refine. This should give O(N/p) * maxlevel
* with N the total number of quadrants.
*/
/* parallel sort the incoming points */
lcount = (size_t) num_points;
nmemb = P4EST_ALLOC_ZERO (size_t, num_procs);
isizet = (int) sizeof (size_t);
mpiret = sc_MPI_Allgather (&lcount, isizet, sc_MPI_BYTE,
nmemb, isizet, sc_MPI_BYTE, mpicomm);
SC_CHECK_MPI (mpiret);
sc_psort (mpicomm, points, nmemb, sizeof (p4est_quadrant_t),
p4est_quadrant_compare_piggy);
P4EST_FREE (nmemb);
#ifdef P4EST_ENABLE_DEBUG
first_quad = points;
for (zz = 1; zz < lcount; ++zz) {
next_quad = points + zz;
P4EST_ASSERT (p4est_quadrant_compare_piggy (first_quad, next_quad) <= 0);
first_quad = next_quad;
}
#endif
/* create the p4est */
p4est = P4EST_ALLOC_ZERO (p4est_t, 1);
ppstate.points = points;
ppstate.num_points = num_points;
ppstate.max_points = max_points;
ppstate.current = 0;
ppstate.maxlevel = maxlevel;
/* assign some data members */
p4est->data_size = 2 * sizeof (p4est_locidx_t); /* temporary */
p4est->user_pointer = &ppstate;
p4est->connectivity = connectivity;
num_trees = connectivity->num_trees;
/* create parallel environment */
p4est_comm_parallel_env_create (p4est, mpicomm);
/* allocate memory pools */
p4est->user_data_pool = sc_mempool_new (p4est->data_size);
p4est->quadrant_pool = sc_mempool_new (sizeof (p4est_quadrant_t));
P4EST_GLOBAL_PRODUCTIONF ("New " P4EST_STRING
" with %lld trees on %d processors\n",
(long long) num_trees, num_procs);
/* allocate trees */
p4est->trees = sc_array_new (sizeof (p4est_tree_t));
sc_array_resize (p4est->trees, num_trees);
for (jt = 0; jt < num_trees; ++jt) {
tree = p4est_tree_array_index (p4est->trees, jt);
sc_array_init (&tree->quadrants, sizeof (p4est_quadrant_t));
P4EST_QUADRANT_INIT (&tree->first_desc);
P4EST_QUADRANT_INIT (&tree->last_desc);
tree->quadrants_offset = 0;
for (i = 0; i <= P4EST_QMAXLEVEL; ++i) {
tree->quadrants_per_level[i] = 0;
}
for (; i <= P4EST_MAXLEVEL; ++i) {
tree->quadrants_per_level[i] = -1;
}
tree->maxlevel = 0;
}
p4est->local_num_quadrants = 0;
p4est->global_num_quadrants = 0;
/* create point based partition */
P4EST_QUADRANT_INIT (&f);
p4est->global_first_position =
P4EST_ALLOC_ZERO (p4est_quadrant_t, num_procs + 1);
if (num_points == 0) {
P4EST_VERBOSE ("Empty processor");
first_tree = p4est->first_local_tree = -1;
first_quad = NULL;
}
else {
/* we are probably not empty */
if (rank == 0) {
first_tree = p4est->first_local_tree = 0;
p4est_quadrant_set_morton (&f, maxlevel, 0);
}
else {
first_tree = p4est->first_local_tree = points->p.which_tree;
p4est_node_to_quadrant (points, maxlevel, &f);
}
first_quad = &f;
}
last_tree = p4est->last_local_tree = -2;
p4est_comm_global_partition (p4est, first_quad);
first_quad = p4est->global_first_position + rank;
next_quad = p4est->global_first_position + (rank + 1);
next_tree = next_quad->p.which_tree;
if (first_tree >= 0 &&
p4est_quadrant_is_equal (first_quad, next_quad) &&
first_quad->p.which_tree == next_quad->p.which_tree) {
/* if all our points are consumed by the next processor we are empty */
first_tree = p4est->first_local_tree = -1;
}
if (first_tree >= 0) {
/* we are definitely not empty */
if (next_quad->x == 0 && next_quad->y == 0
#ifdef P4_TO_P8
&& next_quad->z == 0
#endif
) {
last_tree = p4est->last_local_tree = next_tree - 1;
}
else {
last_tree = p4est->last_local_tree = next_tree;
}
P4EST_ASSERT (first_tree <= last_tree);
}
/* fill the local trees */
P4EST_QUADRANT_INIT (&a);
P4EST_QUADRANT_INIT (&b);
P4EST_QUADRANT_INIT (&c);
P4EST_QUADRANT_INIT (&l);
n = *next_quad;
n.level = (int8_t) maxlevel;
for (jt = first_tree; jt <= last_tree; ++jt) {
int onlyone = 0;
int includeb = 0;
tree = p4est_tree_array_index (p4est->trees, jt);
/* determine first local quadrant of this tree */
if (jt == first_tree) {
a = *first_quad;
a.level = (int8_t) maxlevel;
first_quad = next_quad = NULL; /* free to use further down */
P4EST_ASSERT (p4est_quadrant_is_valid (&a));
}
else {
p4est_quadrant_set_morton (&a, maxlevel, 0);
P4EST_ASSERT (jt < next_tree || p4est_quadrant_compare (&a, &n) < 0);
}
/* enlarge first local quadrant if possible */
if (jt < next_tree) {
while (p4est_quadrant_child_id (&a) == 0 && a.level > 0) {
p4est_quadrant_parent (&a, &a);
}
P4EST_ASSERT (jt == first_tree || a.level == 0);
}
else {
for (c = a; p4est_quadrant_child_id (&c) == 0; a = c) {
p4est_quadrant_parent (&c, &c);
p4est_quadrant_last_descendant (&c, &l, maxlevel);
if (p4est_quadrant_compare (&l, &n) >= 0) {
break;
}
}
P4EST_ASSERT (a.level > 0);
P4EST_ASSERT ((p4est_quadrant_last_descendant (&a, &l, maxlevel),
p4est_quadrant_compare (&l, &n) < 0));
}
p4est_quadrant_first_descendant (&a, &tree->first_desc, P4EST_QMAXLEVEL);
/* determine largest possible last quadrant of this tree */
if (jt < next_tree) {
p4est_quadrant_last_descendant (&a, &l, maxlevel);
p4est_quadrant_set_morton (&b, 0, 0);
p4est_quadrant_last_descendant (&b, &b, maxlevel);
if (p4est_quadrant_is_equal (&l, &b)) {
onlyone = 1;
}
else {
includeb = 1;
for (c = b; p4est_quadrant_child_id (&c) == P4EST_CHILDREN - 1; b = c) {
p4est_quadrant_parent (&c, &c);
p4est_quadrant_first_descendant (&c, &f, maxlevel);
if (p4est_quadrant_compare (&l, &f) >= 0) {
break;
}
}
}
}
else {
b = n;
}
/* create a complete tree */
if (onlyone) {
quad = p4est_quadrant_array_push (&tree->quadrants);
*quad = a;
p4est_quadrant_init_data (p4est, jt, quad, p4est_points_init);
tree->maxlevel = a.level;
++tree->quadrants_per_level[a.level];
}
else {
p4est_complete_region (p4est, &a, 1, &b, includeb,
tree, jt, p4est_points_init);
quad = p4est_quadrant_array_index (&tree->quadrants,
tree->quadrants.elem_count - 1);
}
tree->quadrants_offset = p4est->local_num_quadrants;
p4est->local_num_quadrants += tree->quadrants.elem_count;
p4est_quadrant_last_descendant (quad, &tree->last_desc, P4EST_QMAXLEVEL);
/* verification */
#ifdef P4EST_ENABLE_DEBUG
first_quad = p4est_quadrant_array_index (&tree->quadrants, 0);
for (zz = 1; zz < tree->quadrants.elem_count; ++zz) {
next_quad = p4est_quadrant_array_index (&tree->quadrants, zz);
P4EST_ASSERT (((p4est_locidx_t *) first_quad->p.user_data)[1] ==
((p4est_locidx_t *) next_quad->p.user_data)[0]);
first_quad = next_quad;
}
#endif
}
if (last_tree >= 0) {
for (; jt < num_trees; ++jt) {
tree = p4est_tree_array_index (p4est->trees, jt);
tree->quadrants_offset = p4est->local_num_quadrants;
}
}
/* compute some member variables */
p4est->global_first_quadrant = P4EST_ALLOC (p4est_gloidx_t, num_procs + 1);
p4est_comm_count_quadrants (p4est);
/* print more statistics */
P4EST_VERBOSEF ("total local quadrants %lld\n",
(long long) p4est->local_num_quadrants);
P4EST_ASSERT (p4est_is_valid (p4est));
p4est_log_indent_pop ();
P4EST_GLOBAL_PRODUCTIONF ("Done " P4EST_STRING
"_new_points with %lld total quadrants\n",
(long long) p4est->global_num_quadrants);
/* refine to have one point per quadrant */
if (max_points >= 0) {
p4est_refine_ext (p4est, 1, maxlevel, p4est_points_refine,
p4est_points_init, NULL);
#ifdef P4EST_ENABLE_DEBUG
for (jt = first_tree; jt <= last_tree; ++jt) {
tree = p4est_tree_array_index (p4est->trees, jt);
first_quad = p4est_quadrant_array_index (&tree->quadrants, 0);
for (zz = 1; zz < tree->quadrants.elem_count; ++zz) {
next_quad = p4est_quadrant_array_index (&tree->quadrants, zz);
P4EST_ASSERT (((p4est_locidx_t *) first_quad->p.user_data)[1] ==
((p4est_locidx_t *) next_quad->p.user_data)[0]);
first_quad = next_quad;
}
}
#endif
}
/* initialize user pointer and data size */
p4est_reset_data (p4est, data_size, init_fn, user_pointer);
return p4est;
}
int
p6est_profile_sync (p6est_profile_t * profile)
{
p4est_lnodes_t *lnodes = profile->lnodes;
p4est_locidx_t nln = lnodes->num_local_nodes;
sc_array_t lrview;
p4est_lnodes_buffer_t *countbuf;
sc_array_t *sharers;
size_t zz, nsharers;
int nleft;
int8_t *recv, *send;
int *array_of_indices;
p4est_locidx_t recv_total;
p4est_locidx_t *recv_offsets, recv_offset;
p4est_locidx_t send_total;
p4est_locidx_t *send_offsets, send_offset;
p4est_locidx_t (*lr)[2];
sc_array_t *lc = profile->lnode_columns;
sc_MPI_Request *recv_request, *send_request;
sc_array_t *work;
int any_change = 0;
int any_global_change;
int mpiret, mpirank;
int evenodd = profile->evenodd;
lr = (p4est_locidx_t (*)[2]) profile->lnode_ranges;
sharers = lnodes->sharers;
nsharers = sharers->elem_count;
mpiret = sc_MPI_Comm_rank (lnodes->mpicomm, &mpirank);
SC_CHECK_MPI (mpiret);
sc_array_init_data (&lrview, lr, 2 * sizeof (p4est_locidx_t), nln);
countbuf = p4est_lnodes_share_all_begin (&lrview, lnodes);
send_offsets = P4EST_ALLOC (p4est_locidx_t, nsharers + 1);
send_offset = 0;
for (zz = 0; zz < nsharers; zz++) {
p4est_lnodes_rank_t *sharer;
sc_array_t *send_buf;
size_t zy, nnodes;
send_offsets[zz] = send_offset;
sharer = p4est_lnodes_rank_array_index (sharers, zz);
if (sharer->rank == mpirank) {
continue;
}
send_buf = (sc_array_t *) sc_array_index (countbuf->send_buffers, zz);
nnodes = sharer->shared_nodes.elem_count;
P4EST_ASSERT (nnodes == send_buf->elem_count);
P4EST_ASSERT (send_buf->elem_size == 2 * sizeof (p4est_locidx_t));
for (zy = 0; zy < nnodes; zy++) {
p4est_locidx_t *lp =
(p4est_locidx_t *) sc_array_index (send_buf, zy);
P4EST_ASSERT (lp[0] >= 0);
P4EST_ASSERT (lp[1] >= 0);
send_offset += lp[1];
}
}
send_total = send_offsets[nsharers] = send_offset;
p4est_lnodes_share_all_end (countbuf);
recv_offsets = P4EST_ALLOC (p4est_locidx_t, nsharers + 1);
recv_offset = 0;
for (zz = 0; zz < nsharers; zz++) {
p4est_lnodes_rank_t *sharer;
sc_array_t *recv_buf;
size_t zy, nnodes;
recv_offsets[zz] = recv_offset;
sharer = p4est_lnodes_rank_array_index (sharers, zz);
if (sharer->rank == mpirank) {
continue;
}
recv_buf = (sc_array_t *) sc_array_index (countbuf->recv_buffers, zz);
nnodes = sharer->shared_nodes.elem_count;
P4EST_ASSERT (nnodes == recv_buf->elem_count);
P4EST_ASSERT (recv_buf->elem_size == 2 * sizeof (p4est_locidx_t));
for (zy = 0; zy < nnodes; zy++) {
p4est_locidx_t *lp =
(p4est_locidx_t *) sc_array_index (recv_buf, zy);
P4EST_ASSERT (lp[0] >= 0);
P4EST_ASSERT (lp[1] >= 0);
recv_offset += lp[1];
}
}
recv_total = recv_offsets[nsharers] = recv_offset;
recv = P4EST_ALLOC (int8_t, recv_total);
recv_request = P4EST_ALLOC (sc_MPI_Request, nsharers);
send = P4EST_ALLOC (int8_t, send_total);
send_request = P4EST_ALLOC (sc_MPI_Request, nsharers);
/* post receives */
nleft = 0;
for (zz = 0; zz < nsharers; zz++) {
p4est_lnodes_rank_t *sharer;
int icount = recv_offsets[zz + 1] - recv_offsets[zz];
sharer = p4est_lnodes_rank_array_index (sharers, zz);
if (sharer->rank == mpirank) {
recv_request[zz] = sc_MPI_REQUEST_NULL;
continue;
}
if (icount) {
mpiret =
sc_MPI_Irecv (recv + recv_offsets[zz], icount * sizeof (int8_t),
sc_MPI_BYTE, sharer->rank, P6EST_COMM_BALANCE,
lnodes->mpicomm, recv_request + zz);
SC_CHECK_MPI (mpiret);
nleft++;
}
else {
recv_request[zz] = sc_MPI_REQUEST_NULL;
}
}
/* post sends */
for (zz = 0; zz < nsharers; zz++) {
p4est_lnodes_rank_t *sharer;
size_t zy, nnodes;
int icount;
sc_array_t *shared_nodes;
sharer = p4est_lnodes_rank_array_index (sharers, zz);
if (sharer->rank == mpirank) {
send_request[zz] = sc_MPI_REQUEST_NULL;
continue;
}
shared_nodes = &sharer->shared_nodes;
nnodes = shared_nodes->elem_count;
icount = 0;
for (zy = 0; zy < nnodes; zy++) {
p4est_locidx_t nidx;
int8_t *c;
nidx = *((p4est_locidx_t *) sc_array_index (shared_nodes, zy));
if (lr[nidx][1]) {
c = (int8_t *) sc_array_index (lc, lr[nidx][0]);
memcpy (send + send_offsets[zz] + icount, c,
lr[nidx][1] * sizeof (int8_t));
icount += lr[nidx][1];
}
else {
P4EST_ASSERT (!lr[nidx][0]);
}
}
P4EST_ASSERT (icount == send_offsets[zz + 1] - send_offsets[zz]);
if (icount) {
mpiret =
sc_MPI_Isend (send + send_offsets[zz], icount * sizeof (int8_t),
sc_MPI_BYTE, sharer->rank, P6EST_COMM_BALANCE,
lnodes->mpicomm, send_request + zz);
SC_CHECK_MPI (mpiret);
}
else {
send_request[zz] = sc_MPI_REQUEST_NULL;
}
}
work = sc_array_new (sizeof (int8_t));
array_of_indices = P4EST_ALLOC (int, nsharers);
while (nleft) {
int outcount;
int i;
mpiret = sc_MPI_Waitsome (nsharers, recv_request, &outcount,
array_of_indices, sc_MPI_STATUSES_IGNORE);
SC_CHECK_MPI (mpiret);
for (i = 0; i < outcount; i++) {
p4est_lnodes_rank_t *sharer;
size_t zy, nnode;
sc_array_t *shared_nodes;
sc_array_t *recv_buf;
zz = array_of_indices[i];
sharer = p4est_lnodes_rank_array_index (sharers, zz);
shared_nodes = &sharer->shared_nodes;
recv_buf = (sc_array_t *) sc_array_index (countbuf->recv_buffers, zz);
nnode = shared_nodes->elem_count;
P4EST_ASSERT (nnode == recv_buf->elem_count);
recv_offset = recv_offsets[zz];
for (zy = 0; zy < nnode; zy++) {
p4est_locidx_t *lp;
p4est_locidx_t nidx;
sc_array_t oldview, newview;
nidx = *((p4est_locidx_t *) sc_array_index (shared_nodes, zy));
lp = (p4est_locidx_t *) sc_array_index (recv_buf, zy);
sc_array_init_view (&oldview, lc, lr[nidx][0], lr[nidx][1]);
sc_array_init_data (&newview, recv + recv_offset, sizeof (int8_t),
lp[1]);
if (profile->ptype == P6EST_PROFILE_UNION) {
p6est_profile_union (&oldview, &newview, work);
if (work->elem_count > oldview.elem_count) {
int8_t *c;
any_change = 1;
lr[nidx][0] = lc->elem_count;
lr[nidx][1] = work->elem_count;
profile->lnode_changed[evenodd][nidx] = 1;
c = (int8_t *) sc_array_push_count (lc, work->elem_count);
memcpy (c, work->array, work->elem_count * work->elem_size);
}
}
else {
p6est_profile_intersection (&oldview, &newview, work);
P4EST_ASSERT (work->elem_count <= oldview.elem_count);
if (work->elem_count < oldview.elem_count) {
lr[nidx][1] = work->elem_count;
memcpy (oldview.array, work->array,
work->elem_count * work->elem_size);
}
}
recv_offset += lp[1];
}
P4EST_ASSERT (recv_offset == recv_offsets[zz + 1]);
}
nleft -= outcount;
P4EST_ASSERT (nleft >= 0);
}
P4EST_FREE (array_of_indices);
sc_array_destroy (work);
p6est_profile_compress (profile);
p4est_lnodes_buffer_destroy (countbuf);
P4EST_FREE (recv_request);
P4EST_FREE (recv_offsets);
P4EST_FREE (recv);
{
mpiret = sc_MPI_Waitall (nsharers, send_request, sc_MPI_STATUSES_IGNORE);
SC_CHECK_MPI (mpiret);
P4EST_FREE (send_request);
P4EST_FREE (send_offsets);
P4EST_FREE (send);
any_global_change = any_change;
mpiret = sc_MPI_Allreduce (&any_change, &any_global_change, 1, sc_MPI_INT,
sc_MPI_LOR, lnodes->mpicomm);
SC_CHECK_MPI (mpiret);
}
return any_global_change;
}
void
sc_init (sc_MPI_Comm mpicomm,
int catch_signals, int print_backtrace,
sc_log_handler_t log_handler, int log_threshold)
{
int w;
const char *trace_file_name;
const char *trace_file_prio;
sc_identifier = -1;
sc_mpicomm = sc_MPI_COMM_NULL;
sc_print_backtrace = print_backtrace;
if (mpicomm != sc_MPI_COMM_NULL) {
int mpiret;
sc_mpicomm = mpicomm;
mpiret = sc_MPI_Comm_rank (sc_mpicomm, &sc_identifier);
SC_CHECK_MPI (mpiret);
}
sc_set_signal_handler (catch_signals);
sc_package_id = sc_package_register (log_handler, log_threshold,
"libsc", "The SC Library");
trace_file_name = getenv ("SC_TRACE_FILE");
if (trace_file_name != NULL) {
char buffer[BUFSIZ];
if (sc_identifier >= 0) {
snprintf (buffer, BUFSIZ, "%s.%d.log", trace_file_name, sc_identifier);
}
else {
snprintf (buffer, BUFSIZ, "%s.log", trace_file_name);
}
SC_CHECK_ABORT (sc_trace_file == NULL, "Trace file not NULL");
sc_trace_file = fopen (buffer, "wb");
SC_CHECK_ABORT (sc_trace_file != NULL, "Trace file open");
trace_file_prio = getenv ("SC_TRACE_LP");
if (trace_file_prio != NULL) {
if (!strcmp (trace_file_prio, "SC_LP_TRACE")) {
sc_trace_prio = SC_LP_TRACE;
}
else if (!strcmp (trace_file_prio, "SC_LP_DEBUG")) {
sc_trace_prio = SC_LP_DEBUG;
}
else if (!strcmp (trace_file_prio, "SC_LP_VERBOSE")) {
sc_trace_prio = SC_LP_VERBOSE;
}
else if (!strcmp (trace_file_prio, "SC_LP_INFO")) {
sc_trace_prio = SC_LP_INFO;
}
else if (!strcmp (trace_file_prio, "SC_LP_STATISTICS")) {
sc_trace_prio = SC_LP_STATISTICS;
}
else if (!strcmp (trace_file_prio, "SC_LP_PRODUCTION")) {
sc_trace_prio = SC_LP_PRODUCTION;
}
else if (!strcmp (trace_file_prio, "SC_LP_ESSENTIAL")) {
sc_trace_prio = SC_LP_ESSENTIAL;
}
else if (!strcmp (trace_file_prio, "SC_LP_ERROR")) {
sc_trace_prio = SC_LP_ERROR;
}
else {
SC_ABORT ("Invalid trace priority");
}
}
}
w = 24;
SC_GLOBAL_ESSENTIALF ("This is %s\n", SC_PACKAGE_STRING);
#if 0
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "F77", SC_F77);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "FFLAGS", SC_FFLAGS);
#endif
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "CPP", SC_CPP);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "CPPFLAGS", SC_CPPFLAGS);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "CC", SC_CC);
#if 0
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "C_VERSION", SC_C_VERSION);
#endif
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "CFLAGS", SC_CFLAGS);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "LDFLAGS", SC_LDFLAGS);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "LIBS", SC_LIBS);
#if 0
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "BLAS_LIBS", SC_BLAS_LIBS);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "LAPACK_LIBS", SC_LAPACK_LIBS);
SC_GLOBAL_PRODUCTIONF ("%-*s %s\n", w, "FLIBS", SC_FLIBS);
#endif
#if defined(SC_ENABLE_MPI) && defined(SC_ENABLE_MPICOMMSHARED)
if (mpicomm != MPI_COMM_NULL) {
int mpiret;
MPI_Comm intranode, internode;
/* compute the node comms by default */
sc_mpi_comm_attach_node_comms (mpicomm, 0);
sc_mpi_comm_get_node_comms (mpicomm, &intranode, &internode);
if (intranode == MPI_COMM_NULL) {
SC_GLOBAL_STATISTICS ("No shared memory node communicators\n");
}
else {
int intrasize;
mpiret = MPI_Comm_size (intranode, &intrasize);
SC_CHECK_MPI (mpiret);
SC_GLOBAL_STATISTICSF ("Shared memory node communicator size: %d\n",
intrasize);
}
}
#endif
}
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;
sc_MPI_Comm mpicomm;
int proc_size;
int nf;
/* MPI init */
mpiret = sc_MPI_Init(&argc, &argv);
SC_CHECK_MPI(mpiret);
mpicomm = sc_MPI_COMM_WORLD;
/* sc_init (mpicomm, 1, 1, NULL, SC_LP_ESSENTIAL); */
mpiret = MPI_Comm_size(mpicomm, &proc_size);
SC_CHECK_MPI (mpiret);
/* pXest init */
sc_init (mpicomm, 1, 1, NULL, SC_LP_ALWAYS);
p4est_init(NULL, SC_LP_PRODUCTION);
int min_quadrants = 0;
int min_level = 0;
int fill_uniform = 1;
p4est_connectivity_t *conn = test_problem_build_conn();
p4est_geometry_t* p4est_geom = test_problem_build_geom(conn);
p4est_t* p4est = test_problem_build_p4est(
mpicomm,
conn,
min_quadrants,
min_level,
fill_uniform
);
dgmath_jit_dbase_t* dgmath_jit_dbase = dgmath_jit_dbase_init();
global_p4est_pointer = p4est;
global_dgmath_jit_dbase = dgmath_jit_dbase;
global_geom_pointer = p4est_geom;
/* run tests */
Suite *s1 = suite_create("Test the new style of hp-amr");
SRunner *sr = srunner_create(s1);
TCase *tc1 = tcase_create("Test a step of hp-amr");
tcase_add_test(tc1, test_hp_amr_step);
suite_add_tcase(s1,tc1);
tcase_set_timeout(tc1, 100);
srunner_run_all(sr, CK_ENV);
nf = srunner_ntests_failed(sr);
dgmath_jit_dbase_destroy(dgmath_jit_dbase);
p4est_destroy(p4est);
p4est_connectivity_destroy(conn);
if(p4est_geom != NULL)
p4est_geometry_destroy (p4est_geom);
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI(mpiret);
srunner_free(sr);
return nf == 0 ? 0 : 1;
}
/** The main function of the step1 example program.
*
* It creates a connectivity and forest, refines it, and writes a VTK file.
*/
int
main (int argc, char **argv)
{
p4est_wrapper_t *p4estw;
int refinement_list[2], refine_list_len;
int mpi_rank, mpi_num_proc, mpiret;
int num_nodes, num_elements;
int *lnodes;
// TODO: unable to pass dynamicaly alocated 2D array
//double coordinates[][NUM_DIMS];
double coordinates[100][NUM_DIMS];
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
sc_MPI_Comm mpicomm = sc_MPI_COMM_WORLD;
sc_MPI_Comm_rank(mpicomm, &mpi_rank);
sc_MPI_Comm_size(mpicomm, &mpi_num_proc);
// so far all scenarios for 2 processors only
assert(mpi_num_proc == 2);
p4estw = p4estw_create(mpicomm);
p4estw_refine_all(p4estw);
p4estw_partition(p4estw);
refinement_list[0] = refinement_list[1] = 0;
if(SCENARIO == 1)
{
if(mpi_rank == 1)
{
refinement_list[0] = refinement_list[1] = 1;
refine_list_len = 2;
}
}
else if(SCENARIO == 2)
{
if(mpi_rank == 1)
{
refinement_list[0] = 1;
refine_list_len = 1;
}
}
else if((SCENARIO == 3) || (SCENARIO == 5))
{
if(mpi_rank == 0)
{
refinement_list[1] = 1;
refine_list_len = 1;
}
}
if(SCENARIO != 4)
p4estw_refine_selected(p4estw, refine_list_len, refinement_list);
if(SCENARIO == 5)
p4estw_partition(p4estw);
p4estw_get_dimensions(p4estw, &num_elements, &num_nodes);
lnodes = malloc(num_elements * NUM_ELEM_NODES * sizeof(int));
//coordinates = calloc(num_nodes * NUM_DIMS, sizeof *coordinates);
p4estw_get_data(p4estw, lnodes, coordinates);
p4estw_destroy(p4estw);
print_my_structures(p4estw, coordinates);
/* 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;
}
