HYPRE_Int
hypre_SparseMSGSetupRAPOp( hypre_StructMatrix *R,
hypre_StructMatrix *A,
hypre_StructMatrix *P,
HYPRE_Int cdir,
hypre_Index cindex,
hypre_Index cstride,
hypre_Index stridePR,
hypre_StructMatrix *Ac )
{
HYPRE_Int ierr = 0;
hypre_StructStencil *stencil;
stencil = hypre_StructMatrixStencil(A);
switch (hypre_StructStencilNDim(stencil))
{
case 2:
/*--------------------------------------------------------------------
* Set lower triangular (+ diagonal) coefficients
*--------------------------------------------------------------------*/
ierr = hypre_SparseMSG2BuildRAPSym(A, P, R, cdir,
cindex, cstride, stridePR, Ac);
/*--------------------------------------------------------------------
* For non-symmetric A, set upper triangular coefficients as well
*--------------------------------------------------------------------*/
if(!hypre_StructMatrixSymmetric(A))
ierr += hypre_SparseMSG2BuildRAPNoSym(A, P, R, cdir,
cindex, cstride, stridePR, Ac);
break;
case 3:
/*--------------------------------------------------------------------
* Set lower triangular (+ diagonal) coefficients
*--------------------------------------------------------------------*/
ierr = hypre_SparseMSG3BuildRAPSym(A, P, R, cdir,
cindex, cstride, stridePR, Ac);
/*--------------------------------------------------------------------
* For non-symmetric A, set upper triangular coefficients as well
*--------------------------------------------------------------------*/
if(!hypre_StructMatrixSymmetric(A))
ierr += hypre_SparseMSG3BuildRAPNoSym(A, P, R, cdir,
cindex, cstride, stridePR, Ac);
break;
}
hypre_StructMatrixAssemble(Ac);
return ierr;
}
hypre_StructMatrix *
hypre_StructMatrixCreate( MPI_Comm comm,
hypre_StructGrid *grid,
hypre_StructStencil *user_stencil )
{
hypre_StructMatrix *matrix;
int i;
matrix = hypre_CTAlloc(hypre_StructMatrix, 1);
hypre_StructMatrixComm(matrix) = comm;
hypre_StructGridRef(grid, &hypre_StructMatrixGrid(matrix));
hypre_StructMatrixUserStencil(matrix) =
hypre_StructStencilRef(user_stencil);
hypre_StructMatrixDataAlloced(matrix) = 1;
hypre_StructMatrixRefCount(matrix) = 1;
/* set defaults */
hypre_StructMatrixSymmetric(matrix) = 0;
for (i = 0; i < 6; i++)
hypre_StructMatrixNumGhost(matrix)[i] = 0;
return matrix;
}
int
HYPRE_StructMatrixSetSymmetric( HYPRE_StructMatrix matrix,
int symmetric )
{
int ierr = 0;
hypre_StructMatrixSymmetric(matrix) = symmetric;
return ierr;
}
int
hypre_StructMatrixInitializeShell( hypre_StructMatrix *matrix )
{
int ierr = 0;
hypre_StructGrid *grid;
hypre_StructStencil *user_stencil;
hypre_StructStencil *stencil;
hypre_Index *stencil_shape;
int stencil_size;
int num_values;
int *symm_elements;
int *num_ghost;
int extra_ghost[] = {0, 0, 0, 0, 0, 0};
hypre_BoxArray *data_space;
hypre_BoxArray *boxes;
hypre_Box *box;
hypre_Box *data_box;
int **data_indices;
int data_size;
int data_box_volume;
int i, j, d;
grid = hypre_StructMatrixGrid(matrix);
/*-----------------------------------------------------------------------
* Set up stencil and num_values:
* The stencil is a "symmetrized" version of the user's stencil
* as computed by hypre_StructStencilSymmetrize.
*
* The `symm_elements' array is used to determine what data is
* explicitely stored (symm_elements[i] < 0) and what data does is
* not explicitely stored (symm_elements[i] >= 0), but is instead
* stored as the transpose coefficient at a neighboring grid point.
*-----------------------------------------------------------------------*/
if (hypre_StructMatrixStencil(matrix) == NULL)
{
user_stencil = hypre_StructMatrixUserStencil(matrix);
hypre_StructStencilSymmetrize(user_stencil, &stencil, &symm_elements);
stencil_shape = hypre_StructStencilShape(stencil);
stencil_size = hypre_StructStencilSize(stencil);
if (!hypre_StructMatrixSymmetric(matrix))
{
/* store all element data */
for (i = 0; i < stencil_size; i++)
symm_elements[i] = -1;
num_values = stencil_size;
}
else
{
num_values = (stencil_size + 1) / 2;
}
hypre_StructMatrixStencil(matrix) = stencil;
hypre_StructMatrixSymmElements(matrix) = symm_elements;
hypre_StructMatrixNumValues(matrix) = num_values;
}
/*-----------------------------------------------------------------------
* Set ghost-layer size for symmetric storage
* - All stencil coeffs are to be available at each point in the
* grid, as well as in the user-specified ghost layer.
*-----------------------------------------------------------------------*/
num_ghost = hypre_StructMatrixNumGhost(matrix);
stencil = hypre_StructMatrixStencil(matrix);
stencil_shape = hypre_StructStencilShape(stencil);
stencil_size = hypre_StructStencilSize(stencil);
symm_elements = hypre_StructMatrixSymmElements(matrix);
for (i = 0; i < stencil_size; i++)
{
if (symm_elements[i] >= 0)
{
for (d = 0; d < 3; d++)
{
extra_ghost[2*d] =
hypre_max(extra_ghost[2*d], -hypre_IndexD(stencil_shape[i], d));
extra_ghost[2*d + 1] =
hypre_max(extra_ghost[2*d + 1], hypre_IndexD(stencil_shape[i], d));
}
}
}
for (d = 0; d < 3; d++)
{
num_ghost[2*d] += extra_ghost[2*d];
num_ghost[2*d + 1] += extra_ghost[2*d + 1];
}
/*-----------------------------------------------------------------------
* Set up data_space
*-----------------------------------------------------------------------*/
if (hypre_StructMatrixDataSpace(matrix) == NULL)
{
boxes = hypre_StructGridBoxes(grid);
data_space = hypre_BoxArrayCreate(hypre_BoxArraySize(boxes));
hypre_ForBoxI(i, boxes)
{
box = hypre_BoxArrayBox(boxes, i);
data_box = hypre_BoxArrayBox(data_space, i);
hypre_CopyBox(box, data_box);
for (d = 0; d < 3; d++)
{
hypre_BoxIMinD(data_box, d) -= num_ghost[2*d];
hypre_BoxIMaxD(data_box, d) += num_ghost[2*d + 1];
}
}
hypre_StructMatrix *
hypre_PFMGCreateCoarseOp5( hypre_StructMatrix *R,
hypre_StructMatrix *A,
hypre_StructMatrix *P,
hypre_StructGrid *coarse_grid,
HYPRE_Int cdir )
{
hypre_StructMatrix *RAP;
hypre_Index *RAP_stencil_shape;
hypre_StructStencil *RAP_stencil;
HYPRE_Int RAP_stencil_size;
HYPRE_Int RAP_stencil_dim;
HYPRE_Int RAP_num_ghost[] = {1, 1, 1, 1, 1, 1};
hypre_Index index_temp;
HYPRE_Int j, i;
HYPRE_Int stencil_rank;
RAP_stencil_dim = 2;
/*-----------------------------------------------------------------------
* Define RAP_stencil
*-----------------------------------------------------------------------*/
stencil_rank = 0;
/*-----------------------------------------------------------------------
* non-symmetric case
*-----------------------------------------------------------------------*/
if (!hypre_StructMatrixSymmetric(A))
{
/*--------------------------------------------------------------------
* 5 point coarse grid stencil
*--------------------------------------------------------------------*/
RAP_stencil_size = 5;
RAP_stencil_shape = hypre_CTAlloc(hypre_Index, RAP_stencil_size);
for (j = -1; j < 2; j++)
{
for (i = -1; i < 2; i++)
{
/*--------------------------------------------------------------
* Storage for 5 elements (c,w,e,n,s)
*--------------------------------------------------------------*/
if (i*j == 0)
{
hypre_SetIndex(index_temp,i,j,0);
MapIndex(index_temp, cdir, RAP_stencil_shape[stencil_rank]);
stencil_rank++;
}
}
}
}
/*-----------------------------------------------------------------------
* symmetric case
*-----------------------------------------------------------------------*/
else
{
/*--------------------------------------------------------------------
* 5 point coarse grid stencil
* Only store the lower triangular part + diagonal = 3 entries,
* lower triangular means the lower triangular part on the matrix
* in the standard lexicographic ordering.
*--------------------------------------------------------------------*/
RAP_stencil_size = 3;
RAP_stencil_shape = hypre_CTAlloc(hypre_Index, RAP_stencil_size);
for (j = -1; j < 1; j++)
{
for (i = -1; i < 1; i++)
{
/*--------------------------------------------------------------
* Store 3 elements in (c,w,s)
*--------------------------------------------------------------*/
if( i*j == 0 )
{
hypre_SetIndex(index_temp,i,j,0);
MapIndex(index_temp, cdir, RAP_stencil_shape[stencil_rank]);
stencil_rank++;
}
}
}
}
RAP_stencil = hypre_StructStencilCreate(RAP_stencil_dim, RAP_stencil_size,
RAP_stencil_shape);
RAP = hypre_StructMatrixCreate(hypre_StructMatrixComm(A),
coarse_grid, RAP_stencil);
hypre_StructStencilDestroy(RAP_stencil);
/*-----------------------------------------------------------------------
* Coarse operator in symmetric iff fine operator is
*-----------------------------------------------------------------------*/
hypre_StructMatrixSymmetric(RAP) = hypre_StructMatrixSymmetric(A);
/*-----------------------------------------------------------------------
* Set number of ghost points - one one each boundary
*-----------------------------------------------------------------------*/
hypre_StructMatrixSetNumGhost(RAP, RAP_num_ghost);
return RAP;
}
hypre_StructMatrix *
hypre_SMG2CreateRAPOp( hypre_StructMatrix *R,
hypre_StructMatrix *A,
hypre_StructMatrix *PT,
hypre_StructGrid *coarse_grid )
{
hypre_StructMatrix *RAP;
hypre_Index *RAP_stencil_shape;
hypre_StructStencil *RAP_stencil;
int RAP_stencil_size;
int RAP_stencil_dim;
int RAP_num_ghost[] = {1, 1, 1, 1, 0, 0};
int j, i;
int stencil_rank;
RAP_stencil_dim = 2;
/*-----------------------------------------------------------------------
* Define RAP_stencil
*-----------------------------------------------------------------------*/
stencil_rank = 0;
/*-----------------------------------------------------------------------
* non-symmetric case
*-----------------------------------------------------------------------*/
if (!hypre_StructMatrixSymmetric(A))
{
/*--------------------------------------------------------------------
* 5 or 9 point fine grid stencil produces 9 point RAP
*--------------------------------------------------------------------*/
RAP_stencil_size = 9;
RAP_stencil_shape = hypre_CTAlloc(hypre_Index, RAP_stencil_size);
for (j = -1; j < 2; j++)
{
for (i = -1; i < 2; i++)
{
/*--------------------------------------------------------------
* Storage for 9 elements (c,w,e,n,s,sw,se,nw,se)
*--------------------------------------------------------------*/
hypre_SetIndex(RAP_stencil_shape[stencil_rank],i,j,0);
stencil_rank++;
}
}
}
/*-----------------------------------------------------------------------
* symmetric case
*-----------------------------------------------------------------------*/
else
{
/*--------------------------------------------------------------------
* 5 or 9 point fine grid stencil produces 9 point RAP
* Only store the lower triangular part + diagonal = 5 entries,
* lower triangular means the lower triangular part on the matrix
* in the standard lexicalgraphic ordering.
*--------------------------------------------------------------------*/
RAP_stencil_size = 5;
RAP_stencil_shape = hypre_CTAlloc(hypre_Index, RAP_stencil_size);
for (j = -1; j < 1; j++)
{
for (i = -1; i < 2; i++)
{
/*--------------------------------------------------------------
* Store 5 elements in (c,w,s,sw,se)
*--------------------------------------------------------------*/
if( i+j <=0 )
{
hypre_SetIndex(RAP_stencil_shape[stencil_rank],i,j,0);
stencil_rank++;
}
}
}
}
RAP_stencil = hypre_StructStencilCreate(RAP_stencil_dim, RAP_stencil_size,
RAP_stencil_shape);
RAP = hypre_StructMatrixCreate(hypre_StructMatrixComm(A),
coarse_grid, RAP_stencil);
hypre_StructStencilDestroy(RAP_stencil);
/*-----------------------------------------------------------------------
* Coarse operator in symmetric iff fine operator is
*-----------------------------------------------------------------------*/
hypre_StructMatrixSymmetric(RAP) = hypre_StructMatrixSymmetric(A);
/*-----------------------------------------------------------------------
* Set number of ghost points
*-----------------------------------------------------------------------*/
if (hypre_StructMatrixSymmetric(A))
{
RAP_num_ghost[1] = 0;
RAP_num_ghost[3] = 0;
}
hypre_StructMatrixSetNumGhost(RAP, RAP_num_ghost);
return RAP;
}
HYPRE_Int
hypre_PFMGSetupRAPOp( hypre_StructMatrix *R,
hypre_StructMatrix *A,
hypre_StructMatrix *P,
HYPRE_Int cdir,
hypre_Index cindex,
hypre_Index cstride,
HYPRE_Int rap_type,
hypre_StructMatrix *Ac )
{
HYPRE_Int P_stored_as_transpose = 0;
hypre_StructStencil *stencil;
stencil = hypre_StructMatrixStencil(A);
if (rap_type == 0)
{
switch (hypre_StructStencilNDim(stencil))
{
case 2:
/*--------------------------------------------------------------------
* Set lower triangular (+ diagonal) coefficients
*--------------------------------------------------------------------*/
hypre_PFMG2BuildRAPSym(A, P, R, cdir, cindex, cstride, Ac);
/*--------------------------------------------------------------------
* For non-symmetric A, set upper triangular coefficients as well
*--------------------------------------------------------------------*/
if(!hypre_StructMatrixSymmetric(A))
hypre_PFMG2BuildRAPNoSym(A, P, R, cdir, cindex, cstride, Ac);
break;
case 3:
/*--------------------------------------------------------------------
* Set lower triangular (+ diagonal) coefficients
*--------------------------------------------------------------------*/
hypre_PFMG3BuildRAPSym(A, P, R, cdir, cindex, cstride, Ac);
/*--------------------------------------------------------------------
* For non-symmetric A, set upper triangular coefficients as well
*--------------------------------------------------------------------*/
if(!hypre_StructMatrixSymmetric(A))
hypre_PFMG3BuildRAPNoSym(A, P, R, cdir, cindex, cstride, Ac);
break;
}
}
else if (rap_type == 1)
{
switch (hypre_StructStencilNDim(stencil))
{
case 2:
hypre_PFMGBuildCoarseOp5(A, P, R, cdir, cindex, cstride, Ac);
break;
case 3:
hypre_PFMGBuildCoarseOp7(A, P, R, cdir, cindex, cstride, Ac);
break;
}
}
else if (rap_type == 2)
{
hypre_SemiBuildRAP(A, P, R, cdir, cindex, cstride,
P_stored_as_transpose, Ac);
}
hypre_StructMatrixAssemble(Ac);
return hypre_error_flag;
}
HYPRE_Int
hypre_SMGSetupRAPOp( hypre_StructMatrix *R,
hypre_StructMatrix *A,
hypre_StructMatrix *PT,
hypre_StructMatrix *Ac,
hypre_Index cindex,
hypre_Index cstride )
{
HYPRE_Int ierr = 0;
#if NEWRAP
HYPRE_Int cdir;
HYPRE_Int P_stored_as_transpose = 1;
#endif
hypre_StructStencil *stencil;
stencil = hypre_StructMatrixStencil(A);
#if OLDRAP
switch (hypre_StructStencilDim(stencil))
{
case 2:
/*--------------------------------------------------------------------
* Set lower triangular (+ diagonal) coefficients
*--------------------------------------------------------------------*/
ierr = hypre_SMG2BuildRAPSym(A, PT, R, Ac, cindex, cstride);
/*--------------------------------------------------------------------
* For non-symmetric A, set upper triangular coefficients as well
*--------------------------------------------------------------------*/
if(!hypre_StructMatrixSymmetric(A))
{
ierr += hypre_SMG2BuildRAPNoSym(A, PT, R, Ac, cindex, cstride);
/*-----------------------------------------------------------------
* Collapse stencil for periodic probems on coarsest grid.
*-----------------------------------------------------------------*/
ierr = hypre_SMG2RAPPeriodicNoSym(Ac, cindex, cstride);
}
else
{
/*-----------------------------------------------------------------
* Collapse stencil for periodic problems on coarsest grid.
*-----------------------------------------------------------------*/
ierr = hypre_SMG2RAPPeriodicSym(Ac, cindex, cstride);
}
break;
case 3:
/*--------------------------------------------------------------------
* Set lower triangular (+ diagonal) coefficients
*--------------------------------------------------------------------*/
ierr = hypre_SMG3BuildRAPSym(A, PT, R, Ac, cindex, cstride);
/*--------------------------------------------------------------------
* For non-symmetric A, set upper triangular coefficients as well
*--------------------------------------------------------------------*/
if(!hypre_StructMatrixSymmetric(A))
{
ierr += hypre_SMG3BuildRAPNoSym(A, PT, R, Ac, cindex, cstride);
/*-----------------------------------------------------------------
* Collapse stencil for periodic probems on coarsest grid.
*-----------------------------------------------------------------*/
ierr = hypre_SMG3RAPPeriodicNoSym(Ac, cindex, cstride);
}
else
{
/*-----------------------------------------------------------------
* Collapse stencil for periodic problems on coarsest grid.
*-----------------------------------------------------------------*/
ierr = hypre_SMG3RAPPeriodicSym(Ac, cindex, cstride);
}
break;
}
#endif
#if NEWRAP
switch (hypre_StructStencilDim(stencil))
{
case 2:
cdir = 1;
ierr = hypre_SemiBuildRAP(A, PT, R, cdir, cindex, cstride,
P_stored_as_transpose, Ac);
break;
case 3:
cdir = 2;
ierr = hypre_SemiBuildRAP(A, PT, R, cdir, cindex, cstride,
P_stored_as_transpose, Ac);
break;
}
#endif
hypre_StructMatrixAssemble(Ac);
return ierr;
}
hypre_StructMatrixDataAlloced(mask) = 0;
hypre_StructMatrixDataSize(mask) = hypre_StructMatrixDataSize(matrix);
data_space = hypre_StructMatrixDataSpace(matrix);
data_indices = hypre_StructMatrixDataIndices(matrix);
mask_data_indices = hypre_CTAlloc(int *, hypre_BoxArraySize(data_space));
hypre_ForBoxI(i, data_space)
{
mask_data_indices[i] = hypre_TAlloc(int, num_stencil_indices);
for (j = 0; j < num_stencil_indices; j++)
{
mask_data_indices[i][j] = data_indices[i][stencil_indices[j]];
}
}
hypre_StructMatrixDataIndices(mask) = mask_data_indices;
hypre_StructMatrixSymmetric(mask) = hypre_StructMatrixSymmetric(matrix);
hypre_StructMatrixSymmElements(mask) = hypre_TAlloc(int, stencil_size);
for (i = 0; i < stencil_size; i++)
{
hypre_StructMatrixSymmElements(mask)[i] =
hypre_StructMatrixSymmElements(matrix)[i];
}
for (i = 0; i < 6; i++)
{
hypre_StructMatrixNumGhost(mask)[i] =
hypre_StructMatrixNumGhost(matrix)[i];
}
hypre_StructMatrixGlobalSize(mask) =
