HYPRE_Int
hypre_BoxBoundaryIntersect( hypre_Box *box,
hypre_StructGrid *grid,
HYPRE_Int d,
HYPRE_Int dir,
hypre_BoxArray *boundary )
{
HYPRE_Int ndim = hypre_BoxNDim(box);
hypre_BoxManager *boxman;
hypre_BoxManEntry **entries;
hypre_BoxArray *int_boxes, *tmp_boxes;
hypre_Box *bbox, *ibox;
HYPRE_Int nentries, i;
/* set bbox to the box surface of interest */
hypre_BoxArraySetSize(boundary, 1);
bbox = hypre_BoxArrayBox(boundary, 0);
hypre_CopyBox(box, bbox);
if (dir > 0)
{
hypre_BoxIMinD(bbox, d) = hypre_BoxIMaxD(bbox, d);
}
else if (dir < 0)
{
hypre_BoxIMaxD(bbox, d) = hypre_BoxIMinD(bbox, d);
}
/* temporarily shift bbox in direction dir and intersect with the grid */
hypre_BoxIMinD(bbox, d) += dir;
hypre_BoxIMaxD(bbox, d) += dir;
boxman = hypre_StructGridBoxMan(grid);
hypre_BoxManIntersect(boxman, hypre_BoxIMin(bbox), hypre_BoxIMax(bbox),
&entries, &nentries);
hypre_BoxIMinD(bbox, d) -= dir;
hypre_BoxIMaxD(bbox, d) -= dir;
/* shift intersected boxes in direction -dir and subtract from bbox */
int_boxes = hypre_BoxArrayCreate(nentries, ndim);
tmp_boxes = hypre_BoxArrayCreate(0, ndim);
for (i = 0; i < nentries; i++)
{
ibox = hypre_BoxArrayBox(int_boxes, i);
hypre_BoxManEntryGetExtents(
entries[i], hypre_BoxIMin(ibox), hypre_BoxIMax(ibox));
hypre_BoxIMinD(ibox, d) -= dir;
hypre_BoxIMaxD(ibox, d) -= dir;
}
hypre_SubtractBoxArrays(boundary, int_boxes, tmp_boxes);
hypre_BoxArrayDestroy(int_boxes);
hypre_BoxArrayDestroy(tmp_boxes);
hypre_TFree(entries);
return hypre_error_flag;
}
HYPRE_Int
AddValuesVector( hypre_StructGrid *grid,
hypre_StructVector *vector,
HYPRE_Real value )
{
HYPRE_Int ierr = 0;
hypre_BoxArray *gridboxes;
HYPRE_Int i,ib;
hypre_IndexRef ilower;
hypre_IndexRef iupper;
hypre_Box *box;
HYPRE_Real *values;
HYPRE_Int volume,dim;
gridboxes = hypre_StructGridBoxes(grid);
dim = hypre_StructGridNDim(grid);
ib=0;
hypre_ForBoxI(ib, gridboxes)
{
box = hypre_BoxArrayBox(gridboxes, ib);
volume = hypre_BoxVolume(box);
values = hypre_CTAlloc(HYPRE_Real, volume);
for (i = 0; i < volume; i++)
{
values[i] = value;
}
ilower = hypre_BoxIMin(box);
iupper = hypre_BoxIMax(box);
HYPRE_StructVectorSetBoxValues(vector, ilower, iupper, values);
hypre_TFree(values);
}
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;
}
int
hypre_BoxSetExtents( hypre_Box *box,
hypre_Index imin,
hypre_Index imax )
{
int ierr = 0;
hypre_CopyIndex(imin, hypre_BoxIMin(box));
hypre_CopyIndex(imax, hypre_BoxIMax(box));
return ierr;
}
int
hypre_StructCopy( hypre_StructVector *x,
hypre_StructVector *y )
{
int ierr = 0;
hypre_Box *x_data_box;
hypre_Box *y_data_box;
int xi;
int yi;
double *xp;
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);
x_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(x), i);
y_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(y), i);
xp = hypre_StructVectorBoxData(x, i);
yp = hypre_StructVectorBoxData(y, i);
hypre_BoxGetSize(box, loop_size);
hypre_BoxLoop2Begin(loop_size,
x_data_box, start, unit_stride, xi,
y_data_box, start, unit_stride, yi);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,xi,yi
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop2For(loopi, loopj, loopk, xi, yi)
{
yp[yi] = xp[xi];
}
hypre_BoxLoop2End(xi, yi);
}
int
hypre_SMGAxpy( double alpha,
hypre_StructVector *x,
hypre_StructVector *y,
hypre_Index base_index,
hypre_Index base_stride )
{
int ierr = 0;
hypre_Box *x_data_box;
hypre_Box *y_data_box;
int xi;
int yi;
double *xp;
double *yp;
hypre_BoxArray *boxes;
hypre_Box *box;
hypre_Index loop_size;
hypre_IndexRef start;
int i;
int loopi, loopj, loopk;
box = hypre_BoxCreate();
boxes = hypre_StructGridBoxes(hypre_StructVectorGrid(y));
hypre_ForBoxI(i, boxes)
{
hypre_CopyBox(hypre_BoxArrayBox(boxes, i), box);
hypre_ProjectBox(box, base_index, base_stride);
start = hypre_BoxIMin(box);
x_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(x), i);
y_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(y), i);
xp = hypre_StructVectorBoxData(x, i);
yp = hypre_StructVectorBoxData(y, i);
hypre_BoxGetStrideSize(box, base_stride, loop_size);
hypre_BoxLoop2Begin(loop_size,
x_data_box, start, base_stride, xi,
y_data_box, start, base_stride, yi);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,xi,yi
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop2For(loopi, loopj, loopk, xi, yi)
{
yp[yi] += alpha * xp[xi];
}
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_SStructGraphFindBoxEndpt(hypre_SStructGraph *graph,
int part,
int var,
int proc,
int endpt,
int boxi)
{
hypre_SStructGrid *grid = hypre_SStructGraphGrid(graph);
int type = hypre_SStructGraphObjectType(graph);
hypre_BoxMap *map;
hypre_BoxMapEntry *map_entry;
hypre_StructGrid *sgrid;
hypre_Box *box;
int rank;
HYPRE_BigInt big_rank;
map= hypre_SStructGridMap(grid, part, var);
hypre_BoxMapFindBoxProcEntry(map, boxi, proc, &map_entry);
sgrid= hypre_SStructPGridSGrid(hypre_SStructGridPGrid(grid, part), var);
box = hypre_StructGridBox(sgrid, boxi);
/* get the global rank of the endpt corner of box boxi */
if (endpt < 1)
{
hypre_SStructMapEntryGetGlobalRank(map_entry, hypre_BoxIMin(box), &big_rank,
type);
}
else
{
hypre_SStructMapEntryGetGlobalRank(map_entry, hypre_BoxIMax(box), &big_rank,
type);
}
if (type == HYPRE_SSTRUCT || type == HYPRE_STRUCT)
{
rank = (int)(big_rank - hypre_SStructGridGhstartRank(grid));
}
if (type == HYPRE_PARCSR)
{
rank = (int)(big_rank - hypre_SStructGridStartRank(grid));
}
return rank;
}
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);
}
int
hypre_SStructPMatrixSetBoxValues( hypre_SStructPMatrix *pmatrix,
hypre_Index ilower,
hypre_Index iupper,
int var,
int nentries,
int *entries,
double *values,
int add_to )
{
hypre_SStructStencil *stencil = hypre_SStructPMatrixStencil(pmatrix, var);
int *smap = hypre_SStructPMatrixSMap(pmatrix, var);
int *vars = hypre_SStructStencilVars(stencil);
hypre_StructMatrix *smatrix;
hypre_Box *box;
int *sentries;
int i;
smatrix = hypre_SStructPMatrixSMatrix(pmatrix, var, vars[entries[0]]);
box = hypre_BoxCreate();
hypre_CopyIndex(ilower, hypre_BoxIMin(box));
hypre_CopyIndex(iupper, hypre_BoxIMax(box));
sentries = hypre_SStructPMatrixSEntries(pmatrix);
for (i = 0; i < nentries; i++)
{
sentries[i] = smap[entries[i]];
}
hypre_StructMatrixSetBoxValues(smatrix, box, nentries, sentries, values, add_to);
hypre_BoxDestroy(box);
return hypre_error_flag;
}
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_AMR_CFCoarsen( hypre_SStructMatrix * A,
hypre_SStructMatrix * fac_A,
hypre_Index refine_factors,
HYPRE_Int level )
{
MPI_Comm comm = hypre_SStructMatrixComm(A);
hypre_SStructGraph *graph = hypre_SStructMatrixGraph(A);
HYPRE_Int graph_type = hypre_SStructGraphObjectType(graph);
hypre_SStructGrid *grid = hypre_SStructGraphGrid(graph);
HYPRE_Int nUventries = hypre_SStructGraphNUVEntries(graph);
HYPRE_IJMatrix ij_A = hypre_SStructMatrixIJMatrix(A);
HYPRE_Int matrix_type= hypre_SStructMatrixObjectType(A);
HYPRE_Int ndim = hypre_SStructMatrixNDim(A);
hypre_SStructPMatrix *A_pmatrix;
hypre_StructMatrix *smatrix_var;
hypre_StructStencil *stencils;
HYPRE_Int stencil_size;
hypre_Index stencil_shape_i;
hypre_Index loop_size;
hypre_Box refined_box;
double **a_ptrs;
hypre_Box *A_dbox;
HYPRE_Int part_crse= level-1;
HYPRE_Int part_fine= level;
hypre_BoxManager *fboxman;
hypre_BoxManEntry **boxman_entries, *boxman_entry;
HYPRE_Int nboxman_entries;
hypre_Box boxman_entry_box;
hypre_BoxArrayArray ***fgrid_cinterface_extents;
hypre_StructGrid *cgrid;
hypre_BoxArray *cgrid_boxes;
hypre_Box *cgrid_box;
hypre_Index node_extents;
hypre_Index stridec, stridef;
hypre_BoxArrayArray *cinterface_arrays;
hypre_BoxArray *cinterface_array;
hypre_Box *fgrid_cinterface;
HYPRE_Int centre;
HYPRE_Int ci, fi, boxi;
HYPRE_Int max_stencil_size= 27;
HYPRE_Int false= 0;
HYPRE_Int true = 1;
HYPRE_Int found;
HYPRE_Int *stencil_ranks, *rank_stencils;
HYPRE_Int rank, startrank;
double *vals;
HYPRE_Int i, j, iA;
HYPRE_Int nvars, var1;
hypre_Index lindex, zero_index;
hypre_Index index1, index2;
hypre_Index index_temp;
hypre_SStructUVEntry *Uventry;
HYPRE_Int nUentries, cnt1;
HYPRE_Int box_array_size;
HYPRE_Int *ncols, *rows, *cols;
HYPRE_Int *temp1, *temp2;
HYPRE_Int myid;
hypre_MPI_Comm_rank(comm, &myid);
hypre_SetIndex(zero_index, 0, 0, 0);
/*--------------------------------------------------------------------------
* Task: Coarsen the CF interface connections of A into fac_A so that
* fac_A will have the stencil coefficients extending into a coarsened
* fbox. The centre coefficient is constructed to preserve the row sum.
*--------------------------------------------------------------------------*/
if (graph_type == HYPRE_SSTRUCT)
{
startrank = hypre_SStructGridGhstartRank(grid);
}
if (graph_type == HYPRE_PARCSR)
{
startrank = hypre_SStructGridStartRank(grid);
}
/*--------------------------------------------------------------------------
* Fine grid strides by the refinement factors.
*--------------------------------------------------------------------------*/
hypre_SetIndex(stridec, 1, 1, 1);
for (i= 0; i< ndim; i++)
{
stridef[i]= refine_factors[i];
}
for (i= ndim; i< 3; i++)
{
stridef[i]= 1;
}
/*--------------------------------------------------------------------------
* Determine the c/f interface index boxes: fgrid_cinterface_extents.
* These are between fpart= level and cpart= (level-1). The
* fgrid_cinterface_extents are indexed by cboxes, but fboxes that
* abutt a given cbox must be considered. Moreover, for each fbox,
* we can have a c/f interface from a number of different stencil
* directions- i.e., we have a boxarrayarray for each cbox, each
* fbox leading to a boxarray.
*
* Algo.: For each cbox:
* 1) refine & stretch by a unit in each dimension.
* 2) boxman_intersect with the fgrid boxman to get all fboxes contained
* or abutting this cbox.
* 3) get the fgrid_cinterface_extents for each of these fboxes.
*
* fgrid_cinterface_extents[var1][ci]
*--------------------------------------------------------------------------*/
A_pmatrix= hypre_SStructMatrixPMatrix(fac_A, part_crse);
nvars = hypre_SStructPMatrixNVars(A_pmatrix);
fgrid_cinterface_extents= hypre_TAlloc(hypre_BoxArrayArray **, nvars);
for (var1= 0; var1< nvars; var1++)
{
fboxman= hypre_SStructGridBoxManager(grid, part_fine, var1);
stencils= hypre_SStructPMatrixSStencil(A_pmatrix, var1, var1);
cgrid= hypre_SStructPGridSGrid(hypre_SStructPMatrixPGrid(A_pmatrix), var1);
cgrid_boxes= hypre_StructGridBoxes(cgrid);
fgrid_cinterface_extents[var1]= hypre_TAlloc(hypre_BoxArrayArray *,
hypre_BoxArraySize(cgrid_boxes));
hypre_ForBoxI(ci, cgrid_boxes)
{
cgrid_box= hypre_BoxArrayBox(cgrid_boxes, ci);
hypre_StructMapCoarseToFine(hypre_BoxIMin(cgrid_box), zero_index,
refine_factors, hypre_BoxIMin(&refined_box));
hypre_SetIndex(index1, refine_factors[0]-1, refine_factors[1]-1,
refine_factors[2]-1);
hypre_StructMapCoarseToFine(hypre_BoxIMax(cgrid_box), index1,
refine_factors, hypre_BoxIMax(&refined_box));
/*------------------------------------------------------------------------
* Stretch the refined_box so that a BoxManIntersect will get abutting
* fboxes.
*------------------------------------------------------------------------*/
for (i= 0; i< ndim; i++)
{
hypre_BoxIMin(&refined_box)[i]-= 1;
hypre_BoxIMax(&refined_box)[i]+= 1;
}
hypre_BoxManIntersect(fboxman, hypre_BoxIMin(&refined_box),
hypre_BoxIMax(&refined_box), &boxman_entries,
&nboxman_entries);
fgrid_cinterface_extents[var1][ci]= hypre_BoxArrayArrayCreate(nboxman_entries);
/*------------------------------------------------------------------------
* Get the fgrid_cinterface_extents using var1-var1 stencil (only like-
* variables couple).
*------------------------------------------------------------------------*/
if (stencils != NULL)
{
for (i= 0; i< nboxman_entries; i++)
{
hypre_BoxManEntryGetExtents(boxman_entries[i],
hypre_BoxIMin(&boxman_entry_box),
hypre_BoxIMax(&boxman_entry_box));
hypre_CFInterfaceExtents2(&boxman_entry_box, cgrid_box, stencils, refine_factors,
hypre_BoxArrayArrayBoxArray(fgrid_cinterface_extents[var1][ci], i) );
}
}
hypre_TFree(boxman_entries);
} /* hypre_ForBoxI(ci, cgrid_boxes) */
} /* for (var1= 0; var1< nvars; var1++) */
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_SMGResidual( 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_stride = (residual_data -> base_stride);
hypre_BoxArray *base_points = (residual_data -> base_points);
hypre_ComputePkg *compute_pkg = (residual_data -> 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 *b_data_box;
hypre_Box *r_data_box;
int Ai;
int xi;
int bi;
int ri;
double *Ap;
double *xp;
double *bp;
double *rp;
hypre_Index loop_size;
hypre_IndexRef start;
hypre_StructStencil *stencil;
hypre_Index *stencil_shape;
int stencil_size;
int compute_i, i, j, si;
int loopi, loopj, loopk;
hypre_BeginTiming(residual_data -> time_index);
/*-----------------------------------------------------------------------
* Compute residual r = b - Ax
*-----------------------------------------------------------------------*/
stencil = hypre_StructMatrixStencil(A);
stencil_shape = hypre_StructStencilShape(stencil);
stencil_size = hypre_StructStencilSize(stencil);
for (compute_i = 0; compute_i < 2; compute_i++)
{
switch(compute_i)
{
case 0:
{
xp = hypre_StructVectorData(x);
hypre_InitializeIndtComputations(compute_pkg, xp, &comm_handle);
compute_box_aa = hypre_ComputePkgIndtBoxes(compute_pkg);
/*----------------------------------------
* Copy b into r
*----------------------------------------*/
compute_box_a = base_points;
hypre_ForBoxI(i, compute_box_a)
{
compute_box = hypre_BoxArrayBox(compute_box_a, i);
start = hypre_BoxIMin(compute_box);
b_data_box =
hypre_BoxArrayBox(hypre_StructVectorDataSpace(b), i);
r_data_box =
hypre_BoxArrayBox(hypre_StructVectorDataSpace(r), i);
bp = hypre_StructVectorBoxData(b, i);
rp = hypre_StructVectorBoxData(r, i);
hypre_BoxGetStrideSize(compute_box, base_stride, loop_size);
hypre_BoxLoop2Begin(loop_size,
b_data_box, start, base_stride, bi,
r_data_box, start, base_stride, ri);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,bi,ri
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop2For(loopi, loopj, loopk, bi, ri)
{
rp[ri] = bp[bi];
}
hypre_BoxLoop2End(bi, ri);
}
}
break;
case 1:
{
hypre_FinalizeIndtComputations(comm_handle);
compute_box_aa = hypre_ComputePkgDeptBoxes(compute_pkg);
}
break;
}
/*--------------------------------------------------------------------
* Compute r -= A*x
*--------------------------------------------------------------------*/
hypre_ForBoxArrayI(i, compute_box_aa)
{
compute_box_a = hypre_BoxArrayArrayBoxArray(compute_box_aa, i);
A_data_box = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(A), i);
x_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(x), i);
r_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(r), i);
rp = hypre_StructVectorBoxData(r, i);
hypre_ForBoxI(j, compute_box_a)
{
compute_box = hypre_BoxArrayBox(compute_box_a, j);
start = hypre_BoxIMin(compute_box);
for (si = 0; si < stencil_size; si++)
{
Ap = hypre_StructMatrixBoxData(A, i, si);
xp = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[si]);
hypre_BoxGetStrideSize(compute_box, base_stride,
loop_size);
hypre_BoxLoop3Begin(loop_size,
A_data_box, start, base_stride, Ai,
x_data_box, start, base_stride, xi,
r_data_box, start, base_stride, ri);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,Ai,xi,ri
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop3For(loopi, loopj, loopk, Ai, xi, ri)
{
rp[ri] -= Ap[Ai] * xp[xi];
}
hypre_BoxLoop3End(Ai, xi, ri);
}
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_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_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 */
int
hypre_PointRelax( void *relax_vdata,
hypre_StructMatrix *A,
hypre_StructVector *b,
hypre_StructVector *x )
{
hypre_PointRelaxData *relax_data = (hypre_PointRelaxData *)relax_vdata;
int max_iter = (relax_data -> max_iter);
int zero_guess = (relax_data -> zero_guess);
double weight = (relax_data -> weight);
int num_pointsets = (relax_data -> num_pointsets);
int *pointset_ranks = (relax_data -> pointset_ranks);
hypre_Index *pointset_strides = (relax_data -> pointset_strides);
hypre_StructVector *t = (relax_data -> t);
int diag_rank = (relax_data -> diag_rank);
hypre_ComputePkg **compute_pkgs = (relax_data -> compute_pkgs);
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 *b_data_box;
hypre_Box *x_data_box;
hypre_Box *t_data_box;
int Ai;
int bi;
int xi;
int ti;
double *Ap;
double *bp;
double *xp;
double *tp;
hypre_IndexRef stride;
hypre_IndexRef start;
hypre_Index loop_size;
hypre_StructStencil *stencil;
hypre_Index *stencil_shape;
int stencil_size;
int iter, p, compute_i, i, j, si;
int loopi, loopj, loopk;
int pointset;
int ierr = 0;
/*----------------------------------------------------------
* Initialize some things and deal with special cases
*----------------------------------------------------------*/
hypre_BeginTiming(relax_data -> time_index);
hypre_StructMatrixDestroy(relax_data -> A);
hypre_StructVectorDestroy(relax_data -> b);
hypre_StructVectorDestroy(relax_data -> x);
(relax_data -> A) = hypre_StructMatrixRef(A);
(relax_data -> x) = hypre_StructVectorRef(x);
(relax_data -> b) = hypre_StructVectorRef(b);
(relax_data -> num_iterations) = 0;
/* if max_iter is zero, return */
if (max_iter == 0)
{
/* if using a zero initial guess, return zero */
if (zero_guess)
{
hypre_StructVectorSetConstantValues(x, 0.0);
}
hypre_EndTiming(relax_data -> time_index);
return ierr;
}
stencil = hypre_StructMatrixStencil(A);
stencil_shape = hypre_StructStencilShape(stencil);
stencil_size = hypre_StructStencilSize(stencil);
/*----------------------------------------------------------
* Do zero_guess iteration
*----------------------------------------------------------*/
p = 0;
iter = 0;
if (zero_guess)
{
pointset = pointset_ranks[p];
compute_pkg = compute_pkgs[pointset];
stride = pointset_strides[pointset];
for (compute_i = 0; compute_i < 2; compute_i++)
{
switch(compute_i)
{
case 0:
{
compute_box_aa = hypre_ComputePkgIndtBoxes(compute_pkg);
}
break;
case 1:
{
compute_box_aa = hypre_ComputePkgDeptBoxes(compute_pkg);
}
break;
}
hypre_ForBoxArrayI(i, compute_box_aa)
{
compute_box_a = hypre_BoxArrayArrayBoxArray(compute_box_aa, i);
A_data_box =
hypre_BoxArrayBox(hypre_StructMatrixDataSpace(A), i);
b_data_box =
hypre_BoxArrayBox(hypre_StructVectorDataSpace(b), i);
x_data_box =
hypre_BoxArrayBox(hypre_StructVectorDataSpace(x), i);
Ap = hypre_StructMatrixBoxData(A, i, diag_rank);
bp = hypre_StructVectorBoxData(b, i);
xp = hypre_StructVectorBoxData(x, i);
hypre_ForBoxI(j, compute_box_a)
{
compute_box = hypre_BoxArrayBox(compute_box_a, j);
start = hypre_BoxIMin(compute_box);
hypre_BoxGetStrideSize(compute_box, stride, loop_size);
hypre_BoxLoop3Begin(loop_size,
A_data_box, start, stride, Ai,
b_data_box, start, stride, bi,
x_data_box, start, stride, xi);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,Ai,bi,xi
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop3For(loopi, loopj, loopk, Ai, bi, xi)
{
xp[xi] = bp[bi] / Ap[Ai];
}
hypre_BoxLoop3End(Ai, bi, xi);
}
}
}
double
hypre_StructOverlapInnerProd( hypre_StructVector *x,
hypre_StructVector *y )
{
double final_innerprod_result;
double local_result, overlap_result;
double process_result;
hypre_Box *x_data_box;
hypre_Box *y_data_box;
hypre_BoxArray *overlap_boxes;
HYPRE_Int xi;
HYPRE_Int yi;
double *xp;
double *yp;
hypre_BoxArray *boxes;
hypre_Box *boxi, *boxj, intersect_box;
hypre_StructGrid *grid= hypre_StructVectorGrid(y);
hypre_BoxManager *boxman = hypre_StructGridBoxMan(grid);
hypre_BoxArray *neighbor_boxes;
HYPRE_Int *neighbors_procs= NULL;
hypre_BoxArray *selected_nboxes;
hypre_BoxArray *tmp_box_array, *tmp2_box_array;
hypre_Index loop_size;
hypre_IndexRef start;
hypre_Index unit_stride;
HYPRE_Int i, j;
HYPRE_Int myid;
HYPRE_Int boxarray_size;
HYPRE_Int loopi, loopj, loopk;
#ifdef HYPRE_USE_PTHREADS
HYPRE_Int threadid = hypre_GetThreadID();
#endif
local_result = 0.0;
process_result = 0.0;
hypre_SetIndex(unit_stride, 1, 1, 1);
hypre_MPI_Comm_rank(hypre_StructVectorComm(y), &myid);
/*-----------------------------------------------------------------------
* Determine the overlapped boxes on this local processor.
*-----------------------------------------------------------------------*/
boxes = hypre_StructGridBoxes(hypre_StructVectorGrid(y));
boxarray_size= hypre_BoxArraySize(boxes);
/*-----------------------------------------------------------------------
* To compute the inner product over this local processor, given a box,
* the inner product between x & y is computed over the whole box and
* over any overlapping between this box and overlap_boxes. The latter
* result is subtracted from the former. Overlapping between more than
* two boxes are handled.
*-----------------------------------------------------------------------*/
hypre_ForBoxI(i, boxes)
{
boxi = hypre_BoxArrayBox(boxes, i);
start = hypre_BoxIMin(boxi);
x_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(x), i);
y_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(y), i);
xp = hypre_StructVectorBoxData(x, i);
yp = hypre_StructVectorBoxData(y, i);
hypre_BoxGetSize(boxi, loop_size);
#ifdef HYPRE_USE_PTHREADS
local_result_ref[threadid] = &local_result;
#endif
hypre_BoxLoop2Begin(loop_size,
x_data_box, start, unit_stride, xi,
y_data_box, start, unit_stride, yi);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,xi,yi
#define HYPRE_SMP_REDUCTION_OP +
#define HYPRE_SMP_REDUCTION_VARS local_result
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop2For(loopi, loopj, loopk, xi, yi)
{
local_result += xp[xi] * yp[yi];
}
int
hypre_SMGResidual( void *residual_vdata,
hypre_StructMatrix *A,
hypre_StructVector *x,
hypre_StructVector *b,
hypre_StructVector *r )
{
int ierr = 0;
hypre_SMGResidualData *residual_data = (hypre_SMGResidualData *)residual_vdata;
hypre_IndexRef base_stride = (residual_data -> base_stride);
hypre_BoxArray *base_points = (residual_data -> base_points);
hypre_ComputePkg *compute_pkg = (residual_data -> 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 *b_data_box;
hypre_Box *r_data_box;
int Ai;
int xi;
int bi;
int ri;
double *Ap;
double *xp;
double *bp;
double *rp;
hypre_Index loop_size;
hypre_IndexRef start;
hypre_StructStencil *stencil;
hypre_Index *stencil_shape;
int stencil_size;
int compute_i, i, j, si;
int loopi, loopj, loopk;
hypre_BeginTiming(residual_data -> time_index);
/*-----------------------------------------------------------------------
* Compute residual r = b - Ax
*-----------------------------------------------------------------------*/
stencil = hypre_StructMatrixStencil(A);
stencil_shape = hypre_StructStencilShape(stencil);
stencil_size = hypre_StructStencilSize(stencil);
for (compute_i = 0; compute_i < 2; compute_i++)
{
switch(compute_i)
{
case 0:
{
xp = hypre_StructVectorData(x);
hypre_InitializeIndtComputations(compute_pkg, xp, &comm_handle);
compute_box_aa = hypre_ComputePkgIndtBoxes(compute_pkg);
/*----------------------------------------
* Copy b into r
*----------------------------------------*/
compute_box_a = base_points;
hypre_ForBoxI(i, compute_box_a)
{
compute_box = hypre_BoxArrayBox(compute_box_a, i);
start = hypre_BoxIMin(compute_box);
b_data_box =
hypre_BoxArrayBox(hypre_StructVectorDataSpace(b), i);
r_data_box =
hypre_BoxArrayBox(hypre_StructVectorDataSpace(r), i);
bp = hypre_StructVectorBoxData(b, i);
rp = hypre_StructVectorBoxData(r, i);
hypre_BoxGetStrideSize(compute_box, base_stride, loop_size);
hypre_BoxLoop2Begin(loop_size,
b_data_box, start, base_stride, bi,
r_data_box, start, base_stride, ri);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,bi,ri
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop2For(loopi, loopj, loopk, bi, ri)
{
rp[ri] = bp[bi];
}
hypre_BoxLoop2End(bi, ri);
}
}
break;
case 1:
{
hypre_FinalizeIndtComputations(comm_handle);
compute_box_aa = hypre_ComputePkgDeptBoxes(compute_pkg);
}
break;
}
/*--------------------------------------------------------------------
* Compute r -= A*x
*--------------------------------------------------------------------*/
hypre_ForBoxArrayI(i, compute_box_aa)
{
compute_box_a = hypre_BoxArrayArrayBoxArray(compute_box_aa, i);
A_data_box = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(A), i);
x_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(x), i);
r_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(r), i);
rp = hypre_StructVectorBoxData(r, i);
hypre_ForBoxI(j, compute_box_a)
{
compute_box = hypre_BoxArrayBox(compute_box_a, j);
start = hypre_BoxIMin(compute_box);
for (si = 0; si < stencil_size; si++)
{
Ap = hypre_StructMatrixBoxData(A, i, si);
xp = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[si]);
hypre_BoxGetStrideSize(compute_box, base_stride,
loop_size);
hypre_BoxLoop3Begin(loop_size,
A_data_box, start, base_stride, Ai,
x_data_box, start, base_stride, xi,
r_data_box, start, base_stride, ri);
#if 0
/* The following portion is preprocessed to be handled by ROSE outliner */
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,Ai,xi,ri
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop3For(loopi, loopj, loopk, Ai, xi, ri)
{
rp[ri] -= Ap[Ai] * xp[xi];
}
hypre_BoxLoop3End(Ai, xi, ri);
#else
for (hypre__block = 0; hypre__block < hypre__num_blocks;
hypre__block++)
{
loopi = 0;
loopj = 0;
loopk = 0;
hypre__nx = hypre__mx;
hypre__ny = hypre__my;
hypre__nz = hypre__mz;
if (hypre__num_blocks > 1)
{
if (hypre__dir == 0)
{
loopi =
hypre__block * hypre__div +
(((hypre__mod) <
(hypre__block)) ? (hypre__mod)
: (hypre__block));
hypre__nx =
hypre__div +
((hypre__mod > hypre__block) ? 1 : 0);
}
else if (hypre__dir == 1)
{
loopj =
hypre__block * hypre__div +
(((hypre__mod) <
(hypre__block)) ? (hypre__mod)
: (hypre__block));
hypre__ny =
hypre__div +
((hypre__mod > hypre__block) ? 1 : 0);
}
else if (hypre__dir == 2)
{
loopk =
hypre__block * hypre__div +
(((hypre__mod) <
(hypre__block)) ? (hypre__mod)
: (hypre__block));
hypre__nz =
hypre__div +
((hypre__mod > hypre__block) ? 1 : 0);
}
};
Ai =
hypre__i1start + loopi * hypre__sx1 +
loopj * hypre__sy1 + loopk * hypre__sz1;
xi =
hypre__i2start + loopi * hypre__sx2 +
loopj * hypre__sy2 + loopk * hypre__sz2;
ri =
hypre__i3start + loopi * hypre__sx3 +
loopj * hypre__sy3 + loopk * hypre__sz3;
//begin of the loop
#if 0 //
for (loopk = 0; loopk < hypre__nz; loopk++)
{
for (loopj = 0; loopj < hypre__ny; loopj++)
{
for (loopi = 0; loopi < hypre__nx; loopi++)
{
{
rp[ri] -= Ap[Ai] * xp[xi];
}
Ai += hypre__sx1;
xi += hypre__sx2;
ri += hypre__sx3;
}
Ai += hypre__sy1 - hypre__nx * hypre__sx1;
xi += hypre__sy2 - hypre__nx * hypre__sx2;
ri += hypre__sy3 - hypre__nx * hypre__sx3;
}
Ai += hypre__sz1 - hypre__ny * hypre__sy1;
xi += hypre__sz2 - hypre__ny * hypre__sy2;
ri += hypre__sz3 - hypre__ny * hypre__sy3;
} // end of the loop
#else
#if BLCR_CHECKPOINTING
// Only checkpoint it at the first occurrance.
if (g_checkpoint_flag == 0)
{
int err;
cr_checkpoint_args_t cr_args;
cr_checkpoint_handle_t cr_handle;
cr_initialize_checkpoint_args_t(&cr_args);
cr_args.cr_scope = CR_SCOPE_PROC;// a process
cr_args.cr_target = 0; //self
cr_args.cr_signal = SIGKILL; // kill after checkpointing
cr_args.cr_fd = open("dump.yy", O_WRONLY|O_CREAT|O_LARGEFILE, 0400);
if (cr_args.cr_fd < 0) {
printf("Error: cannot open file for checkpoiting context\n");
abort();
}
g_checkpoint_flag ++;
printf("Checkpoiting: starting here ..\n");
err = cr_request_checkpoint(&cr_args, &cr_handle);
if (err < 0) {
printf("cannot request checkpoining! err=%d\n",err);
abort();
}
// block until the request is served
cr_enter_cs(cr);
cr_leave_cs(cr);
printf("Checkpoiting: restarting here ..\n");
}
#endif
OUT__1__6755__(&Ai,&xi,&ri,&Ap,&xp,&rp,&loopi,&loopj,&loopk,&hypre__sx1,&hypre__sy1,&hypre__sz1,&hypre__sx2,&hypre__sy2,&hypre__sz2,&hypre__sx3,&hypre__sy3,&hypre__sz3,&hypre__nx,&hypre__ny,&hypre__nz);
#endif
}
};
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;
}
int
hypre_SStructUMatrixSetBoxValues( hypre_SStructMatrix *matrix,
int part,
hypre_Index ilower,
hypre_Index iupper,
int var,
int nentries,
int *entries,
double *values,
int add_to )
{
HYPRE_IJMatrix ijmatrix = hypre_SStructMatrixIJMatrix(matrix);
hypre_SStructGraph *graph = hypre_SStructMatrixGraph(matrix);
hypre_SStructGrid *grid = hypre_SStructGraphGrid(graph);
hypre_SStructStencil *stencil = hypre_SStructGraphStencil(graph, part, var);
int *vars = hypre_SStructStencilVars(stencil);
hypre_Index *shape = hypre_SStructStencilShape(stencil);
int size = hypre_SStructStencilSize(stencil);
hypre_IndexRef offset;
hypre_BoxMap *map;
hypre_BoxMapEntry **map_entries;
int nmap_entries;
hypre_BoxMapEntry **map_to_entries;
int nmap_to_entries;
int nrows;
int *ncols;
HYPRE_BigInt *rows;
HYPRE_BigInt *cols;
double *ijvalues;
hypre_Box *box;
hypre_Box *to_box;
hypre_Box *map_box;
hypre_Box *int_box;
hypre_Index index;
hypre_Index rs, cs;
int sy, sz;
HYPRE_BigInt row_base, col_base;
int val_base;
int e, entry, ii, jj, i, j, k;
int proc, myproc;
/* GEC1002 the matrix type */
int matrix_type = hypre_SStructMatrixObjectType(matrix);
box = hypre_BoxCreate();
/*------------------------------------------
* all stencil entries
*------------------------------------------*/
if (entries[0] < size)
{
to_box = hypre_BoxCreate();
map_box = hypre_BoxCreate();
int_box = hypre_BoxCreate();
hypre_CopyIndex(ilower, hypre_BoxIMin(box));
hypre_CopyIndex(iupper, hypre_BoxIMax(box));
/* ZTODO: check that this change fixes multiple-entry problem */
nrows = hypre_BoxVolume(box)*nentries;
ncols = hypre_CTAlloc(int, nrows);
for (i = 0; i < nrows; i++)
{
ncols[i] = 1;
}
rows = hypre_CTAlloc(HYPRE_BigInt, nrows);
cols = hypre_CTAlloc(HYPRE_BigInt, nrows);
ijvalues = hypre_CTAlloc(double, nrows);
sy = (hypre_IndexX(iupper) - hypre_IndexX(ilower) + 1);
sz = (hypre_IndexY(iupper) - hypre_IndexY(ilower) + 1) * sy;
map = hypre_SStructGridMap(grid, part, var);
hypre_BoxMapIntersect(map, ilower, iupper, &map_entries, &nmap_entries);
for (ii = 0; ii < nmap_entries; ii++)
{
/* Only Set values if I am the owner process; off-process AddTo and Get
* values are done by IJ */
if (!add_to)
{
hypre_SStructMapEntryGetProcess(map_entries[ii], &proc);
MPI_Comm_rank(hypre_SStructGridComm(grid), &myproc);
if (proc != myproc)
{
continue;
}
}
/* GEC1002 introducing the strides based on the type of the matrix */
hypre_SStructMapEntryGetStrides(map_entries[ii], rs, matrix_type);
hypre_CopyIndex(ilower, hypre_BoxIMin(box));
hypre_CopyIndex(iupper, hypre_BoxIMax(box));
hypre_BoxMapEntryGetExtents(map_entries[ii],
hypre_BoxIMin(map_box),
hypre_BoxIMax(map_box));
hypre_IntersectBoxes(box, map_box, int_box);
hypre_CopyBox(int_box, box);
nrows = 0;
for (e = 0; e < nentries; e++)
{
entry = entries[e];
hypre_CopyBox(box, to_box);
offset = shape[entry];
hypre_BoxIMinX(to_box) += hypre_IndexX(offset);
hypre_BoxIMinY(to_box) += hypre_IndexY(offset);
hypre_BoxIMinZ(to_box) += hypre_IndexZ(offset);
hypre_BoxIMaxX(to_box) += hypre_IndexX(offset);
hypre_BoxIMaxY(to_box) += hypre_IndexY(offset);
hypre_BoxIMaxZ(to_box) += hypre_IndexZ(offset);
map = hypre_SStructGridMap(grid, part, vars[entry]);
hypre_BoxMapIntersect(map, hypre_BoxIMin(to_box),
hypre_BoxIMax(to_box),
&map_to_entries, &nmap_to_entries );
for (jj = 0; jj < nmap_to_entries; jj++)
{
/* GEC1002 introducing the strides based on the type of the matrix */
hypre_SStructMapEntryGetStrides(map_to_entries[jj], cs, matrix_type);
hypre_BoxMapEntryGetExtents(map_to_entries[jj],
hypre_BoxIMin(map_box),
hypre_BoxIMax(map_box));
hypre_IntersectBoxes(to_box, map_box, int_box);
hypre_CopyIndex(hypre_BoxIMin(int_box), index);
/* GEC1002 introducing the rank based on the type of the matrix */
hypre_SStructMapEntryGetGlobalRank(map_to_entries[jj],
index, &col_base,matrix_type);
hypre_IndexX(index) -= hypre_IndexX(offset);
hypre_IndexY(index) -= hypre_IndexY(offset);
hypre_IndexZ(index) -= hypre_IndexZ(offset);
/* GEC1002 introducing the rank based on the type of the matrix */
hypre_SStructMapEntryGetGlobalRank(map_entries[ii],
index, &row_base,matrix_type);
hypre_IndexX(index) -= hypre_IndexX(ilower);
hypre_IndexY(index) -= hypre_IndexY(ilower);
hypre_IndexZ(index) -= hypre_IndexZ(ilower);
val_base = e + (hypre_IndexX(index) +
hypre_IndexY(index)*sy +
hypre_IndexZ(index)*sz) * nentries;
for (k = 0; k < hypre_BoxSizeZ(int_box); k++)
{
for (j = 0; j < hypre_BoxSizeY(int_box); j++)
{
for (i = 0; i < hypre_BoxSizeX(int_box); i++)
{
rows[nrows] = row_base + (HYPRE_BigInt)(i*rs[0] + j*rs[1] + k*rs[2]);
cols[nrows] = col_base + (HYPRE_BigInt)(i*cs[0] + j*cs[1] + k*cs[2]);
ijvalues[nrows] =
values[val_base + (i + j*sy + k*sz)*nentries];
nrows++;
}
}
}
}
hypre_TFree(map_to_entries);
}
/*------------------------------------------
* set IJ values one stencil entry at a time
*------------------------------------------*/
if (add_to > 0)
{
HYPRE_IJMatrixAddToValues(ijmatrix, nrows, ncols,
(const HYPRE_BigInt *) rows,
(const HYPRE_BigInt *) cols,
(const double *) ijvalues);
}
else if (add_to > -1)
{
HYPRE_IJMatrixSetValues(ijmatrix, nrows, ncols,
(const HYPRE_BigInt *) rows,
(const HYPRE_BigInt *) cols,
(const double *) ijvalues);
}
else
{
HYPRE_IJMatrixGetValues(ijmatrix, nrows, ncols, rows, cols, values);
}
}
hypre_TFree(map_entries);
hypre_TFree(ncols);
hypre_TFree(rows);
hypre_TFree(cols);
hypre_TFree(ijvalues);
hypre_BoxDestroy(to_box);
hypre_BoxDestroy(map_box);
hypre_BoxDestroy(int_box);
}
HYPRE_Int
hypre_FacZeroCData( void *fac_vdata,
hypre_SStructMatrix *A )
{
hypre_FACData *fac_data = fac_vdata;
hypre_SStructGrid *grid;
hypre_SStructPGrid *p_cgrid;
hypre_StructGrid *cgrid;
hypre_BoxArray *cgrid_boxes;
hypre_Box *cgrid_box;
hypre_BoxManager *fboxman;
hypre_BoxManEntry **boxman_entries;
HYPRE_Int nboxman_entries;
hypre_Box scaled_box;
hypre_Box intersect_box;
hypre_SStructPMatrix *level_pmatrix;
hypre_StructStencil *stencils;
HYPRE_Int stencil_size;
hypre_Index *refine_factors;
hypre_Index temp_index;
hypre_Index ilower, iupper;
HYPRE_Int max_level = fac_data -> max_levels;
HYPRE_Int *level_to_part = fac_data -> level_to_part;
HYPRE_Int ndim = hypre_SStructMatrixNDim(A);
HYPRE_Int part_crse = 0;
HYPRE_Int part_fine = 1;
HYPRE_Int level;
HYPRE_Int nvars, var;
HYPRE_Int ci, i, j, rem, intersect_size;
double *values;
HYPRE_Int ierr = 0;
for (level= max_level; level> 0; level--)
{
level_pmatrix = hypre_SStructMatrixPMatrix(fac_data -> A_level[level], part_crse);
grid = (fac_data -> grid_level[level]);
refine_factors= &(fac_data -> refine_factors[level]);
p_cgrid= hypre_SStructGridPGrid(grid, part_crse);
nvars = hypre_SStructPGridNVars(p_cgrid);
for (var= 0; var< nvars; var++)
{
stencils = hypre_SStructPMatrixSStencil(level_pmatrix, var, var);
stencil_size= hypre_StructStencilSize(stencils);
/*---------------------------------------------------------------------
* For each variable, find the underlying boxes for each coarse box.
*---------------------------------------------------------------------*/
cgrid = hypre_SStructPGridSGrid(p_cgrid, var);
cgrid_boxes = hypre_StructGridBoxes(cgrid);
fboxman = hypre_SStructGridBoxManager(grid, part_fine, var);
hypre_ForBoxI(ci, cgrid_boxes)
{
cgrid_box= hypre_BoxArrayBox(cgrid_boxes, ci);
hypre_ClearIndex(temp_index);
hypre_StructMapCoarseToFine(hypre_BoxIMin(cgrid_box), temp_index,
*refine_factors, hypre_BoxIMin(&scaled_box));
for (i= 0; i< ndim; i++)
{
temp_index[i]= (*refine_factors)[i]-1;
}
hypre_StructMapCoarseToFine(hypre_BoxIMax(cgrid_box), temp_index,
*refine_factors, hypre_BoxIMax(&scaled_box));
hypre_BoxManIntersect(fboxman, hypre_BoxIMin(&scaled_box),
hypre_BoxIMax(&scaled_box), &boxman_entries,
&nboxman_entries);
for (i= 0; i< nboxman_entries; i++)
{
hypre_BoxManEntryGetExtents(boxman_entries[i], ilower, iupper);
hypre_BoxSetExtents(&intersect_box, ilower, iupper);
hypre_IntersectBoxes(&intersect_box, &scaled_box, &intersect_box);
/* adjust the box so that it is divisible by refine_factors */
for (j= 0; j< ndim; j++)
{
rem= hypre_BoxIMin(&intersect_box)[j]%(*refine_factors)[j];
if (rem)
{
hypre_BoxIMin(&intersect_box)[j]+=(*refine_factors)[j] - rem;
}
}
hypre_ClearIndex(temp_index);
hypre_StructMapFineToCoarse(hypre_BoxIMin(&intersect_box), temp_index,
*refine_factors, hypre_BoxIMin(&intersect_box));
hypre_StructMapFineToCoarse(hypre_BoxIMax(&intersect_box), temp_index,
*refine_factors, hypre_BoxIMax(&intersect_box));
intersect_size= hypre_BoxVolume(&intersect_box);
if (intersect_size > 0)
{
/*------------------------------------------------------------
* Coarse underlying box found. Now zero off.
*------------------------------------------------------------*/
values= hypre_CTAlloc(double, intersect_size);
for (j= 0; j< stencil_size; j++)
{
HYPRE_SStructMatrixSetBoxValues(fac_data -> A_level[level],
part_crse,
hypre_BoxIMin(&intersect_box),
hypre_BoxIMax(&intersect_box),
var, 1, &j, values);
HYPRE_SStructMatrixSetBoxValues(A,
level_to_part[level-1],
hypre_BoxIMin(&intersect_box),
hypre_BoxIMax(&intersect_box),
var, 1, &j, values);
}
hypre_TFree(values);
} /* if (intersect_size > 0) */
} /* for (i= 0; i< nboxman_entries; i++) */
hypre_TFree(boxman_entries);
} /* hypre_ForBoxI(ci, cgrid_boxes) */
} /* for (var= 0; var< nvars; var++) */
/*--------------------------------------------------------------------------
* 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_SStructSendInfoData *
hypre_SStructSendInfo( hypre_StructGrid *fgrid,
hypre_BoxManager *cboxman,
hypre_Index rfactor )
{
hypre_SStructSendInfoData *sendinfo_data;
MPI_Comm comm= hypre_SStructVectorComm(fgrid);
hypre_BoxArray *grid_boxes;
hypre_Box *grid_box, cbox;
hypre_Box *intersect_box, boxman_entry_box;
hypre_BoxManEntry **boxman_entries;
HYPRE_Int nboxman_entries;
hypre_BoxArrayArray *send_boxes;
HYPRE_Int **send_processes;
HYPRE_Int **send_remote_boxnums;
hypre_Index ilower, iupper, index;
HYPRE_Int myproc, proc;
HYPRE_Int cnt;
HYPRE_Int i, j;
hypre_ClearIndex(index);
hypre_MPI_Comm_rank(comm, &myproc);
sendinfo_data= hypre_CTAlloc(hypre_SStructSendInfoData, 1);
/*------------------------------------------------------------------------
* Create the structured sendbox patterns.
*
* send_boxes are obtained by intersecting this proc's fgrid boxes
* with cgrid's box_man. Intersecting BoxManEntries not on this proc
* will give boxes that we will need to send data to- i.e., we scan
* through the boxes of grid and find the processors that own a chunk
* of it.
*------------------------------------------------------------------------*/
intersect_box = hypre_CTAlloc(hypre_Box, 1);
grid_boxes = hypre_StructGridBoxes(fgrid);
send_boxes= hypre_BoxArrayArrayCreate(hypre_BoxArraySize(grid_boxes));
send_processes= hypre_CTAlloc(HYPRE_Int *, hypre_BoxArraySize(grid_boxes));
send_remote_boxnums= hypre_CTAlloc(HYPRE_Int *, hypre_BoxArraySize(grid_boxes));
hypre_ForBoxI(i, grid_boxes)
{
grid_box= hypre_BoxArrayBox(grid_boxes, i);
/*---------------------------------------------------------------------
* Find the boxarray that must be sent. BoxManIntersect returns
* the full extents of the boxes that intersect with the given box.
* We further need to intersect each box in the list with the given
* box to determine the actual box that needs to be sent.
*---------------------------------------------------------------------*/
hypre_SStructIndexScaleF_C(hypre_BoxIMin(grid_box), index,
rfactor, hypre_BoxIMin(&cbox));
hypre_SStructIndexScaleF_C(hypre_BoxIMax(grid_box), index,
rfactor, hypre_BoxIMax(&cbox));
hypre_BoxManIntersect(cboxman, hypre_BoxIMin(&cbox), hypre_BoxIMax(&cbox),
&boxman_entries, &nboxman_entries);
cnt= 0;
for (j= 0; j< nboxman_entries; j++)
{
hypre_SStructBoxManEntryGetProcess(boxman_entries[j], &proc);
if (proc != myproc)
{
cnt++;
}
}
send_processes[i] = hypre_CTAlloc(HYPRE_Int, cnt);
send_remote_boxnums[i]= hypre_CTAlloc(HYPRE_Int, cnt);
cnt= 0;
for (j= 0; j< nboxman_entries; j++)
{
hypre_SStructBoxManEntryGetProcess(boxman_entries[j], &proc);
/* determine the chunk of the boxman_entries[j] box that is needed */
hypre_BoxManEntryGetExtents(boxman_entries[j], ilower, iupper);
hypre_BoxSetExtents(&boxman_entry_box, ilower, iupper);
hypre_IntersectBoxes(&boxman_entry_box, &cbox, &boxman_entry_box);
if (proc != myproc)
{
send_processes[i][cnt] = proc;
hypre_SStructBoxManEntryGetBoxnum(boxman_entries[j],
&send_remote_boxnums[i][cnt]);
hypre_AppendBox(&boxman_entry_box,
hypre_BoxArrayArrayBoxArray(send_boxes, i));
cnt++;
}
}
hypre_TFree(boxman_entries);
} /* hypre_ForBoxI(i, grid_boxes) */
HYPRE_Int
hypre_FacSemiRestrictSetup2( void *fac_restrict_vdata,
hypre_SStructVector *r,
HYPRE_Int part_crse,
HYPRE_Int part_fine,
hypre_SStructPVector *rc,
hypre_Index rfactors )
{
HYPRE_Int ierr = 0;
hypre_FacSemiRestrictData2 *fac_restrict_data = fac_restrict_vdata;
MPI_Comm comm= hypre_SStructPVectorComm(rc);
hypre_CommInfo *comm_info;
hypre_CommPkg **interlevel_comm;
hypre_SStructPVector *rf= hypre_SStructVectorPVector(r, part_fine);
hypre_StructVector *s_rc, *s_cvector;
hypre_SStructPGrid *pgrid;
hypre_SStructPVector *fgrid_cvectors;
hypre_SStructPGrid *fgrid_coarsen;
hypre_BoxArrayArray **identity_arrayboxes;
hypre_BoxArrayArray **fullwgt_ownboxes;
hypre_BoxArrayArray **fullwgt_sendboxes;
hypre_BoxArray *boxarray;
hypre_BoxArray *tmp_boxarray, *intersect_boxes;
HYPRE_Int ***own_cboxnums;
hypre_BoxArrayArray **send_boxes, *send_rboxes;
HYPRE_Int ***send_processes;
HYPRE_Int ***send_remote_boxnums;
hypre_BoxArrayArray **recv_boxes, *recv_rboxes;
HYPRE_Int ***recv_processes;
HYPRE_Int ***recv_remote_boxnums;
hypre_BoxManager *boxman;
hypre_BoxManEntry **boxman_entries;
HYPRE_Int nboxman_entries;
hypre_Box box, scaled_box;
hypre_Index zero_index, index, ilower, iupper;
HYPRE_Int ndim= hypre_SStructVectorNDim(r);
HYPRE_Int myproc, proc;
HYPRE_Int nvars, vars;
HYPRE_Int num_values;
HYPRE_Int i, cnt1, cnt2;
HYPRE_Int fi, ci;
hypre_MPI_Comm_rank(comm, &myproc);
hypre_ClearIndex(zero_index);
nvars= hypre_SStructPVectorNVars(rc);
(fac_restrict_data -> nvars)= nvars;
hypre_CopyIndex(rfactors, (fac_restrict_data -> stride));
for (i= ndim; i< 3; i++)
{
rfactors[i]= 1;
}
/* work vector for storing the fullweighted fgrid boxes */
hypre_SStructPGridCreate(hypre_SStructPVectorComm(rf), ndim, &fgrid_coarsen);
pgrid= hypre_SStructPVectorPGrid(rf);
for (vars= 0; vars< nvars; vars++)
{
boxarray= hypre_StructGridBoxes(hypre_SStructPGridSGrid(pgrid, vars));
hypre_ForBoxI(fi, boxarray)
{
hypre_CopyBox(hypre_BoxArrayBox(boxarray, fi), &box);
hypre_StructMapFineToCoarse(hypre_BoxIMin(&box), zero_index,
rfactors, hypre_BoxIMin(&box));
hypre_StructMapFineToCoarse(hypre_BoxIMax(&box), zero_index,
rfactors, hypre_BoxIMax(&box));
hypre_SStructPGridSetExtents(fgrid_coarsen,
hypre_BoxIMin(&box),
hypre_BoxIMax(&box));
}
}
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_SMGResidual( void *residual_vdata,
hypre_StructMatrix *A,
hypre_StructVector *x,
hypre_StructVector *b,
hypre_StructVector *r )
{
HYPRE_Int ierr;
hypre_SMGResidualData *residual_data = residual_vdata;
hypre_IndexRef base_stride = (residual_data -> base_stride);
hypre_BoxArray *base_points = (residual_data -> base_points);
hypre_ComputePkg *compute_pkg = (residual_data -> 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 *b_data_box;
hypre_Box *r_data_box;
HYPRE_Int Ai;
HYPRE_Int xi;
HYPRE_Int bi;
HYPRE_Int ri;
double *Ap0;
double *xp0;
double *bp;
double *rp;
hypre_Index loop_size;
hypre_IndexRef start;
hypre_StructStencil *stencil;
hypre_Index *stencil_shape;
HYPRE_Int stencil_size;
HYPRE_Int compute_i, i, j, si;
HYPRE_Int loopi, loopj, loopk;
double *Ap1, *Ap2;
double *Ap3, *Ap4;
double *Ap5, *Ap6;
double *Ap7, *Ap8, *Ap9;
double *Ap10, *Ap11, *Ap12, *Ap13, *Ap14;
double *Ap15, *Ap16, *Ap17, *Ap18;
double *Ap19, *Ap20, *Ap21, *Ap22, *Ap23, *Ap24, *Ap25, *Ap26;
double *xp1, *xp2;
double *xp3, *xp4;
double *xp5, *xp6;
double *xp7, *xp8, *xp9;
double *xp10, *xp11, *xp12, *xp13, *xp14;
double *xp15, *xp16, *xp17, *xp18;
double *xp19, *xp20, *xp21, *xp22, *xp23, *xp24, *xp25, *xp26;
hypre_BeginTiming(residual_data -> time_index);
/*-----------------------------------------------------------------------
* Compute residual r = b - Ax
*-----------------------------------------------------------------------*/
stencil = hypre_StructMatrixStencil(A);
stencil_shape = hypre_StructStencilShape(stencil);
stencil_size = hypre_StructStencilSize(stencil);
for (compute_i = 0; compute_i < 2; compute_i++)
{
switch(compute_i)
{
case 0:
{
xp0 = hypre_StructVectorData(x);
hypre_InitializeIndtComputations(compute_pkg, xp0, &comm_handle);
compute_box_aa = hypre_ComputePkgIndtBoxes(compute_pkg);
/*----------------------------------------
* Copy b into r
*----------------------------------------*/
compute_box_a = base_points;
hypre_ForBoxI(i, compute_box_a)
{
compute_box = hypre_BoxArrayBox(compute_box_a, i);
start = hypre_BoxIMin(compute_box);
b_data_box =
hypre_BoxArrayBox(hypre_StructVectorDataSpace(b), i);
r_data_box =
hypre_BoxArrayBox(hypre_StructVectorDataSpace(r), i);
bp = hypre_StructVectorBoxData(b, i);
rp = hypre_StructVectorBoxData(r, i);
hypre_BoxGetStrideSize(compute_box, base_stride, loop_size);
hypre_BoxLoop2Begin(loop_size,
b_data_box, start, base_stride, bi,
r_data_box, start, base_stride, ri);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,bi,ri
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop2For(loopi, loopj, loopk, bi, ri)
{
rp[ri] = bp[bi];
}
hypre_BoxLoop2End(bi, ri);
}
}
break;
case 1:
{
hypre_FinalizeIndtComputations(comm_handle);
compute_box_aa = hypre_ComputePkgDeptBoxes(compute_pkg);
}
break;
}
/*--------------------------------------------------------------------
* Compute r -= A*x
*--------------------------------------------------------------------*/
hypre_ForBoxArrayI(i, compute_box_aa)
{
compute_box_a = hypre_BoxArrayArrayBoxArray(compute_box_aa, i);
A_data_box = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(A), i);
x_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(x), i);
r_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(r), i);
rp = hypre_StructVectorBoxData(r, i);
/*--------------------------------------------------------------
* Switch statement to direct control (based on stencil size) to
* code to get pointers and offsets fo A and x.
*--------------------------------------------------------------*/
switch (stencil_size)
{
case 1:
Ap0 = hypre_StructMatrixBoxData(A, i, 0);
xp0 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[0]);
break;
case 3:
Ap0 = hypre_StructMatrixBoxData(A, i, 0);
Ap1 = hypre_StructMatrixBoxData(A, i, 1);
Ap2 = hypre_StructMatrixBoxData(A, i, 2);
xp0 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[0]);
xp1 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[1]);
xp2 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[2]);
break;
case 5:
Ap0 = hypre_StructMatrixBoxData(A, i, 0);
Ap1 = hypre_StructMatrixBoxData(A, i, 1);
Ap2 = hypre_StructMatrixBoxData(A, i, 2);
Ap3 = hypre_StructMatrixBoxData(A, i, 3);
Ap4 = hypre_StructMatrixBoxData(A, i, 4);
xp0 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[0]);
xp1 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[1]);
xp2 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[2]);
xp3 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[3]);
xp4 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[4]);
break;
case 7:
Ap0 = hypre_StructMatrixBoxData(A, i, 0);
Ap1 = hypre_StructMatrixBoxData(A, i, 1);
Ap2 = hypre_StructMatrixBoxData(A, i, 2);
Ap3 = hypre_StructMatrixBoxData(A, i, 3);
Ap4 = hypre_StructMatrixBoxData(A, i, 4);
Ap5 = hypre_StructMatrixBoxData(A, i, 5);
Ap6 = hypre_StructMatrixBoxData(A, i, 6);
xp0 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[0]);
xp1 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[1]);
xp2 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[2]);
xp3 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[3]);
xp4 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[4]);
xp5 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[5]);
xp6 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[6]);
break;
case 9:
Ap0 = hypre_StructMatrixBoxData(A, i, 0);
Ap1 = hypre_StructMatrixBoxData(A, i, 1);
Ap2 = hypre_StructMatrixBoxData(A, i, 2);
Ap3 = hypre_StructMatrixBoxData(A, i, 3);
Ap4 = hypre_StructMatrixBoxData(A, i, 4);
Ap5 = hypre_StructMatrixBoxData(A, i, 5);
Ap6 = hypre_StructMatrixBoxData(A, i, 6);
Ap7 = hypre_StructMatrixBoxData(A, i, 7);
Ap8 = hypre_StructMatrixBoxData(A, i, 8);
xp0 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[0]);
xp1 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[1]);
xp2 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[2]);
xp3 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[3]);
xp4 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[4]);
xp5 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[5]);
xp6 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[6]);
xp7 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[7]);
xp8 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[8]);
break;
case 15:
Ap0 = hypre_StructMatrixBoxData(A, i, 0);
Ap1 = hypre_StructMatrixBoxData(A, i, 1);
Ap2 = hypre_StructMatrixBoxData(A, i, 2);
Ap3 = hypre_StructMatrixBoxData(A, i, 3);
Ap4 = hypre_StructMatrixBoxData(A, i, 4);
Ap5 = hypre_StructMatrixBoxData(A, i, 5);
Ap6 = hypre_StructMatrixBoxData(A, i, 6);
Ap7 = hypre_StructMatrixBoxData(A, i, 7);
Ap8 = hypre_StructMatrixBoxData(A, i, 8);
Ap9 = hypre_StructMatrixBoxData(A, i, 9);
Ap10 = hypre_StructMatrixBoxData(A, i, 10);
Ap11 = hypre_StructMatrixBoxData(A, i, 11);
Ap12 = hypre_StructMatrixBoxData(A, i, 12);
Ap13 = hypre_StructMatrixBoxData(A, i, 13);
Ap14 = hypre_StructMatrixBoxData(A, i, 14);
xp0 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[0]);
xp1 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[1]);
xp2 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[2]);
xp3 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[3]);
xp4 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[4]);
xp5 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[5]);
xp6 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[6]);
xp7 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[7]);
xp8 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[8]);
xp9 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[9]);
xp10 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[10]);
xp11 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[11]);
xp12 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[12]);
xp13 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[13]);
xp14 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[14]);
break;
case 19:
Ap0 = hypre_StructMatrixBoxData(A, i, 0);
Ap1 = hypre_StructMatrixBoxData(A, i, 1);
Ap2 = hypre_StructMatrixBoxData(A, i, 2);
Ap3 = hypre_StructMatrixBoxData(A, i, 3);
Ap4 = hypre_StructMatrixBoxData(A, i, 4);
Ap5 = hypre_StructMatrixBoxData(A, i, 5);
Ap6 = hypre_StructMatrixBoxData(A, i, 6);
Ap7 = hypre_StructMatrixBoxData(A, i, 7);
Ap8 = hypre_StructMatrixBoxData(A, i, 8);
Ap9 = hypre_StructMatrixBoxData(A, i, 9);
Ap10 = hypre_StructMatrixBoxData(A, i, 10);
Ap11 = hypre_StructMatrixBoxData(A, i, 11);
Ap12 = hypre_StructMatrixBoxData(A, i, 12);
Ap13 = hypre_StructMatrixBoxData(A, i, 13);
Ap14 = hypre_StructMatrixBoxData(A, i, 14);
Ap15 = hypre_StructMatrixBoxData(A, i, 15);
Ap16 = hypre_StructMatrixBoxData(A, i, 16);
Ap17 = hypre_StructMatrixBoxData(A, i, 17);
Ap18 = hypre_StructMatrixBoxData(A, i, 18);
xp0 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[0]);
xp1 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[1]);
xp2 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[2]);
xp3 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[3]);
xp4 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[4]);
xp5 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[5]);
xp6 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[6]);
xp7 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[7]);
xp8 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[8]);
xp9 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[9]);
xp10 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[10]);
xp11 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[11]);
xp12 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[12]);
xp13 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[13]);
xp14 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[14]);
xp15 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[15]);
xp16 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[16]);
xp17 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[17]);
xp18 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[18]);
break;
case 27:
Ap0 = hypre_StructMatrixBoxData(A, i, 0);
Ap1 = hypre_StructMatrixBoxData(A, i, 1);
Ap2 = hypre_StructMatrixBoxData(A, i, 2);
Ap3 = hypre_StructMatrixBoxData(A, i, 3);
Ap4 = hypre_StructMatrixBoxData(A, i, 4);
Ap5 = hypre_StructMatrixBoxData(A, i, 5);
Ap6 = hypre_StructMatrixBoxData(A, i, 6);
Ap7 = hypre_StructMatrixBoxData(A, i, 7);
Ap8 = hypre_StructMatrixBoxData(A, i, 8);
Ap9 = hypre_StructMatrixBoxData(A, i, 9);
Ap10 = hypre_StructMatrixBoxData(A, i, 10);
Ap11 = hypre_StructMatrixBoxData(A, i, 11);
Ap12 = hypre_StructMatrixBoxData(A, i, 12);
Ap13 = hypre_StructMatrixBoxData(A, i, 13);
Ap14 = hypre_StructMatrixBoxData(A, i, 14);
Ap15 = hypre_StructMatrixBoxData(A, i, 15);
Ap16 = hypre_StructMatrixBoxData(A, i, 16);
Ap17 = hypre_StructMatrixBoxData(A, i, 17);
Ap18 = hypre_StructMatrixBoxData(A, i, 18);
Ap19 = hypre_StructMatrixBoxData(A, i, 19);
Ap20 = hypre_StructMatrixBoxData(A, i, 20);
Ap21 = hypre_StructMatrixBoxData(A, i, 21);
Ap22 = hypre_StructMatrixBoxData(A, i, 22);
Ap23 = hypre_StructMatrixBoxData(A, i, 23);
Ap24 = hypre_StructMatrixBoxData(A, i, 24);
Ap25 = hypre_StructMatrixBoxData(A, i, 25);
Ap26 = hypre_StructMatrixBoxData(A, i, 26);
xp0 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[0]);
xp1 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[1]);
xp2 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[2]);
xp3 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[3]);
xp4 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[4]);
xp5 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[5]);
xp6 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[6]);
xp7 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[7]);
xp8 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[8]);
xp9 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[9]);
xp10 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[10]);
xp11 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[11]);
xp12 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[12]);
xp13 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[13]);
xp14 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[14]);
xp15 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[15]);
xp16 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[16]);
xp17 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[17]);
xp18 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[18]);
xp19 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[19]);
xp20 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[20]);
xp21 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[21]);
xp22 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[22]);
xp23 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[23]);
xp24 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[24]);
xp25 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[25]);
xp26 = hypre_StructVectorBoxData(x, i) +
hypre_BoxOffsetDistance(x_data_box, stencil_shape[26]);
break;
default:
;
}
hypre_ForBoxI(j, compute_box_a)
{
compute_box = hypre_BoxArrayBox(compute_box_a, j);
start = hypre_BoxIMin(compute_box);
/*------------------------------------------------------
* Switch statement to direct control to appropriate
* box loop depending on stencil size
*------------------------------------------------------*/
switch (stencil_size)
{
case 1:
hypre_BoxGetStrideSize(compute_box, base_stride, loop_size);
hypre_BoxLoop3Begin(loop_size,
A_data_box, start, base_stride, Ai,
x_data_box, start, base_stride, xi,
r_data_box, start, base_stride, ri);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,Ai,xi,ri
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop3For(loopi, loopj, loopk, Ai, xi, ri)
{
rp[ri] = rp[ri]
- Ap0[Ai] * xp0[xi];
}
hypre_BoxLoop3End(Ai, xi, ri);
break;
case 3:
hypre_BoxGetStrideSize(compute_box, base_stride, loop_size);
hypre_BoxLoop3Begin(loop_size,
A_data_box, start, base_stride, Ai,
x_data_box, start, base_stride, xi,
r_data_box, start, base_stride, ri);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,Ai,xi,ri
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop3For(loopi, loopj, loopk, Ai, xi, ri)
{
rp[ri] = rp[ri]
- Ap0[Ai] * xp0[xi]
- Ap1[Ai] * xp1[xi]
- Ap2[Ai] * xp2[xi];
}
