int
hypre_PrintBoxArrayData( FILE *file,
hypre_BoxArray *box_array,
hypre_BoxArray *data_space,
int num_values,
double *data )
{
int ierr = 0;
hypre_Box *box;
hypre_Box *data_box;
int data_box_volume;
int datai;
hypre_Index loop_size;
hypre_IndexRef start;
hypre_Index stride;
int i, j;
int loopi, loopj, loopk;
/*----------------------------------------
* Print data
*----------------------------------------*/
hypre_SetIndex(stride, 1, 1, 1);
hypre_ForBoxI(i, box_array)
{
box = hypre_BoxArrayBox(box_array, i);
data_box = hypre_BoxArrayBox(data_space, i);
start = hypre_BoxIMin(box);
data_box_volume = hypre_BoxVolume(data_box);
hypre_BoxGetSize(box, loop_size);
hypre_BoxLoop1Begin(loop_size,
data_box, start, stride, datai);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,datai
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop1For(loopi, loopj, loopk, datai)
{
for (j = 0; j < num_values; j++)
{
fprintf(file, "%d: (%d, %d, %d; %d) %e\n",
i,
hypre_IndexX(start) + loopi,
hypre_IndexY(start) + loopj,
hypre_IndexZ(start) + loopk,
j,
data[datai + j*data_box_volume]);
}
}
hypre_BoxLoop1End(datai);
data += num_values*data_box_volume;
}
HYPRE_Int
hypre_StructVectorSetRandomValues( hypre_StructVector *vector,
HYPRE_Int seed )
{
hypre_Box *v_data_box;
HYPRE_Int vi;
double *vp;
hypre_BoxArray *boxes;
hypre_Box *box;
hypre_Index loop_size;
hypre_IndexRef start;
hypre_Index unit_stride;
HYPRE_Int i;
/*-----------------------------------------------------------------------
* Set the vector coefficients
*-----------------------------------------------------------------------*/
srand( seed );
hypre_SetIndex(unit_stride, 1, 1, 1);
boxes = hypre_StructGridBoxes(hypre_StructVectorGrid(vector));
hypre_ForBoxI(i, boxes)
{
box = hypre_BoxArrayBox(boxes, i);
start = hypre_BoxIMin(box);
v_data_box =
hypre_BoxArrayBox(hypre_StructVectorDataSpace(vector), i);
vp = hypre_StructVectorBoxData(vector, i);
hypre_BoxGetSize(box, loop_size);
hypre_BoxLoop1Begin(hypre_StructVectorDim(vector), loop_size,
v_data_box, start, unit_stride, vi);
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(HYPRE_BOX_PRIVATE,vi ) HYPRE_SMP_SCHEDULE
#endif
hypre_BoxLoop1For(vi)
{
vp[vi] = 2.0*rand()/RAND_MAX - 1.0;
}
hypre_BoxLoop1End(vi);
}
int
hypre_SMGSetStructVectorConstantValues( hypre_StructVector *vector,
double values,
hypre_BoxArray *box_array,
hypre_Index stride )
{
int ierr = 0;
hypre_Box *v_data_box;
int vi;
double *vp;
hypre_Box *box;
hypre_Index loop_size;
hypre_IndexRef start;
int loopi, loopj, loopk;
int i;
/*-----------------------------------------------------------------------
* Set the vector coefficients
*-----------------------------------------------------------------------*/
hypre_ForBoxI(i, box_array)
{
box = hypre_BoxArrayBox(box_array, i);
start = hypre_BoxIMin(box);
v_data_box =
hypre_BoxArrayBox(hypre_StructVectorDataSpace(vector), i);
vp = hypre_StructVectorBoxData(vector, i);
hypre_BoxGetStrideSize(box, stride, loop_size);
hypre_BoxLoop1Begin(loop_size,
v_data_box, start, stride, vi);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,vi
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop1For(loopi, loopj, loopk, vi)
{
vp[vi] = values;
}
hypre_BoxLoop1End(vi);
}
int
hypre_StructScale( double alpha,
hypre_StructVector *y )
{
int ierr = 0;
hypre_Box *y_data_box;
int yi;
double *yp;
hypre_BoxArray *boxes;
hypre_Box *box;
hypre_Index loop_size;
hypre_IndexRef start;
hypre_Index unit_stride;
int i;
int loopi, loopj, loopk;
hypre_SetIndex(unit_stride, 1, 1, 1);
boxes = hypre_StructGridBoxes(hypre_StructVectorGrid(y));
hypre_ForBoxI(i, boxes)
{
box = hypre_BoxArrayBox(boxes, i);
start = hypre_BoxIMin(box);
y_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(y), i);
yp = hypre_StructVectorBoxData(y, i);
hypre_BoxGetSize(box, loop_size);
hypre_BoxLoop1Begin(loop_size,
y_data_box, start, unit_stride, yi);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,yi
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop1For(loopi, loopj, loopk, yi)
{
yp[yi] *= alpha;
}
hypre_BoxLoop1End(yi);
}
HYPRE_Int
hypre_StructScale( double alpha,
hypre_StructVector *y )
{
hypre_Box *y_data_box;
HYPRE_Int yi;
double *yp;
hypre_BoxArray *boxes;
hypre_Box *box;
hypre_Index loop_size;
hypre_IndexRef start;
hypre_Index unit_stride;
HYPRE_Int i;
hypre_SetIndex(unit_stride, 1, 1, 1);
boxes = hypre_StructGridBoxes(hypre_StructVectorGrid(y));
hypre_ForBoxI(i, boxes)
{
box = hypre_BoxArrayBox(boxes, i);
start = hypre_BoxIMin(box);
y_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(y), i);
yp = hypre_StructVectorBoxData(y, i);
hypre_BoxGetSize(box, loop_size);
hypre_BoxLoop1Begin(hypre_StructVectorDim(y), loop_size,
y_data_box, start, unit_stride, yi);
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(HYPRE_BOX_PRIVATE,yi) HYPRE_SMP_SCHEDULE
#endif
hypre_BoxLoop1For(yi)
{
yp[yi] *= alpha;
}
hypre_BoxLoop1End(yi);
}
HYPRE_Int
hypre_SemiInterp( void *interp_vdata,
hypre_StructMatrix *P,
hypre_StructVector *xc,
hypre_StructVector *e )
{
hypre_SemiInterpData *interp_data = interp_vdata;
HYPRE_Int P_stored_as_transpose;
hypre_ComputePkg *compute_pkg;
hypre_IndexRef cindex;
hypre_IndexRef findex;
hypre_IndexRef stride;
hypre_StructGrid *fgrid;
HYPRE_Int *fgrid_ids;
hypre_StructGrid *cgrid;
hypre_BoxArray *cgrid_boxes;
HYPRE_Int *cgrid_ids;
hypre_CommHandle *comm_handle;
hypre_BoxArrayArray *compute_box_aa;
hypre_BoxArray *compute_box_a;
hypre_Box *compute_box;
hypre_Box *P_dbox;
hypre_Box *xc_dbox;
hypre_Box *e_dbox;
HYPRE_Int Pi;
HYPRE_Int xci;
HYPRE_Int ei;
HYPRE_Int constant_coefficient;
HYPRE_Real *Pp0, *Pp1;
HYPRE_Real *xcp;
HYPRE_Real *ep, *ep0, *ep1;
hypre_Index loop_size;
hypre_Index start;
hypre_Index startc;
hypre_Index stridec;
hypre_StructStencil *stencil;
hypre_Index *stencil_shape;
HYPRE_Int compute_i, fi, ci, j;
/*-----------------------------------------------------------------------
* Initialize some things
*-----------------------------------------------------------------------*/
hypre_BeginTiming(interp_data -> time_index);
P_stored_as_transpose = (interp_data -> P_stored_as_transpose);
compute_pkg = (interp_data -> compute_pkg);
cindex = (interp_data -> cindex);
findex = (interp_data -> findex);
stride = (interp_data -> stride);
stencil = hypre_StructMatrixStencil(P);
stencil_shape = hypre_StructStencilShape(stencil);
constant_coefficient = hypre_StructMatrixConstantCoefficient(P);
hypre_assert( constant_coefficient==0 || constant_coefficient==1 );
/* ... constant_coefficient==2 for P shouldn't happen, see
hypre_PFMGCreateInterpOp in pfmg_setup_interp.c */
if (constant_coefficient) hypre_StructVectorClearBoundGhostValues(e, 0);
hypre_SetIndex3(stridec, 1, 1, 1);
/*-----------------------------------------------------------------------
* Compute e at coarse points (injection)
*-----------------------------------------------------------------------*/
fgrid = hypre_StructVectorGrid(e);
fgrid_ids = hypre_StructGridIDs(fgrid);
cgrid = hypre_StructVectorGrid(xc);
cgrid_boxes = hypre_StructGridBoxes(cgrid);
cgrid_ids = hypre_StructGridIDs(cgrid);
fi = 0;
hypre_ForBoxI(ci, cgrid_boxes)
{
while (fgrid_ids[fi] != cgrid_ids[ci])
{
fi++;
}
compute_box = hypre_BoxArrayBox(cgrid_boxes, ci);
hypre_CopyIndex(hypre_BoxIMin(compute_box), startc);
hypre_StructMapCoarseToFine(startc, cindex, stride, start);
e_dbox = hypre_BoxArrayBox(hypre_StructVectorDataSpace(e), fi);
xc_dbox = hypre_BoxArrayBox(hypre_StructVectorDataSpace(xc), ci);
ep = hypre_StructVectorBoxData(e, fi);
xcp = hypre_StructVectorBoxData(xc, ci);
hypre_BoxGetSize(compute_box, loop_size);
hypre_BoxLoop2Begin(hypre_StructMatrixNDim(P), loop_size,
e_dbox, start, stride, ei,
xc_dbox, startc, stridec, xci);
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(HYPRE_BOX_PRIVATE,ei,xci) HYPRE_SMP_SCHEDULE
#endif
hypre_BoxLoop2For(ei, xci)
{
ep[ei] = xcp[xci];
}
hypre_BoxLoop2End(ei, xci);
}
/*-----------------------------------------------------------------------
* Compute e at fine points
*-----------------------------------------------------------------------*/
for (compute_i = 0; compute_i < 2; compute_i++)
{
switch(compute_i)
{
case 0:
{
ep = hypre_StructVectorData(e);
hypre_InitializeIndtComputations(compute_pkg, ep, &comm_handle);
compute_box_aa = hypre_ComputePkgIndtBoxes(compute_pkg);
}
break;
case 1:
{
hypre_FinalizeIndtComputations(comm_handle);
compute_box_aa = hypre_ComputePkgDeptBoxes(compute_pkg);
}
break;
}
hypre_ForBoxArrayI(fi, compute_box_aa)
{
compute_box_a = hypre_BoxArrayArrayBoxArray(compute_box_aa, fi);
P_dbox = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(P), fi);
e_dbox = hypre_BoxArrayBox(hypre_StructVectorDataSpace(e), fi);
if (P_stored_as_transpose)
{
if ( constant_coefficient )
{
Pp0 = hypre_StructMatrixBoxData(P, fi, 1);
Pp1 = hypre_StructMatrixBoxData(P, fi, 0) -
hypre_CCBoxOffsetDistance(P_dbox, stencil_shape[0]);
}
else
{
Pp0 = hypre_StructMatrixBoxData(P, fi, 1);
Pp1 = hypre_StructMatrixBoxData(P, fi, 0) -
hypre_BoxOffsetDistance(P_dbox, stencil_shape[0]);
}
}
else
{
Pp0 = hypre_StructMatrixBoxData(P, fi, 0);
Pp1 = hypre_StructMatrixBoxData(P, fi, 1);
}
ep = hypre_StructVectorBoxData(e, fi);
ep0 = ep + hypre_BoxOffsetDistance(e_dbox, stencil_shape[0]);
ep1 = ep + hypre_BoxOffsetDistance(e_dbox, stencil_shape[1]);
hypre_ForBoxI(j, compute_box_a)
{
compute_box = hypre_BoxArrayBox(compute_box_a, j);
hypre_CopyIndex(hypre_BoxIMin(compute_box), start);
hypre_StructMapFineToCoarse(start, findex, stride, startc);
hypre_BoxGetStrideSize(compute_box, stride, loop_size);
if ( constant_coefficient )
{
Pi = hypre_CCBoxIndexRank( P_dbox, startc );
hypre_BoxLoop1Begin(hypre_StructMatrixNDim(P), loop_size,
e_dbox, start, stride, ei);
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(HYPRE_BOX_PRIVATE,ei) HYPRE_SMP_SCHEDULE
#endif
hypre_BoxLoop1For(ei)
{
ep[ei] = (Pp0[Pi] * ep0[ei] +
Pp1[Pi] * ep1[ei]);
}
hypre_BoxLoop1End(ei);
}
else
{
hypre_BoxLoop2Begin(hypre_StructMatrixNDim(P), loop_size,
P_dbox, startc, stridec, Pi,
e_dbox, start, stride, ei);
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(HYPRE_BOX_PRIVATE,Pi,ei) HYPRE_SMP_SCHEDULE
#endif
hypre_BoxLoop2For(Pi, ei)
{
ep[ei] = (Pp0[Pi] * ep0[ei] +
Pp1[Pi] * ep1[ei]);
}
hypre_BoxLoop2End(Pi, ei);
}
}
int
hypre_StructMatvecCompute( void *matvec_vdata,
double alpha,
hypre_StructMatrix *A,
hypre_StructVector *x,
double beta,
hypre_StructVector *y )
{
int ierr = 0;
hypre_StructMatvecData *matvec_data = matvec_vdata;
hypre_ComputePkg *compute_pkg;
hypre_CommHandle *comm_handle;
hypre_BoxArrayArray *compute_box_aa;
hypre_BoxArray *compute_box_a;
hypre_Box *compute_box;
hypre_Box *A_data_box;
hypre_Box *x_data_box;
hypre_Box *y_data_box;
int Ai;
int xi;
int xoff0;
int xoff1;
int xoff2;
int xoff3;
int xoff4;
int xoff5;
int xoff6;
int yi;
double *Ap0;
double *Ap1;
double *Ap2;
double *Ap3;
double *Ap4;
double *Ap5;
double *Ap6;
double *xp;
double *yp;
hypre_BoxArray *boxes;
hypre_Box *box;
hypre_Index loop_size;
hypre_IndexRef start;
hypre_IndexRef stride;
hypre_StructStencil *stencil;
hypre_Index *stencil_shape;
int stencil_size;
int depth;
double temp;
int compute_i, i, j, si;
int loopi, loopj, loopk;
/*-----------------------------------------------------------------------
* Initialize some things
*-----------------------------------------------------------------------*/
compute_pkg = (matvec_data -> compute_pkg);
stride = hypre_ComputePkgStride(compute_pkg);
/*-----------------------------------------------------------------------
* Do (alpha == 0.0) computation
*-----------------------------------------------------------------------*/
if (alpha == 0.0)
{
boxes = hypre_StructGridBoxes(hypre_StructMatrixGrid(A));
hypre_ForBoxI(i, boxes)
{
box = hypre_BoxArrayBox(boxes, i);
start = hypre_BoxIMin(box);
y_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(y), i);
yp = hypre_StructVectorBoxData(y, i);
hypre_BoxGetSize(box, loop_size);
hypre_BoxLoop1Begin(loop_size,
y_data_box, start, stride, yi);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,yi
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop1For(loopi, loopj, loopk, yi)
{
yp[yi] *= beta;
}
hypre_BoxLoop1End(yi);
}
/*--------------------------------------------------------------------------
* hypre_FacZeroCFSten: Zeroes the coarse stencil coefficients that reach
* into an underlying coarsened refinement box.
* Algo: For each cbox
* {
* 1) refine cbox and expand by one in each direction
* 2) boxman_intersect with the fboxman
* 3) loop over intersection boxes to see if stencil
* reaches over.
* }
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_FacZeroCFSten( hypre_SStructPMatrix *Af,
hypre_SStructPMatrix *Ac,
hypre_SStructGrid *grid,
HYPRE_Int fine_part,
hypre_Index rfactors )
{
hypre_BoxManager *fboxman;
hypre_BoxManEntry **boxman_entries;
HYPRE_Int nboxman_entries;
hypre_SStructPGrid *p_cgrid;
hypre_Box fgrid_box;
hypre_StructGrid *cgrid;
hypre_BoxArray *cgrid_boxes;
hypre_Box *cgrid_box;
hypre_Box scaled_box;
hypre_Box *shift_ibox;
hypre_StructMatrix *smatrix;
hypre_StructStencil *stencils;
HYPRE_Int stencil_size;
hypre_Index refine_factors, upper_shift;
hypre_Index stride;
hypre_Index stencil_shape;
hypre_Index zero_index, ilower, iupper;
HYPRE_Int nvars, var1, var2;
HYPRE_Int ndim;
hypre_Box *ac_dbox;
HYPRE_Real *ac_ptr;
hypre_Index loop_size;
HYPRE_Int iac;
HYPRE_Int ci, i, j;
HYPRE_Int abs_shape;
HYPRE_Int ierr = 0;
p_cgrid = hypre_SStructPMatrixPGrid(Ac);
nvars = hypre_SStructPMatrixNVars(Ac);
ndim = hypre_SStructPGridNDim(p_cgrid);
hypre_BoxInit(&fgrid_box, ndim);
hypre_BoxInit(&scaled_box, ndim);
hypre_ClearIndex(zero_index);
hypre_ClearIndex(stride);
hypre_ClearIndex(upper_shift);
for (i= 0; i< ndim; i++)
{
stride[i]= 1;
upper_shift[i]= rfactors[i]-1;
}
hypre_CopyIndex(rfactors, refine_factors);
if (ndim < 3)
{
for (i= ndim; i< 3; i++)
{
refine_factors[i]= 1;
}
}
for (var1= 0; var1< nvars; var1++)
{
cgrid= hypre_SStructPGridSGrid(hypre_SStructPMatrixPGrid(Ac), var1);
cgrid_boxes= hypre_StructGridBoxes(cgrid);
fboxman= hypre_SStructGridBoxManager(grid, fine_part, var1);
/*------------------------------------------------------------------
* For each parent coarse box find all fboxes that may be connected
* through a stencil entry- refine this box, expand it by one
* in each direction, and boxman_intersect with fboxman
*------------------------------------------------------------------*/
hypre_ForBoxI(ci, cgrid_boxes)
{
cgrid_box= hypre_BoxArrayBox(cgrid_boxes, ci);
hypre_StructMapCoarseToFine(hypre_BoxIMin(cgrid_box), zero_index,
refine_factors, hypre_BoxIMin(&scaled_box));
hypre_StructMapCoarseToFine(hypre_BoxIMax(cgrid_box), upper_shift,
refine_factors, hypre_BoxIMax(&scaled_box));
hypre_SubtractIndexes(hypre_BoxIMin(&scaled_box), stride, 3,
hypre_BoxIMin(&scaled_box));
hypre_AddIndexes(hypre_BoxIMax(&scaled_box), stride, 3,
hypre_BoxIMax(&scaled_box));
hypre_BoxManIntersect(fboxman, hypre_BoxIMin(&scaled_box),
hypre_BoxIMax(&scaled_box), &boxman_entries,
&nboxman_entries);
for (var2= 0; var2< nvars; var2++)
{
stencils= hypre_SStructPMatrixSStencil(Ac, var1, var2);
if (stencils != NULL)
{
stencil_size= hypre_StructStencilSize(stencils);
smatrix = hypre_SStructPMatrixSMatrix(Ac, var1, var2);
ac_dbox = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(smatrix),
ci);
/*---------------------------------------------------------
* Find the stencil coefficients that must be zeroed off.
* Loop over all possible boxes.
*---------------------------------------------------------*/
for (i= 0; i< stencil_size; i++)
{
hypre_CopyIndex(hypre_StructStencilElement(stencils, i),
stencil_shape);
AbsStencilShape(stencil_shape, abs_shape);
if (abs_shape) /* non-centre stencils are zeroed */
{
/* look for connecting fboxes that must be zeroed. */
for (j= 0; j< nboxman_entries; j++)
{
hypre_BoxManEntryGetExtents(boxman_entries[j], ilower, iupper);
hypre_BoxSetExtents(&fgrid_box, ilower, iupper);
shift_ibox= hypre_CF_StenBox(&fgrid_box, cgrid_box, stencil_shape,
refine_factors, ndim);
if ( hypre_BoxVolume(shift_ibox) )
{
ac_ptr= hypre_StructMatrixExtractPointerByIndex(smatrix,
ci,
stencil_shape);
hypre_BoxGetSize(shift_ibox, loop_size);
hypre_BoxLoop1Begin(ndim, loop_size,
ac_dbox, hypre_BoxIMin(shift_ibox),
stride, iac);
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(HYPRE_BOX_PRIVATE,iac) HYPRE_SMP_SCHEDULE
#endif
hypre_BoxLoop1For(iac)
{
ac_ptr[iac] = 0.0;
}
hypre_BoxLoop1End(iac);
} /* if ( hypre_BoxVolume(shift_ibox) ) */
hypre_BoxDestroy(shift_ibox);
} /* for (j= 0; j< nboxman_entries; j++) */
} /* if (abs_shape) */
} /* for (i= 0; i< stencil_size; i++) */
} /* if (stencils != NULL) */
} /* for (var2= 0; var2< nvars; var2++) */
hypre_TFree(boxman_entries);
} /* hypre_ForBoxI ci */
HYPRE_Int
hypre_PrintBoxArrayData( FILE *file,
hypre_BoxArray *box_array,
hypre_BoxArray *data_space,
HYPRE_Int num_values,
HYPRE_Int dim,
HYPRE_Complex *data )
{
hypre_Box *box;
hypre_Box *data_box;
HYPRE_Int data_box_volume;
HYPRE_Int datai;
hypre_Index loop_size;
hypre_IndexRef start;
hypre_Index stride;
hypre_Index index;
HYPRE_Int i, j, d;
HYPRE_Complex value;
/*----------------------------------------
* Print data
*----------------------------------------*/
hypre_SetIndex(stride, 1);
hypre_ForBoxI(i, box_array)
{
box = hypre_BoxArrayBox(box_array, i);
data_box = hypre_BoxArrayBox(data_space, i);
start = hypre_BoxIMin(box);
data_box_volume = hypre_BoxVolume(data_box);
hypre_BoxGetSize(box, loop_size);
hypre_BoxLoop1Begin(dim, loop_size,
data_box, start, stride, datai);
hypre_BoxLoop1For(datai)
{
/* Print lines of the form: "%d: (%d, %d, %d; %d) %.14e\n" */
hypre_BoxLoopGetIndex(index);
for (j = 0; j < num_values; j++)
{
hypre_fprintf(file, "%d: (%d",
i, hypre_IndexD(start, 0) + hypre_IndexD(index, 0));
for (d = 1; d < dim; d++)
{
hypre_fprintf(file, ", %d",
hypre_IndexD(start, d) + hypre_IndexD(index, d));
}
value = data[datai + j*data_box_volume];
#ifdef HYPRE_COMPLEX
hypre_fprintf(file, "; %d) %.14e , %.14e\n",
j, hypre_creal(value), hypre_cimag(value));
#else
hypre_fprintf(file, "; %d) %.14e\n", j, value);
#endif
}
}
hypre_BoxLoop1End(datai);
data += num_values*data_box_volume;
}
HYPRE_Int
hypre_CreateCommInfoFromStencil( hypre_StructGrid *grid,
hypre_StructStencil *stencil,
hypre_CommInfo **comm_info_ptr )
{
HYPRE_Int ndim = hypre_StructGridNDim(grid);
HYPRE_Int i,j,k, d, m, s, si;
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_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_Box *stencil_box, *sbox; /* extents of the stencil grid */
HYPRE_Int *stencil_grid;
HYPRE_Int grow[HYPRE_MAXDIM][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_Index istart, istop, sgindex;
hypre_IndexRef start;
hypre_Index loop_size, stride;
HYPRE_Int num_periods, loc, box_id, id, proc_id;
HYPRE_Int myid;
MPI_Comm comm;
/*------------------------------------------------------
* Initializations
*------------------------------------------------------*/
hypre_SetIndex(ilower, 0);
hypre_SetIndex(iupper, 0);
hypre_SetIndex(istart, 0);
hypre_SetIndex(istop, 0);
hypre_SetIndex(sgindex, 0);
local_boxes = hypre_StructGridBoxes(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);
stencil_box = hypre_BoxCreate(ndim);
hypre_SetIndex(hypre_BoxIMin(stencil_box), 0);
hypre_SetIndex(hypre_BoxIMax(stencil_box), 2);
/* Set initial values to zero */
stencil_grid = hypre_CTAlloc(HYPRE_Int, hypre_BoxVolume(stencil_box));
sbox = hypre_BoxCreate(ndim);
hypre_SetIndex(stride, 1);
/*------------------------------------------------------
* Compute the "grow" information from the stencil
*------------------------------------------------------*/
stencil_shape = hypre_StructStencilShape(stencil);
for (d = 0; d < ndim; 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 < ndim; 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 */
hypre_BoxSetExtents(sbox, istart, istop);
start = hypre_BoxIMin(sbox);
hypre_BoxGetSize(sbox, loop_size);
hypre_BoxLoop1Begin(ndim, loop_size,
stencil_box, start, stride, si);
hypre_BoxLoopSetOneBlock();
hypre_BoxLoop1For(si)
{
stencil_grid[si] = 1;
}
hypre_BoxLoop1End(si);
}
/*------------------------------------------------------
* 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, ndim);
recv_boxes = hypre_BoxArrayArrayCreate(num_boxes, ndim);
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, ndim);
recv_rboxnums = hypre_CTAlloc(HYPRE_Int *, num_boxes);
recv_rboxes = hypre_BoxArrayArrayCreate(num_boxes, ndim);
grow_box = hypre_BoxCreate(hypre_StructGridNDim(grid));
extend_box = hypre_BoxCreate(hypre_StructGridNDim(grid));
int_box = hypre_BoxCreate(hypre_StructGridNDim(grid));
periodic_box = hypre_BoxCreate(hypre_StructGridNDim(grid));
/* storage we will use and keep track of the neighbors */
neighbor_alloc = 30; /* initial guess at max size */
neighbor_boxes = hypre_BoxArrayCreate(neighbor_alloc, ndim);
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 = i;
/* grow box local i according to the stencil*/
hypre_CopyBox(box, grow_box);
for (d = 0; d < ndim; 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 < ndim; 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 < ndim; 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 */
si = hypre_BoxIndexRank(stencil_box, sgindex);
if (stencil_grid[si])
{
/* 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 < ndim; 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 */
si = hypre_BoxIndexRank(stencil_box, sgindex);
if (stencil_grid[si])
{
/* grow the neighbor box and intersect */
hypre_CopyBox(hood_box, grow_box);
for (d = 0; d < ndim; 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 */
