int
HYPRE_StructMatrixSetBoxValues( HYPRE_StructMatrix matrix,
int *ilower,
int *iupper,
int num_stencil_indices,
int *stencil_indices,
double *values )
{
hypre_Index new_ilower;
hypre_Index new_iupper;
hypre_Box *new_value_box;
int d;
int ierr = 0;
hypre_ClearIndex(new_ilower);
hypre_ClearIndex(new_iupper);
for (d = 0; d < hypre_StructGridDim(hypre_StructMatrixGrid(matrix)); d++)
{
hypre_IndexD(new_ilower, d) = ilower[d];
hypre_IndexD(new_iupper, d) = iupper[d];
}
new_value_box = hypre_BoxCreate();
hypre_BoxSetExtents(new_value_box, new_ilower, new_iupper);
ierr = hypre_StructMatrixSetBoxValues(matrix, new_value_box,
num_stencil_indices, stencil_indices,
values, 0);
hypre_BoxDestroy(new_value_box);
return (ierr);
}
hypre_StructMatrix *
hypre_StructMatrixCreate( MPI_Comm comm,
hypre_StructGrid *grid,
hypre_StructStencil *user_stencil )
{
hypre_StructMatrix *matrix;
int i;
matrix = hypre_CTAlloc(hypre_StructMatrix, 1);
hypre_StructMatrixComm(matrix) = comm;
hypre_StructGridRef(grid, &hypre_StructMatrixGrid(matrix));
hypre_StructMatrixUserStencil(matrix) =
hypre_StructStencilRef(user_stencil);
hypre_StructMatrixDataAlloced(matrix) = 1;
hypre_StructMatrixRefCount(matrix) = 1;
/* set defaults */
hypre_StructMatrixSymmetric(matrix) = 0;
for (i = 0; i < 6; i++)
hypre_StructMatrixNumGhost(matrix)[i] = 0;
return matrix;
}
int
hypre_StructMatrixDestroy( hypre_StructMatrix *matrix )
{
int i;
int ierr = 0;
if (matrix)
{
hypre_StructMatrixRefCount(matrix) --;
if (hypre_StructMatrixRefCount(matrix) == 0)
{
if (hypre_StructMatrixDataAlloced(matrix))
{
hypre_SharedTFree(hypre_StructMatrixData(matrix));
}
hypre_CommPkgDestroy(hypre_StructMatrixCommPkg(matrix));
hypre_ForBoxI(i, hypre_StructMatrixDataSpace(matrix))
hypre_TFree(hypre_StructMatrixDataIndices(matrix)[i]);
hypre_TFree(hypre_StructMatrixDataIndices(matrix));
hypre_BoxArrayDestroy(hypre_StructMatrixDataSpace(matrix));
hypre_TFree(hypre_StructMatrixSymmElements(matrix));
hypre_StructStencilDestroy(hypre_StructMatrixUserStencil(matrix));
hypre_StructStencilDestroy(hypre_StructMatrixStencil(matrix));
hypre_StructGridDestroy(hypre_StructMatrixGrid(matrix));
hypre_TFree(matrix);
}
}
return ierr;
}
HYPRE_Int
hypre_SMGResidualSetup( void *residual_vdata,
hypre_StructMatrix *A,
hypre_StructVector *x,
hypre_StructVector *b,
hypre_StructVector *r )
{
HYPRE_Int ierr = 0;
hypre_SMGResidualData *residual_data = residual_vdata;
hypre_IndexRef base_index = (residual_data -> base_index);
hypre_IndexRef base_stride = (residual_data -> base_stride);
hypre_StructGrid *grid;
hypre_StructStencil *stencil;
hypre_BoxArray *base_points;
hypre_ComputeInfo *compute_info;
hypre_ComputePkg *compute_pkg;
/*----------------------------------------------------------
* Set up base points and the compute package
*----------------------------------------------------------*/
grid = hypre_StructMatrixGrid(A);
stencil = hypre_StructMatrixStencil(A);
base_points = hypre_BoxArrayDuplicate(hypre_StructGridBoxes(grid));
hypre_ProjectBoxArray(base_points, base_index, base_stride);
hypre_CreateComputeInfo(grid, stencil, &compute_info);
hypre_ComputeInfoProjectComp(compute_info, base_index, base_stride);
hypre_ComputePkgCreate(compute_info, hypre_StructVectorDataSpace(x), 1,
grid, &compute_pkg);
/*----------------------------------------------------------
* Set up the residual data structure
*----------------------------------------------------------*/
(residual_data -> A) = hypre_StructMatrixRef(A);
(residual_data -> x) = hypre_StructVectorRef(x);
(residual_data -> b) = hypre_StructVectorRef(b);
(residual_data -> r) = hypre_StructVectorRef(r);
(residual_data -> base_points) = base_points;
(residual_data -> compute_pkg) = compute_pkg;
/*-----------------------------------------------------
* Compute flops
*-----------------------------------------------------*/
(residual_data -> flops) =
(hypre_StructMatrixGlobalSize(A) + hypre_StructVectorGlobalSize(x)) /
(hypre_IndexX(base_stride) *
hypre_IndexY(base_stride) *
hypre_IndexZ(base_stride) );
return ierr;
}
int
HYPRE_StructMatrixGetGrid( HYPRE_StructMatrix matrix, HYPRE_StructGrid *grid )
{
int ierr = 0;
*grid = hypre_StructMatrixGrid(matrix);
return ierr;
}
int
hypre_StructMatvecSetup( void *matvec_vdata,
hypre_StructMatrix *A,
hypre_StructVector *x )
{
int ierr = 0;
hypre_StructMatvecData *matvec_data = matvec_vdata;
hypre_StructGrid *grid;
hypre_StructStencil *stencil;
hypre_BoxArrayArray *send_boxes;
hypre_BoxArrayArray *recv_boxes;
int **send_processes;
int **recv_processes;
hypre_BoxArrayArray *indt_boxes;
hypre_BoxArrayArray *dept_boxes;
hypre_Index unit_stride;
hypre_ComputePkg *compute_pkg;
/*----------------------------------------------------------
* Set up the compute package
*----------------------------------------------------------*/
grid = hypre_StructMatrixGrid(A);
stencil = hypre_StructMatrixStencil(A);
hypre_CreateComputeInfo(grid, stencil,
&send_boxes, &recv_boxes,
&send_processes, &recv_processes,
&indt_boxes, &dept_boxes);
hypre_SetIndex(unit_stride, 1, 1, 1);
hypre_ComputePkgCreate(send_boxes, recv_boxes,
unit_stride, unit_stride,
send_processes, recv_processes,
indt_boxes, dept_boxes,
unit_stride,
grid, hypre_StructVectorDataSpace(x), 1,
&compute_pkg);
/*----------------------------------------------------------
* Set up the matvec data structure
*----------------------------------------------------------*/
(matvec_data -> A) = hypre_StructMatrixRef(A);
(matvec_data -> x) = hypre_StructVectorRef(x);
(matvec_data -> compute_pkg) = compute_pkg;
return ierr;
}
int
HYPRE_StructMatrixSetValues( HYPRE_StructMatrix matrix,
int *grid_index,
int num_stencil_indices,
int *stencil_indices,
double *values )
{
hypre_Index new_grid_index;
int d;
int ierr = 0;
hypre_ClearIndex(new_grid_index);
for (d = 0; d < hypre_StructGridDim(hypre_StructMatrixGrid(matrix)); d++)
{
hypre_IndexD(new_grid_index, d) = grid_index[d];
}
ierr = hypre_StructMatrixSetValues(matrix, new_grid_index,
num_stencil_indices, stencil_indices,
values, 0);
return (ierr);
}
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];
}
}
HYPRE_Int
hypre_PFMGSetup( void *pfmg_vdata,
hypre_StructMatrix *A,
hypre_StructVector *b,
hypre_StructVector *x )
{
hypre_PFMGData *pfmg_data = pfmg_vdata;
MPI_Comm comm = (pfmg_data -> comm);
HYPRE_Int relax_type = (pfmg_data -> relax_type);
HYPRE_Int usr_jacobi_weight= (pfmg_data -> usr_jacobi_weight);
double jacobi_weight = (pfmg_data -> jacobi_weight);
HYPRE_Int skip_relax = (pfmg_data -> skip_relax);
double *dxyz = (pfmg_data -> dxyz);
HYPRE_Int rap_type;
HYPRE_Int max_iter;
HYPRE_Int max_levels;
HYPRE_Int num_levels;
hypre_Index cindex;
hypre_Index findex;
hypre_Index stride;
hypre_Index coarsen;
HYPRE_Int *cdir_l;
HYPRE_Int *active_l;
hypre_StructGrid **grid_l;
hypre_StructGrid **P_grid_l;
double *data;
HYPRE_Int data_size = 0;
double *relax_weights;
double *mean, *deviation;
double alpha, beta;
hypre_StructMatrix **A_l;
hypre_StructMatrix **P_l;
hypre_StructMatrix **RT_l;
hypre_StructVector **b_l;
hypre_StructVector **x_l;
/* temp vectors */
hypre_StructVector **tx_l;
hypre_StructVector **r_l;
hypre_StructVector **e_l;
void **relax_data_l;
void **matvec_data_l;
void **restrict_data_l;
void **interp_data_l;
hypre_StructGrid *grid;
HYPRE_Int dim;
hypre_Box *cbox;
double min_dxyz;
HYPRE_Int cdir, periodic, cmaxsize;
HYPRE_Int d, l;
HYPRE_Int dxyz_flag;
HYPRE_Int b_num_ghost[] = {0, 0, 0, 0, 0, 0};
HYPRE_Int x_num_ghost[] = {1, 1, 1, 1, 1, 1};
HYPRE_Int ierr = 0;
#if DEBUG
char filename[255];
#endif
/*-----------------------------------------------------
* Set up coarse grids
*-----------------------------------------------------*/
grid = hypre_StructMatrixGrid(A);
dim = hypre_StructGridDim(grid);
/* Compute a new max_levels value based on the grid */
cbox = hypre_BoxDuplicate(hypre_StructGridBoundingBox(grid));
max_levels =
hypre_Log2(hypre_BoxSizeD(cbox, 0)) + 2 +
hypre_Log2(hypre_BoxSizeD(cbox, 1)) + 2 +
hypre_Log2(hypre_BoxSizeD(cbox, 2)) + 2;
if ((pfmg_data -> max_levels) > 0)
{
max_levels = hypre_min(max_levels, (pfmg_data -> max_levels));
}
(pfmg_data -> max_levels) = max_levels;
/* compute dxyz */
if ((dxyz[0] == 0) || (dxyz[1] == 0) || (dxyz[2] == 0))
{
mean = hypre_CTAlloc(double, 3);
deviation = hypre_CTAlloc(double, 3);
hypre_PFMGComputeDxyz(A, dxyz, mean, deviation);
dxyz_flag= 0;
for (d = 0; d < dim; d++)
{
deviation[d] -= mean[d]*mean[d];
/* square of coeff. of variation */
if (deviation[d]/(mean[d]*mean[d]) > .1)
{
dxyz_flag= 1;
break;
}
}
hypre_TFree(mean);
hypre_TFree(deviation);
}
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);
}
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);
}
int
hypre_SMGResidualSetup( void *residual_vdata,
hypre_StructMatrix *A,
hypre_StructVector *x,
hypre_StructVector *b,
hypre_StructVector *r )
{
int ierr = 0;
hypre_SMGResidualData *residual_data = residual_vdata;
hypre_IndexRef base_index = (residual_data -> base_index);
hypre_IndexRef base_stride = (residual_data -> base_stride);
hypre_Index unit_stride;
hypre_StructGrid *grid;
hypre_StructStencil *stencil;
hypre_BoxArrayArray *send_boxes;
hypre_BoxArrayArray *recv_boxes;
int **send_processes;
int **recv_processes;
hypre_BoxArrayArray *indt_boxes;
hypre_BoxArrayArray *dept_boxes;
hypre_BoxArray *base_points;
hypre_ComputePkg *compute_pkg;
/*----------------------------------------------------------
* Set up base points and the compute package
*----------------------------------------------------------*/
grid = hypre_StructMatrixGrid(A);
stencil = hypre_StructMatrixStencil(A);
hypre_SetIndex(unit_stride, 1, 1, 1);
base_points = hypre_BoxArrayDuplicate(hypre_StructGridBoxes(grid));
hypre_ProjectBoxArray(base_points, base_index, base_stride);
hypre_CreateComputeInfo(grid, stencil,
&send_boxes, &recv_boxes,
&send_processes, &recv_processes,
&indt_boxes, &dept_boxes);
hypre_ProjectBoxArrayArray(indt_boxes, base_index, base_stride);
hypre_ProjectBoxArrayArray(dept_boxes, base_index, base_stride);
hypre_ComputePkgCreate(send_boxes, recv_boxes,
unit_stride, unit_stride,
send_processes, recv_processes,
indt_boxes, dept_boxes,
base_stride, grid,
hypre_StructVectorDataSpace(x), 1,
&compute_pkg);
/*----------------------------------------------------------
* Set up the residual data structure
*----------------------------------------------------------*/
(residual_data -> A) = hypre_StructMatrixRef(A);
(residual_data -> x) = hypre_StructVectorRef(x);
(residual_data -> b) = hypre_StructVectorRef(b);
(residual_data -> r) = hypre_StructVectorRef(r);
(residual_data -> base_points) = base_points;
(residual_data -> compute_pkg) = compute_pkg;
/*-----------------------------------------------------
* Compute flops
*-----------------------------------------------------*/
(residual_data -> flops) =
(hypre_StructMatrixGlobalSize(A) + hypre_StructVectorGlobalSize(x)) /
(hypre_IndexX(base_stride) *
hypre_IndexY(base_stride) *
hypre_IndexZ(base_stride) );
return ierr;
}
int
hypre_PointRelaxSetup( void *relax_vdata,
hypre_StructMatrix *A,
hypre_StructVector *b,
hypre_StructVector *x )
{
hypre_PointRelaxData *relax_data = (hypre_PointRelaxData *)relax_vdata;
int num_pointsets = (relax_data -> num_pointsets);
int *pointset_sizes = (relax_data -> pointset_sizes);
hypre_Index *pointset_strides = (relax_data -> pointset_strides);
hypre_Index **pointset_indices = (relax_data -> pointset_indices);
hypre_StructVector *t;
int diag_rank;
hypre_ComputePkg **compute_pkgs;
hypre_Index unit_stride;
hypre_Index diag_index;
hypre_IndexRef stride;
hypre_IndexRef index;
hypre_StructGrid *grid;
hypre_StructStencil *stencil;
hypre_BoxArrayArray *send_boxes;
hypre_BoxArrayArray *recv_boxes;
int **send_processes;
int **recv_processes;
hypre_BoxArrayArray *indt_boxes;
hypre_BoxArrayArray *dept_boxes;
hypre_BoxArrayArray *orig_indt_boxes;
hypre_BoxArrayArray *orig_dept_boxes;
hypre_BoxArrayArray *box_aa;
hypre_BoxArray *box_a;
hypre_Box *box;
int box_aa_size;
int box_a_size;
hypre_BoxArrayArray *new_box_aa;
hypre_BoxArray *new_box_a;
hypre_Box *new_box;
double scale;
int frac;
int i, j, k, p, m, compute_i;
int ierr = 0;
/*----------------------------------------------------------
* Set up the temp vector
*----------------------------------------------------------*/
if ((relax_data -> t) == NULL)
{
t = hypre_StructVectorCreate(hypre_StructVectorComm(b),
hypre_StructVectorGrid(b));
hypre_StructVectorSetNumGhost(t, hypre_StructVectorNumGhost(b));
hypre_StructVectorInitialize(t);
hypre_StructVectorAssemble(t);
(relax_data -> t) = t;
}
/*----------------------------------------------------------
* Find the matrix diagonal
*----------------------------------------------------------*/
grid = hypre_StructMatrixGrid(A);
stencil = hypre_StructMatrixStencil(A);
hypre_SetIndex(diag_index, 0, 0, 0);
diag_rank = hypre_StructStencilElementRank(stencil, diag_index);
/*----------------------------------------------------------
* Set up the compute packages
*----------------------------------------------------------*/
hypre_SetIndex(unit_stride, 1, 1, 1);
compute_pkgs = hypre_CTAlloc(hypre_ComputePkg *, num_pointsets);
for (p = 0; p < num_pointsets; p++)
{
hypre_CreateComputeInfo(grid, stencil,
&send_boxes, &recv_boxes,
&send_processes, &recv_processes,
&orig_indt_boxes, &orig_dept_boxes);
stride = pointset_strides[p];
for (compute_i = 0; compute_i < 2; compute_i++)
{
switch(compute_i)
{
case 0:
box_aa = orig_indt_boxes;
break;
case 1:
box_aa = orig_dept_boxes;
break;
}
box_aa_size = hypre_BoxArrayArraySize(box_aa);
new_box_aa = hypre_BoxArrayArrayCreate(box_aa_size);
for (i = 0; i < box_aa_size; i++)
{
box_a = hypre_BoxArrayArrayBoxArray(box_aa, i);
box_a_size = hypre_BoxArraySize(box_a);
new_box_a = hypre_BoxArrayArrayBoxArray(new_box_aa, i);
hypre_BoxArraySetSize(new_box_a, box_a_size * pointset_sizes[p]);
k = 0;
for (m = 0; m < pointset_sizes[p]; m++)
{
index = pointset_indices[p][m];
for (j = 0; j < box_a_size; j++)
{
box = hypre_BoxArrayBox(box_a, j);
new_box = hypre_BoxArrayBox(new_box_a, k);
hypre_CopyBox(box, new_box);
hypre_ProjectBox(new_box, index, stride);
k++;
}
}
}
switch(compute_i)
{
case 0:
indt_boxes = new_box_aa;
break;
case 1:
dept_boxes = new_box_aa;
break;
}
}
hypre_ComputePkgCreate(send_boxes, recv_boxes,
unit_stride, unit_stride,
send_processes, recv_processes,
indt_boxes, dept_boxes,
stride, grid,
hypre_StructVectorDataSpace(x), 1,
&compute_pkgs[p]);
hypre_BoxArrayArrayDestroy(orig_indt_boxes);
hypre_BoxArrayArrayDestroy(orig_dept_boxes);
}
/*----------------------------------------------------------
* Set up the relax data structure
*----------------------------------------------------------*/
(relax_data -> A) = hypre_StructMatrixRef(A);
(relax_data -> x) = hypre_StructVectorRef(x);
(relax_data -> b) = hypre_StructVectorRef(b);
(relax_data -> diag_rank) = diag_rank;
(relax_data -> compute_pkgs) = compute_pkgs;
/*-----------------------------------------------------
* Compute flops
*-----------------------------------------------------*/
scale = 0.0;
for (p = 0; p < num_pointsets; p++)
{
stride = pointset_strides[p];
frac = hypre_IndexX(stride);
frac *= hypre_IndexY(stride);
frac *= hypre_IndexZ(stride);
scale += (pointset_sizes[p] / frac);
}
(relax_data -> flops) = scale * (hypre_StructMatrixGlobalSize(A) +
hypre_StructVectorGlobalSize(x));
return ierr;
}
HYPRE_Int
HYPRE_StructDiagScale( HYPRE_StructSolver solver,
HYPRE_StructMatrix HA,
HYPRE_StructVector Hy,
HYPRE_StructVector Hx )
{
hypre_StructMatrix *A = (hypre_StructMatrix *) HA;
hypre_StructVector *y = (hypre_StructVector *) Hy;
hypre_StructVector *x = (hypre_StructVector *) Hx;
hypre_BoxArray *boxes;
hypre_Box *box;
hypre_Box *A_data_box;
hypre_Box *y_data_box;
hypre_Box *x_data_box;
double *Ap;
double *yp;
double *xp;
HYPRE_Int Ai;
HYPRE_Int yi;
HYPRE_Int xi;
hypre_Index index;
hypre_IndexRef start;
hypre_Index stride;
hypre_Index loop_size;
HYPRE_Int i;
/* x = D^{-1} y */
hypre_SetIndex(stride, 1, 1, 1);
boxes = hypre_StructGridBoxes(hypre_StructMatrixGrid(A));
hypre_ForBoxI(i, boxes)
{
box = hypre_BoxArrayBox(boxes, i);
A_data_box = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(A), i);
x_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(x), i);
y_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(y), i);
hypre_SetIndex(index, 0, 0, 0);
Ap = hypre_StructMatrixExtractPointerByIndex(A, i, index);
xp = hypre_StructVectorBoxData(x, i);
yp = hypre_StructVectorBoxData(y, i);
start = hypre_BoxIMin(box);
hypre_BoxGetSize(box, loop_size);
hypre_BoxLoop3Begin(hypre_StructVectorDim(Hx), loop_size,
A_data_box, start, stride, Ai,
x_data_box, start, stride, xi,
y_data_box, start, stride, yi);
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(HYPRE_BOX_PRIVATE,yi,xi,Ai) HYPRE_SMP_SCHEDULE
#endif
hypre_BoxLoop3For(Ai, xi, yi)
{
xp[xi] = yp[yi] / Ap[Ai];
}
hypre_BoxLoop3End(Ai, xi, yi);
}
int
HYPRE_StructDiagScale( HYPRE_StructSolver solver,
HYPRE_StructMatrix HA,
HYPRE_StructVector Hy,
HYPRE_StructVector Hx )
{
hypre_StructMatrix *A = (hypre_StructMatrix *) HA;
hypre_StructVector *y = (hypre_StructVector *) Hy;
hypre_StructVector *x = (hypre_StructVector *) Hx;
hypre_BoxArray *boxes;
hypre_Box *box;
hypre_Box *A_data_box;
hypre_Box *y_data_box;
hypre_Box *x_data_box;
double *Ap;
double *yp;
double *xp;
int Ai;
int yi;
int xi;
hypre_Index index;
hypre_IndexRef start;
hypre_Index stride;
hypre_Index loop_size;
int i;
int loopi, loopj, loopk;
int ierr = 0;
/* x = D^{-1} y */
hypre_SetIndex(stride, 1, 1, 1);
boxes = hypre_StructGridBoxes(hypre_StructMatrixGrid(A));
hypre_ForBoxI(i, boxes)
{
box = hypre_BoxArrayBox(boxes, i);
A_data_box = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(A), i);
x_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(x), i);
y_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(y), i);
hypre_SetIndex(index, 0, 0, 0);
Ap = hypre_StructMatrixExtractPointerByIndex(A, i, index);
xp = hypre_StructVectorBoxData(x, i);
yp = hypre_StructVectorBoxData(y, i);
start = hypre_BoxIMin(box);
hypre_BoxGetSize(box, loop_size);
hypre_BoxLoop3Begin(loop_size,
A_data_box, start, stride, Ai,
x_data_box, start, stride, xi,
y_data_box, start, stride, yi);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,yi,xi,Ai
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop3For(loopi, loopj, loopk, Ai, xi, yi)
{
xp[xi] = yp[yi] / Ap[Ai];
}
hypre_BoxLoop3End(Ai, xi, yi);
}
HYPRE_Int
hypre_StructInterpAssemble( hypre_StructMatrix *A,
hypre_StructMatrix *P,
HYPRE_Int P_stored_as_transpose,
HYPRE_Int cdir,
hypre_Index index,
hypre_Index stride )
{
hypre_StructGrid *grid = hypre_StructMatrixGrid(A);
hypre_BoxArrayArray *box_aa;
hypre_BoxArray *box_a;
hypre_Box *box;
hypre_CommInfo *comm_info;
hypre_CommPkg *comm_pkg;
hypre_CommHandle *comm_handle;
HYPRE_Int num_ghost[] = {0, 0, 0, 0, 0, 0};
HYPRE_Int i, j, s, dim;
if (hypre_StructMatrixConstantCoefficient(P) != 0)
{
return hypre_error_flag;
}
/* set num_ghost */
dim = hypre_StructGridDim(grid);
for (j = 0; j < dim; j++)
{
num_ghost[2*j] = 1;
num_ghost[2*j+1] = 1;
}
if (P_stored_as_transpose)
{
num_ghost[2*cdir] = 2;
num_ghost[2*cdir+1] = 2;
}
/* comm_info <-- From fine grid grown by num_ghost */
hypre_CreateCommInfoFromNumGhost(grid, num_ghost, &comm_info);
/* Project and map comm_info onto coarsened index space */
hypre_CommInfoProjectSend(comm_info, index, stride);
hypre_CommInfoProjectRecv(comm_info, index, stride);
for (s = 0; s < 3; s++)
{
switch(s)
{
case 0:
box_aa = hypre_CommInfoSendBoxes(comm_info);
hypre_SetIndex(hypre_CommInfoSendStride(comm_info), 1, 1, 1);
break;
case 1:
box_aa = hypre_CommInfoRecvBoxes(comm_info);
hypre_SetIndex(hypre_CommInfoRecvStride(comm_info), 1, 1, 1);
break;
case 2:
box_aa = hypre_CommInfoSendRBoxes(comm_info);
break;
}
hypre_ForBoxArrayI(j, box_aa)
{
box_a = hypre_BoxArrayArrayBoxArray(box_aa, j);
hypre_ForBoxI(i, box_a)
{
box = hypre_BoxArrayBox(box_a, i);
hypre_StructMapFineToCoarse(hypre_BoxIMin(box), index, stride,
hypre_BoxIMin(box));
hypre_StructMapFineToCoarse(hypre_BoxIMax(box), index, stride,
hypre_BoxIMax(box));
}
}
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_StructMatrix *
hypre_StructMatrixCreateMask( hypre_StructMatrix *matrix,
int num_stencil_indices,
int *stencil_indices )
{
hypre_StructMatrix *mask;
hypre_StructStencil *stencil;
hypre_Index *stencil_shape;
int stencil_size;
hypre_Index *mask_stencil_shape;
int mask_stencil_size;
hypre_BoxArray *data_space;
int **data_indices;
int **mask_data_indices;
int i, j;
stencil = hypre_StructMatrixStencil(matrix);
stencil_shape = hypre_StructStencilShape(stencil);
stencil_size = hypre_StructStencilSize(stencil);
mask = hypre_CTAlloc(hypre_StructMatrix, 1);
hypre_StructMatrixComm(mask) = hypre_StructMatrixComm(matrix);
hypre_StructGridRef(hypre_StructMatrixGrid(matrix),
&hypre_StructMatrixGrid(mask));
hypre_StructMatrixUserStencil(mask) =
hypre_StructStencilRef(hypre_StructMatrixUserStencil(matrix));
mask_stencil_size = num_stencil_indices;
mask_stencil_shape = hypre_CTAlloc(hypre_Index, num_stencil_indices);
for (i = 0; i < num_stencil_indices; i++)
{
hypre_CopyIndex(stencil_shape[stencil_indices[i]],
mask_stencil_shape[i]);
}
hypre_StructMatrixStencil(mask) =
hypre_StructStencilCreate(hypre_StructStencilDim(stencil),
mask_stencil_size,
mask_stencil_shape);
hypre_StructMatrixNumValues(mask) = hypre_StructMatrixNumValues(matrix);
hypre_StructMatrixDataSpace(mask) =
hypre_BoxArrayDuplicate(hypre_StructMatrixDataSpace(matrix));
hypre_StructMatrixData(mask) = hypre_StructMatrixData(matrix);
hypre_StructMatrixDataAlloced(mask) = 0;
hypre_StructMatrixDataSize(mask) = hypre_StructMatrixDataSize(matrix);
data_space = hypre_StructMatrixDataSpace(matrix);
data_indices = hypre_StructMatrixDataIndices(matrix);
mask_data_indices = hypre_CTAlloc(int *, hypre_BoxArraySize(data_space));
hypre_ForBoxI(i, data_space)
{
mask_data_indices[i] = hypre_TAlloc(int, num_stencil_indices);
for (j = 0; j < num_stencil_indices; j++)
{
mask_data_indices[i][j] = data_indices[i][stencil_indices[j]];
}
}
