HYPRE_Int
hypre_SparseMSGInterp( void *interp_vdata,
hypre_StructMatrix *P,
hypre_StructVector *xc,
hypre_StructVector *e )
{
HYPRE_Int ierr = 0;
hypre_SparseMSGInterpData *interp_data = interp_vdata;
hypre_ComputePkg *compute_pkg;
hypre_IndexRef cindex;
hypre_IndexRef findex;
hypre_IndexRef stride;
hypre_IndexRef strideP;
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;
double *Pp0, *Pp1;
double *xcp;
double *ep, *ep0, *ep1;
hypre_Index loop_size;
hypre_Index start;
hypre_Index startc;
hypre_Index startP;
hypre_Index stridec;
hypre_StructStencil *stencil;
hypre_Index *stencil_shape;
HYPRE_Int compute_i, fi, ci, j;
HYPRE_Int loopi, loopj, loopk;
/*-----------------------------------------------------------------------
* Initialize some things
*-----------------------------------------------------------------------*/
hypre_BeginTiming(interp_data -> time_index);
compute_pkg = (interp_data -> compute_pkg);
cindex = (interp_data -> cindex);
findex = (interp_data -> findex);
stride = (interp_data -> stride);
strideP = (interp_data -> strideP);
stencil = hypre_StructMatrixStencil(P);
stencil_shape = hypre_StructStencilShape(stencil);
hypre_SetIndex(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(loop_size,
e_dbox, start, stride, ei,
xc_dbox, startc, stridec, xci);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,ei,xci
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop2For(loopi, loopj, loopk, 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);
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_StructMapCoarseToFine(startc, cindex, strideP, startP);
hypre_BoxGetStrideSize(compute_box, stride, loop_size);
hypre_BoxLoop2Begin(loop_size,
P_dbox, startP, strideP, Pi,
e_dbox, start, stride, ei);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,Pi,ei
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop2For(loopi, loopj, loopk, Pi, ei)
{
ep[ei] = (Pp0[Pi] * ep0[ei] +
Pp1[Pi] * ep1[ei]);
}
hypre_BoxLoop2End(Pi, ei);
}
}
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);
}
}
HYPRE_Int
hypre_PFMGBuildCoarseOp5( hypre_StructMatrix *A,
hypre_StructMatrix *P,
hypre_StructMatrix *R,
HYPRE_Int cdir,
hypre_Index cindex,
hypre_Index cstride,
hypre_StructMatrix *RAP )
{
hypre_Index index;
hypre_Index index_temp;
hypre_StructGrid *fgrid;
hypre_BoxArray *fgrid_boxes;
hypre_Box *fgrid_box;
HYPRE_Int *fgrid_ids;
hypre_StructGrid *cgrid;
hypre_BoxArray *cgrid_boxes;
hypre_Box *cgrid_box;
HYPRE_Int *cgrid_ids;
hypre_IndexRef cstart, bfstart, stridef;
hypre_Index fstart, bcstart, stridec;
hypre_Index loop_size;
HYPRE_Int constant_coefficient;
HYPRE_Int fi, ci, fbi;
HYPRE_Int loopi, loopj, loopk;
hypre_Box *A_dbox;
hypre_Box *P_dbox;
hypre_Box *RAP_dbox;
hypre_BoxArray *bdy_boxes, *tmp_boxes;
hypre_Box *bdy_box, *fcbox;
double *pb, *pa;
double *a_cc, *a_cw, *a_ce, *a_cb, *a_ca;
double *rap_cc, *rap_cw, *rap_ce;
double *rap_cb, *rap_ca;
double west, east;
double center_int, center_bdy;
HYPRE_Int iA, iAm1, iAp1;
HYPRE_Int iAc;
HYPRE_Int iP, iPm1, iPp1;
HYPRE_Int OffsetA;
HYPRE_Int OffsetP;
stridef = cstride;
hypre_SetIndex(stridec, 1, 1, 1);
fgrid = hypre_StructMatrixGrid(A);
fgrid_boxes = hypre_StructGridBoxes(fgrid);
fgrid_ids = hypre_StructGridIDs(fgrid);
cgrid = hypre_StructMatrixGrid(RAP);
cgrid_boxes = hypre_StructGridBoxes(cgrid);
cgrid_ids = hypre_StructGridIDs(cgrid);
constant_coefficient = hypre_StructMatrixConstantCoefficient(RAP);
hypre_assert( hypre_StructMatrixConstantCoefficient(A) == constant_coefficient );
if ( constant_coefficient==0 )
{
hypre_assert( hypre_StructMatrixConstantCoefficient(R) == 0 );
hypre_assert( hypre_StructMatrixConstantCoefficient(P) == 0 );
}
else /* 1 or 2 */
{
hypre_assert( hypre_StructMatrixConstantCoefficient(R) == 1 );
hypre_assert( hypre_StructMatrixConstantCoefficient(P) == 1 );
}
fcbox = hypre_BoxCreate();
bdy_boxes = hypre_BoxArrayCreate(0);
tmp_boxes = hypre_BoxArrayCreate(0);
fi = 0;
hypre_ForBoxI(ci, cgrid_boxes)
{
while (fgrid_ids[fi] != cgrid_ids[ci])
{
fi++;
}
cgrid_box = hypre_BoxArrayBox(cgrid_boxes, ci);
fgrid_box = hypre_BoxArrayBox(fgrid_boxes, fi);
cstart = hypre_BoxIMin(cgrid_box);
hypre_StructMapCoarseToFine(cstart, cindex, cstride, fstart);
A_dbox = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(A), fi);
P_dbox = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(P), fi);
RAP_dbox = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(RAP), ci);
/*-----------------------------------------------------------------
* Extract pointers for interpolation operator:
* pb is pointer for weight for f-point below c-point
* pa is pointer for weight for f-point above c-point
*-----------------------------------------------------------------*/
hypre_SetIndex(index_temp,0,-1,0);
MapIndex(index_temp, cdir, index);
pa = hypre_StructMatrixExtractPointerByIndex(P, fi, index);
hypre_SetIndex(index_temp,0,1,0);
MapIndex(index_temp, cdir, index);
pb = hypre_StructMatrixExtractPointerByIndex(P, fi, index) -
hypre_BoxOffsetDistance(P_dbox, index);
/*-----------------------------------------------------------------
* Extract pointers for 5-point fine grid operator:
*
* a_cc is pointer for center coefficient
* a_cw is pointer for west coefficient
* a_ce is pointer for east coefficient
* a_cb is pointer for below coefficient
* a_ca is pointer for above coefficient
*-----------------------------------------------------------------*/
hypre_SetIndex(index_temp,0,0,0);
MapIndex(index_temp, cdir, index);
a_cc = hypre_StructMatrixExtractPointerByIndex(A, fi, index);
hypre_SetIndex(index_temp,-1,0,0);
MapIndex(index_temp, cdir, index);
a_cw = hypre_StructMatrixExtractPointerByIndex(A, fi, index);
hypre_SetIndex(index_temp,1,0,0);
MapIndex(index_temp, cdir, index);
a_ce = hypre_StructMatrixExtractPointerByIndex(A, fi, index);
hypre_SetIndex(index_temp,0,-1,0);
MapIndex(index_temp, cdir, index);
a_cb = hypre_StructMatrixExtractPointerByIndex(A, fi, index);
hypre_SetIndex(index_temp,0,1,0);
MapIndex(index_temp, cdir, index);
a_ca = hypre_StructMatrixExtractPointerByIndex(A, fi, index);
/*-----------------------------------------------------------------
* Extract pointers for coarse grid operator
* rap_cc is pointer for center coefficient (etc.)
*-----------------------------------------------------------------*/
hypre_SetIndex(index_temp,0,0,0);
MapIndex(index_temp, cdir, index);
rap_cc = hypre_StructMatrixExtractPointerByIndex(RAP, ci, index);
hypre_SetIndex(index_temp,-1,0,0);
MapIndex(index_temp, cdir, index);
rap_cw = hypre_StructMatrixExtractPointerByIndex(RAP, ci, index);
hypre_SetIndex(index_temp,1,0,0);
MapIndex(index_temp, cdir, index);
rap_ce = hypre_StructMatrixExtractPointerByIndex(RAP, ci, index);
hypre_SetIndex(index_temp,0,-1,0);
MapIndex(index_temp, cdir, index);
rap_cb = hypre_StructMatrixExtractPointerByIndex(RAP, ci, index);
hypre_SetIndex(index_temp,0,1,0);
MapIndex(index_temp, cdir, index);
rap_ca = hypre_StructMatrixExtractPointerByIndex(RAP, ci, index);
/*-----------------------------------------------------------------
* Define offsets for fine grid stencil and interpolation
*
* In the BoxLoop below I assume iA and iP refer to data associated
* with the point which we are building the stencil for. The below
* Offsets are used in refering to data associated with other points.
*-----------------------------------------------------------------*/
hypre_SetIndex(index_temp,0,1,0);
MapIndex(index_temp, cdir, index);
OffsetP = hypre_BoxOffsetDistance(P_dbox,index);
OffsetA = hypre_BoxOffsetDistance(A_dbox,index);
/*--------------------------------------------------------------
* Loop for symmetric 5-point fine grid operator; produces a
* symmetric 5-point coarse grid operator.
*--------------------------------------------------------------*/
if ( constant_coefficient==0 )
{
hypre_BoxGetSize(cgrid_box, loop_size);
hypre_BoxLoop3Begin(loop_size,
P_dbox, cstart, stridec, iP,
A_dbox, fstart, stridef, iA,
RAP_dbox, cstart, stridec, iAc);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,iP,iA,iAc,iAm1,iAp1,iPm1,iPp1,west,east
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop3For(loopi, loopj, loopk, iP, iA, iAc)
{
iAm1 = iA - OffsetA;
iAp1 = iA + OffsetA;
iPm1 = iP - OffsetP;
iPp1 = iP + OffsetP;
rap_cb[iAc] = a_cb[iA] * pa[iPm1];
rap_ca[iAc] = a_ca[iA] * pb[iPp1];
west = a_cw[iA] + 0.5 * a_cw[iAm1] + 0.5 * a_cw[iAp1];
east = a_ce[iA] + 0.5 * a_ce[iAm1] + 0.5 * a_ce[iAp1];
/*-----------------------------------------------------
* Prevent non-zero entries reaching off grid
*-----------------------------------------------------*/
if(a_cw[iA] == 0.0) west = 0.0;
if(a_ce[iA] == 0.0) east = 0.0;
rap_cw[iAc] = west;
rap_ce[iAc] = east;
rap_cc[iAc] = a_cc[iA] + a_cw[iA] + a_ce[iA]
+ a_cb[iA] * pb[iP] + a_ca[iA] * pa[iP]
- west - east;
}
hypre_BoxLoop3End(iP, iA, iAc);
}
HYPRE_Int
hypre_StructCoarsen( hypre_StructGrid *fgrid,
hypre_Index index,
hypre_Index stride,
HYPRE_Int prune,
hypre_StructGrid **cgrid_ptr )
{
hypre_StructGrid *cgrid;
MPI_Comm comm;
HYPRE_Int ndim;
hypre_BoxArray *my_boxes;
hypre_Index periodic;
hypre_Index ilower, iupper;
hypre_Box *box;
hypre_Box *new_box;
hypre_Box *bounding_box;
HYPRE_Int i, j, myid, count;
HYPRE_Int info_size, max_nentries;
HYPRE_Int num_entries;
HYPRE_Int *fids, *cids;
hypre_Index new_dist;
hypre_IndexRef max_distance;
HYPRE_Int proc, id;
HYPRE_Int coarsen_factor, known;
HYPRE_Int num, last_proc;
#if 0
hypre_StructAssumedPart *fap = NULL, *cap = NULL;
#endif
hypre_BoxManager *fboxman, *cboxman;
hypre_BoxManEntry *entries;
hypre_BoxManEntry *entry;
void *entry_info = NULL;
#if TIME_DEBUG
HYPRE_Int tindex;
char new_title[80];
hypre_sprintf(new_title,"Coarsen.%d",s_coarsen_num);
tindex = hypre_InitializeTiming(new_title);
s_coarsen_num++;
hypre_BeginTiming(tindex);
#endif
hypre_SetIndex(ilower, 0);
hypre_SetIndex(iupper, 0);
/* get relevant information from the fine grid */
fids = hypre_StructGridIDs(fgrid);
fboxman = hypre_StructGridBoxMan(fgrid);
comm = hypre_StructGridComm(fgrid);
ndim = hypre_StructGridNDim(fgrid);
max_distance = hypre_StructGridMaxDistance(fgrid);
/* initial */
hypre_MPI_Comm_rank(comm, &myid );
/* create new coarse grid */
hypre_StructGridCreate(comm, ndim, &cgrid);
/* coarsen my boxes and create the coarse grid ids (same as fgrid) */
my_boxes = hypre_BoxArrayDuplicate(hypre_StructGridBoxes(fgrid));
cids = hypre_TAlloc(HYPRE_Int, hypre_BoxArraySize(my_boxes));
for (i = 0; i < hypre_BoxArraySize(my_boxes); i++)
{
box = hypre_BoxArrayBox(my_boxes, i);
hypre_StructCoarsenBox(box, index, stride);
cids[i] = fids[i];
}
/* prune? */
/* zero volume boxes are needed when forming P and P^T */
if (prune)
{
count = 0;
hypre_ForBoxI(i, my_boxes)
{
box = hypre_BoxArrayBox(my_boxes, i);
if (hypre_BoxVolume(box))
{
hypre_CopyBox(box, hypre_BoxArrayBox(my_boxes, count));
cids[count] = cids[i];
count++;
}
}
hypre_BoxArraySetSize(my_boxes, count);
}
int
hypre_SMG2BuildRAPSym( hypre_StructMatrix *A,
hypre_StructMatrix *PT,
hypre_StructMatrix *R,
hypre_StructMatrix *RAP,
hypre_Index cindex,
hypre_Index cstride )
{
hypre_Index index;
hypre_StructStencil *fine_stencil;
int fine_stencil_size;
hypre_StructGrid *fgrid;
int *fgrid_ids;
hypre_StructGrid *cgrid;
hypre_BoxArray *cgrid_boxes;
int *cgrid_ids;
hypre_Box *cgrid_box;
hypre_IndexRef cstart;
hypre_Index stridec;
hypre_Index fstart;
hypre_IndexRef stridef;
hypre_Index loop_size;
int fi, ci;
int loopi, loopj, loopk;
hypre_Box *A_dbox;
hypre_Box *PT_dbox;
hypre_Box *R_dbox;
hypre_Box *RAP_dbox;
double *pa, *pb;
double *ra, *rb;
double *a_cc, *a_cw, *a_ce, *a_cs, *a_cn;
double *a_csw, *a_cse, *a_cnw;
double *rap_cc, *rap_cw, *rap_cs;
double *rap_csw, *rap_cse;
int iA, iAm1, iAp1;
int iAc;
int iP, iP1;
int iR;
int yOffsetA;
int xOffsetP;
int yOffsetP;
int ierr = 0;
fine_stencil = hypre_StructMatrixStencil(A);
fine_stencil_size = hypre_StructStencilSize(fine_stencil);
stridef = cstride;
hypre_SetIndex(stridec, 1, 1, 1);
fgrid = hypre_StructMatrixGrid(A);
fgrid_ids = hypre_StructGridIDs(fgrid);
cgrid = hypre_StructMatrixGrid(RAP);
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++;
}
cgrid_box = hypre_BoxArrayBox(cgrid_boxes, ci);
cstart = hypre_BoxIMin(cgrid_box);
hypre_StructMapCoarseToFine(cstart, cindex, cstride, fstart);
A_dbox = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(A), fi);
PT_dbox = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(PT), fi);
R_dbox = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(R), fi);
RAP_dbox = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(RAP), ci);
/*-----------------------------------------------------------------
* Extract pointers for interpolation operator:
* pa is pointer for weight for f-point above c-point
* pb is pointer for weight for f-point below c-point
*-----------------------------------------------------------------*/
hypre_SetIndex(index,0,1,0);
pa = hypre_StructMatrixExtractPointerByIndex(PT, fi, index);
hypre_SetIndex(index,0,-1,0);
pb = hypre_StructMatrixExtractPointerByIndex(PT, fi, index);
/*-----------------------------------------------------------------
* Extract pointers for restriction operator:
* ra is pointer for weight for f-point above c-point
* rb is pointer for weight for f-point below c-point
*-----------------------------------------------------------------*/
hypre_SetIndex(index,0,1,0);
ra = hypre_StructMatrixExtractPointerByIndex(R, fi, index);
hypre_SetIndex(index,0,-1,0);
rb = hypre_StructMatrixExtractPointerByIndex(R, fi, index);
/*-----------------------------------------------------------------
* Extract pointers for 5-point fine grid operator:
*
* a_cc is pointer for center coefficient
* a_cw is pointer for west coefficient
* a_ce is pointer for east coefficient
* a_cs is pointer for south coefficient
* a_cn is pointer for north coefficient
*-----------------------------------------------------------------*/
hypre_SetIndex(index,0,0,0);
a_cc = hypre_StructMatrixExtractPointerByIndex(A, fi, index);
hypre_SetIndex(index,-1,0,0);
a_cw = hypre_StructMatrixExtractPointerByIndex(A, fi, index);
hypre_SetIndex(index,1,0,0);
a_ce = hypre_StructMatrixExtractPointerByIndex(A, fi, index);
hypre_SetIndex(index,0,-1,0);
a_cs = hypre_StructMatrixExtractPointerByIndex(A, fi, index);
hypre_SetIndex(index,0,1,0);
a_cn = hypre_StructMatrixExtractPointerByIndex(A, fi, index);
/*-----------------------------------------------------------------
* Extract additional pointers for 9-point fine grid operator:
*
* a_csw is pointer for southwest coefficient
* a_cse is pointer for southeast coefficient
* a_cnw is pointer for northwest coefficient
* a_cne is pointer for northeast coefficient
*-----------------------------------------------------------------*/
if(fine_stencil_size > 5)
{
hypre_SetIndex(index,-1,-1,0);
a_csw = hypre_StructMatrixExtractPointerByIndex(A, fi, index);
hypre_SetIndex(index,1,-1,0);
a_cse = hypre_StructMatrixExtractPointerByIndex(A, fi, index);
hypre_SetIndex(index,-1,1,0);
a_cnw = hypre_StructMatrixExtractPointerByIndex(A, fi, index);
}
/*-----------------------------------------------------------------
* Extract pointers for coarse grid operator - always 9-point:
*
* We build only the lower triangular part (plus diagonal).
*
* rap_cc is pointer for center coefficient (etc.)
*-----------------------------------------------------------------*/
hypre_SetIndex(index,0,0,0);
rap_cc = hypre_StructMatrixExtractPointerByIndex(RAP, ci, index);
hypre_SetIndex(index,-1,0,0);
rap_cw = hypre_StructMatrixExtractPointerByIndex(RAP, ci, index);
hypre_SetIndex(index,0,-1,0);
rap_cs = hypre_StructMatrixExtractPointerByIndex(RAP, ci, index);
hypre_SetIndex(index,-1,-1,0);
rap_csw = hypre_StructMatrixExtractPointerByIndex(RAP, ci, index);
hypre_SetIndex(index,1,-1,0);
rap_cse = hypre_StructMatrixExtractPointerByIndex(RAP, ci, index);
/*-----------------------------------------------------------------
* Define offsets for fine grid stencil and interpolation
*
* In the BoxLoop below I assume iA and iP refer to data associated
* with the point which we are building the stencil for. The below
* Offsets are used in refering to data associated with other points.
*-----------------------------------------------------------------*/
hypre_SetIndex(index,0,1,0);
yOffsetA = hypre_BoxOffsetDistance(A_dbox,index);
yOffsetP = hypre_BoxOffsetDistance(PT_dbox,index);
hypre_SetIndex(index,1,0,0);
xOffsetP = hypre_BoxOffsetDistance(PT_dbox,index);
/*-----------------------------------------------------------------
* Switch statement to direct control to apropriate BoxLoop depending
* on stencil size. Default is full 9-point.
*-----------------------------------------------------------------*/
switch (fine_stencil_size)
{
/*--------------------------------------------------------------
* Loop for symmetric 5-point fine grid operator; produces a
* symmetric 9-point coarse grid operator. We calculate only the
* lower triangular stencil entries: (southwest, south, southeast,
* west, and center).
*--------------------------------------------------------------*/
case 5:
hypre_BoxGetSize(cgrid_box, loop_size);
hypre_BoxLoop4Begin(loop_size,
PT_dbox, cstart, stridec, iP,
R_dbox, cstart, stridec, iR,
A_dbox, fstart, stridef, iA,
RAP_dbox, cstart, stridec, iAc);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,iP,iR,iA,iAc,iAm1,iAp1,iP1
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop4For(loopi, loopj, loopk, iP, iR, iA, iAc)
{
iAm1 = iA - yOffsetA;
iAp1 = iA + yOffsetA;
iP1 = iP - yOffsetP - xOffsetP;
rap_csw[iAc] = rb[iR] * a_cw[iAm1] * pa[iP1];
iP1 = iP - yOffsetP;
rap_cs[iAc] = rb[iR] * a_cc[iAm1] * pa[iP1]
+ rb[iR] * a_cs[iAm1]
+ a_cs[iA] * pa[iP1];
iP1 = iP - yOffsetP + xOffsetP;
rap_cse[iAc] = rb[iR] * a_ce[iAm1] * pa[iP1];
iP1 = iP - xOffsetP;
rap_cw[iAc] = a_cw[iA]
+ rb[iR] * a_cw[iAm1] * pb[iP1]
+ ra[iR] * a_cw[iAp1] * pa[iP1];
rap_cc[iAc] = a_cc[iA]
+ rb[iR] * a_cc[iAm1] * pb[iP]
+ ra[iR] * a_cc[iAp1] * pa[iP]
+ rb[iR] * a_cn[iAm1]
+ ra[iR] * a_cs[iAp1]
+ a_cs[iA] * pb[iP]
+ a_cn[iA] * pa[iP];
}
hypre_BoxLoop4End(iP, iR, iA, iAc);
break;
/*--------------------------------------------------------------
* Loop for symmetric 9-point fine grid operator; produces a
* symmetric 9-point coarse grid operator. We calculate only the
* lower triangular stencil entries: (southwest, south, southeast,
* west, and center).
*--------------------------------------------------------------*/
default:
hypre_BoxGetSize(cgrid_box, loop_size);
hypre_BoxLoop4Begin(loop_size,
PT_dbox, cstart, stridec, iP,
R_dbox, cstart, stridec, iR,
A_dbox, fstart, stridef, iA,
RAP_dbox, cstart, stridec, iAc);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,iP,iR,iA,iAc,iAm1,iAp1,iP1
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop4For(loopi, loopj, loopk, iP, iR, iA, iAc)
{
iAm1 = iA - yOffsetA;
iAp1 = iA + yOffsetA;
iP1 = iP - yOffsetP - xOffsetP;
rap_csw[iAc] = rb[iR] * a_cw[iAm1] * pa[iP1]
+ rb[iR] * a_csw[iAm1]
+ a_csw[iA] * pa[iP1];
iP1 = iP - yOffsetP;
rap_cs[iAc] = rb[iR] * a_cc[iAm1] * pa[iP1]
+ rb[iR] * a_cs[iAm1]
+ a_cs[iA] * pa[iP1];
iP1 = iP - yOffsetP + xOffsetP;
rap_cse[iAc] = rb[iR] * a_ce[iAm1] * pa[iP1]
+ rb[iR] * a_cse[iAm1]
+ a_cse[iA] * pa[iP1];
iP1 = iP - xOffsetP;
rap_cw[iAc] = a_cw[iA]
+ rb[iR] * a_cw[iAm1] * pb[iP1]
+ ra[iR] * a_cw[iAp1] * pa[iP1]
+ rb[iR] * a_cnw[iAm1]
+ ra[iR] * a_csw[iAp1]
+ a_csw[iA] * pb[iP1]
+ a_cnw[iA] * pa[iP1];
rap_cc[iAc] = a_cc[iA]
+ rb[iR] * a_cc[iAm1] * pb[iP]
+ ra[iR] * a_cc[iAp1] * pa[iP]
+ rb[iR] * a_cn[iAm1]
+ ra[iR] * a_cs[iAp1]
+ a_cs[iA] * pb[iP]
+ a_cn[iA] * pa[iP];
}
hypre_BoxLoop4End(iP, iR, iA, iAc);
break;
} /* end switch statement */
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_SemiRestrict( void *restrict_vdata,
hypre_StructMatrix *R,
hypre_StructVector *r,
hypre_StructVector *rc )
{
int ierr = 0;
hypre_SemiRestrictData *restrict_data = (hypre_SemiRestrictData *)restrict_vdata;
int R_stored_as_transpose;
hypre_ComputePkg *compute_pkg;
hypre_IndexRef cindex;
hypre_IndexRef stride;
hypre_StructGrid *fgrid;
int *fgrid_ids;
hypre_StructGrid *cgrid;
hypre_BoxArray *cgrid_boxes;
int *cgrid_ids;
hypre_CommHandle *comm_handle;
hypre_BoxArrayArray *compute_box_aa;
hypre_BoxArray *compute_box_a;
hypre_Box *compute_box;
hypre_Box *R_dbox;
hypre_Box *r_dbox;
hypre_Box *rc_dbox;
int Ri;
int ri;
int rci;
double *Rp0, *Rp1;
double *rp, *rp0, *rp1;
double *rcp;
hypre_Index loop_size;
hypre_IndexRef start;
hypre_Index startc;
hypre_Index stridec;
hypre_StructStencil *stencil;
hypre_Index *stencil_shape;
int compute_i, fi, ci, j;
int loopi, loopj, loopk;
/*-----------------------------------------------------------------------
* Initialize some things.
*-----------------------------------------------------------------------*/
hypre_BeginTiming(restrict_data -> time_index);
R_stored_as_transpose = (restrict_data -> R_stored_as_transpose);
compute_pkg = (restrict_data -> compute_pkg);
cindex = (restrict_data -> cindex);
stride = (restrict_data -> stride);
stencil = hypre_StructMatrixStencil(R);
stencil_shape = hypre_StructStencilShape(stencil);
hypre_SetIndex(stridec, 1, 1, 1);
/*--------------------------------------------------------------------
* Restrict the residual.
*--------------------------------------------------------------------*/
fgrid = hypre_StructVectorGrid(r);
fgrid_ids = hypre_StructGridIDs(fgrid);
cgrid = hypre_StructVectorGrid(rc);
cgrid_boxes = hypre_StructGridBoxes(cgrid);
cgrid_ids = hypre_StructGridIDs(cgrid);
for (compute_i = 0; compute_i < 2; compute_i++)
{
switch(compute_i)
{
case 0:
{
rp = hypre_StructVectorData(r);
hypre_InitializeIndtComputations(compute_pkg, rp, &comm_handle);
compute_box_aa = hypre_ComputePkgIndtBoxes(compute_pkg);
}
break;
case 1:
{
hypre_FinalizeIndtComputations(comm_handle);
compute_box_aa = hypre_ComputePkgDeptBoxes(compute_pkg);
}
break;
}
fi = 0;
hypre_ForBoxArrayI(ci, cgrid_boxes)
{
while (fgrid_ids[fi] != cgrid_ids[ci])
{
fi++;
}
compute_box_a = hypre_BoxArrayArrayBoxArray(compute_box_aa, fi);
R_dbox = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(R), fi);
r_dbox = hypre_BoxArrayBox(hypre_StructVectorDataSpace(r), fi);
rc_dbox = hypre_BoxArrayBox(hypre_StructVectorDataSpace(rc), ci);
if (R_stored_as_transpose)
{
Rp0 = hypre_StructMatrixBoxData(R, fi, 1) -
hypre_BoxOffsetDistance(R_dbox, stencil_shape[1]);
Rp1 = hypre_StructMatrixBoxData(R, fi, 0);
}
else
{
Rp0 = hypre_StructMatrixBoxData(R, fi, 0);
Rp1 = hypre_StructMatrixBoxData(R, fi, 1);
}
rp = hypre_StructVectorBoxData(r, fi);
rp0 = rp + hypre_BoxOffsetDistance(r_dbox, stencil_shape[0]);
rp1 = rp + hypre_BoxOffsetDistance(r_dbox, stencil_shape[1]);
rcp = hypre_StructVectorBoxData(rc, ci);
hypre_ForBoxI(j, compute_box_a)
{
compute_box = hypre_BoxArrayBox(compute_box_a, j);
start = hypre_BoxIMin(compute_box);
hypre_StructMapFineToCoarse(start, cindex, stride, startc);
hypre_BoxGetStrideSize(compute_box, stride, loop_size);
hypre_BoxLoop3Begin(loop_size,
R_dbox, startc, stridec, Ri,
r_dbox, start, stride, ri,
rc_dbox, startc, stridec, rci);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,Ri,ri,rci
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop3For(loopi, loopj, loopk, Ri, ri, rci)
{
rcp[rci] = rp[ri] + (Rp0[Ri] * rp0[ri] +
Rp1[Ri] * rp1[ri]);
}
hypre_BoxLoop3End(Ri, ri, rci);
}
}
