hypre_StructMatrix *
hypre_SMGCreateRAPOp( hypre_StructMatrix *R,
hypre_StructMatrix *A,
hypre_StructMatrix *PT,
hypre_StructGrid *coarse_grid )
{
hypre_StructMatrix *RAP;
hypre_StructStencil *stencil;
#if NEWRAP
HYPRE_Int cdir;
HYPRE_Int P_stored_as_transpose = 1;
#endif
stencil = hypre_StructMatrixStencil(A);
#if OLDRAP
switch (hypre_StructStencilDim(stencil))
{
case 2:
RAP = hypre_SMG2CreateRAPOp(R ,A, PT, coarse_grid);
break;
case 3:
RAP = hypre_SMG3CreateRAPOp(R ,A, PT, coarse_grid);
break;
}
#endif
#if NEWRAP
switch (hypre_StructStencilDim(stencil))
{
case 2:
cdir = 1;
RAP = hypre_SemiCreateRAPOp(R ,A, PT, coarse_grid, cdir,
P_stored_as_transpose);
break;
case 3:
cdir = 2;
RAP = hypre_SemiCreateRAPOp(R ,A, PT, coarse_grid, cdir,
P_stored_as_transpose);
break;
}
#endif
return RAP;
}
int
hypre_SMGRelaxSetNewMatrixStencil( void *relax_vdata,
hypre_StructStencil *diff_stencil )
{
hypre_SMGRelaxData *relax_data = relax_vdata;
hypre_Index *stencil_shape = hypre_StructStencilShape(diff_stencil);
int stencil_size = hypre_StructStencilSize(diff_stencil);
int stencil_dim = hypre_StructStencilDim(diff_stencil);
int i;
int ierr = 0;
for (i = 0; i < stencil_size; i++)
{
if (hypre_IndexD(stencil_shape[i], (stencil_dim - 1)) != 0)
{
(relax_data -> setup_a_rem) = 1;
}
else
{
(relax_data -> setup_a_sol) = 1;
}
}
return ierr;
}
hypre_StructMatrix *
hypre_SparseMSGCreateRAPOp( hypre_StructMatrix *R,
hypre_StructMatrix *A,
hypre_StructMatrix *P,
hypre_StructGrid *coarse_grid,
HYPRE_Int cdir )
{
hypre_StructMatrix *RAP;
hypre_StructStencil *stencil;
stencil = hypre_StructMatrixStencil(A);
switch (hypre_StructStencilDim(stencil))
{
case 2:
RAP = hypre_SparseMSG2CreateRAPOp(R ,A, P, coarse_grid, cdir);
break;
case 3:
RAP = hypre_SparseMSG3CreateRAPOp(R ,A, P, coarse_grid, cdir);
break;
}
return RAP;
}
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_StructStencilDim(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_StructStencil *
hypre_StructStencilCreate( HYPRE_Int dim,
HYPRE_Int size,
hypre_Index *shape )
{
hypre_StructStencil *stencil;
stencil = hypre_TAlloc(hypre_StructStencil, 1);
hypre_StructStencilShape(stencil) = shape;
hypre_StructStencilSize(stencil) = size;
hypre_StructStencilDim(stencil) = dim;
hypre_StructStencilRefCount(stencil) = 1;
return stencil;
}
int
HYPRE_StructStencilSetElement( HYPRE_StructStencil stencil,
int element_index,
int *offset )
{
int ierr = 0;
hypre_Index *shape;
int d;
shape = hypre_StructStencilShape(stencil);
hypre_ClearIndex(shape[element_index]);
for (d = 0; d < hypre_StructStencilDim(stencil); d++)
{
hypre_IndexD(shape[element_index], d) = offset[d];
}
return ierr;
}
HYPRE_Int
hypre_StructStencilSymmetrize( hypre_StructStencil *stencil,
hypre_StructStencil **symm_stencil_ptr,
HYPRE_Int **symm_elements_ptr )
{
hypre_Index *stencil_shape = hypre_StructStencilShape(stencil);
HYPRE_Int stencil_size = hypre_StructStencilSize(stencil);
hypre_StructStencil *symm_stencil;
hypre_Index *symm_stencil_shape;
HYPRE_Int symm_stencil_size;
HYPRE_Int *symm_elements;
HYPRE_Int no_symmetric_stencil_element;
HYPRE_Int i, j, d;
/*------------------------------------------------------
* Copy stencil elements into `symm_stencil_shape'
*------------------------------------------------------*/
symm_stencil_shape = hypre_CTAlloc(hypre_Index, 2*stencil_size);
for (i = 0; i < stencil_size; i++)
{
hypre_CopyIndex(stencil_shape[i], symm_stencil_shape[i]);
}
/*------------------------------------------------------
* Create symmetric stencil elements and `symm_elements'
*------------------------------------------------------*/
symm_elements = hypre_CTAlloc(HYPRE_Int, 2*stencil_size);
for (i = 0; i < 2*stencil_size; i++)
symm_elements[i] = -1;
symm_stencil_size = stencil_size;
for (i = 0; i < stencil_size; i++)
{
if (symm_elements[i] < 0)
{
/* note: start at i to handle "center" element correctly */
no_symmetric_stencil_element = 1;
for (j = i; j < stencil_size; j++)
{
if ( (hypre_IndexX(symm_stencil_shape[j]) ==
-hypre_IndexX(symm_stencil_shape[i]) ) &&
(hypre_IndexY(symm_stencil_shape[j]) ==
-hypre_IndexY(symm_stencil_shape[i]) ) &&
(hypre_IndexZ(symm_stencil_shape[j]) ==
-hypre_IndexZ(symm_stencil_shape[i]) ) )
{
/* only "off-center" elements have symmetric entries */
if (i != j)
symm_elements[j] = i;
no_symmetric_stencil_element = 0;
}
}
if (no_symmetric_stencil_element)
{
/* add symmetric stencil element to `symm_stencil' */
for (d = 0; d < 3; d++)
{
hypre_IndexD(symm_stencil_shape[symm_stencil_size], d) =
-hypre_IndexD(symm_stencil_shape[i], d);
}
symm_elements[symm_stencil_size] = i;
symm_stencil_size++;
}
}
}
symm_stencil = hypre_StructStencilCreate(hypre_StructStencilDim(stencil),
symm_stencil_size,
symm_stencil_shape);
*symm_stencil_ptr = symm_stencil;
*symm_elements_ptr = symm_elements;
return hypre_error_flag;
}
hypre_SStructPMatrix *
hypre_SysPFMGCreateRAPOp( hypre_SStructPMatrix *R,
hypre_SStructPMatrix *A,
hypre_SStructPMatrix *P,
hypre_SStructPGrid *coarse_grid,
HYPRE_Int cdir )
{
hypre_SStructPMatrix *RAP;
HYPRE_Int ndim;
HYPRE_Int nvars;
hypre_SStructVariable vartype;
hypre_SStructStencil **RAP_stencils;
hypre_StructMatrix *RAP_s;
hypre_StructMatrix *R_s;
hypre_StructMatrix *A_s;
hypre_StructMatrix *P_s;
hypre_Index **RAP_shapes;
hypre_StructStencil *sstencil;
hypre_Index *shape;
HYPRE_Int s;
HYPRE_Int *sstencil_sizes;
HYPRE_Int stencil_size;
hypre_StructGrid *cgrid;
HYPRE_Int vi,vj;
HYPRE_Int sten_cntr;
HYPRE_Int P_stored_as_transpose = 0;
ndim = hypre_StructStencilDim(hypre_SStructPMatrixSStencil(A, 0, 0));
nvars = hypre_SStructPMatrixNVars(A);
vartype = hypre_SStructPGridVarType(coarse_grid, 0);
cgrid = hypre_SStructPGridVTSGrid(coarse_grid, vartype);
RAP_stencils = hypre_CTAlloc(hypre_SStructStencil *, nvars);
RAP_shapes = hypre_CTAlloc(hypre_Index *, nvars);
sstencil_sizes = hypre_CTAlloc(HYPRE_Int, nvars);
/*--------------------------------------------------------------------------
* Symmetry within a block is exploited, but not symmetry of the form
* A_{vi,vj} = A_{vj,vi}^T.
*--------------------------------------------------------------------------*/
for (vi = 0; vi < nvars; vi++)
{
R_s = hypre_SStructPMatrixSMatrix(R, vi, vi);
stencil_size = 0;
for (vj = 0; vj < nvars; vj++)
{
A_s = hypre_SStructPMatrixSMatrix(A, vi, vj);
P_s = hypre_SStructPMatrixSMatrix(P, vj, vj);
sstencil_sizes[vj] = 0;
if (A_s != NULL)
{
RAP_s = hypre_SemiCreateRAPOp(R_s, A_s, P_s,
cgrid, cdir,
P_stored_as_transpose);
/* Just want stencil for RAP */
hypre_StructMatrixInitializeShell(RAP_s);
sstencil = hypre_StructMatrixStencil(RAP_s);
shape = hypre_StructStencilShape(sstencil);
sstencil_sizes[vj] = hypre_StructStencilSize(sstencil);
stencil_size += sstencil_sizes[vj];
RAP_shapes[vj] = hypre_CTAlloc(hypre_Index,
sstencil_sizes[vj]);
for (s = 0; s < sstencil_sizes[vj]; s++)
{
hypre_CopyIndex(shape[s],RAP_shapes[vj][s]);
}
hypre_StructMatrixDestroy(RAP_s);
}
}
HYPRE_SStructStencilCreate(ndim, stencil_size, &RAP_stencils[vi]);
sten_cntr = 0;
for (vj = 0; vj < nvars; vj++)
{
if (sstencil_sizes[vj] > 0)
{
for (s = 0; s < sstencil_sizes[vj]; s++)
{
HYPRE_SStructStencilSetEntry(RAP_stencils[vi],
sten_cntr, RAP_shapes[vj][s], vj);
sten_cntr++;
}
hypre_TFree(RAP_shapes[vj]);
}
}
}
/* create RAP Pmatrix */
hypre_SStructPMatrixCreate(hypre_SStructPMatrixComm(A),
coarse_grid, RAP_stencils, &RAP);
hypre_TFree(RAP_shapes);
hypre_TFree(sstencil_sizes);
return RAP;
}
int
hypre_SStructPMatrixCreate( MPI_Comm comm,
hypre_SStructPGrid *pgrid,
hypre_SStructStencil **stencils,
hypre_SStructPMatrix **pmatrix_ptr )
{
hypre_SStructPMatrix *pmatrix;
int nvars;
int **smaps;
hypre_StructStencil ***sstencils;
hypre_StructMatrix ***smatrices;
int **symmetric;
hypre_StructStencil *sstencil;
int *vars;
hypre_Index *sstencil_shape;
int sstencil_size;
int new_dim;
int *new_sizes;
hypre_Index **new_shapes;
int size;
hypre_StructGrid *sgrid;
int vi, vj;
int i, j, k;
pmatrix = hypre_TAlloc(hypre_SStructPMatrix, 1);
hypre_SStructPMatrixComm(pmatrix) = comm;
hypre_SStructPMatrixPGrid(pmatrix) = pgrid;
hypre_SStructPMatrixStencils(pmatrix) = stencils;
nvars = hypre_SStructPGridNVars(pgrid);
hypre_SStructPMatrixNVars(pmatrix) = nvars;
/* create sstencils */
smaps = hypre_TAlloc(int *, nvars);
sstencils = hypre_TAlloc(hypre_StructStencil **, nvars);
new_sizes = hypre_TAlloc(int, nvars);
new_shapes = hypre_TAlloc(hypre_Index *, nvars);
size = 0;
for (vi = 0; vi < nvars; vi++)
{
sstencils[vi] = hypre_TAlloc(hypre_StructStencil *, nvars);
for (vj = 0; vj < nvars; vj++)
{
sstencils[vi][vj] = NULL;
new_sizes[vj] = 0;
}
sstencil = hypre_SStructStencilSStencil(stencils[vi]);
vars = hypre_SStructStencilVars(stencils[vi]);
sstencil_shape = hypre_StructStencilShape(sstencil);
sstencil_size = hypre_StructStencilSize(sstencil);
smaps[vi] = hypre_TAlloc(int, sstencil_size);
for (i = 0; i < sstencil_size; i++)
{
j = vars[i];
new_sizes[j]++;
}
for (vj = 0; vj < nvars; vj++)
{
if (new_sizes[vj])
{
new_shapes[vj] = hypre_TAlloc(hypre_Index, new_sizes[vj]);
new_sizes[vj] = 0;
}
}
for (i = 0; i < sstencil_size; i++)
{
j = vars[i];
k = new_sizes[j];
hypre_CopyIndex(sstencil_shape[i], new_shapes[j][k]);
smaps[vi][i] = k;
new_sizes[j]++;
}
new_dim = hypre_StructStencilDim(sstencil);
for (vj = 0; vj < nvars; vj++)
{
if (new_sizes[vj])
{
sstencils[vi][vj] = hypre_StructStencilCreate(new_dim,
new_sizes[vj],
new_shapes[vj]);
}
size = hypre_max(size, new_sizes[vj]);
}
}
hypre_SStructPMatrixSMaps(pmatrix) = smaps;
hypre_SStructPMatrixSStencils(pmatrix) = sstencils;
hypre_TFree(new_sizes);
hypre_TFree(new_shapes);
/* create smatrices */
smatrices = hypre_TAlloc(hypre_StructMatrix **, nvars);
for (vi = 0; vi < nvars; vi++)
{
smatrices[vi] = hypre_TAlloc(hypre_StructMatrix *, nvars);
for (vj = 0; vj < nvars; vj++)
{
smatrices[vi][vj] = NULL;
if (sstencils[vi][vj] != NULL)
{
sgrid = hypre_SStructPGridSGrid(pgrid, vi);
smatrices[vi][vj] =
hypre_StructMatrixCreate(comm, sgrid, sstencils[vi][vj]);
}
}
}
hypre_SStructPMatrixSMatrices(pmatrix) = smatrices;
/* create symmetric */
symmetric = hypre_TAlloc(int *, nvars);
for (vi = 0; vi < nvars; vi++)
{
symmetric[vi] = hypre_TAlloc(int, nvars);
for (vj = 0; vj < nvars; vj++)
{
symmetric[vi][vj] = 0;
}
}
hypre_SStructPMatrixSymmetric(pmatrix) = symmetric;
hypre_SStructPMatrixSEntriesSize(pmatrix) = size;
hypre_SStructPMatrixSEntries(pmatrix) = hypre_TAlloc(int, size);
hypre_SStructPMatrixRefCount(pmatrix) = 1;
*pmatrix_ptr = pmatrix;
return hypre_error_flag;
}
HYPRE_Int
hypre_SMGSolve( void *smg_vdata,
hypre_StructMatrix *A,
hypre_StructVector *b,
hypre_StructVector *x )
{
hypre_SMGData *smg_data = smg_vdata;
double tol = (smg_data -> tol);
HYPRE_Int max_iter = (smg_data -> max_iter);
HYPRE_Int rel_change = (smg_data -> rel_change);
HYPRE_Int zero_guess = (smg_data -> zero_guess);
HYPRE_Int num_levels = (smg_data -> num_levels);
HYPRE_Int num_pre_relax = (smg_data -> num_pre_relax);
HYPRE_Int num_post_relax = (smg_data -> num_post_relax);
hypre_IndexRef base_index = (smg_data -> base_index);
hypre_IndexRef base_stride = (smg_data -> base_stride);
hypre_StructMatrix **A_l = (smg_data -> A_l);
hypre_StructMatrix **PT_l = (smg_data -> PT_l);
hypre_StructMatrix **R_l = (smg_data -> R_l);
hypre_StructVector **b_l = (smg_data -> b_l);
hypre_StructVector **x_l = (smg_data -> x_l);
hypre_StructVector **r_l = (smg_data -> r_l);
hypre_StructVector **e_l = (smg_data -> e_l);
void **relax_data_l = (smg_data -> relax_data_l);
void **residual_data_l = (smg_data -> residual_data_l);
void **restrict_data_l = (smg_data -> restrict_data_l);
void **interp_data_l = (smg_data -> interp_data_l);
HYPRE_Int logging = (smg_data -> logging);
double *norms = (smg_data -> norms);
double *rel_norms = (smg_data -> rel_norms);
double b_dot_b = 0, r_dot_r, eps = 0;
double e_dot_e = 0, x_dot_x = 1;
HYPRE_Int i, l;
#if DEBUG
char filename[255];
#endif
/*-----------------------------------------------------
* Initialize some things and deal with special cases
*-----------------------------------------------------*/
hypre_BeginTiming(smg_data -> time_index);
hypre_StructMatrixDestroy(A_l[0]);
hypre_StructVectorDestroy(b_l[0]);
hypre_StructVectorDestroy(x_l[0]);
A_l[0] = hypre_StructMatrixRef(A);
b_l[0] = hypre_StructVectorRef(b);
x_l[0] = hypre_StructVectorRef(x);
(smg_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(smg_data -> time_index);
return hypre_error_flag;
}
/* part of convergence check */
if (tol > 0.0)
{
/* eps = (tol^2) */
b_dot_b = hypre_StructInnerProd(b_l[0], b_l[0]);
eps = tol*tol;
/* if rhs is zero, return a zero solution */
if (b_dot_b == 0.0)
{
hypre_StructVectorSetConstantValues(x, 0.0);
if (logging > 0)
{
norms[0] = 0.0;
rel_norms[0] = 0.0;
}
hypre_EndTiming(smg_data -> time_index);
return hypre_error_flag;
}
}
/*-----------------------------------------------------
* Do V-cycles:
* For each index l, "fine" = l, "coarse" = (l+1)
*-----------------------------------------------------*/
for (i = 0; i < max_iter; i++)
{
/*--------------------------------------------------
* Down cycle
*--------------------------------------------------*/
/* fine grid pre-relaxation */
if (num_levels > 1)
{
hypre_SMGRelaxSetRegSpaceRank(relax_data_l[0], 0, 0);
hypre_SMGRelaxSetRegSpaceRank(relax_data_l[0], 1, 1);
}
hypre_SMGRelaxSetMaxIter(relax_data_l[0], num_pre_relax);
hypre_SMGRelaxSetZeroGuess(relax_data_l[0], zero_guess);
hypre_SMGRelax(relax_data_l[0], A_l[0], b_l[0], x_l[0]);
zero_guess = 0;
/* compute fine grid residual (b - Ax) */
hypre_SMGResidual(residual_data_l[0], A_l[0], x_l[0], b_l[0], r_l[0]);
/* convergence check */
if (tol > 0.0)
{
r_dot_r = hypre_StructInnerProd(r_l[0], r_l[0]);
if (logging > 0)
{
norms[i] = sqrt(r_dot_r);
if (b_dot_b > 0)
rel_norms[i] = sqrt(r_dot_r/b_dot_b);
else
rel_norms[i] = 0.0;
}
/* always do at least 1 V-cycle */
if ((r_dot_r/b_dot_b < eps) && (i > 0))
{
if (rel_change)
{
if ((e_dot_e/x_dot_x) < eps)
break;
}
else
{
break;
}
}
}
if (num_levels > 1)
{
/* restrict fine grid residual */
hypre_SemiRestrict(restrict_data_l[0], R_l[0], r_l[0], b_l[1]);
#if DEBUG
if(hypre_StructStencilDim(hypre_StructMatrixStencil(A)) == 3)
{
hypre_sprintf(filename, "zout_xdown.%02d", 0);
hypre_StructVectorPrint(filename, x_l[0], 0);
hypre_sprintf(filename, "zout_rdown.%02d", 0);
hypre_StructVectorPrint(filename, r_l[0], 0);
hypre_sprintf(filename, "zout_b.%02d", 1);
hypre_StructVectorPrint(filename, b_l[1], 0);
}
#endif
for (l = 1; l <= (num_levels - 2); l++)
{
/* pre-relaxation */
hypre_SMGRelaxSetRegSpaceRank(relax_data_l[l], 0, 0);
hypre_SMGRelaxSetRegSpaceRank(relax_data_l[l], 1, 1);
hypre_SMGRelaxSetMaxIter(relax_data_l[l], num_pre_relax);
hypre_SMGRelaxSetZeroGuess(relax_data_l[l], 1);
hypre_SMGRelax(relax_data_l[l], A_l[l], b_l[l], x_l[l]);
/* compute residual (b - Ax) */
hypre_SMGResidual(residual_data_l[l],
A_l[l], x_l[l], b_l[l], r_l[l]);
/* restrict residual */
hypre_SemiRestrict(restrict_data_l[l], R_l[l], r_l[l], b_l[l+1]);
#if DEBUG
if(hypre_StructStencilDim(hypre_StructMatrixStencil(A)) == 3)
{
hypre_sprintf(filename, "zout_xdown.%02d", l);
hypre_StructVectorPrint(filename, x_l[l], 0);
hypre_sprintf(filename, "zout_rdown.%02d", l);
hypre_StructVectorPrint(filename, r_l[l], 0);
hypre_sprintf(filename, "zout_b.%02d", l+1);
hypre_StructVectorPrint(filename, b_l[l+1], 0);
}
#endif
}
/*--------------------------------------------------
* Bottom
*--------------------------------------------------*/
hypre_SMGRelaxSetZeroGuess(relax_data_l[l], 1);
hypre_SMGRelax(relax_data_l[l], A_l[l], b_l[l], x_l[l]);
#if DEBUG
if(hypre_StructStencilDim(hypre_StructMatrixStencil(A)) == 3)
{
hypre_sprintf(filename, "zout_xbottom.%02d", l);
hypre_StructVectorPrint(filename, x_l[l], 0);
}
#endif
/*--------------------------------------------------
* Up cycle
*--------------------------------------------------*/
for (l = (num_levels - 2); l >= 1; l--)
{
/* interpolate error and correct (x = x + Pe_c) */
hypre_SemiInterp(interp_data_l[l], PT_l[l], x_l[l+1], e_l[l]);
hypre_StructAxpy(1.0, e_l[l], x_l[l]);
#if DEBUG
if(hypre_StructStencilDim(hypre_StructMatrixStencil(A)) == 3)
{
hypre_sprintf(filename, "zout_eup.%02d", l);
hypre_StructVectorPrint(filename, e_l[l], 0);
hypre_sprintf(filename, "zout_xup.%02d", l);
hypre_StructVectorPrint(filename, x_l[l], 0);
}
#endif
/* post-relaxation */
hypre_SMGRelaxSetRegSpaceRank(relax_data_l[l], 0, 1);
hypre_SMGRelaxSetRegSpaceRank(relax_data_l[l], 1, 0);
hypre_SMGRelaxSetMaxIter(relax_data_l[l], num_post_relax);
hypre_SMGRelaxSetZeroGuess(relax_data_l[l], 0);
hypre_SMGRelax(relax_data_l[l], A_l[l], b_l[l], x_l[l]);
}
/* interpolate error and correct on fine grid (x = x + Pe_c) */
hypre_SemiInterp(interp_data_l[0], PT_l[0], x_l[1], e_l[0]);
hypre_SMGAxpy(1.0, e_l[0], x_l[0], base_index, base_stride);
#if DEBUG
if(hypre_StructStencilDim(hypre_StructMatrixStencil(A)) == 3)
{
hypre_sprintf(filename, "zout_eup.%02d", 0);
hypre_StructVectorPrint(filename, e_l[0], 0);
hypre_sprintf(filename, "zout_xup.%02d", 0);
hypre_StructVectorPrint(filename, x_l[0], 0);
}
#endif
}
/* part of convergence check */
if ((tol > 0.0) && (rel_change))
{
if (num_levels > 1)
{
e_dot_e = hypre_StructInnerProd(e_l[0], e_l[0]);
x_dot_x = hypre_StructInnerProd(x_l[0], x_l[0]);
}
else
{
e_dot_e = 0.0;
x_dot_x = 1.0;
}
}
/* fine grid post-relaxation */
if (num_levels > 1)
{
hypre_SMGRelaxSetRegSpaceRank(relax_data_l[0], 0, 1);
hypre_SMGRelaxSetRegSpaceRank(relax_data_l[0], 1, 0);
}
hypre_SMGRelaxSetMaxIter(relax_data_l[0], num_post_relax);
hypre_SMGRelaxSetZeroGuess(relax_data_l[0], 0);
hypre_SMGRelax(relax_data_l[0], A_l[0], b_l[0], x_l[0]);
(smg_data -> num_iterations) = (i + 1);
}
hypre_EndTiming(smg_data -> time_index);
return hypre_error_flag;
}
int
hypre_SMGRelaxSetupASol( void *relax_vdata,
hypre_StructMatrix *A,
hypre_StructVector *b,
hypre_StructVector *x )
{
hypre_SMGRelaxData *relax_data = relax_vdata;
int num_spaces = (relax_data -> num_spaces);
int *space_indices = (relax_data -> space_indices);
int *space_strides = (relax_data -> space_strides);
hypre_StructVector *temp_vec = (relax_data -> temp_vec);
int num_pre_relax = (relax_data -> num_pre_relax);
int num_post_relax = (relax_data -> num_post_relax);
hypre_StructStencil *stencil = hypre_StructMatrixStencil(A);
hypre_Index *stencil_shape = hypre_StructStencilShape(stencil);
int stencil_size = hypre_StructStencilSize(stencil);
int stencil_dim = hypre_StructStencilDim(stencil);
hypre_StructMatrix *A_sol;
void **solve_data;
hypre_Index base_index;
hypre_Index base_stride;
int num_stencil_indices;
int *stencil_indices;
int i;
int ierr = 0;
/*----------------------------------------------------------
* Free up old data before putting new data into structure
*----------------------------------------------------------*/
hypre_SMGRelaxDestroyASol(relax_vdata);
/*----------------------------------------------------------
* Set up data
*----------------------------------------------------------*/
hypre_CopyIndex((relax_data -> base_index), base_index);
hypre_CopyIndex((relax_data -> base_stride), base_stride);
stencil_indices = hypre_TAlloc(int, stencil_size);
num_stencil_indices = 0;
for (i = 0; i < stencil_size; i++)
{
if (hypre_IndexD(stencil_shape[i], (stencil_dim - 1)) == 0)
{
stencil_indices[num_stencil_indices] = i;
num_stencil_indices++;
}
}
A_sol = hypre_StructMatrixCreateMask(A, num_stencil_indices, stencil_indices);
hypre_StructStencilDim(hypre_StructMatrixStencil(A_sol)) = stencil_dim - 1;
hypre_TFree(stencil_indices);
/* Set up solve_data */
solve_data = hypre_TAlloc(void *, num_spaces);
for (i = 0; i < num_spaces; i++)
{
hypre_IndexD(base_index, (stencil_dim - 1)) = space_indices[i];
hypre_IndexD(base_stride, (stencil_dim - 1)) = space_strides[i];
if (stencil_dim > 2)
{
solve_data[i] = hypre_SMGCreate(relax_data -> comm);
hypre_SMGSetNumPreRelax( solve_data[i], num_pre_relax);
hypre_SMGSetNumPostRelax( solve_data[i], num_post_relax);
hypre_SMGSetBase(solve_data[i], base_index, base_stride);
hypre_SMGSetMemoryUse(solve_data[i], (relax_data -> memory_use));
hypre_SMGSetTol(solve_data[i], 0.0);
hypre_SMGSetMaxIter(solve_data[i], 1);
hypre_SMGSetup(solve_data[i], A_sol, temp_vec, x);
}
else
{
solve_data[i] = hypre_CyclicReductionCreate(relax_data -> comm);
hypre_CyclicReductionSetBase(solve_data[i], base_index, base_stride);
hypre_CyclicReductionSetup(solve_data[i], A_sol, temp_vec, x);
}
}
(relax_data -> A_sol) = A_sol;
(relax_data -> solve_data) = solve_data;
(relax_data -> setup_a_sol) = 0;
return ierr;
}
int
hypre_SMGRelaxSetupARem( void *relax_vdata,
hypre_StructMatrix *A,
hypre_StructVector *b,
hypre_StructVector *x )
{
hypre_SMGRelaxData *relax_data = relax_vdata;
int num_spaces = (relax_data -> num_spaces);
int *space_indices = (relax_data -> space_indices);
int *space_strides = (relax_data -> space_strides);
hypre_StructVector *temp_vec = (relax_data -> temp_vec);
hypre_StructStencil *stencil = hypre_StructMatrixStencil(A);
hypre_Index *stencil_shape = hypre_StructStencilShape(stencil);
int stencil_size = hypre_StructStencilSize(stencil);
int stencil_dim = hypre_StructStencilDim(stencil);
hypre_StructMatrix *A_rem;
void **residual_data;
hypre_Index base_index;
hypre_Index base_stride;
int num_stencil_indices;
int *stencil_indices;
int i;
int ierr = 0;
/*----------------------------------------------------------
* Free up old data before putting new data into structure
*----------------------------------------------------------*/
hypre_SMGRelaxDestroyARem(relax_vdata);
/*----------------------------------------------------------
* Set up data
*----------------------------------------------------------*/
hypre_CopyIndex((relax_data -> base_index), base_index);
hypre_CopyIndex((relax_data -> base_stride), base_stride);
stencil_indices = hypre_TAlloc(int, stencil_size);
num_stencil_indices = 0;
for (i = 0; i < stencil_size; i++)
{
if (hypre_IndexD(stencil_shape[i], (stencil_dim - 1)) != 0)
{
stencil_indices[num_stencil_indices] = i;
num_stencil_indices++;
}
}
A_rem = hypre_StructMatrixCreateMask(A, num_stencil_indices, stencil_indices);
hypre_TFree(stencil_indices);
/* Set up residual_data */
residual_data = hypre_TAlloc(void *, num_spaces);
for (i = 0; i < num_spaces; i++)
{
hypre_IndexD(base_index, (stencil_dim - 1)) = space_indices[i];
hypre_IndexD(base_stride, (stencil_dim - 1)) = space_strides[i];
residual_data[i] = hypre_SMGResidualCreate();
hypre_SMGResidualSetBase(residual_data[i], base_index, base_stride);
hypre_SMGResidualSetup(residual_data[i], A_rem, x, b, temp_vec);
}
(relax_data -> A_rem) = A_rem;
(relax_data -> residual_data) = residual_data;
(relax_data -> setup_a_rem) = 0;
return ierr;
}
int
hypre_SMGRelaxSetup( void *relax_vdata,
hypre_StructMatrix *A,
hypre_StructVector *b,
hypre_StructVector *x )
{
hypre_SMGRelaxData *relax_data = relax_vdata;
int stencil_dim;
int a_sol_test;
int ierr = 0;
stencil_dim = hypre_StructStencilDim(hypre_StructMatrixStencil(A));
(relax_data -> stencil_dim) = stencil_dim;
hypre_StructMatrixDestroy(relax_data -> A);
hypre_StructVectorDestroy(relax_data -> b);
hypre_StructVectorDestroy(relax_data -> x);
(relax_data -> A) = hypre_StructMatrixRef(A);
(relax_data -> b) = hypre_StructVectorRef(b);
(relax_data -> x) = hypre_StructVectorRef(x);
/*----------------------------------------------------------
* Set up memory according to memory_use parameter.
*
* If a subset of the solver memory is not to be set up
* until the solve is actually done, it's "setup" tag
* should have a value greater than 1.
*----------------------------------------------------------*/
if ((stencil_dim - 1) <= (relax_data -> memory_use))
{
a_sol_test = 1;
}
else
{
a_sol_test = 0;
}
/*----------------------------------------------------------
* Set up the solver
*----------------------------------------------------------*/
if ((relax_data -> setup_temp_vec) > 0)
{
ierr = hypre_SMGRelaxSetupTempVec(relax_vdata, A, b, x);
}
if ((relax_data -> setup_a_rem) > 0)
{
ierr = hypre_SMGRelaxSetupARem(relax_vdata, A, b, x);
}
if ((relax_data -> setup_a_sol) > a_sol_test)
{
ierr = hypre_SMGRelaxSetupASol(relax_vdata, A, b, x);
}
if ((relax_data -> base_box_array) == NULL)
{
ierr = hypre_SMGRelaxSetupBaseBoxArray(relax_vdata, A, b, x);
}
return ierr;
}
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_CFInterfaceExtents: Given a cgrid_box, a fgrid_box, and stencils,
* find the extents of the C/F interface (interface nodes in the C box).
* Boxes corresponding to stencil shifts are stored in the first stencil_size
* boxes, and the union of these are appended to the end of the returned
* box_array.
*--------------------------------------------------------------------------*/
hypre_BoxArray *
hypre_CFInterfaceExtents( hypre_Box *fgrid_box,
hypre_Box *cgrid_box,
hypre_StructStencil *stencils,
hypre_Index rfactors )
{
hypre_BoxArray *stencil_box_extents;
hypre_BoxArray *union_boxes;
hypre_Box *cfine_box;
hypre_Box *box;
hypre_Index stencil_shape, cstart, zero_index, neg_index;
HYPRE_Int stencil_size;
HYPRE_Int abs_stencil;
HYPRE_Int ndim= hypre_StructStencilDim(stencils);
HYPRE_Int i, j;
hypre_ClearIndex(zero_index);
hypre_ClearIndex(neg_index);
for (i= 0; i< ndim; i++)
{
neg_index[i]= -1;
}
hypre_CopyIndex(hypre_BoxIMin(cgrid_box), cstart);
stencil_size = hypre_StructStencilSize(stencils);
stencil_box_extents= hypre_BoxArrayCreate(stencil_size);
union_boxes = hypre_BoxArrayCreate(0);
for (i= 0; i< stencil_size; i++)
{
hypre_CopyIndex(hypre_StructStencilElement(stencils, i), stencil_shape);
AbsStencilShape(stencil_shape, abs_stencil);
if (abs_stencil) /* only do if not the centre stencil */
{
cfine_box= hypre_CF_StenBox(fgrid_box, cgrid_box, stencil_shape, rfactors,
ndim);
if ( hypre_BoxVolume(cfine_box) )
{
hypre_AppendBox(cfine_box, union_boxes);
hypre_CopyBox(cfine_box, hypre_BoxArrayBox(stencil_box_extents, i));
for (j= 0; j< ndim; j++)
{
hypre_BoxIMin(cfine_box)[j]-= cstart[j];
hypre_BoxIMax(cfine_box)[j]-= cstart[j];
}
hypre_CopyBox(cfine_box, hypre_BoxArrayBox(stencil_box_extents, i));
}
else
{
hypre_BoxSetExtents(hypre_BoxArrayBox(stencil_box_extents, i),
zero_index, neg_index);
}
hypre_BoxDestroy(cfine_box);
}
else /* centre */
{
hypre_BoxSetExtents(hypre_BoxArrayBox(stencil_box_extents, i),
zero_index, neg_index);
}
}
/*--------------------------------------------------------------------------
* Union the stencil_box_extents to get the full CF extents and append to
* the end of the stencil_box_extents BoxArray. Then shift the unioned boxes
* by cstart.
*--------------------------------------------------------------------------*/
if (hypre_BoxArraySize(union_boxes) > 1)
{
hypre_UnionBoxes(union_boxes);
}
hypre_ForBoxI(i, union_boxes)
{
hypre_AppendBox(hypre_BoxArrayBox(union_boxes, i), stencil_box_extents);
}
hypre_StructMatrix *
hypre_StructMatrixCreateMask( hypre_StructMatrix *matrix,
int num_stencil_indices,
int *stencil_indices )
{
hypre_StructMatrix *mask;
hypre_StructStencil *stencil;
hypre_Index *stencil_shape;
int stencil_size;
hypre_Index *mask_stencil_shape;
int mask_stencil_size;
hypre_BoxArray *data_space;
int **data_indices;
int **mask_data_indices;
int i, j;
stencil = hypre_StructMatrixStencil(matrix);
stencil_shape = hypre_StructStencilShape(stencil);
stencil_size = hypre_StructStencilSize(stencil);
mask = hypre_CTAlloc(hypre_StructMatrix, 1);
hypre_StructMatrixComm(mask) = hypre_StructMatrixComm(matrix);
hypre_StructGridRef(hypre_StructMatrixGrid(matrix),
&hypre_StructMatrixGrid(mask));
hypre_StructMatrixUserStencil(mask) =
hypre_StructStencilRef(hypre_StructMatrixUserStencil(matrix));
mask_stencil_size = num_stencil_indices;
mask_stencil_shape = hypre_CTAlloc(hypre_Index, num_stencil_indices);
for (i = 0; i < num_stencil_indices; i++)
{
hypre_CopyIndex(stencil_shape[stencil_indices[i]],
mask_stencil_shape[i]);
}
hypre_StructMatrixStencil(mask) =
hypre_StructStencilCreate(hypre_StructStencilDim(stencil),
mask_stencil_size,
mask_stencil_shape);
hypre_StructMatrixNumValues(mask) = hypre_StructMatrixNumValues(matrix);
hypre_StructMatrixDataSpace(mask) =
hypre_BoxArrayDuplicate(hypre_StructMatrixDataSpace(matrix));
hypre_StructMatrixData(mask) = hypre_StructMatrixData(matrix);
hypre_StructMatrixDataAlloced(mask) = 0;
hypre_StructMatrixDataSize(mask) = hypre_StructMatrixDataSize(matrix);
data_space = hypre_StructMatrixDataSpace(matrix);
data_indices = hypre_StructMatrixDataIndices(matrix);
mask_data_indices = hypre_CTAlloc(int *, hypre_BoxArraySize(data_space));
hypre_ForBoxI(i, data_space)
{
mask_data_indices[i] = hypre_TAlloc(int, num_stencil_indices);
for (j = 0; j < num_stencil_indices; j++)
{
mask_data_indices[i][j] = data_indices[i][stencil_indices[j]];
}
}
