hypre_CSRBooleanMatrix *
hypre_CSRBooleanMatrixRead( const char *file_name )
{
hypre_CSRBooleanMatrix *matrix;
FILE *fp;
HYPRE_Int *matrix_i;
HYPRE_Int *matrix_j;
HYPRE_Int num_rows;
HYPRE_Int num_nonzeros;
HYPRE_Int max_col = 0;
HYPRE_Int file_base = 1;
HYPRE_Int j;
/*----------------------------------------------------------
* Read in the data
*----------------------------------------------------------*/
fp = fopen(file_name, "r");
hypre_fscanf(fp, "%d", &num_rows);
matrix_i = hypre_CTAlloc(HYPRE_Int, num_rows + 1);
for (j = 0; j < num_rows+1; j++)
{
hypre_fscanf(fp, "%d", &matrix_i[j]);
matrix_i[j] -= file_base;
}
num_nonzeros = matrix_i[num_rows];
matrix = hypre_CSRBooleanMatrixCreate(num_rows, num_rows, matrix_i[num_rows]);
hypre_CSRBooleanMatrix_Get_I(matrix) = matrix_i;
hypre_CSRBooleanMatrixInitialize(matrix);
matrix_j = hypre_CSRBooleanMatrix_Get_J(matrix);
for (j = 0; j < num_nonzeros; j++)
{
hypre_fscanf(fp, "%d", &matrix_j[j]);
matrix_j[j] -= file_base;
if (matrix_j[j] > max_col)
{
max_col = matrix_j[j];
}
}
fclose(fp);
hypre_CSRBooleanMatrix_Get_NNZ(matrix) = num_nonzeros;
hypre_CSRBooleanMatrix_Get_NCols(matrix) = ++max_col;
return matrix;
}
hypre_ParVector
*hypre_ParVectorRead( MPI_Comm comm,
const char *file_name )
{
char new_file_name[80];
hypre_ParVector *par_vector;
HYPRE_Int my_id, num_procs;
HYPRE_Int *partitioning;
HYPRE_Int global_size, i;
FILE *fp;
hypre_MPI_Comm_rank(comm,&my_id);
hypre_MPI_Comm_size(comm,&num_procs);
partitioning = hypre_CTAlloc(HYPRE_Int,num_procs+1);
hypre_sprintf(new_file_name,"%s.INFO.%d",file_name,my_id);
fp = fopen(new_file_name, "r");
hypre_fscanf(fp, "%d\n", &global_size);
#ifdef HYPRE_NO_GLOBAL_PARTITION
for (i=0; i < 2; i++)
hypre_fscanf(fp, "%d\n", &partitioning[i]);
fclose (fp);
#else
for (i=0; i < num_procs; i++)
hypre_fscanf(fp, "%d\n", &partitioning[i]);
fclose (fp);
partitioning[num_procs] = global_size;
#endif
par_vector = hypre_CTAlloc(hypre_ParVector, 1);
hypre_ParVectorComm(par_vector) = comm;
hypre_ParVectorGlobalSize(par_vector) = global_size;
#ifdef HYPRE_NO_GLOBAL_PARTITION
hypre_ParVectorFirstIndex(par_vector) = partitioning[0];
hypre_ParVectorLastIndex(par_vector) = partitioning[1]-1;
#else
hypre_ParVectorFirstIndex(par_vector) = partitioning[my_id];
hypre_ParVectorLastIndex(par_vector) = partitioning[my_id+1]-1;
#endif
hypre_ParVectorPartitioning(par_vector) = partitioning;
hypre_ParVectorOwnsData(par_vector) = 1;
hypre_ParVectorOwnsPartitioning(par_vector) = 1;
hypre_sprintf(new_file_name,"%s.%d",file_name,my_id);
hypre_ParVectorLocalVector(par_vector) = hypre_SeqVectorRead(new_file_name);
/* multivector code not written yet >>> */
hypre_assert( hypre_ParVectorNumVectors(par_vector) == 1 );
return par_vector;
}
HYPRE_Int
HYPRE_IJMatrixRead( const char *filename,
MPI_Comm comm,
HYPRE_Int type,
HYPRE_IJMatrix *matrix_ptr )
{
HYPRE_IJMatrix matrix;
HYPRE_Int ilower, iupper, jlower, jupper;
HYPRE_Int ncols, I, J;
HYPRE_Complex value;
HYPRE_Int myid, ret;
char new_filename[255];
FILE *file;
hypre_MPI_Comm_rank(comm, &myid);
hypre_sprintf(new_filename,"%s.%05d", filename, myid);
if ((file = fopen(new_filename, "r")) == NULL)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_fscanf(file, "%d %d %d %d", &ilower, &iupper, &jlower, &jupper);
HYPRE_IJMatrixCreate(comm, ilower, iupper, jlower, jupper, &matrix);
HYPRE_IJMatrixSetObjectType(matrix, type);
HYPRE_IJMatrixInitialize(matrix);
/* It is important to ensure that whitespace follows the index value to help
* catch mistakes in the input file. See comments in IJVectorRead(). */
ncols = 1;
while ( (ret = hypre_fscanf(file, "%d %d%*[ \t]%le", &I, &J, &value)) != EOF )
{
if (ret != 3)
{
hypre_error_w_msg(HYPRE_ERROR_GENERIC, "Error in IJ matrix input file.");
return hypre_error_flag;
}
if (I < ilower || I > iupper)
HYPRE_IJMatrixAddToValues(matrix, 1, &ncols, &I, &J, &value);
else
HYPRE_IJMatrixSetValues(matrix, 1, &ncols, &I, &J, &value);
}
HYPRE_IJMatrixAssemble(matrix);
fclose(file);
*matrix_ptr = matrix;
return hypre_error_flag;
}
void mat_dh_read_csr_private(HYPRE_Int *mOUT, HYPRE_Int **rpOUT, HYPRE_Int **cvalOUT,
double **avalOUT, FILE* fp)
{
START_FUNC_DH
HYPRE_Int i, m, nz, items;
HYPRE_Int *rp, *cval;
double *aval;
/* read header line */
items = hypre_fscanf(fp,"%d %d",&m, &nz);
if (items != 2) {
SET_V_ERROR("failed to read header");
} else {
hypre_printf("mat_dh_read_csr_private:: m= %i nz= %i\n", m, nz);
}
*mOUT = m;
rp = *rpOUT = (HYPRE_Int*)MALLOC_DH((m+1)*sizeof(HYPRE_Int)); CHECK_V_ERROR;
cval = *cvalOUT = (HYPRE_Int*)MALLOC_DH(nz*sizeof(HYPRE_Int)); CHECK_V_ERROR;
aval = *avalOUT = (double*)MALLOC_DH(nz*sizeof(double)); CHECK_V_ERROR;
/* read rp[] block */
for (i=0; i<=m; ++i) {
items = hypre_fscanf(fp,"%d", &(rp[i]));
if (items != 1) {
hypre_sprintf(msgBuf_dh, "failed item %i of %i in rp block", i, m+1);
SET_V_ERROR(msgBuf_dh);
}
}
/* read cval[] block */
for (i=0; i<nz; ++i) {
items = hypre_fscanf(fp,"%d", &(cval[i]));
if (items != 1) {
hypre_sprintf(msgBuf_dh, "failed item %i of %i in cval block", i, m+1);
SET_V_ERROR(msgBuf_dh);
}
}
/* read aval[] block */
for (i=0; i<nz; ++i) {
items = hypre_fscanf(fp,"%lg", &(aval[i]));
if (items != 1) {
hypre_sprintf(msgBuf_dh, "failed item %i of %i in aval block", i, m+1);
SET_V_ERROR(msgBuf_dh);
}
}
END_FUNC_DH
}
hypre_ParCSRBooleanMatrix *
hypre_ParCSRBooleanMatrixRead( MPI_Comm comm, const char *file_name )
{
hypre_ParCSRBooleanMatrix *matrix;
hypre_CSRBooleanMatrix *diag;
hypre_CSRBooleanMatrix *offd;
HYPRE_Int my_id, i, num_procs;
char new_file_d[80], new_file_o[80], new_file_info[80];
HYPRE_Int global_num_rows, global_num_cols, num_cols_offd;
HYPRE_Int local_num_rows;
HYPRE_Int *row_starts;
HYPRE_Int *col_starts;
HYPRE_Int *col_map_offd;
FILE *fp;
HYPRE_Int equal = 1;
hypre_MPI_Comm_rank(comm,&my_id);
hypre_MPI_Comm_size(comm,&num_procs);
row_starts = hypre_CTAlloc(HYPRE_Int, num_procs+1);
col_starts = hypre_CTAlloc(HYPRE_Int, num_procs+1);
hypre_sprintf(new_file_d,"%s.D.%d",file_name,my_id);
hypre_sprintf(new_file_o,"%s.O.%d",file_name,my_id);
hypre_sprintf(new_file_info,"%s.INFO.%d",file_name,my_id);
fp = fopen(new_file_info, "r");
hypre_fscanf(fp, "%d", &global_num_rows);
hypre_fscanf(fp, "%d", &global_num_cols);
hypre_fscanf(fp, "%d", &num_cols_offd);
for (i=0; i < num_procs; i++)
hypre_fscanf(fp, "%d %d", &row_starts[i], &col_starts[i]);
row_starts[num_procs] = global_num_rows;
col_starts[num_procs] = global_num_cols;
col_map_offd = hypre_CTAlloc(HYPRE_Int, num_cols_offd);
for (i=0; i < num_cols_offd; i++)
hypre_fscanf(fp, "%d", &col_map_offd[i]);
fclose(fp);
for (i=num_procs; i >= 0; i--)
if (row_starts[i] != col_starts[i])
{
equal = 0;
break;
}
if (equal)
{
hypre_TFree(col_starts);
col_starts = row_starts;
}
diag = hypre_CSRBooleanMatrixRead(new_file_d);
local_num_rows = hypre_CSRBooleanMatrix_Get_NRows(diag);
if (num_cols_offd)
{
offd = hypre_CSRBooleanMatrixRead(new_file_o);
}
else
offd = hypre_CSRBooleanMatrixCreate(local_num_rows,0,0);
matrix = hypre_CTAlloc(hypre_ParCSRBooleanMatrix, 1);
hypre_ParCSRBooleanMatrix_Get_Comm(matrix) = comm;
hypre_ParCSRBooleanMatrix_Get_GlobalNRows(matrix) = global_num_rows;
hypre_ParCSRBooleanMatrix_Get_GlobalNCols(matrix) = global_num_cols;
hypre_ParCSRBooleanMatrix_Get_StartRow(matrix) = row_starts[my_id];
hypre_ParCSRBooleanMatrix_Get_FirstColDiag(matrix) = col_starts[my_id];
hypre_ParCSRBooleanMatrix_Get_RowStarts(matrix) = row_starts;
hypre_ParCSRBooleanMatrix_Get_ColStarts(matrix) = col_starts;
hypre_ParCSRBooleanMatrix_Get_CommPkg(matrix) = NULL;
/* set defaults */
hypre_ParCSRBooleanMatrix_Get_OwnsData(matrix) = 1;
hypre_ParCSRBooleanMatrix_Get_OwnsRowStarts(matrix) = 1;
hypre_ParCSRBooleanMatrix_Get_OwnsColStarts(matrix) = 1;
if (row_starts == col_starts)
hypre_ParCSRBooleanMatrix_Get_OwnsColStarts(matrix) = 0;
hypre_ParCSRBooleanMatrix_Get_Diag(matrix) = diag;
hypre_ParCSRBooleanMatrix_Get_Offd(matrix) = offd;
if (num_cols_offd)
hypre_ParCSRBooleanMatrix_Get_ColMapOffd(matrix) = col_map_offd;
else
hypre_ParCSRBooleanMatrix_Get_ColMapOffd(matrix) = NULL;
return matrix;
}
HYPRE_Int
hypre_ParVectorReadIJ( MPI_Comm comm,
const char *filename,
HYPRE_Int *base_j_ptr,
hypre_ParVector **vector_ptr)
{
HYPRE_Int global_size;
hypre_ParVector *vector;
hypre_Vector *local_vector;
double *local_data;
HYPRE_Int *partitioning;
HYPRE_Int base_j;
HYPRE_Int myid, num_procs, i, j, J;
char new_filename[255];
FILE *file;
hypre_MPI_Comm_size(comm, &num_procs);
hypre_MPI_Comm_rank(comm, &myid);
hypre_sprintf(new_filename,"%s.%05d", filename, myid);
if ((file = fopen(new_filename, "r")) == NULL)
{
hypre_printf("Error: can't open output file %s\n", new_filename);
hypre_error(HYPRE_ERROR_GENERIC);
return hypre_error_flag;
}
hypre_fscanf(file, "%d", &global_size);
#ifdef HYPRE_NO_GLOBAL_PARTITION
/* this may need to be changed so that the base is available in the file! */
partitioning = hypre_CTAlloc(HYPRE_Int,2);
hypre_fscanf(file, "%d", partitioning);
for (i = 0; i < 2; i++)
{
hypre_fscanf(file, "%d", partitioning+i);
}
#else
partitioning = hypre_CTAlloc(HYPRE_Int,num_procs+1);
hypre_fscanf(file, "%d", partitioning);
for (i = 1; i <= num_procs; i++)
{
hypre_fscanf(file, "%d", partitioning+i);
partitioning[i] -= partitioning[0];
}
base_j = partitioning[0];
partitioning[0] = 0;
#endif
vector = hypre_ParVectorCreate(comm, global_size,
partitioning);
hypre_ParVectorInitialize(vector);
local_vector = hypre_ParVectorLocalVector(vector);
local_data = hypre_VectorData(local_vector);
#ifdef HYPRE_NO_GLOBAL_PARTITION
for (j = 0; j < partitioning[1] - partitioning[0]; j++)
#else
for (j = 0; j < partitioning[myid+1] - partitioning[myid]; j++)
#endif
{
hypre_fscanf(file, "%d %le", &J, local_data + j);
}
fclose(file);
*base_j_ptr = base_j;
*vector_ptr = vector;
/* multivector code not written yet >>> */
hypre_assert( hypre_ParVectorNumVectors(vector) == 1 );
if ( hypre_ParVectorNumVectors(vector) != 1 ) hypre_error(HYPRE_ERROR_GENERIC);
return hypre_error_flag;
}
void mat_dh_read_triples_private(HYPRE_Int ignore, HYPRE_Int *mOUT, HYPRE_Int **rpOUT,
HYPRE_Int **cvalOUT, double **avalOUT, FILE* fp)
{
START_FUNC_DH
HYPRE_Int m, n, nz, items, i, j;
HYPRE_Int idx = 0;
HYPRE_Int *cval, *rp, *I, *J;
double *aval, *A, v;
char junk[MAX_JUNK];
fpos_t fpos;
/* skip over header */
if (ignore && myid_dh == 0) {
hypre_printf("mat_dh_read_triples_private:: ignoring following header lines:\n");
hypre_printf("--------------------------------------------------------------\n");
for (i=0; i<ignore; ++i) {
fgets(junk, MAX_JUNK, fp);
hypre_printf("%s", junk);
}
hypre_printf("--------------------------------------------------------------\n");
if (fgetpos(fp, &fpos)) SET_V_ERROR("fgetpos failed!");
hypre_printf("\nmat_dh_read_triples_private::1st two non-ignored lines:\n");
hypre_printf("--------------------------------------------------------------\n");
for (i=0; i<2; ++i) {
fgets(junk, MAX_JUNK, fp);
hypre_printf("%s", junk);
}
hypre_printf("--------------------------------------------------------------\n");
if (fsetpos(fp, &fpos)) SET_V_ERROR("fsetpos failed!");
}
if (feof(fp)) hypre_printf("trouble!");
/* determine matrix dimensions */
m=n=nz=0;
while (!feof(fp)) {
items = hypre_fscanf(fp,"%d %d %lg",&i,&j,&v);
if (items != 3) {
break;
}
++nz;
if (i > m) m = i;
if (j > n) n = j;
}
if (myid_dh == 0) {
hypre_printf("mat_dh_read_triples_private: m= %i nz= %i\n", m, nz);
}
/* reset file, and skip over header again */
rewind(fp);
for (i=0; i<ignore; ++i) {
fgets(junk, MAX_JUNK, fp);
}
/* error check for squareness */
if (m != n) {
hypre_sprintf(msgBuf_dh, "matrix is not square; row= %i, cols= %i", m, n);
SET_V_ERROR(msgBuf_dh);
}
*mOUT = m;
/* allocate storage */
rp = *rpOUT = (HYPRE_Int*)MALLOC_DH((m+1)*sizeof(HYPRE_Int)); CHECK_V_ERROR;
cval = *cvalOUT = (HYPRE_Int*)MALLOC_DH(nz*sizeof(HYPRE_Int)); CHECK_V_ERROR;
aval = *avalOUT = (double*)MALLOC_DH(nz*sizeof(double)); CHECK_V_ERROR;
I = (HYPRE_Int*)MALLOC_DH(nz*sizeof(HYPRE_Int)); CHECK_V_ERROR;
J = (HYPRE_Int*)MALLOC_DH(nz*sizeof(HYPRE_Int)); CHECK_V_ERROR;
A = (double*)MALLOC_DH(nz*sizeof(double)); CHECK_V_ERROR;
/* read <row, col, value> triples into arrays */
while (!feof(fp)) {
items = hypre_fscanf(fp,"%d %d %lg",&i,&j,&v);
if (items < 3) break;
j--;
i--;
I[idx] = i;
J[idx] = j;
A[idx] = v;
++idx;
}
/* convert from triples to sparse-compressed-row storage */
convert_triples_to_scr_private(m, nz, I, J, A, rp, cval, aval); CHECK_V_ERROR;
/* if matrix is triangular */
{ HYPRE_Int type;
type = isTriangular(m, rp, cval); CHECK_V_ERROR;
if (type == IS_UPPER_TRI) {
hypre_printf("CAUTION: matrix is upper triangular; converting to full\n");
} else if (type == IS_LOWER_TRI) {
hypre_printf("CAUTION: matrix is lower triangular; converting to full\n");
}
if (type == IS_UPPER_TRI || type == IS_LOWER_TRI) {
make_full_private(m, &rp, &cval, &aval); CHECK_V_ERROR;
}
}
*rpOUT = rp;
*cvalOUT = cval;
*avalOUT = aval;
FREE_DH(I); CHECK_V_ERROR;
FREE_DH(J); CHECK_V_ERROR;
FREE_DH(A); CHECK_V_ERROR;
END_FUNC_DH
}
HYPRE_Int main(HYPRE_Int argc, char *argv[])
{
HYPRE_Int mype, npes;
HYPRE_Int symmetric;
HYPRE_Int num_runs;
Matrix *A;
ParaSails *ps;
FILE *file;
HYPRE_Int n, beg_row, end_row;
HYPRE_Real time0, time1;
HYPRE_Real setup_time, solve_time;
HYPRE_Real max_setup_time, max_solve_time;
HYPRE_Real cost;
HYPRE_Real *x, *b;
HYPRE_Int i, niter;
HYPRE_Real thresh;
HYPRE_Real threshg;
HYPRE_Int nlevels;
HYPRE_Real filter;
HYPRE_Real loadbal;
hypre_MPI_Init(&argc, &argv);
hypre_MPI_Comm_rank(hypre_MPI_COMM_WORLD, &mype);
hypre_MPI_Comm_size(hypre_MPI_COMM_WORLD, &npes);
/* Read number of rows in matrix */
symmetric = atoi(argv[1]);
num_runs = atoi(argv[2]);
file = fopen(argv[3], "r");
assert(file != NULL);
#ifdef EMSOLVE
hypre_fscanf(file, "%*d %d\n", &n);
#else
hypre_fscanf(file, "%d\n", &n);
#endif
fclose(file);
assert(n >= npes);
beg_row = (HYPRE_Int) ((HYPRE_Real)(mype*n) / npes) + 1; /* assumes 1-based */
end_row = (HYPRE_Int) ((HYPRE_Real)((mype+1)* n) / npes);
if (mype == 0)
assert(beg_row == 1);
if (mype == npes-1)
assert(end_row == n);
#ifdef EMSOLVE
beg_row--;
end_row--;
#endif
x = (HYPRE_Real *) malloc((end_row-beg_row+1) * sizeof(HYPRE_Real));
b = (HYPRE_Real *) malloc((end_row-beg_row+1) * sizeof(HYPRE_Real));
A = MatrixCreate(hypre_MPI_COMM_WORLD, beg_row, end_row);
MatrixRead(A, argv[3]);
if (mype == 0)
hypre_printf("%s\n", argv[3]);
/* MatrixPrint(A, "A"); */
/* Right-hand side */
if (argc > 4)
{
RhsRead(b, A, argv[4]);
if (mype == 0)
hypre_printf("Using rhs from %s\n", argv[4]);
}
else
{
for (i=0; i<end_row-beg_row+1; i++)
b[i] = (HYPRE_Real) (2*rand()) / (HYPRE_Real) RAND_MAX - 1.0;
}
while (num_runs && num_runs >= -1)
{
/* Initial guess */
for (i=0; i<end_row-beg_row+1; i++)
x[i] = 0.0;
if (num_runs == -1)
{
thresh = 0.0;
nlevels = 0;
filter = 0.0;
loadbal = 0.0;
}
else
{
if (mype == 0)
{
#if PARASAILS_EXT_PATTERN
hypre_printf("Enter parameters threshg, thresh, nlevels, "
"filter, beta:\n");
fflush(stdout);
hypre_scanf("%lf %lf %d %lf %lf", &threshg, &thresh, &nlevels,
&filter, &loadbal);
#else
hypre_printf("Enter parameters thresh, nlevels, "
"filter, beta:\n");
fflush(stdout);
hypre_scanf("%lf %d %lf %lf", &thresh, &nlevels,
&filter, &loadbal);
#endif
}
hypre_MPI_Bcast(&threshg, 1, hypre_MPI_DOUBLE, 0, hypre_MPI_COMM_WORLD);
hypre_MPI_Bcast(&thresh, 1, hypre_MPI_DOUBLE, 0, hypre_MPI_COMM_WORLD);
hypre_MPI_Bcast(&nlevels, 1, HYPRE_MPI_INT, 0, hypre_MPI_COMM_WORLD);
hypre_MPI_Bcast(&filter, 1, hypre_MPI_DOUBLE, 0, hypre_MPI_COMM_WORLD);
hypre_MPI_Bcast(&loadbal, 1, hypre_MPI_DOUBLE, 0, hypre_MPI_COMM_WORLD);
if (nlevels < 0)
break;
}
/**************
* Setup phase
**************/
hypre_MPI_Barrier(hypre_MPI_COMM_WORLD);
time0 = hypre_MPI_Wtime();
ps = ParaSailsCreate(hypre_MPI_COMM_WORLD, beg_row, end_row, symmetric);
ps->loadbal_beta = loadbal;
#if PARASAILS_EXT_PATTERN
ParaSailsSetupPatternExt(ps, A, threshg, thresh, nlevels);
#else
ParaSailsSetupPattern(ps, A, thresh, nlevels);
#endif
time1 = hypre_MPI_Wtime();
setup_time = time1-time0;
cost = ParaSailsStatsPattern(ps, A);
if (cost > 5.e11)
{
hypre_printf("Aborting setup and solve due to high cost.\n");
goto cleanup;
}
hypre_MPI_Barrier(hypre_MPI_COMM_WORLD);
time0 = hypre_MPI_Wtime();
err = ParaSailsSetupValues(ps, A, filter);
if (err != 0)
{
hypre_printf("ParaSailsSetupValues returned error.\n");
goto cleanup;
}
time1 = hypre_MPI_Wtime();
setup_time += (time1-time0);
ParaSailsStatsValues(ps, A);
if (!strncmp(argv[3], "testpsmat", 8))
MatrixPrint(ps->M, "M");
#if 0
if (mype == 0)
hypre_printf("SETTING UP VALUES AGAIN WITH FILTERED PATTERN\n");
ps->loadbal_beta = 0;
ParaSailsSetupValues(ps, A, 0.0);
#endif
/*****************
* Solution phase
*****************/
niter = 3000;
if (MatrixNnz(ps->M) == n) /* if diagonal preconditioner */
niter = 5000;
hypre_MPI_Barrier(hypre_MPI_COMM_WORLD);
time0 = hypre_MPI_Wtime();
if (symmetric == 1)
PCG_ParaSails(A, ps, b, x, 1.e-8, niter);
else
FGMRES_ParaSails(A, ps, b, x, 50, 1.e-8, niter);
time1 = hypre_MPI_Wtime();
solve_time = time1-time0;
hypre_MPI_Reduce(&setup_time, &max_setup_time, 1, hypre_MPI_DOUBLE, hypre_MPI_MAX, 0,
hypre_MPI_COMM_WORLD);
hypre_MPI_Reduce(&solve_time, &max_solve_time, 1, hypre_MPI_DOUBLE, hypre_MPI_MAX, 0,
hypre_MPI_COMM_WORLD);
if (mype == 0)
{
hypre_printf("**********************************************\n");
hypre_printf("*** Setup Solve Total\n");
hypre_printf("III %8.1f %8.1f %8.1f\n", max_setup_time, max_solve_time,
max_setup_time+max_solve_time);
hypre_printf("**********************************************\n");
}
cleanup:
ParaSailsDestroy(ps);
num_runs--;
}
free(x);
free(b);
MatrixDestroy(A);
hypre_MPI_Finalize();
return 0;
}
hypre_CSRMatrix *
hypre_GenerateStencilMatrix(HYPRE_Int nx,
HYPRE_Int ny,
HYPRE_Int nz,
char *infile )
{
hypre_CSRMatrix *A;
HYPRE_Int *A_i;
HYPRE_Int *A_j;
double *A_data;
HYPRE_Int grid_size = nx*ny*nz;
HYPRE_Int stencil_size;
typedef HYPRE_Int Index[3];
Index *stencil_offsets;
double *stencil_values;
HYPRE_Int ix, iy, iz, i, j, k, s, ss;
HYPRE_Int I, J, jj;
FILE *fp;
/*---------------------------------------------------
* read in the stencil (diagonal must be first)
*---------------------------------------------------*/
fp = fopen(infile, "r");
hypre_fscanf(fp, "%d\n", &stencil_size);
stencil_offsets = hypre_CTAlloc(Index, stencil_size);
stencil_values = hypre_CTAlloc(double, stencil_size);
for (s = 0; s < stencil_size; s++)
{
hypre_fscanf(fp, "%d", &ss);
hypre_fscanf(fp, "%d%d%d %lf\n",
&stencil_offsets[ss][0],
&stencil_offsets[ss][1],
&stencil_offsets[ss][2],
&stencil_values[ss]);
hypre_printf("%d %d %d %d %f\n", ss,
stencil_offsets[ss][0],
stencil_offsets[ss][1],
stencil_offsets[ss][2],
stencil_values[ss]);
}
fclose(fp);
/*---------------------------------------------------
* set up matrix
*---------------------------------------------------*/
A_i = hypre_CTAlloc(HYPRE_Int, grid_size + 1);
A_j = hypre_CTAlloc(HYPRE_Int, grid_size * stencil_size);
A_data = hypre_CTAlloc(double, grid_size * stencil_size);
jj = 0;
for (iz = 0; iz < nz; iz++)
{
for (iy = 0; iy < ny; iy++)
{
for (ix = 0; ix < nx; ix++)
{
I = ix + iy*nx + iz*ny*nz;
A_i[I] = jj;
for (s = 0; s < stencil_size; s++)
{
i = ix + stencil_offsets[s][0];
j = iy + stencil_offsets[s][1];
k = iz + stencil_offsets[s][2];
if ((i > -1) && (i < nx) &&
(j > -1) && (j < ny) &&
(k > -1) && (k < nz))
{
J = i + j*nx + k*ny*nz;
A_j[jj] = J;
A_data[jj] = stencil_values[s];
jj++;
}
}
}
}
}
A_i[grid_size] = jj;
A = hypre_CSRMatrixCreate(grid_size, grid_size, A_i[grid_size]);
hypre_CSRMatrixI(A) = A_i;
hypre_CSRMatrixJ(A) = A_j;
hypre_CSRMatrixData(A) = A_data;
return A;
}
