HYPRE_Int
hypre_SMGResidualSetup( void *residual_vdata,
hypre_StructMatrix *A,
hypre_StructVector *x,
hypre_StructVector *b,
hypre_StructVector *r )
{
HYPRE_Int ierr = 0;
hypre_SMGResidualData *residual_data = residual_vdata;
hypre_IndexRef base_index = (residual_data -> base_index);
hypre_IndexRef base_stride = (residual_data -> base_stride);
hypre_StructGrid *grid;
hypre_StructStencil *stencil;
hypre_BoxArray *base_points;
hypre_ComputeInfo *compute_info;
hypre_ComputePkg *compute_pkg;
/*----------------------------------------------------------
* Set up base points and the compute package
*----------------------------------------------------------*/
grid = hypre_StructMatrixGrid(A);
stencil = hypre_StructMatrixStencil(A);
base_points = hypre_BoxArrayDuplicate(hypre_StructGridBoxes(grid));
hypre_ProjectBoxArray(base_points, base_index, base_stride);
hypre_CreateComputeInfo(grid, stencil, &compute_info);
hypre_ComputeInfoProjectComp(compute_info, base_index, base_stride);
hypre_ComputePkgCreate(compute_info, hypre_StructVectorDataSpace(x), 1,
grid, &compute_pkg);
/*----------------------------------------------------------
* Set up the residual data structure
*----------------------------------------------------------*/
(residual_data -> A) = hypre_StructMatrixRef(A);
(residual_data -> x) = hypre_StructVectorRef(x);
(residual_data -> b) = hypre_StructVectorRef(b);
(residual_data -> r) = hypre_StructVectorRef(r);
(residual_data -> base_points) = base_points;
(residual_data -> compute_pkg) = compute_pkg;
/*-----------------------------------------------------
* Compute flops
*-----------------------------------------------------*/
(residual_data -> flops) =
(hypre_StructMatrixGlobalSize(A) + hypre_StructVectorGlobalSize(x)) /
(hypre_IndexX(base_stride) *
hypre_IndexY(base_stride) *
hypre_IndexZ(base_stride) );
return ierr;
}
int
hypre_StructMatvecSetup( void *matvec_vdata,
hypre_StructMatrix *A,
hypre_StructVector *x )
{
int ierr = 0;
hypre_StructMatvecData *matvec_data = matvec_vdata;
hypre_StructGrid *grid;
hypre_StructStencil *stencil;
hypre_BoxArrayArray *send_boxes;
hypre_BoxArrayArray *recv_boxes;
int **send_processes;
int **recv_processes;
hypre_BoxArrayArray *indt_boxes;
hypre_BoxArrayArray *dept_boxes;
hypre_Index unit_stride;
hypre_ComputePkg *compute_pkg;
/*----------------------------------------------------------
* Set up the compute package
*----------------------------------------------------------*/
grid = hypre_StructMatrixGrid(A);
stencil = hypre_StructMatrixStencil(A);
hypre_CreateComputeInfo(grid, stencil,
&send_boxes, &recv_boxes,
&send_processes, &recv_processes,
&indt_boxes, &dept_boxes);
hypre_SetIndex(unit_stride, 1, 1, 1);
hypre_ComputePkgCreate(send_boxes, recv_boxes,
unit_stride, unit_stride,
send_processes, recv_processes,
indt_boxes, dept_boxes,
unit_stride,
grid, hypre_StructVectorDataSpace(x), 1,
&compute_pkg);
/*----------------------------------------------------------
* Set up the matvec data structure
*----------------------------------------------------------*/
(matvec_data -> A) = hypre_StructMatrixRef(A);
(matvec_data -> x) = hypre_StructVectorRef(x);
(matvec_data -> compute_pkg) = compute_pkg;
return ierr;
}
HYPRE_Int
hypre_SparseMSGInterpSetup( void *interp_vdata,
hypre_StructMatrix *P,
hypre_StructVector *xc,
hypre_StructVector *e,
hypre_Index cindex,
hypre_Index findex,
hypre_Index stride,
hypre_Index strideP )
{
hypre_SparseMSGInterpData *interp_data = interp_vdata;
hypre_StructGrid *grid;
hypre_StructStencil *stencil;
hypre_ComputeInfo *compute_info;
hypre_ComputePkg *compute_pkg;
HYPRE_Int ierr = 0;
/*----------------------------------------------------------
* Set up the compute package
*----------------------------------------------------------*/
grid = hypre_StructVectorGrid(e);
stencil = hypre_StructMatrixStencil(P);
hypre_CreateComputeInfo(grid, stencil, &compute_info);
hypre_ComputeInfoProjectSend(compute_info, cindex, stride);
hypre_ComputeInfoProjectRecv(compute_info, cindex, stride);
hypre_ComputeInfoProjectComp(compute_info, findex, stride);
hypre_ComputePkgCreate(compute_info, hypre_StructVectorDataSpace(e), 1,
grid, &compute_pkg);
/*----------------------------------------------------------
* Set up the interp data structure
*----------------------------------------------------------*/
(interp_data -> P) = hypre_StructMatrixRef(P);
(interp_data -> compute_pkg) = compute_pkg;
hypre_CopyIndex(cindex, (interp_data -> cindex));
hypre_CopyIndex(findex, (interp_data -> findex));
hypre_CopyIndex(stride, (interp_data -> stride));
hypre_CopyIndex(strideP, (interp_data -> strideP));
return ierr;
}
int hypre_SMGResidualSetup(void *residual_vdata,hypre_StructMatrix *A,hypre_StructVector *x,hypre_StructVector *b,hypre_StructVector *r)
{
int ierr = 0;
hypre_SMGResidualData *residual_data = residual_vdata;
hypre_IndexRef base_index = (residual_data -> base_index);
hypre_IndexRef base_stride = (residual_data -> base_stride);
hypre_Index unit_stride;
hypre_StructGrid *grid;
hypre_StructStencil *stencil;
hypre_BoxArrayArray *send_boxes;
hypre_BoxArrayArray *recv_boxes;
int **send_processes;
int **recv_processes;
hypre_BoxArrayArray *indt_boxes;
hypre_BoxArrayArray *dept_boxes;
hypre_BoxArray *base_points;
hypre_ComputePkg *compute_pkg;
/*----------------------------------------------------------
* Set up base points and the compute package
*----------------------------------------------------------*/
grid = (A -> grid);
stencil = (A -> stencil);
((((unit_stride[0] = 1) , (unit_stride[1] = 1))) , (unit_stride[2] = 1));
base_points = hypre_BoxArrayDuplicate((grid -> boxes));
hypre_ProjectBoxArray(base_points,base_index,base_stride);
hypre_CreateComputeInfo(grid,stencil,&send_boxes,&recv_boxes,&send_processes,&recv_processes,&indt_boxes,&dept_boxes);
hypre_ProjectBoxArrayArray(indt_boxes,base_index,base_stride);
hypre_ProjectBoxArrayArray(dept_boxes,base_index,base_stride);
hypre_ComputePkgCreate(send_boxes,recv_boxes,unit_stride,unit_stride,send_processes,recv_processes,indt_boxes,dept_boxes,base_stride,grid,(x -> data_space),1,&compute_pkg);
/*----------------------------------------------------------
* Set up the residual data structure
*----------------------------------------------------------*/
residual_data -> A = hypre_StructMatrixRef(A);
residual_data -> x = hypre_StructVectorRef(x);
residual_data -> b = hypre_StructVectorRef(b);
residual_data -> r = hypre_StructVectorRef(r);
residual_data -> base_points = base_points;
residual_data -> compute_pkg = compute_pkg;
/*-----------------------------------------------------
* Compute flops
*-----------------------------------------------------*/
residual_data -> flops = (((A -> global_size) + (x -> global_size)) / (((base_stride[0]) * (base_stride[1])) * (base_stride[2])));
return ierr;
}
int
hypre_SMGResidualSetup( void *residual_vdata,
hypre_StructMatrix *A,
hypre_StructVector *x,
hypre_StructVector *b,
hypre_StructVector *r )
{
int ierr = 0;
hypre_SMGResidualData *residual_data = residual_vdata;
hypre_IndexRef base_index = (residual_data -> base_index);
hypre_IndexRef base_stride = (residual_data -> base_stride);
hypre_Index unit_stride;
hypre_StructGrid *grid;
hypre_StructStencil *stencil;
hypre_BoxArrayArray *send_boxes;
hypre_BoxArrayArray *recv_boxes;
int **send_processes;
int **recv_processes;
hypre_BoxArrayArray *indt_boxes;
hypre_BoxArrayArray *dept_boxes;
hypre_BoxArray *base_points;
hypre_ComputePkg *compute_pkg;
/*----------------------------------------------------------
* Set up base points and the compute package
*----------------------------------------------------------*/
grid = hypre_StructMatrixGrid(A);
stencil = hypre_StructMatrixStencil(A);
hypre_SetIndex(unit_stride, 1, 1, 1);
base_points = hypre_BoxArrayDuplicate(hypre_StructGridBoxes(grid));
hypre_ProjectBoxArray(base_points, base_index, base_stride);
hypre_CreateComputeInfo(grid, stencil,
&send_boxes, &recv_boxes,
&send_processes, &recv_processes,
&indt_boxes, &dept_boxes);
hypre_ProjectBoxArrayArray(indt_boxes, base_index, base_stride);
hypre_ProjectBoxArrayArray(dept_boxes, base_index, base_stride);
hypre_ComputePkgCreate(send_boxes, recv_boxes,
unit_stride, unit_stride,
send_processes, recv_processes,
indt_boxes, dept_boxes,
base_stride, grid,
hypre_StructVectorDataSpace(x), 1,
&compute_pkg);
/*----------------------------------------------------------
* Set up the residual data structure
*----------------------------------------------------------*/
(residual_data -> A) = hypre_StructMatrixRef(A);
(residual_data -> x) = hypre_StructVectorRef(x);
(residual_data -> b) = hypre_StructVectorRef(b);
(residual_data -> r) = hypre_StructVectorRef(r);
(residual_data -> base_points) = base_points;
(residual_data -> compute_pkg) = compute_pkg;
/*-----------------------------------------------------
* Compute flops
*-----------------------------------------------------*/
(residual_data -> flops) =
(hypre_StructMatrixGlobalSize(A) + hypre_StructVectorGlobalSize(x)) /
(hypre_IndexX(base_stride) *
hypre_IndexY(base_stride) *
hypre_IndexZ(base_stride) );
return ierr;
}
int
hypre_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);
}
}
}
int
hypre_PointRelaxSetup( void *relax_vdata,
hypre_StructMatrix *A,
hypre_StructVector *b,
hypre_StructVector *x )
{
hypre_PointRelaxData *relax_data = (hypre_PointRelaxData *)relax_vdata;
int num_pointsets = (relax_data -> num_pointsets);
int *pointset_sizes = (relax_data -> pointset_sizes);
hypre_Index *pointset_strides = (relax_data -> pointset_strides);
hypre_Index **pointset_indices = (relax_data -> pointset_indices);
hypre_StructVector *t;
int diag_rank;
hypre_ComputePkg **compute_pkgs;
hypre_Index unit_stride;
hypre_Index diag_index;
hypre_IndexRef stride;
hypre_IndexRef index;
hypre_StructGrid *grid;
hypre_StructStencil *stencil;
hypre_BoxArrayArray *send_boxes;
hypre_BoxArrayArray *recv_boxes;
int **send_processes;
int **recv_processes;
hypre_BoxArrayArray *indt_boxes;
hypre_BoxArrayArray *dept_boxes;
hypre_BoxArrayArray *orig_indt_boxes;
hypre_BoxArrayArray *orig_dept_boxes;
hypre_BoxArrayArray *box_aa;
hypre_BoxArray *box_a;
hypre_Box *box;
int box_aa_size;
int box_a_size;
hypre_BoxArrayArray *new_box_aa;
hypre_BoxArray *new_box_a;
hypre_Box *new_box;
double scale;
int frac;
int i, j, k, p, m, compute_i;
int ierr = 0;
/*----------------------------------------------------------
* Set up the temp vector
*----------------------------------------------------------*/
if ((relax_data -> t) == NULL)
{
t = hypre_StructVectorCreate(hypre_StructVectorComm(b),
hypre_StructVectorGrid(b));
hypre_StructVectorSetNumGhost(t, hypre_StructVectorNumGhost(b));
hypre_StructVectorInitialize(t);
hypre_StructVectorAssemble(t);
(relax_data -> t) = t;
}
/*----------------------------------------------------------
* Find the matrix diagonal
*----------------------------------------------------------*/
grid = hypre_StructMatrixGrid(A);
stencil = hypre_StructMatrixStencil(A);
hypre_SetIndex(diag_index, 0, 0, 0);
diag_rank = hypre_StructStencilElementRank(stencil, diag_index);
/*----------------------------------------------------------
* Set up the compute packages
*----------------------------------------------------------*/
hypre_SetIndex(unit_stride, 1, 1, 1);
compute_pkgs = hypre_CTAlloc(hypre_ComputePkg *, num_pointsets);
for (p = 0; p < num_pointsets; p++)
{
hypre_CreateComputeInfo(grid, stencil,
&send_boxes, &recv_boxes,
&send_processes, &recv_processes,
&orig_indt_boxes, &orig_dept_boxes);
stride = pointset_strides[p];
for (compute_i = 0; compute_i < 2; compute_i++)
{
switch(compute_i)
{
case 0:
box_aa = orig_indt_boxes;
break;
case 1:
box_aa = orig_dept_boxes;
break;
}
box_aa_size = hypre_BoxArrayArraySize(box_aa);
new_box_aa = hypre_BoxArrayArrayCreate(box_aa_size);
for (i = 0; i < box_aa_size; i++)
{
box_a = hypre_BoxArrayArrayBoxArray(box_aa, i);
box_a_size = hypre_BoxArraySize(box_a);
new_box_a = hypre_BoxArrayArrayBoxArray(new_box_aa, i);
hypre_BoxArraySetSize(new_box_a, box_a_size * pointset_sizes[p]);
k = 0;
for (m = 0; m < pointset_sizes[p]; m++)
{
index = pointset_indices[p][m];
for (j = 0; j < box_a_size; j++)
{
box = hypre_BoxArrayBox(box_a, j);
new_box = hypre_BoxArrayBox(new_box_a, k);
hypre_CopyBox(box, new_box);
hypre_ProjectBox(new_box, index, stride);
k++;
}
}
}
switch(compute_i)
{
case 0:
indt_boxes = new_box_aa;
break;
case 1:
dept_boxes = new_box_aa;
break;
}
}
hypre_ComputePkgCreate(send_boxes, recv_boxes,
unit_stride, unit_stride,
send_processes, recv_processes,
indt_boxes, dept_boxes,
stride, grid,
hypre_StructVectorDataSpace(x), 1,
&compute_pkgs[p]);
hypre_BoxArrayArrayDestroy(orig_indt_boxes);
hypre_BoxArrayArrayDestroy(orig_dept_boxes);
}
/*----------------------------------------------------------
* Set up the relax data structure
*----------------------------------------------------------*/
(relax_data -> A) = hypre_StructMatrixRef(A);
(relax_data -> x) = hypre_StructVectorRef(x);
(relax_data -> b) = hypre_StructVectorRef(b);
(relax_data -> diag_rank) = diag_rank;
(relax_data -> compute_pkgs) = compute_pkgs;
/*-----------------------------------------------------
* Compute flops
*-----------------------------------------------------*/
scale = 0.0;
for (p = 0; p < num_pointsets; p++)
{
stride = pointset_strides[p];
frac = hypre_IndexX(stride);
frac *= hypre_IndexY(stride);
frac *= hypre_IndexZ(stride);
scale += (pointset_sizes[p] / frac);
}
(relax_data -> flops) = scale * (hypre_StructMatrixGlobalSize(A) +
hypre_StructVectorGlobalSize(x));
return ierr;
}
HYPRE_Int
hypre_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_SemiInterpSetup( void *interp_vdata,
hypre_StructMatrix *P,
int P_stored_as_transpose,
hypre_StructVector *xc,
hypre_StructVector *e,
hypre_Index cindex,
hypre_Index findex,
hypre_Index stride )
{
hypre_SemiInterpData *interp_data = interp_vdata;
hypre_StructGrid *grid;
hypre_StructStencil *stencil;
hypre_BoxArrayArray *send_boxes;
hypre_BoxArrayArray *recv_boxes;
int **send_processes;
int **recv_processes;
hypre_BoxArrayArray *indt_boxes;
hypre_BoxArrayArray *dept_boxes;
hypre_ComputePkg *compute_pkg;
int ierr = 0;
/*----------------------------------------------------------
* Set up the compute package
*----------------------------------------------------------*/
grid = hypre_StructVectorGrid(e);
stencil = hypre_StructMatrixStencil(P);
hypre_CreateComputeInfo(grid, stencil,
&send_boxes, &recv_boxes,
&send_processes, &recv_processes,
&indt_boxes, &dept_boxes);
hypre_ProjectBoxArrayArray(send_boxes, cindex, stride);
hypre_ProjectBoxArrayArray(recv_boxes, cindex, stride);
hypre_ProjectBoxArrayArray(indt_boxes, findex, stride);
hypre_ProjectBoxArrayArray(dept_boxes, findex, stride);
hypre_ComputePkgCreate(send_boxes, recv_boxes,
stride, stride,
send_processes, recv_processes,
indt_boxes, dept_boxes,
stride, grid,
hypre_StructVectorDataSpace(e), 1,
&compute_pkg);
/*----------------------------------------------------------
* Set up the interp data structure
*----------------------------------------------------------*/
(interp_data -> P) = hypre_StructMatrixRef(P);
(interp_data -> P_stored_as_transpose) = P_stored_as_transpose;
(interp_data -> compute_pkg) = compute_pkg;
hypre_CopyIndex(cindex, (interp_data -> cindex));
hypre_CopyIndex(findex, (interp_data -> findex));
hypre_CopyIndex(stride, (interp_data -> stride));
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;
}
int
hypre_SemiRestrictSetup( void *restrict_vdata,
hypre_StructMatrix *R,
int R_stored_as_transpose,
hypre_StructVector *r,
hypre_StructVector *rc,
hypre_Index cindex,
hypre_Index findex,
hypre_Index stride )
{
hypre_SemiRestrictData *restrict_data = (hypre_SemiRestrictData *)restrict_vdata;
hypre_StructGrid *grid;
hypre_StructStencil *stencil;
hypre_BoxArrayArray *send_boxes;
hypre_BoxArrayArray *recv_boxes;
int **send_processes;
int **recv_processes;
hypre_BoxArrayArray *indt_boxes;
hypre_BoxArrayArray *dept_boxes;
hypre_ComputePkg *compute_pkg;
int ierr = 0;
/*----------------------------------------------------------
* Set up the compute package
*----------------------------------------------------------*/
grid = hypre_StructVectorGrid(r);
stencil = hypre_StructMatrixStencil(R);
hypre_CreateComputeInfo(grid, stencil,
&send_boxes, &recv_boxes,
&send_processes, &recv_processes,
&indt_boxes, &dept_boxes);
hypre_ProjectBoxArrayArray(send_boxes, findex, stride);
hypre_ProjectBoxArrayArray(recv_boxes, findex, stride);
hypre_ProjectBoxArrayArray(indt_boxes, cindex, stride);
hypre_ProjectBoxArrayArray(dept_boxes, cindex, stride);
hypre_ComputePkgCreate(send_boxes, recv_boxes,
stride, stride,
send_processes, recv_processes,
indt_boxes, dept_boxes,
stride, grid,
hypre_StructVectorDataSpace(r), 1,
&compute_pkg);
/*----------------------------------------------------------
* Set up the restrict data structure
*----------------------------------------------------------*/
(restrict_data -> R) = hypre_StructMatrixRef(R);
(restrict_data -> R_stored_as_transpose) = R_stored_as_transpose;
(restrict_data -> compute_pkg) = compute_pkg;
hypre_CopyIndex(cindex ,(restrict_data -> cindex));
hypre_CopyIndex(stride ,(restrict_data -> stride));
return ierr;
}
HYPRE_Int
hypre_SparseMSGSolve( void *smsg_vdata,
hypre_StructMatrix *A,
hypre_StructVector *b,
hypre_StructVector *x )
{
hypre_SparseMSGData *smsg_data = smsg_vdata;
HYPRE_Real tol = (smsg_data -> tol);
HYPRE_Int max_iter = (smsg_data -> max_iter);
HYPRE_Int rel_change = (smsg_data -> rel_change);
HYPRE_Int zero_guess = (smsg_data -> zero_guess);
HYPRE_Int jump = (smsg_data -> jump);
HYPRE_Int num_pre_relax = (smsg_data -> num_pre_relax);
HYPRE_Int num_post_relax = (smsg_data -> num_post_relax);
HYPRE_Int num_fine_relax = (smsg_data -> num_fine_relax);
HYPRE_Int *num_grids = (smsg_data -> num_grids);
HYPRE_Int num_all_grids = (smsg_data -> num_all_grids);
HYPRE_Int num_levels = (smsg_data -> num_levels);
hypre_StructMatrix **A_array = (smsg_data -> A_array);
hypre_StructMatrix **Px_array = (smsg_data -> Px_array);
hypre_StructMatrix **Py_array = (smsg_data -> Py_array);
hypre_StructMatrix **Pz_array = (smsg_data -> Pz_array);
hypre_StructMatrix **RTx_array = (smsg_data -> RTx_array);
hypre_StructMatrix **RTy_array = (smsg_data -> RTy_array);
hypre_StructMatrix **RTz_array = (smsg_data -> RTz_array);
hypre_StructVector **b_array = (smsg_data -> b_array);
hypre_StructVector **x_array = (smsg_data -> x_array);
hypre_StructVector **t_array = (smsg_data -> t_array);
hypre_StructVector **r_array = (smsg_data -> r_array);
hypre_StructVector **e_array = (smsg_data -> e_array);
hypre_StructVector **visitx_array = (smsg_data -> visitx_array);
hypre_StructVector **visity_array = (smsg_data -> visity_array);
hypre_StructVector **visitz_array = (smsg_data -> visitz_array);
HYPRE_Int *grid_on = (smsg_data -> grid_on);
void **relax_array = (smsg_data -> relax_array);
void **matvec_array = (smsg_data -> matvec_array);
void **restrictx_array = (smsg_data -> restrictx_array);
void **restricty_array = (smsg_data -> restricty_array);
void **restrictz_array = (smsg_data -> restrictz_array);
void **interpx_array = (smsg_data -> interpx_array);
void **interpy_array = (smsg_data -> interpy_array);
void **interpz_array = (smsg_data -> interpz_array);
HYPRE_Int logging = (smsg_data -> logging);
HYPRE_Real *norms = (smsg_data -> norms);
HYPRE_Real *rel_norms = (smsg_data -> rel_norms);
HYPRE_Int *restrict_count;
HYPRE_Real b_dot_b, r_dot_r, eps;
HYPRE_Real e_dot_e, x_dot_x;
HYPRE_Int i, l, lx, ly, lz;
HYPRE_Int lymin, lymax, lzmin, lzmax;
HYPRE_Int fi, ci;
HYPRE_Int ierr = 0;
#if DEBUG
char filename[255];
#endif
/*-----------------------------------------------------
* Initialize some things and deal with special cases
*-----------------------------------------------------*/
hypre_BeginTiming(smsg_data -> time_index);
hypre_StructMatrixDestroy(A_array[0]);
hypre_StructVectorDestroy(b_array[0]);
hypre_StructVectorDestroy(x_array[0]);
A_array[0] = hypre_StructMatrixRef(A);
b_array[0] = hypre_StructVectorRef(b);
x_array[0] = hypre_StructVectorRef(x);
(smsg_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(smsg_data -> time_index);
return ierr;
}
/* part of convergence check */
if (tol > 0.0)
{
/* eps = (tol^2) */
b_dot_b = hypre_StructInnerProd(b_array[0], b_array[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(smsg_data -> time_index);
return ierr;
}
}
restrict_count = hypre_TAlloc(HYPRE_Int, num_all_grids);
/*-----------------------------------------------------
* Do V-cycles:
* For each index l, "fine" = l, "coarse" = (l+1)
*-----------------------------------------------------*/
for (i = 0; i < max_iter; i++)
{
/*--------------------------------------------------
* Down cycle:
* Note that r = b = x through the jump region
*--------------------------------------------------*/
/* fine grid pre-relaxation */
hypre_PFMGRelaxSetPreRelax(relax_array[0]);
hypre_PFMGRelaxSetMaxIter(relax_array[0], num_fine_relax);
hypre_PFMGRelaxSetZeroGuess(relax_array[0], zero_guess);
hypre_PFMGRelax(relax_array[0], A_array[0], b_array[0], x_array[0]);
zero_guess = 0;
/* compute fine grid residual (b - Ax) */
hypre_StructCopy(b_array[0], r_array[0]);
hypre_StructMatvecCompute(matvec_array[0],
-1.0, A_array[0], x_array[0], 1.0, r_array[0]);
/* convergence check */
if (tol > 0.0)
{
r_dot_r = hypre_StructInnerProd(r_array[0], r_array[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;
}
/* RDF */
#if 0
hypre_printf("iter = %d, rel_norm = %e\n", i, rel_norms[i]);
#endif
/* 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)
{
/* initialize restrict_count */
for (fi = 0; fi < num_all_grids; fi++)
{
restrict_count[fi] = 0;
}
for (l = 0; l <= (num_levels - 2); l++)
{
lzmin = hypre_max((l - num_grids[1] - num_grids[0] + 2), 0);
lzmax = hypre_min((l), (num_grids[2] - 1));
for (lz = lzmin; lz <= lzmax; lz++)
{
lymin = hypre_max((l - lz - num_grids[0] + 1), 0);
lymax = hypre_min((l - lz), (num_grids[1] - 1));
for (ly = lymin; ly <= lymax; ly++)
{
lx = l - lz - ly;
hypre_SparseMSGMapIndex(lx, ly, lz, num_grids, fi);
if (!grid_on[fi])
{
break;
}
if (restrict_count[fi] > 1)
{
hypre_StructScale((1.0/restrict_count[fi]), b_array[fi]);
}
if (l > jump)
{
/* pre-relaxation */
hypre_PFMGRelaxSetPreRelax(relax_array[fi]);
hypre_PFMGRelaxSetMaxIter(relax_array[fi], num_pre_relax);
hypre_PFMGRelaxSetZeroGuess(relax_array[fi], 1);
hypre_PFMGRelax(relax_array[fi], A_array[fi], b_array[fi],
x_array[fi]);
/* compute residual (b - Ax) */
hypre_StructCopy(b_array[fi], r_array[fi]);
hypre_StructMatvecCompute(matvec_array[fi],
-1.0, A_array[fi], x_array[fi],
1.0, r_array[fi]);
}
if ((lx+1) < num_grids[0])
{
/* restrict to ((lx+1), ly, lz) */
hypre_SparseMSGMapIndex((lx+1), ly, lz, num_grids, ci);
if (grid_on[ci])
{
if (restrict_count[ci])
{
hypre_SparseMSGRestrict(restrictx_array[fi],
RTx_array[lx], r_array[fi],
t_array[ci]);
hypre_StructAxpy(1.0, t_array[ci], b_array[ci]);
}
else
{
hypre_SparseMSGRestrict(restrictx_array[fi],
RTx_array[lx], r_array[fi],
b_array[ci]);
}
restrict_count[ci]++;
}
}
if ((ly+1) < num_grids[1])
{
/* restrict to (lx, (ly+1), lz) */
hypre_SparseMSGMapIndex(lx, (ly+1), lz, num_grids, ci);
if (grid_on[ci])
{
if (restrict_count[ci])
{
hypre_SparseMSGRestrict(restricty_array[fi],
RTy_array[ly], r_array[fi],
t_array[ci]);
hypre_StructAxpy(1.0, t_array[ci], b_array[ci]);
}
else
{
hypre_SparseMSGRestrict(restricty_array[fi],
RTy_array[ly], r_array[fi],
b_array[ci]);
}
restrict_count[ci]++;
}
}
if ((lz+1) < num_grids[2])
{
/* restrict to (lx, ly, (lz+1)) */
hypre_SparseMSGMapIndex(lx, ly, (lz+1), num_grids, ci);
if (grid_on[ci])
{
if (restrict_count[ci])
{
hypre_SparseMSGRestrict(restrictz_array[fi],
RTz_array[lz], r_array[fi],
t_array[ci]);
hypre_StructAxpy(1.0, t_array[ci], b_array[ci]);
}
else
{
hypre_SparseMSGRestrict(restrictz_array[fi],
RTz_array[lz], r_array[fi],
b_array[ci]);
}
restrict_count[ci]++;
}
}
#if DEBUG
hypre_sprintf(filename, "zoutSMSG_bdown.%d.%d.%d", lx, ly, lz);
hypre_StructVectorPrint(filename, b_array[fi], 0);
hypre_sprintf(filename, "zoutSMSG_xdown.%d.%d.%d", lx, ly, lz);
hypre_StructVectorPrint(filename, x_array[fi], 0);
hypre_sprintf(filename, "zoutSMSG_rdown.%d.%d.%d", lx, ly, lz);
hypre_StructVectorPrint(filename, r_array[fi], 0);
#endif
}
}
}
/*--------------------------------------------------
* Bottom
*--------------------------------------------------*/
fi = num_all_grids - 1;
if (restrict_count[fi] > 1)
{
hypre_StructScale((1.0/restrict_count[fi]), b_array[fi]);
}
hypre_PFMGRelaxSetZeroGuess(relax_array[fi], 1);
hypre_PFMGRelax(relax_array[fi], A_array[fi], b_array[fi],
x_array[fi]);
#if DEBUG
hypre_sprintf(filename, "zoutSMSG_bbottom.%d.%d.%d", lx, ly, lz);
hypre_StructVectorPrint(filename, b_array[fi], 0);
hypre_sprintf(filename, "zoutSMSG_xbottom.%d.%d.%d", lx, ly, lz);
hypre_StructVectorPrint(filename, x_array[fi], 0);
#endif
/*--------------------------------------------------
* Up cycle
* Note that r = b = x through the jump region
*--------------------------------------------------*/
for (l = (num_levels - 2); l >= 0; l--)
{
lzmin = hypre_max((l - num_grids[1] - num_grids[0] + 2), 0);
lzmax = hypre_min((l), (num_grids[2] - 1));
for (lz = lzmax; lz >= lzmin; lz--)
{
lymin = hypre_max((l - lz - num_grids[0] + 1), 0);
lymax = hypre_min((l - lz), (num_grids[1] - 1));
for (ly = lymax; ly >= lymin; ly--)
{
lx = l - lz - ly;
hypre_SparseMSGMapIndex(lx, ly, lz, num_grids, fi);
if (!grid_on[fi])
{
break;
}
if ((l >= 1) && (l <= jump))
{
hypre_StructVectorSetConstantValues(x_array[fi], 0.0);
}
if ((lx+1) < num_grids[0])
{
/* interpolate from ((lx+1), ly, lz) */
hypre_SparseMSGMapIndex((lx+1), ly, lz, num_grids, ci);
if (grid_on[ci])
{
hypre_SparseMSGInterp(interpx_array[fi],
Px_array[lx], x_array[ci],
e_array[fi]);
hypre_SparseMSGFilter(visitx_array[fi], e_array[fi],
lx, ly, lz, jump);
hypre_StructAxpy(1.0, e_array[fi], x_array[fi]);
}
}
if ((ly+1) < num_grids[1])
{
/* interpolate from (lx, (ly+1), lz) */
hypre_SparseMSGMapIndex(lx, (ly+1), lz, num_grids, ci);
if (grid_on[ci])
{
hypre_SparseMSGInterp(interpy_array[fi],
Py_array[ly], x_array[ci],
e_array[fi]);
hypre_SparseMSGFilter(visity_array[fi], e_array[fi],
lx, ly, lz, jump);
hypre_StructAxpy(1.0, e_array[fi], x_array[fi]);
}
}
if ((lz+1) < num_grids[2])
{
/* interpolate from (lx, ly, (lz+1)) */
hypre_SparseMSGMapIndex(lx, ly, (lz+1), num_grids, ci);
if (grid_on[ci])
{
hypre_SparseMSGInterp(interpz_array[fi],
Pz_array[lz], x_array[ci],
e_array[fi]);
hypre_SparseMSGFilter(visitz_array[fi], e_array[fi],
lx, ly, lz, jump);
hypre_StructAxpy(1.0, e_array[fi], x_array[fi]);
}
}
#if DEBUG
hypre_sprintf(filename, "zoutSMSG_xup.%d.%d.%d", lx, ly, lz);
hypre_StructVectorPrint(filename, x_array[fi], 0);
#endif
if (l > jump)
{
/* post-relaxation */
hypre_PFMGRelaxSetPostRelax(relax_array[fi]);
hypre_PFMGRelaxSetMaxIter(relax_array[fi],
num_post_relax);
hypre_PFMGRelaxSetZeroGuess(relax_array[fi], 0);
hypre_PFMGRelax(relax_array[fi], A_array[fi], b_array[fi],
x_array[fi]);
}
}
}
}
}
/* part of convergence check */
if ((tol > 0.0) && (rel_change))
{
if (num_levels > 1)
{
e_dot_e = hypre_StructInnerProd(e_array[0], e_array[0]);
x_dot_x = hypre_StructInnerProd(x_array[0], x_array[0]);
}
else
{
e_dot_e = 0.0;
x_dot_x = 1.0;
}
}
/* fine grid post-relaxation */
hypre_PFMGRelaxSetPostRelax(relax_array[0]);
hypre_PFMGRelaxSetMaxIter(relax_array[0], num_fine_relax);
hypre_PFMGRelaxSetZeroGuess(relax_array[0], 0);
hypre_PFMGRelax(relax_array[0], A_array[0], b_array[0], x_array[0]);
(smsg_data -> num_iterations) = (i + 1);
}
hypre_EndTiming(smsg_data -> time_index);
return ierr;
}
