//=======================================================
int EpetraExt_HypreIJMatrix::InitializeDefaults(){
int my_type;
// Get type of Hypre IJ Matrix
EPETRA_CHK_ERR(HYPRE_IJMatrixGetObjectType(Matrix_, &my_type));
MatType_ = my_type;
// Currently only ParCSR is supported
TEUCHOS_TEST_FOR_EXCEPTION(MatType_ != HYPRE_PARCSR, std::logic_error, "Object is not type PARCSR");
// Get the actual ParCSR object from the IJ matrix
EPETRA_CHK_ERR(HYPRE_IJMatrixGetObject(Matrix_, (void**) &ParMatrix_));
int numRows, numCols;
// Get dimensions of the matrix and store as global variables
EPETRA_CHK_ERR(HYPRE_ParCSRMatrixGetDims(ParMatrix_, &numRows, &numCols));
NumGlobalRows_ = numRows;
NumGlobalCols_ = numCols;
// Get the local dimensions of the matrix
int ColStart, ColEnd;
EPETRA_CHK_ERR(HYPRE_ParCSRMatrixGetLocalRange(ParMatrix_, &MyRowStart_, &MyRowEnd_, &ColStart, &ColEnd));
// Determine number of local rows
NumMyRows_ = MyRowEnd_ - MyRowStart_+1;
return 0;
} //InitializeDefaults()
void EuclidGetDimensions(void *A, HYPRE_Int *beg_row, HYPRE_Int *rowsLocal, HYPRE_Int *rowsGlobal)
{
START_FUNC_DH
HYPRE_Int ierr, m, n;
HYPRE_Int row_start, row_end, col_start, col_end;
HYPRE_ParCSRMatrix mat = (HYPRE_ParCSRMatrix) A;
ierr = HYPRE_ParCSRMatrixGetDims(mat, &m, &n);
if (ierr) {
hypre_sprintf(msgBuf_dh, "HYPRE_ParCSRMatrixGetDims() returned %i", ierr);
SET_V_ERROR(msgBuf_dh);
}
ierr = HYPRE_ParCSRMatrixGetLocalRange(mat, &row_start, &row_end,
&col_start, &col_end);
if (ierr) {
hypre_sprintf(msgBuf_dh, "HYPRE_ParCSRMatrixGetLocalRange() returned %i", ierr);
SET_V_ERROR(msgBuf_dh);
}
/* hypre_fprintf(stderr, "\n##### [%i] EuclidGetDimensions: m= %i n= %i beg_row= %i row_end= %i col_start= %i col_end= %i\n",
myid_dh, m,n,row_start,row_end,col_start,col_end);
*/
*beg_row = row_start;
*rowsLocal = (row_end - row_start + 1);
*rowsGlobal = n;
END_FUNC_DH
}
void Euclid_dhInputHypreMat(Euclid_dh ctx, HYPRE_ParCSRMatrix A)
{
START_FUNC_DH
HYPRE_Int M, N;
HYPRE_Int beg_row, end_row, junk;
/* get dimension and ownership information */
HYPRE_ParCSRMatrixGetDims(A, &M , &N);
if (M != N) {
hypre_sprintf(msgBuf_dh, "Global matrix is not square: M= %i, N= %i", M, N);
SET_V_ERROR(msgBuf_dh);
}
HYPRE_ParCSRMatrixGetLocalRange(A, &beg_row, &end_row, &junk, &junk);
ctx->m = end_row - beg_row + 1;
ctx->n = M;
ctx->A = (void*)A;
END_FUNC_DH
}
HYPRE_Int main( HYPRE_Int argc, char *argv[] )
{
HYPRE_Int arg_index;
HYPRE_Int print_usage;
HYPRE_Int build_matrix_arg_index;
HYPRE_Int solver_id;
HYPRE_Int ierr,i,j;
HYPRE_Int num_iterations;
HYPRE_ParCSRMatrix parcsr_A;
HYPRE_Int num_procs, myid;
HYPRE_Int local_row;
HYPRE_Int time_index;
MPI_Comm comm;
HYPRE_Int M, N;
HYPRE_Int first_local_row, last_local_row;
HYPRE_Int first_local_col, last_local_col;
HYPRE_Int size, *col_ind;
HYPRE_Real *values;
/* parameters for BoomerAMG */
HYPRE_Real strong_threshold;
HYPRE_Int num_grid_sweeps;
HYPRE_Real relax_weight;
/* parameters for GMRES */
HYPRE_Int k_dim;
char *paramString = new char[100];
/*-----------------------------------------------------------
* Initialize some stuff
*-----------------------------------------------------------*/
hypre_MPI_Init(&argc, &argv);
hypre_MPI_Comm_size(hypre_MPI_COMM_WORLD, &num_procs );
hypre_MPI_Comm_rank(hypre_MPI_COMM_WORLD, &myid );
/*-----------------------------------------------------------
* Set defaults
*-----------------------------------------------------------*/
build_matrix_arg_index = argc;
solver_id = 0;
strong_threshold = 0.25;
num_grid_sweeps = 2;
relax_weight = 0.5;
k_dim = 20;
/*-----------------------------------------------------------
* Parse command line
*-----------------------------------------------------------*/
print_usage = 0;
arg_index = 1;
while ( (arg_index < argc) && (!print_usage) )
{
if ( strcmp(argv[arg_index], "-solver") == 0 )
{
arg_index++;
solver_id = atoi(argv[arg_index++]);
}
else if ( strcmp(argv[arg_index], "-dbg") == 0 )
{
arg_index++;
atoi(argv[arg_index++]);
}
else if ( strcmp(argv[arg_index], "-help") == 0 )
{
print_usage = 1;
}
else
{
arg_index++;
}
}
/*-----------------------------------------------------------
* Print usage info
*-----------------------------------------------------------*/
if ( (print_usage) && (myid == 0) )
{
hypre_printf("\n");
hypre_printf("Usage: %s [<options>]\n", argv[0]);
hypre_printf("\n");
hypre_printf(" -solver <ID> : solver ID\n");
hypre_printf(" 0=DS-PCG 1=ParaSails-PCG \n");
hypre_printf(" 2=AMG-PCG 3=DS-GMRES \n");
hypre_printf(" 4=PILUT-GMRES 5=AMG-GMRES \n");
hypre_printf("\n");
hypre_printf(" -rlx <val> : relaxation type\n");
hypre_printf(" 0=Weighted Jacobi \n");
hypre_printf(" 1=Gauss-Seidel (very slow!) \n");
hypre_printf(" 3=Hybrid Jacobi/Gauss-Seidel \n");
hypre_printf("\n");
exit(1);
}
/*-----------------------------------------------------------
* Print driver parameters
*-----------------------------------------------------------*/
if (myid == 0)
{
hypre_printf("Running with these driver parameters:\n");
hypre_printf(" solver ID = %d\n", solver_id);
}
/*-----------------------------------------------------------
* Set up matrix
*-----------------------------------------------------------*/
strcpy(paramString, "LS Interface");
time_index = hypre_InitializeTiming(paramString);
hypre_BeginTiming(time_index);
BuildParLaplacian27pt(argc, argv, build_matrix_arg_index, &parcsr_A);
/*-----------------------------------------------------------
* Copy the parcsr matrix into the LSI through interface calls
*-----------------------------------------------------------*/
ierr = HYPRE_ParCSRMatrixGetComm( parcsr_A, &comm );
ierr += HYPRE_ParCSRMatrixGetDims( parcsr_A, &M, &N );
ierr = HYPRE_ParCSRMatrixGetLocalRange( parcsr_A,
&first_local_row, &last_local_row ,
&first_local_col, &last_local_col );
HYPRE_LinSysCore H(hypre_MPI_COMM_WORLD);
HYPRE_Int numLocalEqns = last_local_row - first_local_row + 1;
H.createMatricesAndVectors(M,first_local_row+1,numLocalEqns);
HYPRE_Int index;
HYPRE_Int *rowLengths = new HYPRE_Int[numLocalEqns];
HYPRE_Int **colIndices = new HYPRE_Int*[numLocalEqns];
local_row = 0;
for (i=first_local_row; i<= last_local_row; i++)
{
ierr += HYPRE_ParCSRMatrixGetRow(parcsr_A,i,&size,&col_ind,&values );
rowLengths[local_row] = size;
colIndices[local_row] = new HYPRE_Int[size];
for (j=0; j<size; j++) colIndices[local_row][j] = col_ind[j] + 1;
local_row++;
HYPRE_ParCSRMatrixRestoreRow(parcsr_A,i,&size,&col_ind,&values);
}
H.allocateMatrix(colIndices, rowLengths);
delete [] rowLengths;
for (i=0; i< numLocalEqns; i++) delete [] colIndices[i];
delete [] colIndices;
HYPRE_Int *newColInd;
for (i=first_local_row; i<= last_local_row; i++)
{
ierr += HYPRE_ParCSRMatrixGetRow(parcsr_A,i,&size,&col_ind,&values );
newColInd = new HYPRE_Int[size];
for (j=0; j<size; j++) newColInd[j] = col_ind[j] + 1;
H.sumIntoSystemMatrix(i+1,size,(const HYPRE_Real*)values,
(const HYPRE_Int*)newColInd);
delete [] newColInd;
ierr += HYPRE_ParCSRMatrixRestoreRow(parcsr_A,i,&size,&col_ind,&values);
}
H.matrixLoadComplete();
HYPRE_ParCSRMatrixDestroy(parcsr_A);
/*-----------------------------------------------------------
* Set up the RHS and initial guess
*-----------------------------------------------------------*/
HYPRE_Real ddata=1.0;
HYPRE_Int status;
for (i=first_local_row; i<= last_local_row; i++)
{
index = i + 1;
H.sumIntoRHSVector(1,(const HYPRE_Real*) &ddata, (const HYPRE_Int*) &index);
}
hypre_EndTiming(time_index);
strcpy(paramString, "LS Interface");
hypre_PrintTiming(paramString, hypre_MPI_COMM_WORLD);
hypre_FinalizeTiming(time_index);
hypre_ClearTiming();
/*-----------------------------------------------------------
* Solve the system using PCG
*-----------------------------------------------------------*/
if ( solver_id == 0 )
{
strcpy(paramString, "solver cg");
H.parameters(1, ¶mString);
if (myid == 0) hypre_printf("Solver: DS-PCG\n");
strcpy(paramString, "preconditioner diagonal");
H.parameters(1, ¶mString);
}
else if ( solver_id == 1 )
{
strcpy(paramString, "solver cg");
H.parameters(1, ¶mString);
if (myid == 0) hypre_printf("Solver: ParaSails-PCG\n");
strcpy(paramString, "preconditioner parasails");
H.parameters(1, ¶mString);
strcpy(paramString, "parasailsNlevels 1");
H.parameters(1, ¶mString);
strcpy(paramString, "parasailsThreshold 0.1");
H.parameters(1, ¶mString);
}
else if ( solver_id == 2 )
{
strcpy(paramString, "solver cg");
H.parameters(1, ¶mString);
if (myid == 0) hypre_printf("Solver: AMG-PCG\n");
strcpy(paramString, "preconditioner boomeramg");
H.parameters(1, ¶mString);
strcpy(paramString, "amgCoarsenType falgout");
H.parameters(1, ¶mString);
hypre_sprintf(paramString, "amgStrongThreshold %e", strong_threshold);
H.parameters(1, ¶mString);
hypre_sprintf(paramString, "amgNumSweeps %d", num_grid_sweeps);
H.parameters(1, ¶mString);
strcpy(paramString, "amgRelaxType jacobi");
H.parameters(1, ¶mString);
hypre_sprintf(paramString, "amgRelaxWeight %e", relax_weight);
H.parameters(1, ¶mString);
}
else if ( solver_id == 3 )
{
strcpy(paramString, "solver cg");
H.parameters(1, ¶mString);
if (myid == 0) hypre_printf("Solver: Poly-PCG\n");
strcpy(paramString, "preconditioner poly");
H.parameters(1, ¶mString);
strcpy(paramString, "polyOrder 9");
H.parameters(1, ¶mString);
}
else if ( solver_id == 4 )
{
strcpy(paramString, "solver gmres");
H.parameters(1, ¶mString);
hypre_sprintf(paramString, "gmresDim %d", k_dim);
H.parameters(1, ¶mString);
if (myid == 0) hypre_printf("Solver: DS-GMRES\n");
strcpy(paramString, "preconditioner diagonal");
H.parameters(1, ¶mString);
}
else if ( solver_id == 5 )
{
strcpy(paramString, "solver gmres");
H.parameters(1, ¶mString);
hypre_sprintf(paramString, "gmresDim %d", k_dim);
H.parameters(1, ¶mString);
if (myid == 0) hypre_printf("Solver: PILUT-GMRES\n");
strcpy(paramString, "preconditioner pilut");
H.parameters(1, ¶mString);
strcpy(paramString, "pilutRowSize 0");
H.parameters(1, ¶mString);
strcpy(paramString, "pilutDropTol 0.0");
H.parameters(1, ¶mString);
}
else if ( solver_id == 6 )
{
strcpy(paramString, "solver gmres");
H.parameters(1, ¶mString);
hypre_sprintf(paramString, "gmresDim %d", k_dim);
H.parameters(1, ¶mString);
if (myid == 0) hypre_printf("Solver: AMG-GMRES\n");
strcpy(paramString, "preconditioner boomeramg");
H.parameters(1, ¶mString);
strcpy(paramString, "amgCoarsenType falgout");
H.parameters(1, ¶mString);
hypre_sprintf(paramString, "amgStrongThreshold %e", strong_threshold);
H.parameters(1, ¶mString);
hypre_sprintf(paramString, "amgNumSweeps %d", num_grid_sweeps);
H.parameters(1, ¶mString);
strcpy(paramString, "amgRelaxType jacobi");
H.parameters(1, ¶mString);
hypre_sprintf(paramString, "amgRelaxWeight %e", relax_weight);
H.parameters(1, ¶mString);
}
else if ( solver_id == 7 )
{
strcpy(paramString, "solver gmres");
H.parameters(1, ¶mString);
hypre_sprintf(paramString, "gmresDim %d", k_dim);
H.parameters(1, ¶mString);
if (myid == 0) hypre_printf("Solver: DDILUT-GMRES\n");
strcpy(paramString, "preconditioner ddilut");
H.parameters(1, ¶mString);
strcpy(paramString, "ddilutFillin 5.0");
H.parameters(1, ¶mString);
strcpy(paramString, "ddilutDropTol 0.0");
H.parameters(1, ¶mString);
}
else if ( solver_id == 8 )
{
strcpy(paramString, "solver gmres");
H.parameters(1, ¶mString);
hypre_sprintf(paramString, "gmresDim %d", k_dim);
H.parameters(1, ¶mString);
if (myid == 0) hypre_printf("Solver: POLY-GMRES\n");
strcpy(paramString, "preconditioner poly");
H.parameters(1, ¶mString);
strcpy(paramString, "polyOrder 5");
H.parameters(1, ¶mString);
}
strcpy(paramString, "Krylov Solve");
time_index = hypre_InitializeTiming(paramString);
hypre_BeginTiming(time_index);
H.launchSolver(status, num_iterations);
hypre_EndTiming(time_index);
strcpy(paramString, "Solve phase times");
hypre_PrintTiming(paramString, hypre_MPI_COMM_WORLD);
hypre_FinalizeTiming(time_index);
hypre_ClearTiming();
if (myid == 0)
{
hypre_printf("\n Iterations = %d\n", num_iterations);
hypre_printf("\n");
}
/*-----------------------------------------------------------
* Finalize things
*-----------------------------------------------------------*/
delete [] paramString;
hypre_MPI_Finalize();
return (0);
}
bHYPRE_IJParCSRMatrix
impl_bHYPRE_IJParCSRMatrix_GenerateLaplacian(
/* in */ bHYPRE_MPICommunicator mpi_comm,
/* in */ int32_t nx,
/* in */ int32_t ny,
/* in */ int32_t nz,
/* in */ int32_t Px,
/* in */ int32_t Py,
/* in */ int32_t Pz,
/* in */ int32_t p,
/* in */ int32_t q,
/* in */ int32_t r,
/* in rarray[nvalues] */ double* values,
/* in */ int32_t nvalues,
/* in */ int32_t discretization,
/* out */ sidl_BaseInterface *_ex)
{
*_ex = 0;
{
/* DO-NOT-DELETE splicer.begin(bHYPRE.IJParCSRMatrix.GenerateLaplacian) */
/* Insert-Code-Here {bHYPRE.IJParCSRMatrix.GenerateLaplacian} (GenerateLaplacian method) */
/* The returned matrix represents a Laplacian with 7,9,or 27 point discretization
as specified. Initialize but not Assemble is called before returning. */
int ierr = 0;
bHYPRE_IJParCSRMatrix bHA;
HYPRE_ParCSRMatrix HA;
int first_local_row, last_local_row, first_local_col, last_local_col;
int local_num_rows, size, i;
int * row_sizes;
int * col_inds;
double * row_values;
int stride[1];
MPI_Comm comm = bHYPRE_MPICommunicator__get_data(mpi_comm)->mpi_comm;
;
hypre_assert( nvalues == 4 );
hypre_assert( discretization==7 || discretization==9 || discretization==27 );
hypre_assert( discretization==7 ); /* only 7-point 3D example implemented */
HA = (HYPRE_ParCSRMatrix) GenerateLaplacian(
comm, nx, ny, nz, Px, Py, Pz, p, q, r, values );
/* We need to return a bHYPRE_IJParCSRMatrix. Make a one and copy HA to it... */
ierr += HYPRE_ParCSRMatrixGetLocalRange(
HA, &first_local_row, &last_local_row , &first_local_col, &last_local_col );
local_num_rows = last_local_row - first_local_row + 1;
bHA = bHYPRE_IJParCSRMatrix_Create(
mpi_comm, first_local_row, last_local_row, first_local_col, last_local_col, _ex ); SIDL_CHECK(*_ex);
row_sizes = hypre_CTAlloc( int, local_num_rows );
size = discretization;
for (i=0; i < local_num_rows; i++)
{
row_sizes[i] = size;
}
ierr = bHYPRE_IJParCSRMatrix_SetRowSizes( bHA, row_sizes, local_num_rows, _ex ); SIDL_CHECK(*_ex);
hypre_TFree( row_sizes );
ierr = bHYPRE_IJParCSRMatrix_Initialize( bHA, _ex ); SIDL_CHECK(*_ex);
row_sizes = hypre_CTAlloc( int, 1 );
stride[0] = 1;
/* Copy row data to the new matrix... */
for (i=first_local_row; i<= last_local_row; i++)
{
ierr += HYPRE_ParCSRMatrixGetRow( HA, i, &size, &col_inds, &row_values );
ierr += bHYPRE_IJParCSRMatrix_SetValues(
bHA, 1, &size, &i, col_inds, row_values, size, _ex ); SIDL_CHECK(*_ex);
ierr += HYPRE_ParCSRMatrixRestoreRow( HA, i, &size, &col_inds, &row_values );
}
hypre_assert( ierr == 0 );
return bHA;
hypre_babel_exception_no_return(_ex);
/* DO-NOT-DELETE splicer.end(bHYPRE.IJParCSRMatrix.GenerateLaplacian) */
}
}
