HYPRE_Int
hypre_ParKrylovMatvecT(void *matvec_data,
HYPRE_Complex alpha,
void *A,
void *x,
HYPRE_Complex beta,
void *y )
{
return ( hypre_ParCSRMatrixMatvecT( alpha,
(hypre_ParCSRMatrix *) A,
(hypre_ParVector *) x,
beta,
(hypre_ParVector *) y ) );
}
int
hypre_ParKrylovMatvecT(void *matvec_data,
double alpha,
void *A,
void *x,
double beta,
void *y )
{
return ( hypre_ParCSRMatrixMatvecT( alpha,
(hypre_ParCSRMatrix *) A,
(hypre_ParVector *) x,
beta,
(hypre_ParVector *) y ) );
}
HYPRE_Int hypre_AMEDiscrDivFreeComponent(void *esolver, hypre_ParVector *b)
{
hypre_AMEData *ame_data = esolver;
/* t3 = M b */
hypre_ParCSRMatrixMatvec(1.0, ame_data -> M, b, 0.0, ame_data -> t3);
/* t1 = G^t t3 */
hypre_ParCSRMatrixMatvecT(1.0, ame_data -> G, ame_data -> t3, 0.0, ame_data -> t1);
/* (G^t M G) t2 = t1 */
hypre_ParVectorSetConstantValues(ame_data -> t2, 0.0);
HYPRE_ParCSRPCGSolve(ame_data -> B2_G,
(HYPRE_ParCSRMatrix)ame_data -> A_G,
(HYPRE_ParVector)ame_data -> t1,
(HYPRE_ParVector)ame_data -> t2);
/* b = b - G t2 */
hypre_ParCSRMatrixMatvec(-1.0, ame_data -> G, ame_data -> t2, 1.0, b);
return hypre_error_flag;
}
HYPRE_Int hypre_BoomerAMGRelaxT( hypre_ParCSRMatrix *A,
hypre_ParVector *f,
HYPRE_Int *cf_marker,
HYPRE_Int relax_type,
HYPRE_Int relax_points,
HYPRE_Real relax_weight,
hypre_ParVector *u,
hypre_ParVector *Vtemp )
{
hypre_CSRMatrix *A_diag = hypre_ParCSRMatrixDiag(A);
HYPRE_Real *A_diag_data = hypre_CSRMatrixData(A_diag);
HYPRE_Int *A_diag_i = hypre_CSRMatrixI(A_diag);
HYPRE_Int n_global= hypre_ParCSRMatrixGlobalNumRows(A);
HYPRE_Int n = hypre_CSRMatrixNumRows(A_diag);
HYPRE_Int first_index = hypre_ParVectorFirstIndex(u);
hypre_Vector *u_local = hypre_ParVectorLocalVector(u);
HYPRE_Real *u_data = hypre_VectorData(u_local);
hypre_Vector *Vtemp_local = hypre_ParVectorLocalVector(Vtemp);
HYPRE_Real *Vtemp_data = hypre_VectorData(Vtemp_local);
hypre_CSRMatrix *A_CSR;
HYPRE_Int *A_CSR_i;
HYPRE_Int *A_CSR_j;
HYPRE_Real *A_CSR_data;
hypre_Vector *f_vector;
HYPRE_Real *f_vector_data;
HYPRE_Int i;
HYPRE_Int jj;
HYPRE_Int column;
HYPRE_Int relax_error = 0;
HYPRE_Real *A_mat;
HYPRE_Real *b_vec;
HYPRE_Real zero = 0.0;
/*-----------------------------------------------------------------------
* Switch statement to direct control based on relax_type:
* relax_type = 7 -> Jacobi (uses ParMatvec)
* relax_type = 9 -> Direct Solve
*-----------------------------------------------------------------------*/
switch (relax_type)
{
case 7: /* Jacobi (uses ParMatvec) */
{
/*-----------------------------------------------------------------
* Copy f into temporary vector.
*-----------------------------------------------------------------*/
hypre_ParVectorCopy(f,Vtemp);
/*-----------------------------------------------------------------
* Perform MatvecT Vtemp=f-A^Tu
*-----------------------------------------------------------------*/
hypre_ParCSRMatrixMatvecT(-1.0,A, u, 1.0, Vtemp);
for (i = 0; i < n; i++)
{
/*-----------------------------------------------------------
* If diagonal is nonzero, relax point i; otherwise, skip it.
*-----------------------------------------------------------*/
if (A_diag_data[A_diag_i[i]] != zero)
{
u_data[i] += relax_weight * Vtemp_data[i]
/ A_diag_data[A_diag_i[i]];
}
}
}
break;
case 9: /* Direct solve: use gaussian elimination */
{
/*-----------------------------------------------------------------
* Generate CSR matrix from ParCSRMatrix A
*-----------------------------------------------------------------*/
if (n)
{
A_CSR = hypre_ParCSRMatrixToCSRMatrixAll(A);
f_vector = hypre_ParVectorToVectorAll(f);
A_CSR_i = hypre_CSRMatrixI(A_CSR);
A_CSR_j = hypre_CSRMatrixJ(A_CSR);
A_CSR_data = hypre_CSRMatrixData(A_CSR);
f_vector_data = hypre_VectorData(f_vector);
A_mat = hypre_CTAlloc(HYPRE_Real, n_global*n_global);
b_vec = hypre_CTAlloc(HYPRE_Real, n_global);
/*---------------------------------------------------------------
* Load transpose of CSR matrix into A_mat.
*---------------------------------------------------------------*/
for (i = 0; i < n_global; i++)
{
for (jj = A_CSR_i[i]; jj < A_CSR_i[i+1]; jj++)
{
column = A_CSR_j[jj];
A_mat[column*n_global+i] = A_CSR_data[jj];
}
b_vec[i] = f_vector_data[i];
}
relax_error = gselim(A_mat,b_vec,n_global);
for (i = 0; i < n; i++)
{
u_data[i] = b_vec[first_index+i];
}
hypre_TFree(A_mat);
hypre_TFree(b_vec);
hypre_CSRMatrixDestroy(A_CSR);
A_CSR = NULL;
hypre_SeqVectorDestroy(f_vector);
f_vector = NULL;
}
}
break;
}
return(relax_error);
}
HYPRE_Int
hypre_BoomerAMGCycleT( void *amg_vdata,
hypre_ParVector **F_array,
hypre_ParVector **U_array )
{
hypre_ParAMGData *amg_data = amg_vdata;
/* Data Structure variables */
hypre_ParCSRMatrix **A_array;
hypre_ParCSRMatrix **P_array;
hypre_ParCSRMatrix **R_array;
hypre_ParVector *Vtemp;
HYPRE_Int **CF_marker_array;
/* HYPRE_Int **unknown_map_array; */
/* HYPRE_Int **point_map_array; */
/* HYPRE_Int **v_at_point_array; */
HYPRE_Real cycle_op_count;
HYPRE_Int cycle_type;
HYPRE_Int num_levels;
HYPRE_Int max_levels;
HYPRE_Real *num_coeffs;
HYPRE_Int *num_grid_sweeps;
HYPRE_Int *grid_relax_type;
HYPRE_Int **grid_relax_points;
/* Local variables */
HYPRE_Int *lev_counter;
HYPRE_Int Solve_err_flag;
HYPRE_Int k;
HYPRE_Int j;
HYPRE_Int level;
HYPRE_Int cycle_param;
HYPRE_Int coarse_grid;
HYPRE_Int fine_grid;
HYPRE_Int Not_Finished;
HYPRE_Int num_sweep;
HYPRE_Int relax_type;
HYPRE_Int relax_points;
HYPRE_Real *relax_weight;
HYPRE_Int relax_local;
HYPRE_Int relax_order;
HYPRE_Int old_version = 0;
HYPRE_Real alpha;
HYPRE_Real beta;
#if 0
HYPRE_Real *D_mat;
HYPRE_Real *S_vec;
#endif
/* Acquire data and allocate storage */
A_array = hypre_ParAMGDataAArray(amg_data);
P_array = hypre_ParAMGDataPArray(amg_data);
R_array = hypre_ParAMGDataRArray(amg_data);
CF_marker_array = hypre_ParAMGDataCFMarkerArray(amg_data);
/* unknown_map_array = hypre_ParAMGDataUnknownMapArray(amg_data); */
/* point_map_array = hypre_ParAMGDataPointMapArray(amg_data); */
/* v_at_point_array = hypre_ParAMGDataVatPointArray(amg_data); */
Vtemp = hypre_ParAMGDataVtemp(amg_data);
num_levels = hypre_ParAMGDataNumLevels(amg_data);
max_levels = hypre_ParAMGDataMaxLevels(amg_data);
cycle_type = hypre_ParAMGDataCycleType(amg_data);
/* num_unknowns = hypre_ParCSRMatrixNumRows(A_array[0]); */
num_grid_sweeps = hypre_ParAMGDataNumGridSweeps(amg_data);
grid_relax_type = hypre_ParAMGDataGridRelaxType(amg_data);
grid_relax_points = hypre_ParAMGDataGridRelaxPoints(amg_data);
relax_weight = hypre_ParAMGDataRelaxWeight(amg_data);
relax_order = hypre_ParAMGDataRelaxOrder(amg_data);
cycle_op_count = hypre_ParAMGDataCycleOpCount(amg_data);
lev_counter = hypre_CTAlloc(HYPRE_Int, num_levels);
/* Initialize */
Solve_err_flag = 0;
if (grid_relax_points) old_version = 1;
num_coeffs = hypre_CTAlloc(HYPRE_Real, num_levels);
num_coeffs[0] = hypre_ParCSRMatrixDNumNonzeros(A_array[0]);
for (j = 1; j < num_levels; j++)
num_coeffs[j] = hypre_ParCSRMatrixDNumNonzeros(A_array[j]);
/*---------------------------------------------------------------------
* Initialize cycling control counter
*
* Cycling is controlled using a level counter: lev_counter[k]
*
* Each time relaxation is performed on level k, the
* counter is decremented by 1. If the counter is then
* negative, we go to the next finer level. If non-
* negative, we go to the next coarser level. The
* following actions control cycling:
*
* a. lev_counter[0] is initialized to 1.
* b. lev_counter[k] is initialized to cycle_type for k>0.
*
* c. During cycling, when going down to level k, lev_counter[k]
* is set to the max of (lev_counter[k],cycle_type)
*---------------------------------------------------------------------*/
Not_Finished = 1;
lev_counter[0] = 1;
for (k = 1; k < num_levels; ++k)
{
lev_counter[k] = cycle_type;
}
level = 0;
cycle_param = 0;
/*---------------------------------------------------------------------
* Main loop of cycling
*--------------------------------------------------------------------*/
while (Not_Finished)
{
num_sweep = num_grid_sweeps[cycle_param];
relax_type = grid_relax_type[cycle_param];
if (relax_type != 7 && relax_type != 9) relax_type = 7;
/*------------------------------------------------------------------
* Do the relaxation num_sweep times
*-----------------------------------------------------------------*/
for (j = 0; j < num_sweep; j++)
{
if (num_levels == 1 && max_levels > 1)
{
relax_points = 0;
relax_local = 0;
}
else
{
if (old_version)
relax_points = grid_relax_points[cycle_param][j];
relax_local = relax_order;
}
/*-----------------------------------------------
* VERY sloppy approximation to cycle complexity
*-----------------------------------------------*/
if (old_version && level < num_levels -1)
{
switch (relax_points)
{
case 1:
cycle_op_count += num_coeffs[level+1];
break;
case -1:
cycle_op_count += (num_coeffs[level]-num_coeffs[level+1]);
break;
}
}
else
{
cycle_op_count += num_coeffs[level];
}
/* note: this does not use relax_points, so it doesn't matter if
its the "old version" */
Solve_err_flag = hypre_BoomerAMGRelaxT(A_array[level],
F_array[level],
CF_marker_array[level],
relax_type,
relax_points,
relax_weight[level],
U_array[level],
Vtemp);
if (Solve_err_flag != 0)
{
hypre_TFree(lev_counter);
hypre_TFree(num_coeffs);
return(Solve_err_flag);
}
}
/*------------------------------------------------------------------
* Decrement the control counter and determine which grid to visit next
*-----------------------------------------------------------------*/
--lev_counter[level];
if (lev_counter[level] >= 0 && level != num_levels-1)
{
/*---------------------------------------------------------------
* Visit coarser level next. Compute residual using hypre_ParCSRMatrixMatvec.
* Use interpolation (since transpose i.e. P^TATR instead of
* RAP) using hypre_ParCSRMatrixMatvecT.
* Reset counters and cycling parameters for coarse level
*--------------------------------------------------------------*/
fine_grid = level;
coarse_grid = level + 1;
hypre_ParVectorSetConstantValues(U_array[coarse_grid], 0.0);
hypre_ParVectorCopy(F_array[fine_grid],Vtemp);
alpha = -1.0;
beta = 1.0;
hypre_ParCSRMatrixMatvecT(alpha, A_array[fine_grid], U_array[fine_grid],
beta, Vtemp);
alpha = 1.0;
beta = 0.0;
hypre_ParCSRMatrixMatvecT(alpha,P_array[fine_grid],Vtemp,
beta,F_array[coarse_grid]);
++level;
lev_counter[level] = hypre_max(lev_counter[level],cycle_type);
cycle_param = 1;
if (level == num_levels-1) cycle_param = 3;
}
else if (level != 0)
{
/*---------------------------------------------------------------
* Visit finer level next.
* Use restriction (since transpose i.e. P^TA^TR instead of RAP)
* and add correction using hypre_ParCSRMatrixMatvec.
* Reset counters and cycling parameters for finer level.
*--------------------------------------------------------------*/
fine_grid = level - 1;
coarse_grid = level;
alpha = 1.0;
beta = 1.0;
hypre_ParCSRMatrixMatvec(alpha, R_array[fine_grid], U_array[coarse_grid],
beta, U_array[fine_grid]);
--level;
cycle_param = 2;
if (level == 0) cycle_param = 0;
}
else
{
Not_Finished = 0;
}
}
hypre_ParAMGDataCycleOpCount(amg_data) = cycle_op_count;
hypre_TFree(lev_counter);
hypre_TFree(num_coeffs);
return(Solve_err_flag);
}
HYPRE_Int
hypre_BoomerAMGSolveT( void *amg_vdata,
hypre_ParCSRMatrix *A,
hypre_ParVector *f,
hypre_ParVector *u )
{
MPI_Comm comm = hypre_ParCSRMatrixComm(A);
hypre_ParAMGData *amg_data = amg_vdata;
/* Data Structure variables */
HYPRE_Int amg_print_level;
HYPRE_Int amg_logging;
HYPRE_Real *num_coeffs;
HYPRE_Int *num_variables;
HYPRE_Real cycle_op_count;
HYPRE_Int num_levels;
/* HYPRE_Int num_unknowns; */
HYPRE_Real tol;
char *file_name;
hypre_ParCSRMatrix **A_array;
hypre_ParVector **F_array;
hypre_ParVector **U_array;
/* Local variables */
/*FILE *fp;*/
HYPRE_Int j;
HYPRE_Int Solve_err_flag;
HYPRE_Int min_iter;
HYPRE_Int max_iter;
HYPRE_Int cycle_count;
HYPRE_Real total_coeffs;
HYPRE_Int total_variables;
HYPRE_Int num_procs, my_id;
HYPRE_Real alpha = 1.0;
HYPRE_Real beta = -1.0;
HYPRE_Real cycle_cmplxty = 0.0;
HYPRE_Real operat_cmplxty;
HYPRE_Real grid_cmplxty;
HYPRE_Real conv_factor;
HYPRE_Real resid_nrm;
HYPRE_Real resid_nrm_init;
HYPRE_Real relative_resid;
HYPRE_Real rhs_norm;
HYPRE_Real old_resid;
hypre_ParVector *Vtemp;
hypre_ParVector *Residual;
hypre_MPI_Comm_size(comm, &num_procs);
hypre_MPI_Comm_rank(comm,&my_id);
amg_print_level = hypre_ParAMGDataPrintLevel(amg_data);
amg_logging = hypre_ParAMGDataLogging(amg_data);
if ( amg_logging>1 )
Residual = hypre_ParAMGDataResidual(amg_data);
file_name = hypre_ParAMGDataLogFileName(amg_data);
/* num_unknowns = hypre_ParAMGDataNumUnknowns(amg_data); */
num_levels = hypre_ParAMGDataNumLevels(amg_data);
A_array = hypre_ParAMGDataAArray(amg_data);
F_array = hypre_ParAMGDataFArray(amg_data);
U_array = hypre_ParAMGDataUArray(amg_data);
tol = hypre_ParAMGDataTol(amg_data);
min_iter = hypre_ParAMGDataMinIter(amg_data);
max_iter = hypre_ParAMGDataMaxIter(amg_data);
num_coeffs = hypre_CTAlloc(HYPRE_Real, num_levels);
num_variables = hypre_CTAlloc(HYPRE_Int, num_levels);
num_coeffs[0] = hypre_ParCSRMatrixDNumNonzeros(A_array[0]);
num_variables[0] = hypre_ParCSRMatrixGlobalNumRows(A_array[0]);
A_array[0] = A;
F_array[0] = f;
U_array[0] = u;
/* Vtemp = hypre_ParVectorCreate(hypre_ParCSRMatrixComm(A_array[0]),
hypre_ParCSRMatrixGlobalNumRows(A_array[0]),
hypre_ParCSRMatrixRowStarts(A_array[0]));
hypre_ParVectorInitialize(Vtemp);
hypre_ParVectorSetPartitioningOwner(Vtemp,0);
hypre_ParAMGDataVtemp(amg_data) = Vtemp;
*/
Vtemp = hypre_ParAMGDataVtemp(amg_data);
for (j = 1; j < num_levels; j++)
{
num_coeffs[j] = hypre_ParCSRMatrixDNumNonzeros(A_array[j]);
num_variables[j] = hypre_ParCSRMatrixGlobalNumRows(A_array[j]);
}
/*-----------------------------------------------------------------------
* Write the solver parameters
*-----------------------------------------------------------------------*/
if (my_id == 0 && amg_print_level > 1)
hypre_BoomerAMGWriteSolverParams(amg_data);
/*-----------------------------------------------------------------------
* Initialize the solver error flag and assorted bookkeeping variables
*-----------------------------------------------------------------------*/
Solve_err_flag = 0;
total_coeffs = 0;
total_variables = 0;
cycle_count = 0;
operat_cmplxty = 0;
grid_cmplxty = 0;
/*-----------------------------------------------------------------------
* open the log file and write some initial info
*-----------------------------------------------------------------------*/
if (my_id == 0 && amg_print_level > 1)
{
/*fp = fopen(file_name, "a");*/
hypre_printf("\n\nAMG SOLUTION INFO:\n");
}
/*-----------------------------------------------------------------------
* Compute initial fine-grid residual and print to logfile
*-----------------------------------------------------------------------*/
if ( amg_logging > 1 ) {
hypre_ParVectorCopy(F_array[0], Residual );
hypre_ParCSRMatrixMatvecT(alpha, A_array[0], U_array[0], beta, Residual );
resid_nrm = sqrt(hypre_ParVectorInnerProd( Residual, Residual ));
}
else {
hypre_ParVectorCopy(F_array[0], Vtemp);
hypre_ParCSRMatrixMatvecT(alpha, A_array[0], U_array[0], beta, Vtemp);
resid_nrm = sqrt(hypre_ParVectorInnerProd(Vtemp, Vtemp));
}
resid_nrm_init = resid_nrm;
rhs_norm = sqrt(hypre_ParVectorInnerProd(f, f));
relative_resid = 9999;
if (rhs_norm)
{
relative_resid = resid_nrm_init / rhs_norm;
}
if (my_id ==0 && (amg_print_level > 1))
{
hypre_printf(" relative\n");
hypre_printf(" residual factor residual\n");
hypre_printf(" -------- ------ --------\n");
hypre_printf(" Initial %e %e\n",resid_nrm_init,
relative_resid);
}
/*-----------------------------------------------------------------------
* Main V-cycle loop
*-----------------------------------------------------------------------*/
while ((relative_resid >= tol || cycle_count < min_iter)
&& cycle_count < max_iter
&& Solve_err_flag == 0)
{
hypre_ParAMGDataCycleOpCount(amg_data) = 0;
/* Op count only needed for one cycle */
Solve_err_flag = hypre_BoomerAMGCycleT(amg_data, F_array, U_array);
old_resid = resid_nrm;
/*---------------------------------------------------------------
* Compute fine-grid residual and residual norm
*----------------------------------------------------------------*/
if ( amg_logging > 1 ) {
hypre_ParVectorCopy(F_array[0], Residual );
hypre_ParCSRMatrixMatvecT(alpha, A_array[0], U_array[0], beta, Residual );
resid_nrm = sqrt(hypre_ParVectorInnerProd( Residual, Residual ));
}
else {
hypre_ParVectorCopy(F_array[0], Vtemp);
hypre_ParCSRMatrixMatvecT(alpha, A_array[0], U_array[0], beta, Vtemp);
resid_nrm = sqrt(hypre_ParVectorInnerProd(Vtemp, Vtemp));
}
conv_factor = resid_nrm / old_resid;
relative_resid = 9999;
if (rhs_norm)
{
relative_resid = resid_nrm / rhs_norm;
}
++cycle_count;
hypre_ParAMGDataRelativeResidualNorm(amg_data) = relative_resid;
hypre_ParAMGDataNumIterations(amg_data) = cycle_count;
if (my_id == 0 && (amg_print_level > 1))
{
hypre_printf(" Cycle %2d %e %f %e \n", cycle_count,
resid_nrm, conv_factor, relative_resid);
}
}
if (cycle_count == max_iter) Solve_err_flag = 1;
/*-----------------------------------------------------------------------
* Compute closing statistics
*-----------------------------------------------------------------------*/
conv_factor = pow((resid_nrm/resid_nrm_init),(1.0/((HYPRE_Real) cycle_count)));
for (j=0;j<hypre_ParAMGDataNumLevels(amg_data);j++)
{
total_coeffs += num_coeffs[j];
total_variables += num_variables[j];
}
cycle_op_count = hypre_ParAMGDataCycleOpCount(amg_data);
if (num_variables[0])
grid_cmplxty = ((HYPRE_Real) total_variables) / ((HYPRE_Real) num_variables[0]);
if (num_coeffs[0])
{
operat_cmplxty = total_coeffs / num_coeffs[0];
cycle_cmplxty = cycle_op_count / num_coeffs[0];
}
if (my_id == 0 && amg_print_level > 1)
{
if (Solve_err_flag == 1)
{
hypre_printf("\n\n==============================================");
hypre_printf("\n NOTE: Convergence tolerance was not achieved\n");
hypre_printf(" within the allowed %d V-cycles\n",max_iter);
hypre_printf("==============================================");
}
hypre_printf("\n\n Average Convergence Factor = %f",conv_factor);
hypre_printf("\n\n Complexity: grid = %f\n",grid_cmplxty);
hypre_printf(" operator = %f\n",operat_cmplxty);
hypre_printf(" cycle = %f\n\n",cycle_cmplxty);
}
/*----------------------------------------------------------
* Close the output file (if open)
*----------------------------------------------------------*/
/*if (my_id == 0 && amg_print_level >= 1)
{
fclose(fp);
}*/
hypre_TFree(num_coeffs);
hypre_TFree(num_variables);
return(Solve_err_flag);
}
HYPRE_Int
hypre_MaxwellSolve2( void * maxwell_vdata,
hypre_SStructMatrix * A_in,
hypre_SStructVector * f,
hypre_SStructVector * u )
{
hypre_MaxwellData *maxwell_data = maxwell_vdata;
hypre_ParVector *f_edge;
hypre_ParVector *u_edge;
HYPRE_Int max_iter = maxwell_data-> max_iter;
double tol = maxwell_data-> tol;
HYPRE_Int rel_change = maxwell_data-> rel_change;
HYPRE_Int zero_guess = maxwell_data-> zero_guess;
HYPRE_Int npre_relax = maxwell_data-> num_pre_relax;
HYPRE_Int npost_relax = maxwell_data-> num_post_relax;
hypre_ParCSRMatrix **Ann_l = maxwell_data-> Ann_l;
hypre_ParCSRMatrix **Pn_l = maxwell_data-> Pn_l;
hypre_ParCSRMatrix **RnT_l = maxwell_data-> RnT_l;
hypre_ParVector **bn_l = maxwell_data-> bn_l;
hypre_ParVector **xn_l = maxwell_data-> xn_l;
hypre_ParVector **resn_l = maxwell_data-> resn_l;
hypre_ParVector **en_l = maxwell_data-> en_l;
hypre_ParVector **nVtemp2_l = maxwell_data-> nVtemp2_l;
HYPRE_Int **nCF_marker_l = maxwell_data-> nCF_marker_l;
double *nrelax_weight= maxwell_data-> nrelax_weight;
double *nomega = maxwell_data-> nomega;
HYPRE_Int nrelax_type = maxwell_data-> nrelax_type;
HYPRE_Int node_numlevs = maxwell_data-> node_numlevels;
hypre_ParCSRMatrix *Tgrad = maxwell_data-> Tgrad;
hypre_ParCSRMatrix *T_transpose = maxwell_data-> T_transpose;
hypre_ParCSRMatrix **Aee_l = maxwell_data-> Aee_l;
hypre_IJMatrix **Pe_l = maxwell_data-> Pe_l;
hypre_IJMatrix **ReT_l = maxwell_data-> ReT_l;
hypre_ParVector **be_l = maxwell_data-> be_l;
hypre_ParVector **xe_l = maxwell_data-> xe_l;
hypre_ParVector **rese_l = maxwell_data-> rese_l;
hypre_ParVector **ee_l = maxwell_data-> ee_l;
hypre_ParVector **eVtemp2_l = maxwell_data-> eVtemp2_l;
HYPRE_Int **eCF_marker_l = maxwell_data-> eCF_marker_l;
double *erelax_weight= maxwell_data-> erelax_weight;
double *eomega = maxwell_data-> eomega;
HYPRE_Int erelax_type = maxwell_data-> erelax_type;
HYPRE_Int edge_numlevs = maxwell_data-> edge_numlevels;
HYPRE_Int **BdryRanks_l = maxwell_data-> BdryRanks_l;
HYPRE_Int *BdryRanksCnts_l= maxwell_data-> BdryRanksCnts_l;
HYPRE_Int logging = maxwell_data-> logging;
double *norms = maxwell_data-> norms;
double *rel_norms = maxwell_data-> rel_norms;
HYPRE_Int Solve_err_flag;
HYPRE_Int relax_local, cycle_param;
double b_dot_b = 0, r_dot_r, eps = 0;
double e_dot_e, x_dot_x;
HYPRE_Int i, j;
HYPRE_Int level;
HYPRE_Int ierr= 0;
/* added for the relaxation routines */
hypre_ParVector *ze = NULL;
if (hypre_NumThreads() > 1)
{
/* Aee is always bigger than Ann */
ze = hypre_ParVectorCreate(hypre_ParCSRMatrixComm(Aee_l[0]),
hypre_ParCSRMatrixGlobalNumRows(Aee_l[0]),
hypre_ParCSRMatrixRowStarts(Aee_l[0]));
hypre_ParVectorInitialize(ze);
hypre_ParVectorSetPartitioningOwner(ze,0);
}
hypre_BeginTiming(maxwell_data-> time_index);
hypre_SStructVectorConvert(f, &f_edge);
hypre_SStructVectorConvert(u, &u_edge);
hypre_ParVectorZeroBCValues(f_edge, BdryRanks_l[0], BdryRanksCnts_l[0]);
hypre_ParVectorZeroBCValues(u_edge, BdryRanks_l[0], BdryRanksCnts_l[0]);
be_l[0]= f_edge;
xe_l[0]= u_edge;
/* the nodal fine vectors: xn= 0. bn= T'*(be- Aee*xe) is updated in the cycle. */
hypre_ParVectorSetConstantValues(xn_l[0], 0.0);
relax_local= 0;
cycle_param= 0;
(maxwell_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_ParVectorSetConstantValues(xe_l[0], 0.0);
}
hypre_EndTiming(maxwell_data -> time_index);
return ierr;
}
/* part of convergence check */
if (tol > 0.0)
{
/* eps = (tol^2) */
b_dot_b= hypre_ParVectorInnerProd(be_l[0], be_l[0]);
eps = tol*tol;
/* if rhs is zero, return a zero solution */
if (b_dot_b == 0.0)
{
hypre_ParVectorSetConstantValues(xe_l[0], 0.0);
if (logging > 0)
{
norms[0] = 0.0;
rel_norms[0] = 0.0;
}
hypre_EndTiming(maxwell_data -> time_index);
return ierr;
}
}
/*-----------------------------------------------------
* Do V-cycles:
* For each index l, "fine" = l, "coarse" = (l-1)
*
* solution update:
* edge_sol= edge_sol + T*node_sol
*-----------------------------------------------------*/
for (i = 0; i < max_iter; i++)
{
/* compute fine grid residual & nodal rhs. */
hypre_ParVectorCopy(be_l[0], rese_l[0]);
hypre_ParCSRMatrixMatvec(-1.0, Aee_l[0], xe_l[0], 1.0, rese_l[0]);
hypre_ParVectorZeroBCValues(rese_l[0], BdryRanks_l[0], BdryRanksCnts_l[0]);
hypre_ParCSRMatrixMatvec(1.0, T_transpose, rese_l[0], 0.0, bn_l[0]);
/* convergence check */
if (tol > 0.0)
{
r_dot_r= hypre_ParVectorInnerProd(rese_l[0], rese_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;
}
}
}
hypre_ParVectorCopy(bn_l[0], resn_l[0]);
hypre_ParCSRMatrixMatvec(-1.0, Ann_l[0], xn_l[0], 1.0, resn_l[0]);
r_dot_r= hypre_ParVectorInnerProd(resn_l[0], resn_l[0]);
for (level= 0; level<= node_numlevs-2; level++)
{
/*-----------------------------------------------
* Down cycle
*-----------------------------------------------*/
for (j= 0; j< npre_relax; j++)
{
Solve_err_flag = hypre_BoomerAMGRelaxIF(Ann_l[level],
bn_l[level],
nCF_marker_l[level],
nrelax_type,
relax_local,
cycle_param,
nrelax_weight[level],
nomega[level],
NULL,
xn_l[level],
nVtemp2_l[level],
ze);
} /*for (j= 0; j< npre_relax; j++) */
/* compute residuals */
hypre_ParVectorCopy(bn_l[level], resn_l[level]);
hypre_ParCSRMatrixMatvec(-1.0, Ann_l[level], xn_l[level],
1.0, resn_l[level]);
/* restrict residuals */
hypre_ParCSRMatrixMatvecT(1.0, RnT_l[level], resn_l[level],
0.0, bn_l[level+1]);
/* zero off initial guess for the next level */
hypre_ParVectorSetConstantValues(xn_l[level+1], 0.0);
} /* for (level= 0; level<= node_numlevs-2; level++) */
/* coarsest node solve */
level= node_numlevs-1;
Solve_err_flag = hypre_BoomerAMGRelaxIF(Ann_l[level],
bn_l[level],
nCF_marker_l[level],
nrelax_type,
relax_local,
cycle_param,
nrelax_weight[level],
nomega[level],
NULL,
xn_l[level],
nVtemp2_l[level],
ze);
/*---------------------------------------------------------------------
* Cycle up the levels.
*---------------------------------------------------------------------*/
for (level= (node_numlevs - 2); level>= 1; level--)
{
hypre_ParCSRMatrixMatvec(1.0, Pn_l[level], xn_l[level+1], 0.0,
en_l[level]);
hypre_ParVectorAxpy(1.0, en_l[level], xn_l[level]);
/* post smooth */
for (j= 0; j< npost_relax; j++)
{
Solve_err_flag = hypre_BoomerAMGRelaxIF(Ann_l[level],
bn_l[level],
nCF_marker_l[level],
nrelax_type,
relax_local,
cycle_param,
nrelax_weight[level],
nomega[level],
NULL,
xn_l[level],
nVtemp2_l[level],
ze);
}
} /* for (level= (en_numlevs - 2); level>= 1; level--) */
/* interpolate error and correct on finest grids */
hypre_ParCSRMatrixMatvec(1.0, Pn_l[0], xn_l[1], 0.0, en_l[0]);
hypre_ParVectorAxpy(1.0, en_l[0], xn_l[0]);
for (j= 0; j< npost_relax; j++)
{
Solve_err_flag = hypre_BoomerAMGRelaxIF(Ann_l[0],
bn_l[0],
nCF_marker_l[0],
nrelax_type,
relax_local,
cycle_param,
nrelax_weight[0],
nomega[0],
NULL,
xn_l[0],
nVtemp2_l[0],
ze);
} /* for (j= 0; j< npost_relax; j++) */
hypre_ParVectorCopy(bn_l[0], resn_l[0]);
hypre_ParCSRMatrixMatvec(-1.0, Ann_l[0], xn_l[0], 1.0, resn_l[0]);
/* add the gradient solution component to xe_l[0] */
hypre_ParCSRMatrixMatvec(1.0, Tgrad, xn_l[0], 1.0, xe_l[0]);
hypre_ParVectorCopy(be_l[0], rese_l[0]);
hypre_ParCSRMatrixMatvec(-1.0, Aee_l[0], xe_l[0], 1.0, rese_l[0]);
r_dot_r= hypre_ParVectorInnerProd(rese_l[0], rese_l[0]);
for (level= 0; level<= edge_numlevs-2; level++)
{
/*-----------------------------------------------
* Down cycle
*-----------------------------------------------*/
for (j= 0; j< npre_relax; j++)
{
Solve_err_flag = hypre_BoomerAMGRelaxIF(Aee_l[level],
be_l[level],
eCF_marker_l[level],
erelax_type,
relax_local,
cycle_param,
erelax_weight[level],
eomega[level],
NULL,
xe_l[level],
eVtemp2_l[level],
ze);
} /*for (j= 0; j< npre_relax; j++) */
/* compute residuals */
hypre_ParVectorCopy(be_l[level], rese_l[level]);
hypre_ParCSRMatrixMatvec(-1.0, Aee_l[level], xe_l[level],
1.0, rese_l[level]);
/* restrict residuals */
hypre_ParCSRMatrixMatvecT(1.0,
(hypre_ParCSRMatrix *) hypre_IJMatrixObject(ReT_l[level]),
rese_l[level], 0.0, be_l[level+1]);
hypre_ParVectorZeroBCValues(be_l[level+1], BdryRanks_l[level+1],
BdryRanksCnts_l[level+1]);
/* zero off initial guess for the next level */
hypre_ParVectorSetConstantValues(xe_l[level+1], 0.0);
} /* for (level= 1; level<= edge_numlevels-2; level++) */
/* coarsest edge solve */
level= edge_numlevs-1;
for (j= 0; j< npre_relax; j++)
{
Solve_err_flag = hypre_BoomerAMGRelaxIF(Aee_l[level],
be_l[level],
eCF_marker_l[level],
erelax_type,
relax_local,
cycle_param,
erelax_weight[level],
eomega[level],
NULL,
xe_l[level],
eVtemp2_l[level],
ze);
}
/*---------------------------------------------------------------------
* Up cycle.
*---------------------------------------------------------------------*/
for (level= (edge_numlevs - 2); level>= 1; level--)
{
hypre_ParCSRMatrixMatvec(1.0,
(hypre_ParCSRMatrix *) hypre_IJMatrixObject(Pe_l[level]),
xe_l[level+1], 0.0, ee_l[level]);
hypre_ParVectorZeroBCValues(ee_l[level], BdryRanks_l[level],
BdryRanksCnts_l[level]);
hypre_ParVectorAxpy(1.0, ee_l[level], xe_l[level]);
/* post smooth */
for (j= 0; j< npost_relax; j++)
{
Solve_err_flag = hypre_BoomerAMGRelaxIF(Aee_l[level],
be_l[level],
eCF_marker_l[level],
erelax_type,
relax_local,
cycle_param,
erelax_weight[level],
eomega[level],
NULL,
xe_l[level],
eVtemp2_l[level],
ze);
}
} /* for (level= (edge_numlevs - 2); level>= 1; level--) */
/* interpolate error and correct on finest grids */
hypre_ParCSRMatrixMatvec(1.0,
(hypre_ParCSRMatrix *) hypre_IJMatrixObject(Pe_l[0]),
xe_l[1], 0.0, ee_l[0]);
hypre_ParVectorZeroBCValues(ee_l[0], BdryRanks_l[0],
BdryRanksCnts_l[0]);
hypre_ParVectorAxpy(1.0, ee_l[0], xe_l[0]);
for (j= 0; j< npost_relax; j++)
{
Solve_err_flag = hypre_BoomerAMGRelaxIF(Aee_l[0],
be_l[0],
eCF_marker_l[0],
erelax_type,
relax_local,
cycle_param,
erelax_weight[0],
eomega[0],
NULL,
xe_l[0],
eVtemp2_l[0],
ze);
} /* for (j= 0; j< npost_relax; j++) */
e_dot_e= hypre_ParVectorInnerProd(ee_l[0], ee_l[0]);
x_dot_x= hypre_ParVectorInnerProd(xe_l[0], xe_l[0]);
hypre_ParVectorCopy(be_l[0], rese_l[0]);
hypre_ParCSRMatrixMatvec(-1.0, Aee_l[0], xe_l[0], 1.0, rese_l[0]);
(maxwell_data -> num_iterations) = (i + 1);
}
hypre_EndTiming(maxwell_data -> time_index);
if (ze)
hypre_ParVectorDestroy(ze);
return ierr;
}
HYPRE_Int
hypre_BoomerAMGCycle( void *amg_vdata,
hypre_ParVector **F_array,
hypre_ParVector **U_array )
{
hypre_ParAMGData *amg_data = amg_vdata;
HYPRE_Solver *smoother;
/* Data Structure variables */
hypre_ParCSRMatrix **A_array;
hypre_ParCSRMatrix **P_array;
hypre_ParCSRMatrix **R_array;
hypre_ParVector *Utemp;
hypre_ParVector *Vtemp;
hypre_ParVector *Rtemp;
hypre_ParVector *Ptemp;
hypre_ParVector *Ztemp;
hypre_ParVector *Aux_U;
hypre_ParVector *Aux_F;
hypre_ParCSRBlockMatrix **A_block_array;
hypre_ParCSRBlockMatrix **P_block_array;
hypre_ParCSRBlockMatrix **R_block_array;
HYPRE_Real *Ztemp_data;
HYPRE_Real *Ptemp_data;
HYPRE_Int **CF_marker_array;
/* HYPRE_Int **unknown_map_array;
HYPRE_Int **point_map_array;
HYPRE_Int **v_at_point_array; */
HYPRE_Real cycle_op_count;
HYPRE_Int cycle_type;
HYPRE_Int num_levels;
HYPRE_Int max_levels;
HYPRE_Real *num_coeffs;
HYPRE_Int *num_grid_sweeps;
HYPRE_Int *grid_relax_type;
HYPRE_Int **grid_relax_points;
HYPRE_Int block_mode;
HYPRE_Real *max_eig_est;
HYPRE_Real *min_eig_est;
HYPRE_Int cheby_order;
HYPRE_Real cheby_fraction;
/* Local variables */
HYPRE_Int *lev_counter;
HYPRE_Int Solve_err_flag;
HYPRE_Int k;
HYPRE_Int i, j, jj;
HYPRE_Int level;
HYPRE_Int cycle_param;
HYPRE_Int coarse_grid;
HYPRE_Int fine_grid;
HYPRE_Int Not_Finished;
HYPRE_Int num_sweep;
HYPRE_Int cg_num_sweep = 1;
HYPRE_Int relax_type;
HYPRE_Int relax_points;
HYPRE_Int relax_order;
HYPRE_Int relax_local;
HYPRE_Int old_version = 0;
HYPRE_Real *relax_weight;
HYPRE_Real *omega;
HYPRE_Real alfa, beta, gammaold;
HYPRE_Real gamma = 1.0;
HYPRE_Int local_size;
/* HYPRE_Int *smooth_option; */
HYPRE_Int smooth_type;
HYPRE_Int smooth_num_levels;
HYPRE_Int num_threads, my_id;
HYPRE_Real alpha;
HYPRE_Real **l1_norms = NULL;
HYPRE_Real *l1_norms_level;
HYPRE_Int seq_cg = 0;
MPI_Comm comm;
#if 0
HYPRE_Real *D_mat;
HYPRE_Real *S_vec;
#endif
/* Acquire data and allocate storage */
num_threads = hypre_NumThreads();
A_array = hypre_ParAMGDataAArray(amg_data);
P_array = hypre_ParAMGDataPArray(amg_data);
R_array = hypre_ParAMGDataRArray(amg_data);
CF_marker_array = hypre_ParAMGDataCFMarkerArray(amg_data);
Vtemp = hypre_ParAMGDataVtemp(amg_data);
Rtemp = hypre_ParAMGDataRtemp(amg_data);
Ptemp = hypre_ParAMGDataPtemp(amg_data);
Ztemp = hypre_ParAMGDataZtemp(amg_data);
num_levels = hypre_ParAMGDataNumLevels(amg_data);
max_levels = hypre_ParAMGDataMaxLevels(amg_data);
cycle_type = hypre_ParAMGDataCycleType(amg_data);
A_block_array = hypre_ParAMGDataABlockArray(amg_data);
P_block_array = hypre_ParAMGDataPBlockArray(amg_data);
R_block_array = hypre_ParAMGDataRBlockArray(amg_data);
block_mode = hypre_ParAMGDataBlockMode(amg_data);
num_grid_sweeps = hypre_ParAMGDataNumGridSweeps(amg_data);
grid_relax_type = hypre_ParAMGDataGridRelaxType(amg_data);
grid_relax_points = hypre_ParAMGDataGridRelaxPoints(amg_data);
relax_order = hypre_ParAMGDataRelaxOrder(amg_data);
relax_weight = hypre_ParAMGDataRelaxWeight(amg_data);
omega = hypre_ParAMGDataOmega(amg_data);
smooth_type = hypre_ParAMGDataSmoothType(amg_data);
smooth_num_levels = hypre_ParAMGDataSmoothNumLevels(amg_data);
l1_norms = hypre_ParAMGDataL1Norms(amg_data);
/* smooth_option = hypre_ParAMGDataSmoothOption(amg_data); */
max_eig_est = hypre_ParAMGDataMaxEigEst(amg_data);
min_eig_est = hypre_ParAMGDataMinEigEst(amg_data);
cheby_order = hypre_ParAMGDataChebyOrder(amg_data);
cheby_fraction = hypre_ParAMGDataChebyFraction(amg_data);
cycle_op_count = hypre_ParAMGDataCycleOpCount(amg_data);
lev_counter = hypre_CTAlloc(HYPRE_Int, num_levels);
if (hypre_ParAMGDataParticipate(amg_data)) seq_cg = 1;
/* Initialize */
Solve_err_flag = 0;
if (grid_relax_points) old_version = 1;
num_coeffs = hypre_CTAlloc(HYPRE_Real, num_levels);
num_coeffs[0] = hypre_ParCSRMatrixDNumNonzeros(A_array[0]);
comm = hypre_ParCSRMatrixComm(A_array[0]);
hypre_MPI_Comm_rank(comm,&my_id);
if (block_mode)
{
for (j = 1; j < num_levels; j++)
num_coeffs[j] = hypre_ParCSRBlockMatrixNumNonzeros(A_block_array[j]);
}
else
{
for (j = 1; j < num_levels; j++)
num_coeffs[j] = hypre_ParCSRMatrixDNumNonzeros(A_array[j]);
}
/*---------------------------------------------------------------------
* Initialize cycling control counter
*
* Cycling is controlled using a level counter: lev_counter[k]
*
* Each time relaxation is performed on level k, the
* counter is decremented by 1. If the counter is then
* negative, we go to the next finer level. If non-
* negative, we go to the next coarser level. The
* following actions control cycling:
*
* a. lev_counter[0] is initialized to 1.
* b. lev_counter[k] is initialized to cycle_type for k>0.
*
* c. During cycling, when going down to level k, lev_counter[k]
* is set to the max of (lev_counter[k],cycle_type)
*---------------------------------------------------------------------*/
Not_Finished = 1;
lev_counter[0] = 1;
for (k = 1; k < num_levels; ++k)
{
lev_counter[k] = cycle_type;
}
level = 0;
cycle_param = 1;
smoother = hypre_ParAMGDataSmoother(amg_data);
if (smooth_num_levels > 0)
{
if (smooth_type == 7 || smooth_type == 8
|| smooth_type == 17 || smooth_type == 18
|| smooth_type == 9 || smooth_type == 19)
{
HYPRE_Int actual_local_size = hypre_ParVectorActualLocalSize(Vtemp);
Utemp = hypre_ParVectorCreate(comm,hypre_ParVectorGlobalSize(Vtemp),
hypre_ParVectorPartitioning(Vtemp));
hypre_ParVectorOwnsPartitioning(Utemp) = 0;
local_size
= hypre_VectorSize(hypre_ParVectorLocalVector(Vtemp));
if (local_size < actual_local_size)
{
hypre_VectorData(hypre_ParVectorLocalVector(Utemp)) =
hypre_CTAlloc(HYPRE_Complex, actual_local_size);
hypre_ParVectorActualLocalSize(Utemp) = actual_local_size;
}
else
hypre_ParVectorInitialize(Utemp);
}
}
/*---------------------------------------------------------------------
* Main loop of cycling
*--------------------------------------------------------------------*/
while (Not_Finished)
{
if (num_levels > 1)
{
local_size
= hypre_VectorSize(hypre_ParVectorLocalVector(F_array[level]));
hypre_VectorSize(hypre_ParVectorLocalVector(Vtemp)) = local_size;
if (smooth_num_levels <= level)
{
cg_num_sweep = 1;
num_sweep = num_grid_sweeps[cycle_param];
Aux_U = U_array[level];
Aux_F = F_array[level];
}
else if (smooth_type > 9)
{
hypre_VectorSize(hypre_ParVectorLocalVector(Ztemp)) = local_size;
hypre_VectorSize(hypre_ParVectorLocalVector(Rtemp)) = local_size;
hypre_VectorSize(hypre_ParVectorLocalVector(Ptemp)) = local_size;
Ztemp_data = hypre_VectorData(hypre_ParVectorLocalVector(Ztemp));
Ptemp_data = hypre_VectorData(hypre_ParVectorLocalVector(Ptemp));
hypre_ParVectorSetConstantValues(Ztemp,0);
alpha = -1.0;
beta = 1.0;
hypre_ParCSRMatrixMatvecOutOfPlace(alpha, A_array[level],
U_array[level], beta, F_array[level], Rtemp);
cg_num_sweep = hypre_ParAMGDataSmoothNumSweeps(amg_data);
num_sweep = num_grid_sweeps[cycle_param];
Aux_U = Ztemp;
Aux_F = Rtemp;
}
else
{
cg_num_sweep = 1;
num_sweep = hypre_ParAMGDataSmoothNumSweeps(amg_data);
Aux_U = U_array[level];
Aux_F = F_array[level];
}
relax_type = grid_relax_type[cycle_param];
}
else /* AB: 4/08: removed the max_levels > 1 check - should do this when max-levels = 1 also */
{
/* If no coarsening occurred, apply a simple smoother once */
Aux_U = U_array[level];
Aux_F = F_array[level];
num_sweep = 1;
/* TK: Use the user relax type (instead of 0) to allow for setting a
convergent smoother (e.g. in the solution of singular problems). */
relax_type = hypre_ParAMGDataUserRelaxType(amg_data);
}
if (l1_norms != NULL)
l1_norms_level = l1_norms[level];
else
l1_norms_level = NULL;
if (cycle_param == 3 && seq_cg)
{
hypre_seqAMGCycle(amg_data, level, F_array, U_array);
}
else
{
/*------------------------------------------------------------------
* Do the relaxation num_sweep times
*-----------------------------------------------------------------*/
for (jj = 0; jj < cg_num_sweep; jj++)
{
if (smooth_num_levels > level && smooth_type > 9)
hypre_ParVectorSetConstantValues(Aux_U,0);
for (j = 0; j < num_sweep; j++)
{
if (num_levels == 1 && max_levels > 1)
{
relax_points = 0;
relax_local = 0;
}
else
{
if (old_version)
relax_points = grid_relax_points[cycle_param][j];
relax_local = relax_order;
}
/*-----------------------------------------------
* VERY sloppy approximation to cycle complexity
*-----------------------------------------------*/
if (old_version && level < num_levels -1)
{
switch (relax_points)
{
case 1:
cycle_op_count += num_coeffs[level+1];
break;
case -1:
cycle_op_count += (num_coeffs[level]-num_coeffs[level+1]);
break;
}
}
else
{
cycle_op_count += num_coeffs[level];
}
/*-----------------------------------------------
Choose Smoother
-----------------------------------------------*/
if (smooth_num_levels > level &&
(smooth_type == 7 || smooth_type == 8 ||
smooth_type == 9 || smooth_type == 19 ||
smooth_type == 17 || smooth_type == 18))
{
hypre_VectorSize(hypre_ParVectorLocalVector(Utemp)) = local_size;
alpha = -1.0;
beta = 1.0;
hypre_ParCSRMatrixMatvecOutOfPlace(alpha, A_array[level],
U_array[level], beta, Aux_F, Vtemp);
if (smooth_type == 8 || smooth_type == 18)
HYPRE_ParCSRParaSailsSolve(smoother[level],
(HYPRE_ParCSRMatrix) A_array[level],
(HYPRE_ParVector) Vtemp,
(HYPRE_ParVector) Utemp);
else if (smooth_type == 7 || smooth_type == 17)
HYPRE_ParCSRPilutSolve(smoother[level],
(HYPRE_ParCSRMatrix) A_array[level],
(HYPRE_ParVector) Vtemp,
(HYPRE_ParVector) Utemp);
else if (smooth_type == 9 || smooth_type == 19)
HYPRE_EuclidSolve(smoother[level],
(HYPRE_ParCSRMatrix) A_array[level],
(HYPRE_ParVector) Vtemp,
(HYPRE_ParVector) Utemp);
hypre_ParVectorAxpy(relax_weight[level],Utemp,Aux_U);
}
else if (smooth_num_levels > level &&
(smooth_type == 6 || smooth_type == 16))
{
HYPRE_SchwarzSolve(smoother[level],
(HYPRE_ParCSRMatrix) A_array[level],
(HYPRE_ParVector) Aux_F,
(HYPRE_ParVector) Aux_U);
}
/*else if (relax_type == 99)*/
else if (relax_type == 9 || relax_type == 99)
{ /* Gaussian elimination */
hypre_GaussElimSolve(amg_data, level, relax_type);
}
else if (relax_type == 18)
{ /* L1 - Jacobi*/
if (relax_order == 1 && cycle_param < 3)
{
/* need to do CF - so can't use the AMS one */
HYPRE_Int i;
HYPRE_Int loc_relax_points[2];
if (cycle_type < 2)
{
loc_relax_points[0] = 1;
loc_relax_points[1] = -1;
}
else
{
loc_relax_points[0] = -1;
loc_relax_points[1] = 1;
}
for (i=0; i < 2; i++)
hypre_ParCSRRelax_L1_Jacobi(A_array[level],
Aux_F,
CF_marker_array[level],
loc_relax_points[i],
relax_weight[level],
l1_norms[level],
Aux_U,
Vtemp);
}
else /* not CF - so use through AMS */
{
if (num_threads == 1)
hypre_ParCSRRelax(A_array[level],
Aux_F,
1,
1,
l1_norms_level,
relax_weight[level],
omega[level],0,0,0,0,
Aux_U,
Vtemp,
Ztemp);
else
hypre_ParCSRRelaxThreads(A_array[level],
Aux_F,
1,
1,
l1_norms_level,
relax_weight[level],
omega[level],
Aux_U,
Vtemp,
Ztemp);
}
}
else if (relax_type == 15)
{ /* CG */
if (j ==0) /* do num sweep iterations of CG */
hypre_ParCSRRelax_CG( smoother[level],
A_array[level],
Aux_F,
Aux_U,
num_sweep);
}
else if (relax_type == 16)
{ /* scaled Chebyshev */
HYPRE_Int scale = 1;
HYPRE_Int variant = 0;
hypre_ParCSRRelax_Cheby(A_array[level],
Aux_F,
max_eig_est[level],
min_eig_est[level],
cheby_fraction, cheby_order, scale,
variant, Aux_U, Vtemp, Ztemp );
}
else if (relax_type ==17)
{
hypre_BoomerAMGRelax_FCFJacobi(A_array[level],
Aux_F,
CF_marker_array[level],
relax_weight[level],
Aux_U,
Vtemp);
}
else if (old_version)
{
Solve_err_flag = hypre_BoomerAMGRelax(A_array[level],
Aux_F,
CF_marker_array[level],
relax_type, relax_points,
relax_weight[level],
omega[level],
l1_norms_level,
Aux_U,
Vtemp,
Ztemp);
}
else
{
/* smoother than can have CF ordering */
if (block_mode)
{
Solve_err_flag = hypre_BoomerAMGBlockRelaxIF(A_block_array[level],
Aux_F,
CF_marker_array[level],
relax_type,
relax_local,
cycle_param,
relax_weight[level],
omega[level],
Aux_U,
Vtemp);
}
else
{
Solve_err_flag = hypre_BoomerAMGRelaxIF(A_array[level],
Aux_F,
CF_marker_array[level],
relax_type,
relax_local,
cycle_param,
relax_weight[level],
omega[level],
l1_norms_level,
Aux_U,
Vtemp,
Ztemp);
}
}
if (Solve_err_flag != 0)
return(Solve_err_flag);
}
if (smooth_num_levels > level && smooth_type > 9)
{
gammaold = gamma;
gamma = hypre_ParVectorInnerProd(Rtemp,Ztemp);
if (jj == 0)
hypre_ParVectorCopy(Ztemp,Ptemp);
else
{
beta = gamma/gammaold;
for (i=0; i < local_size; i++)
Ptemp_data[i] = Ztemp_data[i] + beta*Ptemp_data[i];
}
hypre_ParCSRMatrixMatvec(1.0,A_array[level],Ptemp,0.0,Vtemp);
alfa = gamma /hypre_ParVectorInnerProd(Ptemp,Vtemp);
hypre_ParVectorAxpy(alfa,Ptemp,U_array[level]);
hypre_ParVectorAxpy(-alfa,Vtemp,Rtemp);
}
}
}
/*------------------------------------------------------------------
* Decrement the control counter and determine which grid to visit next
*-----------------------------------------------------------------*/
--lev_counter[level];
if (lev_counter[level] >= 0 && level != num_levels-1)
{
/*---------------------------------------------------------------
* Visit coarser level next.
* Compute residual using hypre_ParCSRMatrixMatvec.
* Perform restriction using hypre_ParCSRMatrixMatvecT.
* Reset counters and cycling parameters for coarse level
*--------------------------------------------------------------*/
fine_grid = level;
coarse_grid = level + 1;
hypre_ParVectorSetConstantValues(U_array[coarse_grid], 0.0);
alpha = -1.0;
beta = 1.0;
if (block_mode)
{
hypre_ParVectorCopy(F_array[fine_grid],Vtemp);
hypre_ParCSRBlockMatrixMatvec(alpha, A_block_array[fine_grid], U_array[fine_grid],
beta, Vtemp);
}
else
{
// JSP: avoid unnecessary copy using out-of-place version of SpMV
hypre_ParCSRMatrixMatvecOutOfPlace(alpha, A_array[fine_grid], U_array[fine_grid],
beta, F_array[fine_grid], Vtemp);
}
alpha = 1.0;
beta = 0.0;
if (block_mode)
{
hypre_ParCSRBlockMatrixMatvecT(alpha,R_block_array[fine_grid],Vtemp,
beta,F_array[coarse_grid]);
}
else
{
hypre_ParCSRMatrixMatvecT(alpha,R_array[fine_grid],Vtemp,
beta,F_array[coarse_grid]);
}
++level;
lev_counter[level] = hypre_max(lev_counter[level],cycle_type);
cycle_param = 1;
if (level == num_levels-1) cycle_param = 3;
}
else if (level != 0)
{
/*---------------------------------------------------------------
* Visit finer level next.
* Interpolate and add correction using hypre_ParCSRMatrixMatvec.
* Reset counters and cycling parameters for finer level.
*--------------------------------------------------------------*/
fine_grid = level - 1;
coarse_grid = level;
alpha = 1.0;
beta = 1.0;
if (block_mode)
{
hypre_ParCSRBlockMatrixMatvec(alpha, P_block_array[fine_grid],
U_array[coarse_grid],
beta, U_array[fine_grid]);
}
else
{
hypre_ParCSRMatrixMatvec(alpha, P_array[fine_grid],
U_array[coarse_grid],
beta, U_array[fine_grid]);
}
--level;
cycle_param = 2;
}
else
{
Not_Finished = 0;
}
}
hypre_ParAMGDataCycleOpCount(amg_data) = cycle_op_count;
hypre_TFree(lev_counter);
hypre_TFree(num_coeffs);
if (smooth_num_levels > 0)
{
if (smooth_type == 7 || smooth_type == 8 || smooth_type == 9 ||
smooth_type == 17 || smooth_type == 18 || smooth_type == 19 )
hypre_ParVectorDestroy(Utemp);
}
return(Solve_err_flag);
}
HYPRE_Int
hypre_BoomerAMGAdditiveCycle( void *amg_vdata)
{
hypre_ParAMGData *amg_data = amg_vdata;
/* Data Structure variables */
hypre_ParCSRMatrix **A_array;
hypre_ParCSRMatrix **P_array;
hypre_ParCSRMatrix **R_array;
hypre_ParCSRMatrix *Lambda;
hypre_ParVector **F_array;
hypre_ParVector **U_array;
hypre_ParVector *Vtemp;
hypre_ParVector *Ztemp;
hypre_ParVector *Xtilde, *Rtilde;
HYPRE_Int **CF_marker_array;
HYPRE_Int num_levels;
HYPRE_Int addlvl;
HYPRE_Int additive;
HYPRE_Int mult_additive;
HYPRE_Int simple;
HYPRE_Int i, num_rows;
HYPRE_Int n_global;
HYPRE_Int rlx_order;
/* Local variables */
HYPRE_Int Solve_err_flag = 0;
HYPRE_Int level;
HYPRE_Int coarse_grid;
HYPRE_Int fine_grid;
HYPRE_Int relax_type;
HYPRE_Int rlx_down;
HYPRE_Int rlx_up;
HYPRE_Int *grid_relax_type;
HYPRE_Real **l1_norms;
HYPRE_Real alpha, beta;
HYPRE_Int num_threads;
HYPRE_Real *u_data;
HYPRE_Real *f_data;
HYPRE_Real *v_data;
HYPRE_Real *l1_norms_lvl;
HYPRE_Real *D_inv;
HYPRE_Real *x_global;
HYPRE_Real *r_global;
HYPRE_Real *relax_weight;
HYPRE_Real *omega;
#if 0
HYPRE_Real *D_mat;
HYPRE_Real *S_vec;
#endif
/* Acquire data and allocate storage */
num_threads = hypre_NumThreads();
A_array = hypre_ParAMGDataAArray(amg_data);
F_array = hypre_ParAMGDataFArray(amg_data);
U_array = hypre_ParAMGDataUArray(amg_data);
P_array = hypre_ParAMGDataPArray(amg_data);
R_array = hypre_ParAMGDataRArray(amg_data);
CF_marker_array = hypre_ParAMGDataCFMarkerArray(amg_data);
Vtemp = hypre_ParAMGDataVtemp(amg_data);
Ztemp = hypre_ParAMGDataZtemp(amg_data);
num_levels = hypre_ParAMGDataNumLevels(amg_data);
additive = hypre_ParAMGDataAdditive(amg_data);
mult_additive = hypre_ParAMGDataMultAdditive(amg_data);
simple = hypre_ParAMGDataSimple(amg_data);
grid_relax_type = hypre_ParAMGDataGridRelaxType(amg_data);
Lambda = hypre_ParAMGDataLambda(amg_data);
Xtilde = hypre_ParAMGDataXtilde(amg_data);
Rtilde = hypre_ParAMGDataRtilde(amg_data);
l1_norms = hypre_ParAMGDataL1Norms(amg_data);
D_inv = hypre_ParAMGDataDinv(amg_data);
grid_relax_type = hypre_ParAMGDataGridRelaxType(amg_data);
relax_weight = hypre_ParAMGDataRelaxWeight(amg_data);
omega = hypre_ParAMGDataOmega(amg_data);
rlx_order = hypre_ParAMGDataRelaxOrder(amg_data);
/* Initialize */
addlvl = hypre_max(additive, mult_additive);
addlvl = hypre_max(addlvl, simple);
Solve_err_flag = 0;
/*---------------------------------------------------------------------
* Main loop of cycling --- multiplicative version --- V-cycle
*--------------------------------------------------------------------*/
/* down cycle */
relax_type = grid_relax_type[1];
rlx_down = grid_relax_type[1];
rlx_up = grid_relax_type[2];
for (level = 0; level < num_levels-1; level++)
{
fine_grid = level;
coarse_grid = level + 1;
u_data = hypre_VectorData(hypre_ParVectorLocalVector(U_array[fine_grid]));
f_data = hypre_VectorData(hypre_ParVectorLocalVector(F_array[fine_grid]));
v_data = hypre_VectorData(hypre_ParVectorLocalVector(Vtemp));
l1_norms_lvl = l1_norms[level];
hypre_ParVectorSetConstantValues(U_array[coarse_grid], 0.0);
if (level < addlvl) /* multiplicative version */
{
/* smoothing step */
if (rlx_down == 0)
{
HYPRE_Real *A_data = hypre_CSRMatrixData(hypre_ParCSRMatrixDiag(A_array[fine_grid]));
HYPRE_Int *A_i = hypre_CSRMatrixI(hypre_ParCSRMatrixDiag(A_array[fine_grid]));
hypre_ParVectorCopy(F_array[fine_grid],Vtemp);
num_rows = hypre_CSRMatrixNumRows(hypre_ParCSRMatrixDiag(A_array[fine_grid]));
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE
#endif
for (i = 0; i < num_rows; i++)
u_data[i] = relax_weight[level]*v_data[i] / A_data[A_i[i]];
}
else if (rlx_down != 18)
{
/*hypre_BoomerAMGRelax(A_array[fine_grid],F_array[fine_grid],NULL,rlx_down,0,*/
hypre_BoomerAMGRelaxIF(A_array[fine_grid],F_array[fine_grid],
CF_marker_array[fine_grid], rlx_down,rlx_order,1,
relax_weight[fine_grid], omega[fine_grid],
l1_norms_lvl, U_array[fine_grid], Vtemp, Ztemp);
hypre_ParVectorCopy(F_array[fine_grid],Vtemp);
}
else
{
hypre_ParVectorCopy(F_array[fine_grid],Vtemp);
num_rows = hypre_CSRMatrixNumRows(hypre_ParCSRMatrixDiag(A_array[fine_grid]));
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE
#endif
for (i = 0; i < num_rows; i++)
u_data[i] += v_data[i] / l1_norms_lvl[i];
}
alpha = -1.0;
beta = 1.0;
hypre_ParCSRMatrixMatvec(alpha, A_array[fine_grid], U_array[fine_grid],
beta, Vtemp);
alpha = 1.0;
beta = 0.0;
hypre_ParCSRMatrixMatvecT(alpha,R_array[fine_grid],Vtemp,
beta,F_array[coarse_grid]);
}
else /* additive version */
{
hypre_ParVectorCopy(F_array[fine_grid],Vtemp);
if (level == 0) /* compute residual */
{
hypre_ParVectorCopy(Vtemp, Rtilde);
hypre_ParVectorCopy(U_array[fine_grid],Xtilde);
}
alpha = 1.0;
beta = 0.0;
hypre_ParCSRMatrixMatvecT(alpha,R_array[fine_grid],Vtemp,
beta,F_array[coarse_grid]);
}
}
/* solve coarse grid */
if (addlvl < num_levels)
{
if (simple > -1)
{
x_global = hypre_VectorData(hypre_ParVectorLocalVector(Xtilde));
r_global = hypre_VectorData(hypre_ParVectorLocalVector(Rtilde));
n_global = hypre_VectorSize(hypre_ParVectorLocalVector(Xtilde));
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE
#endif
for (i=0; i < n_global; i++)
x_global[i] += D_inv[i]*r_global[i];
}
else
hypre_ParCSRMatrixMatvec(1.0, Lambda, Rtilde, 1.0, Xtilde);
if (addlvl == 0) hypre_ParVectorCopy(Xtilde, U_array[0]);
}
else
{
fine_grid = num_levels -1;
hypre_ParCSRRelax(A_array[fine_grid], F_array[fine_grid],
1, 1, l1_norms[fine_grid],
1.0, 1.0 ,0,0,0,0,
U_array[fine_grid], Vtemp, Ztemp);
}
/* up cycle */
relax_type = grid_relax_type[2];
for (level = num_levels-1; level > 0; level--)
{
fine_grid = level - 1;
coarse_grid = level;
if (level <= addlvl) /* multiplicative version */
{
alpha = 1.0;
beta = 1.0;
hypre_ParCSRMatrixMatvec(alpha, P_array[fine_grid],
U_array[coarse_grid],
beta, U_array[fine_grid]);
if (rlx_up != 18)
/*hypre_BoomerAMGRelax(A_array[fine_grid],F_array[fine_grid],NULL,rlx_up,0,*/
hypre_BoomerAMGRelaxIF(A_array[fine_grid],F_array[fine_grid],
CF_marker_array[fine_grid],
rlx_up,rlx_order,2,
relax_weight[fine_grid], omega[fine_grid],
l1_norms[fine_grid], U_array[fine_grid], Vtemp, Ztemp);
else if (rlx_order)
{
HYPRE_Int loc_relax_points[2];
loc_relax_points[0] = -1;
loc_relax_points[1] = 1;
for (i=0; i < 2; i++)
hypre_ParCSRRelax_L1_Jacobi(A_array[fine_grid],F_array[fine_grid],
CF_marker_array[fine_grid],
loc_relax_points[i],
1.0, l1_norms[fine_grid],
U_array[fine_grid], Vtemp);
}
else
hypre_ParCSRRelax(A_array[fine_grid], F_array[fine_grid],
1, 1, l1_norms[fine_grid],
1.0, 1.0 ,0,0,0,0,
U_array[fine_grid], Vtemp, Ztemp);
}
else /* additive version */
{
alpha = 1.0;
beta = 1.0;
hypre_ParCSRMatrixMatvec(alpha, P_array[fine_grid],
U_array[coarse_grid],
beta, U_array[fine_grid]);
}
}
return(Solve_err_flag);
}
HYPRE_Int
main( HYPRE_Int argc,
char *argv[] )
{
hypre_CSRMatrix *matrix;
hypre_CSRMatrix *matrix1;
hypre_ParCSRMatrix *par_matrix;
hypre_Vector *x_local;
hypre_Vector *y_local;
hypre_Vector *y2_local;
hypre_ParVector *x;
hypre_ParVector *x2;
hypre_ParVector *y;
hypre_ParVector *y2;
HYPRE_Int vecstride_x, idxstride_x, vecstride_y, idxstride_y;
HYPRE_Int num_procs, my_id;
HYPRE_Int local_size;
HYPRE_Int num_vectors;
HYPRE_Int global_num_rows, global_num_cols;
HYPRE_Int first_index;
HYPRE_Int i, j, ierr=0;
double *data, *data2;
HYPRE_Int *row_starts, *col_starts;
char file_name[80];
/* Initialize MPI */
hypre_MPI_Init(&argc, &argv);
hypre_MPI_Comm_size(hypre_MPI_COMM_WORLD, &num_procs);
hypre_MPI_Comm_rank(hypre_MPI_COMM_WORLD, &my_id);
hypre_printf(" my_id: %d num_procs: %d\n", my_id, num_procs);
if (my_id == 0)
{
matrix = hypre_CSRMatrixRead("input");
hypre_printf(" read input\n");
}
row_starts = NULL;
col_starts = NULL;
par_matrix = hypre_CSRMatrixToParCSRMatrix(hypre_MPI_COMM_WORLD, matrix,
row_starts, col_starts);
hypre_printf(" converted\n");
matrix1 = hypre_ParCSRMatrixToCSRMatrixAll(par_matrix);
hypre_sprintf(file_name,"matrix1.%d",my_id);
if (matrix1) hypre_CSRMatrixPrint(matrix1, file_name);
hypre_ParCSRMatrixPrint(par_matrix,"matrix");
hypre_ParCSRMatrixPrintIJ(par_matrix,0,0,"matrixIJ");
par_matrix = hypre_ParCSRMatrixRead(hypre_MPI_COMM_WORLD,"matrix");
global_num_cols = hypre_ParCSRMatrixGlobalNumCols(par_matrix);
hypre_printf(" global_num_cols %d\n", global_num_cols);
global_num_rows = hypre_ParCSRMatrixGlobalNumRows(par_matrix);
col_starts = hypre_ParCSRMatrixColStarts(par_matrix);
first_index = col_starts[my_id];
local_size = col_starts[my_id+1] - first_index;
num_vectors = 3;
x = hypre_ParMultiVectorCreate( hypre_MPI_COMM_WORLD, global_num_cols,
col_starts, num_vectors );
hypre_ParVectorSetPartitioningOwner(x,0);
hypre_ParVectorInitialize(x);
x_local = hypre_ParVectorLocalVector(x);
data = hypre_VectorData(x_local);
vecstride_x = hypre_VectorVectorStride(x_local);
idxstride_x = hypre_VectorIndexStride(x_local);
for ( j=0; j<num_vectors; ++j )
for (i=0; i < local_size; i++)
data[i*idxstride_x + j*vecstride_x] = first_index+i+1 + 100*j;
x2 = hypre_ParMultiVectorCreate( hypre_MPI_COMM_WORLD, global_num_cols,
col_starts, num_vectors );
hypre_ParVectorSetPartitioningOwner(x2,0);
hypre_ParVectorInitialize(x2);
hypre_ParVectorSetConstantValues(x2,2.0);
row_starts = hypre_ParCSRMatrixRowStarts(par_matrix);
first_index = row_starts[my_id];
local_size = row_starts[my_id+1] - first_index;
y = hypre_ParMultiVectorCreate( hypre_MPI_COMM_WORLD, global_num_rows,
row_starts, num_vectors );
hypre_ParVectorSetPartitioningOwner(y,0);
hypre_ParVectorInitialize(y);
y_local = hypre_ParVectorLocalVector(y);
y2 = hypre_ParMultiVectorCreate( hypre_MPI_COMM_WORLD, global_num_rows,
row_starts, num_vectors );
hypre_ParVectorSetPartitioningOwner(y2,0);
hypre_ParVectorInitialize(y2);
y2_local = hypre_ParVectorLocalVector(y2);
data2 = hypre_VectorData(y2_local);
vecstride_y = hypre_VectorVectorStride(y2_local);
idxstride_y = hypre_VectorIndexStride(y2_local);
for ( j=0; j<num_vectors; ++j )
for (i=0; i < local_size; i++)
data2[i*idxstride_y+j*vecstride_y] = first_index+i+1 + 100*j;
hypre_ParVectorSetConstantValues(y,1.0);
hypre_printf(" initialized vectors, first_index=%i\n", first_index);
hypre_ParVectorPrint(x, "vectorx");
hypre_ParVectorPrint(y, "vectory");
hypre_MatvecCommPkgCreate(par_matrix);
hypre_ParCSRMatrixMatvec ( 1.0, par_matrix, x, 1.0, y);
hypre_printf(" did matvec\n");
hypre_ParVectorPrint(y, "result");
ierr = hypre_ParCSRMatrixMatvecT ( 1.0, par_matrix, y2, 1.0, x2);
hypre_printf(" did matvecT %d\n", ierr);
hypre_ParVectorPrint(x2, "transp");
hypre_ParCSRMatrixDestroy(par_matrix);
hypre_ParVectorDestroy(x);
hypre_ParVectorDestroy(x2);
hypre_ParVectorDestroy(y);
hypre_ParVectorDestroy(y2);
if (my_id == 0) hypre_CSRMatrixDestroy(matrix);
if (matrix1) hypre_CSRMatrixDestroy(matrix1);
/* Finalize MPI */
hypre_MPI_Finalize();
return 0;
}
