HYPRE_Int
hypre_BoxBoundaryIntersect( hypre_Box *box,
hypre_StructGrid *grid,
HYPRE_Int d,
HYPRE_Int dir,
hypre_BoxArray *boundary )
{
HYPRE_Int ndim = hypre_BoxNDim(box);
hypre_BoxManager *boxman;
hypre_BoxManEntry **entries;
hypre_BoxArray *int_boxes, *tmp_boxes;
hypre_Box *bbox, *ibox;
HYPRE_Int nentries, i;
/* set bbox to the box surface of interest */
hypre_BoxArraySetSize(boundary, 1);
bbox = hypre_BoxArrayBox(boundary, 0);
hypre_CopyBox(box, bbox);
if (dir > 0)
{
hypre_BoxIMinD(bbox, d) = hypre_BoxIMaxD(bbox, d);
}
else if (dir < 0)
{
hypre_BoxIMaxD(bbox, d) = hypre_BoxIMinD(bbox, d);
}
/* temporarily shift bbox in direction dir and intersect with the grid */
hypre_BoxIMinD(bbox, d) += dir;
hypre_BoxIMaxD(bbox, d) += dir;
boxman = hypre_StructGridBoxMan(grid);
hypre_BoxManIntersect(boxman, hypre_BoxIMin(bbox), hypre_BoxIMax(bbox),
&entries, &nentries);
hypre_BoxIMinD(bbox, d) -= dir;
hypre_BoxIMaxD(bbox, d) -= dir;
/* shift intersected boxes in direction -dir and subtract from bbox */
int_boxes = hypre_BoxArrayCreate(nentries, ndim);
tmp_boxes = hypre_BoxArrayCreate(0, ndim);
for (i = 0; i < nentries; i++)
{
ibox = hypre_BoxArrayBox(int_boxes, i);
hypre_BoxManEntryGetExtents(
entries[i], hypre_BoxIMin(ibox), hypre_BoxIMax(ibox));
hypre_BoxIMinD(ibox, d) -= dir;
hypre_BoxIMaxD(ibox, d) -= dir;
}
hypre_SubtractBoxArrays(boundary, int_boxes, tmp_boxes);
hypre_BoxArrayDestroy(int_boxes);
hypre_BoxArrayDestroy(tmp_boxes);
hypre_TFree(entries);
return hypre_error_flag;
}
hypre_BoxArray *
hypre_GrowBoxByStencil( hypre_Box *box,
hypre_StructStencil *stencil,
int transpose )
{
hypre_BoxArray *grow_box_array;
hypre_BoxArray *shift_box_array;
hypre_Box *shift_box;
hypre_Index *stencil_shape;
int s, d;
stencil_shape = hypre_StructStencilShape(stencil);
shift_box_array = hypre_BoxArrayCreate(hypre_StructStencilSize(stencil));
shift_box = hypre_BoxCreate();
for (s = 0; s < hypre_StructStencilSize(stencil); s++)
{
if (transpose)
for (d = 0; d < 3; d++)
{
hypre_BoxIMinD(shift_box, d) =
hypre_BoxIMinD(box, d) - hypre_IndexD(stencil_shape[s], d);
hypre_BoxIMaxD(shift_box, d) =
hypre_BoxIMaxD(box, d) - hypre_IndexD(stencil_shape[s], d);
}
else
for (d = 0; d < 3; d++)
{
hypre_BoxIMinD(shift_box, d) =
hypre_BoxIMinD(box, d) + hypre_IndexD(stencil_shape[s], d);
hypre_BoxIMaxD(shift_box, d) =
hypre_BoxIMaxD(box, d) + hypre_IndexD(stencil_shape[s], d);
}
hypre_CopyBox(shift_box, hypre_BoxArrayBox(shift_box_array, s));
}
hypre_BoxDestroy(shift_box);
hypre_UnionBoxes(shift_box_array);
grow_box_array = shift_box_array;
return grow_box_array;
}
HYPRE_Int
hypre_IntersectBoxes( hypre_Box *box1,
hypre_Box *box2,
hypre_Box *ibox )
{
HYPRE_Int d;
/* find x, y, and z bounds */
for (d = 0; d < 3; d++)
{
hypre_BoxIMinD(ibox, d) =
hypre_max(hypre_BoxIMinD(box1, d), hypre_BoxIMinD(box2, d));
hypre_BoxIMaxD(ibox, d) =
hypre_min(hypre_BoxIMaxD(box1, d), hypre_BoxIMaxD(box2, d));
}
return hypre_error_flag;
}
int
hypre_IntersectBoxes( hypre_Box *box1,
hypre_Box *box2,
hypre_Box *ibox )
{
int ierr = 0;
int d;
/* find x, y, and z bounds */
for (d = 0; d < 3; d++)
{
hypre_BoxIMinD(ibox, d) =
hypre_max(hypre_BoxIMinD(box1, d), hypre_BoxIMinD(box2, d));
hypre_BoxIMaxD(ibox, d) =
hypre_min(hypre_BoxIMaxD(box1, d), hypre_BoxIMaxD(box2, d));
}
return ierr;
}
int
hypre_ProjectBox( hypre_Box *box,
hypre_Index index,
hypre_Index stride )
{
int i, s, d, hl, hu, kl, ku;
int ierr = 0;
/*------------------------------------------------------
* project in all 3 dimensions
*------------------------------------------------------*/
for (d = 0; d < 3; d++)
{
i = hypre_IndexD(index, d);
s = hypre_IndexD(stride, d);
hl = hypre_BoxIMinD(box, d) - i;
hu = hypre_BoxIMaxD(box, d) - i;
if ( hl <= 0 )
kl = (int) (hl / s);
else
kl = (int) ((hl + (s-1)) / s);
if ( hu >= 0 )
ku = (int) (hu / s);
else
ku = (int) ((hu - (s-1)) / s);
hypre_BoxIMinD(box, d) = i + kl * s;
hypre_BoxIMaxD(box, d) = i + ku * s;
}
return ierr;
}
int
hypre_StructVectorInitializeShell( hypre_StructVector *vector )
{
int ierr = 0;
hypre_StructGrid *grid;
int *num_ghost;
hypre_BoxArray *data_space;
hypre_BoxArray *boxes;
hypre_Box *box;
hypre_Box *data_box;
int *data_indices;
int data_size;
int i, d;
/*-----------------------------------------------------------------------
* Set up data_space
*-----------------------------------------------------------------------*/
grid = hypre_StructVectorGrid(vector);
if (hypre_StructVectorDataSpace(vector) == NULL)
{
num_ghost = hypre_StructVectorNumGhost(vector);
boxes = hypre_StructGridBoxes(grid);
data_space = hypre_BoxArrayCreate(hypre_BoxArraySize(boxes));
hypre_ForBoxI(i, boxes)
{
box = hypre_BoxArrayBox(boxes, i);
data_box = hypre_BoxArrayBox(data_space, i);
hypre_CopyBox(box, data_box);
for (d = 0; d < 3; d++)
{
hypre_BoxIMinD(data_box, d) -= num_ghost[2*d];
hypre_BoxIMaxD(data_box, d) += num_ghost[2*d + 1];
}
}
hypre_ForBoxI(i, boxes)
{
cbox_array = hypre_BoxArrayArrayBoxArray(indt_boxes, i);
hypre_BoxArraySetSize(cbox_array, 1);
cbox = hypre_BoxArrayBox(cbox_array, 0);
hypre_CopyBox(hypre_BoxArrayBox(boxes, i), cbox);
for (d = 0; d < 3; d++)
{
if ( (border[d][0]) )
{
hypre_BoxIMinD(cbox, d) += border[d][0];
}
if ( (border[d][1]) )
{
hypre_BoxIMaxD(cbox, d) -= border[d][1];
}
}
}
int
hypre_CreateComputeInfo( hypre_StructGrid *grid,
hypre_StructStencil *stencil,
hypre_ComputeInfo **compute_info_ptr )
{
int ierr = 0;
hypre_CommInfo *comm_info;
hypre_BoxArrayArray *indt_boxes;
hypre_BoxArrayArray *dept_boxes;
hypre_BoxArray *boxes;
hypre_BoxArray *cbox_array;
hypre_Box *cbox;
int i;
#ifdef HYPRE_OVERLAP_COMM_COMP
hypre_Box *rembox;
hypre_Index *stencil_shape;
int border[3][2] = {{0, 0}, {0, 0}, {0, 0}};
int cbox_array_size;
int s, d;
#endif
/*------------------------------------------------------
* Extract needed grid info
*------------------------------------------------------*/
boxes = hypre_StructGridBoxes(grid);
/*------------------------------------------------------
* Get communication info
*------------------------------------------------------*/
hypre_CreateCommInfoFromStencil(grid, stencil, &comm_info);
#ifdef HYPRE_OVERLAP_COMM_COMP
/*------------------------------------------------------
* Compute border info
*------------------------------------------------------*/
stencil_shape = hypre_StructStencilShape(stencil);
for (s = 0; s < hypre_StructStencilSize(stencil); s++)
{
for (d = 0; d < 3; d++)
{
i = hypre_IndexD(stencil_shape[s], d);
if (i < 0)
{
border[d][0] = hypre_max(border[d][0], -i);
}
else if (i > 0)
{
border[d][1] = hypre_max(border[d][1], i);
}
}
}
/*------------------------------------------------------
* Set up the dependent boxes
*------------------------------------------------------*/
dept_boxes = hypre_BoxArrayArrayCreate(hypre_BoxArraySize(boxes));
rembox = hypre_BoxCreate();
hypre_ForBoxI(i, boxes)
{
cbox_array = hypre_BoxArrayArrayBoxArray(dept_boxes, i);
hypre_BoxArraySetSize(cbox_array, 6);
hypre_CopyBox(hypre_BoxArrayBox(boxes, i), rembox);
cbox_array_size = 0;
for (d = 0; d < 3; d++)
{
if ( (hypre_BoxVolume(rembox)) && (border[d][0]) )
{
cbox = hypre_BoxArrayBox(cbox_array, cbox_array_size);
hypre_CopyBox(rembox, cbox);
hypre_BoxIMaxD(cbox, d) =
hypre_BoxIMinD(cbox, d) + border[d][0] - 1;
hypre_BoxIMinD(rembox, d) =
hypre_BoxIMinD(cbox, d) + border[d][0];
cbox_array_size++;
}
if ( (hypre_BoxVolume(rembox)) && (border[d][1]) )
{
cbox = hypre_BoxArrayBox(cbox_array, cbox_array_size);
hypre_CopyBox(rembox, cbox);
hypre_BoxIMinD(cbox, d) =
hypre_BoxIMaxD(cbox, d) - border[d][1] + 1;
hypre_BoxIMaxD(rembox, d) =
hypre_BoxIMaxD(cbox, d) - border[d][1];
cbox_array_size++;
}
}
hypre_BoxArraySetSize(cbox_array, cbox_array_size);
}
int
hypre_StructMatrixInitializeShell( hypre_StructMatrix *matrix )
{
int ierr = 0;
hypre_StructGrid *grid;
hypre_StructStencil *user_stencil;
hypre_StructStencil *stencil;
hypre_Index *stencil_shape;
int stencil_size;
int num_values;
int *symm_elements;
int *num_ghost;
int extra_ghost[] = {0, 0, 0, 0, 0, 0};
hypre_BoxArray *data_space;
hypre_BoxArray *boxes;
hypre_Box *box;
hypre_Box *data_box;
int **data_indices;
int data_size;
int data_box_volume;
int i, j, d;
grid = hypre_StructMatrixGrid(matrix);
/*-----------------------------------------------------------------------
* Set up stencil and num_values:
* The stencil is a "symmetrized" version of the user's stencil
* as computed by hypre_StructStencilSymmetrize.
*
* The `symm_elements' array is used to determine what data is
* explicitely stored (symm_elements[i] < 0) and what data does is
* not explicitely stored (symm_elements[i] >= 0), but is instead
* stored as the transpose coefficient at a neighboring grid point.
*-----------------------------------------------------------------------*/
if (hypre_StructMatrixStencil(matrix) == NULL)
{
user_stencil = hypre_StructMatrixUserStencil(matrix);
hypre_StructStencilSymmetrize(user_stencil, &stencil, &symm_elements);
stencil_shape = hypre_StructStencilShape(stencil);
stencil_size = hypre_StructStencilSize(stencil);
if (!hypre_StructMatrixSymmetric(matrix))
{
/* store all element data */
for (i = 0; i < stencil_size; i++)
symm_elements[i] = -1;
num_values = stencil_size;
}
else
{
num_values = (stencil_size + 1) / 2;
}
hypre_StructMatrixStencil(matrix) = stencil;
hypre_StructMatrixSymmElements(matrix) = symm_elements;
hypre_StructMatrixNumValues(matrix) = num_values;
}
/*-----------------------------------------------------------------------
* Set ghost-layer size for symmetric storage
* - All stencil coeffs are to be available at each point in the
* grid, as well as in the user-specified ghost layer.
*-----------------------------------------------------------------------*/
num_ghost = hypre_StructMatrixNumGhost(matrix);
stencil = hypre_StructMatrixStencil(matrix);
stencil_shape = hypre_StructStencilShape(stencil);
stencil_size = hypre_StructStencilSize(stencil);
symm_elements = hypre_StructMatrixSymmElements(matrix);
for (i = 0; i < stencil_size; i++)
{
if (symm_elements[i] >= 0)
{
for (d = 0; d < 3; d++)
{
extra_ghost[2*d] =
hypre_max(extra_ghost[2*d], -hypre_IndexD(stencil_shape[i], d));
extra_ghost[2*d + 1] =
hypre_max(extra_ghost[2*d + 1], hypre_IndexD(stencil_shape[i], d));
}
}
}
for (d = 0; d < 3; d++)
{
num_ghost[2*d] += extra_ghost[2*d];
num_ghost[2*d + 1] += extra_ghost[2*d + 1];
}
/*-----------------------------------------------------------------------
* Set up data_space
*-----------------------------------------------------------------------*/
if (hypre_StructMatrixDataSpace(matrix) == NULL)
{
boxes = hypre_StructGridBoxes(grid);
data_space = hypre_BoxArrayCreate(hypre_BoxArraySize(boxes));
hypre_ForBoxI(i, boxes)
{
box = hypre_BoxArrayBox(boxes, i);
data_box = hypre_BoxArrayBox(data_space, i);
hypre_CopyBox(box, data_box);
for (d = 0; d < 3; d++)
{
hypre_BoxIMinD(data_box, d) -= num_ghost[2*d];
hypre_BoxIMaxD(data_box, d) += num_ghost[2*d + 1];
}
}
int
hypre_SubtractBoxes( hypre_Box *box1,
hypre_Box *box2,
hypre_BoxArray *box_array )
{
int ierr = 0;
hypre_Box *box;
hypre_Box *rembox;
int d, size;
/*------------------------------------------------------
* Set the box array size to the maximum possible,
* plus one, to have space for the remainder box.
*------------------------------------------------------*/
size = hypre_BoxArraySize(box_array);
hypre_BoxArraySetSize(box_array, (size + 7));
/*------------------------------------------------------
* Subtract the boxes by cutting box1 in x, y, then z
*------------------------------------------------------*/
rembox = hypre_BoxArrayBox(box_array, (size + 6));
hypre_CopyBox(box1, rembox);
for (d = 0; d < 3; d++)
{
/* if the boxes do not intersect, the subtraction is trivial */
if ( (hypre_BoxIMinD(box2, d) > hypre_BoxIMaxD(rembox, d)) ||
(hypre_BoxIMaxD(box2, d) < hypre_BoxIMinD(rembox, d)) )
{
size = hypre_BoxArraySize(box_array) - 7;
hypre_CopyBox(box1, hypre_BoxArrayBox(box_array, size));
size++;
break;
}
/* update the box array */
else
{
if ( hypre_BoxIMinD(box2, d) > hypre_BoxIMinD(rembox, d) )
{
box = hypre_BoxArrayBox(box_array, size);
hypre_CopyBox(rembox, box);
hypre_BoxIMaxD(box, d) = hypre_BoxIMinD(box2, d) - 1;
hypre_BoxIMinD(rembox, d) = hypre_BoxIMinD(box2, d);
if ( hypre_BoxVolume(box)>0 ) size++;
}
if ( hypre_BoxIMaxD(box2, d) < hypre_BoxIMaxD(rembox, d) )
{
box = hypre_BoxArrayBox(box_array, size);
hypre_CopyBox(rembox, box);
hypre_BoxIMinD(box, d) = hypre_BoxIMaxD(box2, d) + 1;
hypre_BoxIMaxD(rembox, d) = hypre_BoxIMaxD(box2, d);
if ( hypre_BoxVolume(box)>0 ) size++;
}
}
}
hypre_BoxArraySetSize(box_array, size);
return ierr;
}
int
hypre_BoxNeighborsAssemble( hypre_BoxNeighbors *neighbors,
int max_distance,
int prune )
{
hypre_BoxArray *boxes;
int *procs;
int *ids;
int first_local;
int num_local;
int num_periodic;
int keep_box;
int num_boxes;
hypre_RankLink *rank_link;
hypre_Box *local_box;
hypre_Box *neighbor_box;
int distance;
int distance_index[3];
int diff;
int i, j, d, ilocal, inew;
int ierr = 0;
/*---------------------------------------------
* Find neighboring boxes
*---------------------------------------------*/
boxes = hypre_BoxNeighborsBoxes(neighbors);
procs = hypre_BoxNeighborsProcs(neighbors);
ids = hypre_BoxNeighborsIDs(neighbors);
first_local = hypre_BoxNeighborsFirstLocal(neighbors);
num_local = hypre_BoxNeighborsNumLocal(neighbors);
num_periodic = hypre_BoxNeighborsNumPeriodic(neighbors);
/*---------------------------------------------
* Find neighboring boxes
*---------------------------------------------*/
inew = 0;
num_boxes = 0;
hypre_ForBoxI(i, boxes)
{
keep_box = 0;
for (j = 0; j < num_local + num_periodic; j++)
{
ilocal = first_local + j;
if (i != ilocal)
{
local_box = hypre_BoxArrayBox(boxes, ilocal);
neighbor_box = hypre_BoxArrayBox(boxes, i);
/* compute distance info */
distance = 0;
for (d = 0; d < 3; d++)
{
distance_index[d] = 0;
diff = hypre_BoxIMinD(neighbor_box, d) -
hypre_BoxIMaxD(local_box, d);
if (diff > 0)
{
distance_index[d] = 1;
distance = hypre_max(distance, diff);
}
diff = hypre_BoxIMinD(local_box, d) -
hypre_BoxIMaxD(neighbor_box, d);
if (diff > 0)
{
distance_index[d] = -1;
distance = hypre_max(distance, diff);
}
}
/* create new rank_link */
if (distance <= max_distance)
{
keep_box = 1;
if (j < num_local)
{
hypre_RankLinkCreate(num_boxes, &rank_link);
hypre_RankLinkNext(rank_link) =
hypre_BoxNeighborsRankLink(neighbors, j,
distance_index[0],
distance_index[1],
distance_index[2]);
hypre_BoxNeighborsRankLink(neighbors, j,
distance_index[0],
distance_index[1],
distance_index[2]) = rank_link;
}
}
}
else
{
keep_box = 1;
}
}
if (prune)
{
/* use procs array to store which boxes to keep */
if (keep_box)
{
procs[i] = -procs[i];
if (inew < i)
{
procs[inew] = i;
}
inew = i + 1;
num_boxes++;
}
}
else
{
/* keep all of the boxes */
num_boxes++;
}
}
HYPRE_Int
hypre_CreateCommInfoFromStencil( hypre_StructGrid *grid,
hypre_StructStencil *stencil,
hypre_CommInfo **comm_info_ptr )
{
HYPRE_Int i,j,k, d, m, s;
hypre_BoxArrayArray *send_boxes;
hypre_BoxArrayArray *recv_boxes;
HYPRE_Int **send_procs;
HYPRE_Int **recv_procs;
HYPRE_Int **send_rboxnums;
HYPRE_Int **recv_rboxnums;
hypre_BoxArrayArray *send_rboxes;
hypre_BoxArrayArray *recv_rboxes;
hypre_BoxArray *local_boxes;
HYPRE_Int num_boxes;
HYPRE_Int *local_ids;
hypre_BoxManager *boxman;
hypre_Index *stencil_shape;
hypre_IndexRef stencil_offset;
hypre_IndexRef pshift;
hypre_Box *box;
hypre_Box *hood_box;
hypre_Box *grow_box;
hypre_Box *extend_box;
hypre_Box *int_box;
hypre_Box *periodic_box;
HYPRE_Int stencil_grid[3][3][3];
HYPRE_Int grow[3][2];
hypre_BoxManEntry **entries;
hypre_BoxManEntry *entry;
HYPRE_Int num_entries;
hypre_BoxArray *neighbor_boxes = NULL;
HYPRE_Int *neighbor_procs = NULL;
HYPRE_Int *neighbor_ids = NULL;
HYPRE_Int *neighbor_shifts = NULL;
HYPRE_Int neighbor_count;
HYPRE_Int neighbor_alloc;
hypre_Index ilower, iupper;
hypre_BoxArray *send_box_array;
hypre_BoxArray *recv_box_array;
hypre_BoxArray *send_rbox_array;
hypre_BoxArray *recv_rbox_array;
hypre_Box **cboxes;
hypre_Box *cboxes_mem;
HYPRE_Int *cboxes_neighbor_location;
HYPRE_Int num_cboxes, cbox_alloc;
HYPRE_Int istart[3], istop[3];
HYPRE_Int sgindex[3];
HYPRE_Int num_periods, loc, box_id, id, proc_id;
HYPRE_Int myid;
MPI_Comm comm;
/*------------------------------------------------------
* Initializations
*------------------------------------------------------*/
local_boxes = hypre_StructGridBoxes(grid);
local_ids = hypre_StructGridIDs(grid);
num_boxes = hypre_BoxArraySize(local_boxes);
num_periods = hypre_StructGridNumPeriods(grid);
boxman = hypre_StructGridBoxMan(grid);
comm = hypre_StructGridComm(grid);
hypre_MPI_Comm_rank(comm, &myid);
for (k = 0; k < 3; k++)
{
for (j = 0; j < 3; j++)
{
for (i = 0; i < 3; i++)
{
stencil_grid[i][j][k] = 0;
}
}
}
/*------------------------------------------------------
* Compute the "grow" information from the stencil
*------------------------------------------------------*/
stencil_shape = hypre_StructStencilShape(stencil);
for (d = 0; d < 3; d++)
{
grow[d][0] = 0;
grow[d][1] = 0;
}
for (s = 0; s < hypre_StructStencilSize(stencil); s++)
{
stencil_offset = stencil_shape[s];
for (d = 0; d < 3; d++)
{
m = stencil_offset[d];
istart[d] = 1;
istop[d] = 1;
if (m < 0)
{
istart[d] = 0;
grow[d][0] = hypre_max(grow[d][0], -m);
}
else if (m > 0)
{
istop[d] = 2;
grow[d][1] = hypre_max(grow[d][1], m);
}
}
/* update stencil grid from the grow_stencil */
for (k = istart[2]; k <= istop[2]; k++)
{
for (j = istart[1]; j <= istop[1]; j++)
{
for (i = istart[0]; i <= istop[0]; i++)
{
stencil_grid[i][j][k] = 1;
}
}
}
}
/*------------------------------------------------------
* Compute send/recv boxes and procs for each local box
*------------------------------------------------------*/
/* initialize: for each local box, we create an array of send/recv info */
send_boxes = hypre_BoxArrayArrayCreate(num_boxes);
recv_boxes = hypre_BoxArrayArrayCreate(num_boxes);
send_procs = hypre_CTAlloc(HYPRE_Int *, num_boxes);
recv_procs = hypre_CTAlloc(HYPRE_Int *, num_boxes);
/* Remote boxnums and boxes describe data on the opposing processor, so some
shifting of boxes is needed below for periodic neighbor boxes. Remote box
info is also needed for receives to allow for reverse communication. */
send_rboxnums = hypre_CTAlloc(HYPRE_Int *, num_boxes);
send_rboxes = hypre_BoxArrayArrayCreate(num_boxes);
recv_rboxnums = hypre_CTAlloc(HYPRE_Int *, num_boxes);
recv_rboxes = hypre_BoxArrayArrayCreate(num_boxes);
grow_box = hypre_BoxCreate();
extend_box = hypre_BoxCreate();
int_box = hypre_BoxCreate();
periodic_box = hypre_BoxCreate();
/* storage we will use and keep track of the neighbors */
neighbor_alloc = 30; /* initial guess at max size */
neighbor_boxes = hypre_BoxArrayCreate(neighbor_alloc);
neighbor_procs = hypre_CTAlloc(HYPRE_Int, neighbor_alloc);
neighbor_ids = hypre_CTAlloc(HYPRE_Int, neighbor_alloc);
neighbor_shifts = hypre_CTAlloc(HYPRE_Int, neighbor_alloc);
/* storage we will use to collect all of the intersected boxes (the send and
recv regions for box i (this may not be enough in the case of periodic
boxes, so we will have to check) */
cbox_alloc = hypre_BoxManNEntries(boxman);
cboxes_neighbor_location = hypre_CTAlloc(HYPRE_Int, cbox_alloc);
cboxes = hypre_CTAlloc(hypre_Box *, cbox_alloc);
cboxes_mem = hypre_CTAlloc(hypre_Box, cbox_alloc);
/******* loop through each local box **************/
for (i = 0; i < num_boxes; i++)
{
/* get the box */
box = hypre_BoxArrayBox(local_boxes, i);
/* box_id = local_ids[i]; the box id in the Box Manager is the box number,
* and we use this to find out if a box has intersected with itself */
box_id = i;
/* grow box local i according to the stencil*/
hypre_CopyBox(box, grow_box);
for (d = 0; d < 3; d++)
{
hypre_BoxIMinD(grow_box, d) -= grow[d][0];
hypre_BoxIMaxD(grow_box, d) += grow[d][1];
}
/* extend_box - to find the list of potential neighbors, we need to grow
the local box a bit differently in case, for example, the stencil grows
in one dimension [0] and not the other [1] */
hypre_CopyBox(box, extend_box);
for (d = 0; d < 3; d++)
{
hypre_BoxIMinD(extend_box, d) -= hypre_max(grow[d][0],grow[d][1]);
hypre_BoxIMaxD(extend_box, d) += hypre_max(grow[d][0],grow[d][1]);
}
/*------------------------------------------------
* Determine the neighbors of box i
*------------------------------------------------*/
/* Do this by intersecting the extend box with the BoxManager.
We must also check for periodic neighbors. */
neighbor_count = 0;
hypre_BoxArraySetSize(neighbor_boxes, 0);
/* shift the box by each period (k=0 is original box) */
for (k = 0; k < num_periods; k++)
{
hypre_CopyBox(extend_box, periodic_box);
pshift = hypre_StructGridPShift(grid, k);
hypre_BoxShiftPos(periodic_box, pshift);
/* get the intersections */
hypre_BoxManIntersect(boxman, hypre_BoxIMin(periodic_box) ,
hypre_BoxIMax(periodic_box) ,
&entries , &num_entries);
/* note: do we need to remove the intersection with our original box?
no if periodic, yes if non-periodic (k=0) */
/* unpack entries (first check storage) */
if (neighbor_count + num_entries > neighbor_alloc)
{
neighbor_alloc = neighbor_count + num_entries + 5;
neighbor_procs = hypre_TReAlloc(neighbor_procs, HYPRE_Int,
neighbor_alloc);
neighbor_ids = hypre_TReAlloc(neighbor_ids, HYPRE_Int, neighbor_alloc);
neighbor_shifts = hypre_TReAlloc(neighbor_shifts, HYPRE_Int,
neighbor_alloc);
}
/* check storage for the array */
hypre_BoxArraySetSize(neighbor_boxes, neighbor_count + num_entries);
/* now unpack */
for (j = 0; j < num_entries; j++)
{
entry = entries[j];
proc_id = hypre_BoxManEntryProc(entry);
id = hypre_BoxManEntryId(entry);
/* don't keep box i in the non-periodic case*/
if (!k)
{
if((myid == proc_id) && (box_id == id))
{
continue;
}
}
hypre_BoxManEntryGetExtents(entry, ilower, iupper);
hypre_BoxSetExtents(hypre_BoxArrayBox(neighbor_boxes, neighbor_count),
ilower, iupper);
/* shift the periodic boxes (needs to be the opposite of above) */
if (k)
{
hypre_BoxShiftNeg(
hypre_BoxArrayBox(neighbor_boxes, neighbor_count), pshift);
}
neighbor_procs[neighbor_count] = proc_id;
neighbor_ids[neighbor_count] = id;
neighbor_shifts[neighbor_count] = k;
neighbor_count++;
}
hypre_BoxArraySetSize(neighbor_boxes, neighbor_count);
hypre_TFree(entries);
} /* end of loop through periods k */
/* Now we have a list of all of the neighbors for box i! */
/* note: we don't want/need to remove duplicates - they should have
different intersections (TO DO: put more thought into if there are ever
any exceptions to this? - the intersection routine already eliminates
duplicates - so what i mean is eliminating duplicates from multiple
intersection calls in periodic case) */
/*------------------------------------------------
* Compute recv_box_array for box i
*------------------------------------------------*/
/* check size of storage for cboxes */
/* let's make sure that we have enough storage in case each neighbor
produces a send/recv region */
if (neighbor_count > cbox_alloc)
{
cbox_alloc = neighbor_count;
cboxes_neighbor_location = hypre_TReAlloc(cboxes_neighbor_location,
HYPRE_Int, cbox_alloc);
cboxes = hypre_TReAlloc(cboxes, hypre_Box *, cbox_alloc);
cboxes_mem = hypre_TReAlloc(cboxes_mem, hypre_Box, cbox_alloc);
}
/* Loop through each neighbor box. If the neighbor box intersects the
grown box i (grown according to our stencil), then the intersection is
a recv region. If the neighbor box was shifted to handle periodicity,
we need to (positive) shift it back. */
num_cboxes = 0;
for (k = 0; k < neighbor_count; k++)
{
hood_box = hypre_BoxArrayBox(neighbor_boxes, k);
/* check the stencil grid to see if it makes sense to intersect */
for (d = 0; d < 3; d++)
{
sgindex[d] = 1;
s = hypre_BoxIMinD(hood_box, d) - hypre_BoxIMaxD(box, d);
if (s > 0)
{
sgindex[d] = 2;
}
s = hypre_BoxIMinD(box, d) - hypre_BoxIMaxD(hood_box, d);
if (s > 0)
{
sgindex[d] = 0;
}
}
/* it makes sense only if we have at least one non-zero entry */
if (stencil_grid[sgindex[0]][sgindex[1]][sgindex[2]])
{
/* intersect - result is int_box */
hypre_IntersectBoxes(grow_box, hood_box, int_box);
/* if we have a positive volume box, this is a recv region */
if (hypre_BoxVolume(int_box))
{
/* keep track of which neighbor: k... */
cboxes_neighbor_location[num_cboxes] = k;
cboxes[num_cboxes] = &cboxes_mem[num_cboxes];
/* keep the intersected box */
hypre_CopyBox(int_box, cboxes[num_cboxes]);
num_cboxes++;
}
}
} /* end of loop through each neighbor */
/* create recv_box_array and recv_procs for box i */
recv_box_array = hypre_BoxArrayArrayBoxArray(recv_boxes, i);
hypre_BoxArraySetSize(recv_box_array, num_cboxes);
recv_procs[i] = hypre_CTAlloc(HYPRE_Int, num_cboxes);
recv_rboxnums[i] = hypre_CTAlloc(HYPRE_Int, num_cboxes);
recv_rbox_array = hypre_BoxArrayArrayBoxArray(recv_rboxes, i);
hypre_BoxArraySetSize(recv_rbox_array, num_cboxes);
for (m = 0; m < num_cboxes; m++)
{
loc = cboxes_neighbor_location[m];
recv_procs[i][m] = neighbor_procs[loc];
recv_rboxnums[i][m] = neighbor_ids[loc];
hypre_CopyBox(cboxes[m], hypre_BoxArrayBox(recv_box_array, m));
/* if periodic, positive shift before copying to the rbox_array */
if (neighbor_shifts[loc]) /* periodic if shift != 0 */
{
pshift = hypre_StructGridPShift(grid, neighbor_shifts[loc]);
hypre_BoxShiftPos(cboxes[m], pshift);
}
hypre_CopyBox(cboxes[m], hypre_BoxArrayBox(recv_rbox_array, m));
cboxes[m] = NULL;
}
/*------------------------------------------------
* Compute send_box_array for box i
*------------------------------------------------*/
/* Loop through each neighbor box. If the grown neighbor box intersects
box i, then the intersection is a send region. If the neighbor box was
shifted to handle periodicity, we need to (positive) shift it back. */
num_cboxes = 0;
for (k = 0; k < neighbor_count; k++)
{
hood_box = hypre_BoxArrayBox(neighbor_boxes, k);
/* check the stencil grid to see if it makes sense to intersect */
for (d = 0; d < 3; d++)
{
sgindex[d] = 1;
s = hypre_BoxIMinD(box, d) - hypre_BoxIMaxD(hood_box, d);
if (s > 0)
{
sgindex[d] = 2;
}
s = hypre_BoxIMinD(hood_box, d) - hypre_BoxIMaxD(box, d);
if (s > 0)
{
sgindex[d] = 0;
}
}
/* it makes sense only if we have at least one non-zero entry */
if (stencil_grid[sgindex[0]][sgindex[1]][sgindex[2]])
{
/* grow the neighbor box and intersect */
hypre_CopyBox(hood_box, grow_box);
for (d = 0; d < 3; d++)
{
hypre_BoxIMinD(grow_box, d) -= grow[d][0];
hypre_BoxIMaxD(grow_box, d) += grow[d][1];
}
hypre_IntersectBoxes(box, grow_box, int_box);
/* if we have a positive volume box, this is a send region */
if (hypre_BoxVolume(int_box))
{
/* keep track of which neighbor: k... */
cboxes_neighbor_location[num_cboxes] = k;
cboxes[num_cboxes] = &cboxes_mem[num_cboxes];
/* keep the intersected box */
hypre_CopyBox(int_box, cboxes[num_cboxes]);
num_cboxes++;
}
}
}/* end of loop through neighbors */
/* create send_box_array and send_procs for box i */
send_box_array = hypre_BoxArrayArrayBoxArray(send_boxes, i);
hypre_BoxArraySetSize(send_box_array, num_cboxes);
send_procs[i] = hypre_CTAlloc(HYPRE_Int, num_cboxes);
send_rboxnums[i] = hypre_CTAlloc(HYPRE_Int, num_cboxes);
send_rbox_array = hypre_BoxArrayArrayBoxArray(send_rboxes, i);
hypre_BoxArraySetSize(send_rbox_array, num_cboxes);
for (m = 0; m < num_cboxes; m++)
{
loc = cboxes_neighbor_location[m];
send_procs[i][m] = neighbor_procs[loc];
send_rboxnums[i][m] = neighbor_ids[loc];
hypre_CopyBox(cboxes[m], hypre_BoxArrayBox(send_box_array, m));
/* if periodic, positive shift before copying to the rbox_array */
if (neighbor_shifts[loc]) /* periodic if shift != 0 */
{
pshift = hypre_StructGridPShift(grid, neighbor_shifts[loc]);
hypre_BoxShiftPos(cboxes[m], pshift);
}
hypre_CopyBox(cboxes[m], hypre_BoxArrayBox(send_rbox_array, m));
cboxes[m] = NULL;
}
} /* end of loop through each local box */
int hypre_StructGridAssembleWithAP( hypre_StructGrid *grid )
{
int ierr = 0;
int tmp_i;
int size, global_num_boxes, num_local_boxes;
int i, j, d, k, index;
int num_procs, myid;
int *sendbuf8, *recvbuf8, *sendbuf2, *recvbuf2;
int min_box_size, max_box_size;
int global_min_box_size, global_max_box_size;
int *ids;
int max_regions, max_refinements, ologp;
double gamma;
hypre_Index min_index, max_index;
int prune;
hypre_Box *box;
MPI_Comm comm = hypre_StructGridComm(grid);
hypre_Box *bounding_box = hypre_StructGridBoundingBox(grid);
hypre_BoxArray *local_boxes = hypre_StructGridBoxes(grid);
int dim = hypre_StructGridDim(grid);
hypre_BoxNeighbors *neighbors = hypre_StructGridNeighbors(grid);
int max_distance = hypre_StructGridMaxDistance(grid);
hypre_IndexRef periodic = hypre_StructGridPeriodic(grid);
int *local_boxnums;
double dbl_global_size, tmp_dbl;
hypre_BoxArray *my_partition;
int *part_ids, *part_boxnums;
int *proc_array, proc_count, proc_alloc, count;
int *tmp_proc_ids = NULL;
int max_response_size;
int *ap_proc_ids, *send_buf, *send_buf_starts;
int *response_buf, *response_buf_starts;
hypre_BoxArray *neighbor_boxes, *n_boxes_copy;
int *neighbor_proc_ids, *neighbor_boxnums;
int *order_index, *delete_array;
int tmp_id, start, first_local;
int grow, grow_array[6];
hypre_Box *grow_box;
int *numghost;
int ghostsize;
hypre_Box *ghostbox;
hypre_StructAssumedPart *assumed_part;
hypre_DataExchangeResponse response_obj;
int px = hypre_IndexX(periodic);
int py = hypre_IndexY(periodic);
int pz = hypre_IndexZ(periodic);
int i_periodic = px ? 1 : 0;
int j_periodic = py ? 1 : 0;
int k_periodic = pz ? 1 : 0;
int num_periods, multiple_ap, p;
hypre_Box *result_box, *period_box;
hypre_Index *pshifts;
hypre_IndexRef pshift;
#if NEIGH_PRINT
double start_time, end_time;
#endif
/*---------------------------------------------
Step 1: Initializations
-----------------------------------------------*/
prune = 1; /* default is to prune */
num_local_boxes = hypre_BoxArraySize(local_boxes);
num_periods = (1+2*i_periodic) * (1+2*j_periodic) * (1+2*k_periodic);
MPI_Comm_size(comm, &num_procs);
MPI_Comm_rank(comm, &myid);
/*---------------------------------------------
Step 2: Determine the global size, total number of boxes,
and global bounding box.
Also get the min and max box sizes
since it is convenient to do so.
-----------------------------------------------*/
if (neighbors == NULL)
{
/*these may not be needed - check later */
ids = hypre_TAlloc(int, num_local_boxes);
/* for the vol and number of boxes */
sendbuf2 = hypre_CTAlloc(int, 2);
recvbuf2 = hypre_CTAlloc(int, 2);
size = 0;
bounding_box = hypre_BoxCreate();
grow_box = hypre_BoxCreate();
if (num_local_boxes)
{
min_box_size = hypre_BoxVolume( hypre_BoxArrayBox(local_boxes, 0));
max_box_size = hypre_BoxVolume( hypre_BoxArrayBox(local_boxes, 0));
/* initialize min and max */
for (d=0; d<3; d++)
{
hypre_IndexD(min_index, d) = pow(2,30);
hypre_IndexD(max_index, d) = -pow(2,30);
}
hypre_ForBoxI(i, local_boxes)
{
box = hypre_BoxArrayBox(local_boxes, i);
/* get global size and number of boxes */
tmp_i = hypre_BoxVolume(box);
size += tmp_i;
min_box_size = hypre_min(min_box_size, tmp_i);
max_box_size = hypre_max(max_box_size, tmp_i);
/* set id */
ids[i] = i;
/* 1/3/05 we need this for the case of holes in the domain. (I had
commented
it out on 12/04 - as I thought this was not necessary. */
/* zero volume boxes - still look at for getting the bounding box */
if (hypre_BoxVolume(box) == 0) /* zero volume boxes - still count */
{
hypre_CopyBox(box, grow_box);
for (d = 0; d < 3; d++)
{
if(!hypre_BoxSizeD(box, d))
{
grow = (hypre_BoxIMinD(box, d) - hypre_BoxIMaxD(box, d) + 1)/2;
grow_array[2*d] = grow;
grow_array[2*d+1] = grow;
}
else
{
grow_array[2*d] = 0;
grow_array[2*d+1] = 0;
}
}
/* expand the box */
hypre_BoxExpand(grow_box, grow_array);
box = grow_box; /*pointer copy*/
}
/*now we have a vol > 0 box */
for (d = 0; d < dim; d++) /* for each dimension */
{
hypre_IndexD(min_index, d) = hypre_min( hypre_IndexD(min_index, d),
hypre_BoxIMinD(box, d));
hypre_IndexD(max_index, d) = hypre_max( hypre_IndexD(max_index, d),
hypre_BoxIMaxD(box, d));
}
}/*end for each box loop */
/* bounding box extents */
hypre_BoxSetExtents(bounding_box, min_index, max_index);
}
HYPRE_Int
hypre_GeneralBoxBoundaryIntersect( hypre_Box *box,
hypre_StructGrid *grid,
hypre_Index stencil_element,
hypre_BoxArray *boundary )
{
hypre_BoxManager *boxman;
hypre_BoxManEntry **entries;
hypre_BoxArray *int_boxes, *tmp_boxes;
hypre_Box *bbox, *ibox;
HYPRE_Int nentries, i, j;
HYPRE_Int *dd;
HYPRE_Int ndim;
ndim = hypre_StructGridNDim(grid);
dd = hypre_CTAlloc(HYPRE_Int, ndim);
for (i=0; i < ndim; i++)
dd[i] = hypre_IndexD(stencil_element, i);
/* set bbox to the box surface of interest */
hypre_BoxArraySetSize(boundary, 1);
bbox = hypre_BoxArrayBox(boundary, 0);
hypre_CopyBox(box, bbox);
/* temporarily shift bbox in direction dir and intersect with the grid */
for (i=0; i < ndim; i++)
{
hypre_BoxIMinD(bbox, i) += dd[i];
hypre_BoxIMaxD(bbox, i) += dd[i];
}
boxman = hypre_StructGridBoxMan(grid);
hypre_BoxManIntersect(boxman, hypre_BoxIMin(bbox), hypre_BoxIMax(bbox),
&entries, &nentries);
for (i=0; i < ndim; i++)
{
hypre_BoxIMinD(bbox, i) -= dd[i];
hypre_BoxIMaxD(bbox, i) -= dd[i];
}
/* shift intersected boxes in direction -dir and subtract from bbox */
int_boxes = hypre_BoxArrayCreate(nentries, ndim);
tmp_boxes = hypre_BoxArrayCreate(0, ndim);
for (i = 0; i < nentries; i++)
{
ibox = hypre_BoxArrayBox(int_boxes, i);
hypre_BoxManEntryGetExtents(
entries[i], hypre_BoxIMin(ibox), hypre_BoxIMax(ibox));
for (j=0; j < ndim; j++)
{
hypre_BoxIMinD(ibox, j) -= dd[j];
hypre_BoxIMaxD(ibox, j) -= dd[j];
}
}
hypre_SubtractBoxArrays(boundary, int_boxes, tmp_boxes);
hypre_BoxArrayDestroy(int_boxes);
hypre_BoxArrayDestroy(tmp_boxes);
hypre_TFree(entries);
hypre_TFree(dd);
return hypre_error_flag;
}
int
hypre_StructCoarsen( hypre_StructGrid *fgrid,
hypre_Index index,
hypre_Index stride,
int prune,
hypre_StructGrid **cgrid_ptr )
{
int ierr = 0;
hypre_StructGrid *cgrid;
MPI_Comm comm;
int dim;
hypre_BoxNeighbors *neighbors;
hypre_BoxArray *hood_boxes;
int num_hood;
int *hood_procs;
int *hood_ids;
int first_local;
int num_local;
int num_periodic;
int max_distance;
hypre_Box *bounding_box;
hypre_Index periodic;
MPI_Request *send_requests;
MPI_Status *send_status;
int *send_buffer;
int send_size;
MPI_Request *recv_requests;
MPI_Status *recv_status;
int **recv_buffers;
int *recv_sizes;
int my_rank;
int *send_procs;
int *recv_procs;
int num_sends;
int num_recvs;
hypre_BoxArray *new_hood_boxes;
int new_num_hood;
int *new_hood_procs;
int *new_hood_ids;
int new_first_local;
int new_num_local;
int new_num_periodic;
hypre_Box *box;
hypre_Box *local_box;
hypre_Box *neighbor_box;
hypre_Box *local_cbox;
hypre_Box *neighbor_cbox;
hypre_Index imin;
hypre_Index imax;
int alloc_size;
double perimeter_count, cperimeter_count;
/*double diff, distance, perimeter_count, cperimeter_count;*/
int *iarray;
int *jrecv;
int i, j, d, ilocal;
int data_id, min_id, jj;
/*-----------------------------------------
* Copy needed info from fgrid
*-----------------------------------------*/
comm = hypre_StructGridComm(fgrid);
dim = hypre_StructGridDim(fgrid);
neighbors = hypre_StructGridNeighbors(fgrid);
hood_boxes = hypre_BoxArrayDuplicate(hypre_BoxNeighborsBoxes(neighbors));
num_hood = hypre_BoxArraySize(hood_boxes);
iarray = hypre_BoxNeighborsProcs(neighbors);
hood_procs = hypre_TAlloc(int, num_hood);
for (i = 0; i < num_hood; i++)
{
hood_procs[i] = iarray[i];
}
iarray = hypre_BoxNeighborsIDs(neighbors);
hood_ids = hypre_TAlloc(int, num_hood);
for (i = 0; i < num_hood; i++)
{
hood_ids[i] = iarray[i];
}
first_local = hypre_BoxNeighborsFirstLocal(neighbors);
num_local = hypre_BoxNeighborsNumLocal(neighbors);
num_periodic = hypre_BoxNeighborsNumPeriodic(neighbors);
max_distance = hypre_StructGridMaxDistance(fgrid);
bounding_box = hypre_BoxDuplicate(hypre_StructGridBoundingBox(fgrid));
hypre_CopyIndex(hypre_StructGridPeriodic(fgrid), periodic);
MPI_Comm_rank(comm, &my_rank);
#if DEBUG
sprintf(filename, "zcoarsen.%05d", my_rank);
if ((file = fopen(filename, "a")) == NULL)
{
printf("Error: can't open output file %s\n", filename);
exit(1);
}
fprintf(file, "\n\n============================\n\n");
fprintf(file, "\n\n%d\n\n", debug_count++);
fprintf(file, "num_hood = %d\n", num_hood);
for (i = 0; i < num_hood; i++)
{
box = hypre_BoxArrayBox(hood_boxes, i);
fprintf(file, "(%d,%d,%d) X (%d,%d,%d) ; (%d,%d); %d\n",
hypre_BoxIMinX(box),hypre_BoxIMinY(box),hypre_BoxIMinZ(box),
hypre_BoxIMaxX(box),hypre_BoxIMaxY(box),hypre_BoxIMaxZ(box),
hood_procs[i], hood_ids[i], hypre_BoxVolume(box));
}
fprintf(file, "first_local = %d\n", first_local);
fprintf(file, "num_local = %d\n", num_local);
fprintf(file, "num_periodic = %d\n", num_periodic);
#endif
/*-----------------------------------------
* Coarsen bounding box
*-----------------------------------------*/
hypre_StructCoarsenBox(bounding_box, index, stride);
/*-----------------------------------------
* Coarsen neighborhood boxes & determine
* send / recv procs
*
* NOTE: Currently, this always communicates
* with all neighboring processes.
*-----------------------------------------*/
local_cbox = hypre_BoxCreate();
neighbor_cbox = hypre_BoxCreate();
num_recvs = 0;
num_sends = 0;
recv_procs = NULL;
send_procs = NULL;
for (i = 0; i < num_hood; i++)
{
if (hood_procs[i] != my_rank)
{
for (j = 0; j < num_local; j++)
{
ilocal = first_local + j;
local_box = hypre_BoxArrayBox(hood_boxes, ilocal);
neighbor_box = hypre_BoxArrayBox(hood_boxes, i);
/* coarsen boxes being considered */
hypre_CopyBox(local_box, local_cbox);
hypre_StructCoarsenBox(local_cbox, index, stride);
hypre_CopyBox(neighbor_box, neighbor_cbox);
hypre_StructCoarsenBox(neighbor_cbox, index, stride);
/*-----------------------
* Receive info?
*-----------------------*/
/* always communicate */
#if 0
perimeter_count = 0;
cperimeter_count = 0;
for (d = 0; d < 3; d++)
{
distance = max_distance;
diff = hypre_BoxIMaxD(neighbor_box, d) -
hypre_BoxIMaxD(local_box, d);
if (diff > 0)
{
distance = hypre_min(distance, diff);
}
diff = hypre_BoxIMinD(local_box, d) -
hypre_BoxIMinD(neighbor_box, d);
if (diff > 0)
{
distance = hypre_min(distance, diff);
}
if (distance < max_distance)
{
perimeter_count++;
}
distance = max_distance;
diff = hypre_BoxIMaxD(neighbor_cbox, d) -
hypre_BoxIMaxD(local_cbox, d);
if (diff > 0)
{
distance = hypre_min(distance, diff);
}
diff = hypre_BoxIMinD(local_cbox, d) -
hypre_BoxIMinD(neighbor_cbox, d);
if (diff > 0)
{
distance = hypre_min(distance, diff);
}
if (distance < max_distance)
{
cperimeter_count++;
}
}
#else
perimeter_count = 0;
cperimeter_count = 1;
#endif
if (cperimeter_count > perimeter_count)
{
if (num_recvs == 0)
{
recv_procs = hypre_TAlloc(int, num_hood);
recv_procs[num_recvs] = hood_procs[i];
num_recvs++;
}
else if (hood_procs[i] != recv_procs[num_recvs-1])
{
recv_procs[num_recvs] = hood_procs[i];
num_recvs++;
}
}
/*-----------------------
* Send info?
*-----------------------*/
/* always communicate */
#if 0
perimeter_count = 0;
cperimeter_count = 0;
for (d = 0; d < 3; d++)
{
distance = max_distance;
diff = hypre_BoxIMaxD(local_box, d) -
hypre_BoxIMaxD(neighbor_box, d);
if (diff > 0)
{
distance = hypre_min(distance, diff);
}
diff = hypre_BoxIMinD(neighbor_box, d) -
hypre_BoxIMinD(local_box, d);
if (diff > 0)
{
distance = hypre_min(distance, diff);
}
if (distance < max_distance)
{
perimeter_count++;
}
distance = max_distance;
diff = hypre_BoxIMaxD(local_cbox, d) -
hypre_BoxIMaxD(neighbor_cbox, d);
if (diff > 0)
{
distance = hypre_min(distance, diff);
}
diff = hypre_BoxIMinD(neighbor_cbox, d) -
hypre_BoxIMinD(local_cbox, d);
if (diff > 0)
{
distance = hypre_min(distance, diff);
}
if (distance < max_distance)
{
cperimeter_count++;
}
}
#else
perimeter_count = 0;
cperimeter_count = 1;
#endif
if (cperimeter_count > perimeter_count)
{
if (num_sends == 0)
{
send_procs = hypre_TAlloc(int, num_hood);
send_procs[num_sends] = hood_procs[i];
num_sends++;
}
else if (hood_procs[i] != send_procs[num_sends-1])
{
send_procs[num_sends] = hood_procs[i];
num_sends++;
}
}
