HYPRE_Int
hypre_ParCSRBlockMatrixSetDNumNonzeros( hypre_ParCSRBlockMatrix *matrix)
{
MPI_Comm comm = hypre_ParCSRBlockMatrixComm(matrix);
hypre_CSRBlockMatrix *diag = hypre_ParCSRBlockMatrixDiag(matrix);
HYPRE_Int *diag_i = hypre_CSRBlockMatrixI(diag);
hypre_CSRBlockMatrix *offd = hypre_ParCSRBlockMatrixOffd(matrix);
HYPRE_Int *offd_i = hypre_CSRBlockMatrixI(offd);
HYPRE_Int local_num_rows = hypre_CSRBlockMatrixNumRows(diag);
HYPRE_Real total_num_nonzeros;
HYPRE_Real local_num_nonzeros;
HYPRE_Int ierr = 0;
local_num_nonzeros = (HYPRE_Real) diag_i[local_num_rows] + (HYPRE_Real) offd_i[local_num_rows];
hypre_MPI_Allreduce(&local_num_nonzeros, &total_num_nonzeros, 1,
HYPRE_MPI_REAL, hypre_MPI_SUM, comm);
hypre_ParCSRBlockMatrixDNumNonzeros(matrix) = total_num_nonzeros;
return ierr;
}
HYPRE_Int main( HYPRE_Int argc, char *argv[] )
{
hypre_ParCSRMatrix *par_matrix, *g_matrix, **submatrices;
hypre_CSRMatrix *A_diag, *A_offd;
hypre_CSRBlockMatrix *diag;
hypre_CSRBlockMatrix *offd;
hypre_ParCSRBlockMatrix *par_blk_matrix, *par_blk_matrixT, *rap_matrix;
hypre_Vector *x_local;
hypre_Vector *y_local;
hypre_ParVector *x;
hypre_ParVector *y;
HYPRE_Solver gmres_solver, precon;
HYPRE_Int *diag_i, *diag_j, *offd_i, *offd_j;
HYPRE_Int *diag_i2, *diag_j2, *offd_i2, *offd_j2;
double *diag_d, *diag_d2, *offd_d, *offd_d2;
HYPRE_Int mypid, local_size, nprocs;
HYPRE_Int global_num_rows, global_num_cols, num_cols_offd;
HYPRE_Int num_nonzeros_diag, num_nonzeros_offd, *colMap;
HYPRE_Int ii, jj, kk, row, col, nnz, *indices, *colMap2;
double *data, ddata, *y_data;
HYPRE_Int *row_starts, *col_starts, *rstarts, *cstarts;
HYPRE_Int *row_starts2, *col_starts2;
HYPRE_Int block_size=2, bnnz=4, *index_set;
FILE *fp;
/* --------------------------------------------- */
/* Initialize MPI */
/* --------------------------------------------- */
hypre_MPI_Init(&argc, &argv);
hypre_MPI_Comm_rank(hypre_MPI_COMM_WORLD, &mypid);
hypre_MPI_Comm_size(hypre_MPI_COMM_WORLD, &nprocs);
/* build and fetch matrix */
MyBuildParLaplacian9pt((HYPRE_ParCSRMatrix *) &par_matrix);
global_num_rows = hypre_ParCSRMatrixGlobalNumRows(par_matrix);
global_num_cols = hypre_ParCSRMatrixGlobalNumCols(par_matrix);
row_starts = hypre_ParCSRMatrixRowStarts(par_matrix);
col_starts = hypre_ParCSRMatrixColStarts(par_matrix);
A_diag = hypre_ParCSRMatrixDiag(par_matrix);
A_offd = hypre_ParCSRMatrixOffd(par_matrix);
num_cols_offd = hypre_CSRMatrixNumCols(A_offd);
num_nonzeros_diag = hypre_CSRMatrixNumNonzeros(A_diag);
num_nonzeros_offd = hypre_CSRMatrixNumNonzeros(A_offd);
/* --------------------------------------------- */
/* build vector and apply matvec */
/* --------------------------------------------- */
x = hypre_ParVectorCreate(hypre_MPI_COMM_WORLD,global_num_cols,col_starts);
hypre_ParVectorSetPartitioningOwner(x,0);
hypre_ParVectorInitialize(x);
x_local = hypre_ParVectorLocalVector(x);
data = hypre_VectorData(x_local);
local_size = col_starts[mypid+1] - col_starts[mypid];
for (ii = 0; ii < local_size; ii++) data[ii] = 1.0;
y = hypre_ParVectorCreate(hypre_MPI_COMM_WORLD,global_num_rows,row_starts);
hypre_ParVectorSetPartitioningOwner(y,0);
hypre_ParVectorInitialize(y);
hypre_ParCSRMatrixMatvec (1.0, par_matrix, x, 0.0, y);
ddata = hypre_ParVectorInnerProd(y, y);
if (mypid == 0) hypre_printf("y inner product = %e\n", ddata);
hypre_ParVectorDestroy(x);
hypre_ParVectorDestroy(y);
/* --------------------------------------------- */
/* build block matrix */
/* --------------------------------------------- */
rstarts = hypre_CTAlloc(HYPRE_Int, nprocs+1);
for (ii = 0; ii <= nprocs; ii++) rstarts[ii] = row_starts[ii];
cstarts = hypre_CTAlloc(HYPRE_Int, nprocs+1);
for (ii = 0; ii <= nprocs; ii++) cstarts[ii] = col_starts[ii];
par_blk_matrix = hypre_ParCSRBlockMatrixCreate(hypre_MPI_COMM_WORLD,block_size,
global_num_rows, global_num_cols, rstarts,
cstarts, num_cols_offd, num_nonzeros_diag,
num_nonzeros_offd);
colMap = hypre_ParCSRMatrixColMapOffd(par_matrix);
if (num_cols_offd > 0) colMap2 = hypre_CTAlloc(HYPRE_Int, num_cols_offd);
else colMap2 = NULL;
for (ii = 0; ii < num_cols_offd; ii++) colMap2[ii] = colMap[ii];
hypre_ParCSRBlockMatrixColMapOffd(par_blk_matrix) = colMap2;
diag_i = hypre_CSRMatrixI(hypre_ParCSRMatrixDiag(par_matrix));
diag_j = hypre_CSRMatrixJ(hypre_ParCSRMatrixDiag(par_matrix));
diag_d = hypre_CSRMatrixData(hypre_ParCSRMatrixDiag(par_matrix));
diag = hypre_ParCSRBlockMatrixDiag(par_blk_matrix);
diag_i2 = hypre_CTAlloc(HYPRE_Int, local_size+1);
diag_j2 = hypre_CTAlloc(HYPRE_Int, num_nonzeros_diag);
diag_d2 = hypre_CTAlloc(double, num_nonzeros_diag*bnnz);
for (ii = 0; ii <= local_size; ii++) diag_i2[ii] = diag_i[ii];
for (ii = 0; ii < num_nonzeros_diag; ii++) diag_j2[ii] = diag_j[ii];
hypre_CSRBlockMatrixI(diag) = diag_i2;
hypre_CSRBlockMatrixJ(diag) = diag_j2;
for (ii = 0; ii < num_nonzeros_diag; ii++)
{
for (jj = 0; jj < block_size; jj++)
for (kk = 0; kk < block_size; kk++)
{
if (jj <= kk)
diag_d2[ii*bnnz+jj*block_size+kk] = diag_d[ii];
else
diag_d2[ii*bnnz+jj*block_size+kk] = 0.0;
}
}
hypre_CSRBlockMatrixData(diag) = diag_d2;
offd_i = hypre_CSRMatrixI(hypre_ParCSRMatrixOffd(par_matrix));
offd_j = hypre_CSRMatrixJ(hypre_ParCSRMatrixOffd(par_matrix));
offd_d = hypre_CSRMatrixData(hypre_ParCSRMatrixOffd(par_matrix));
offd = hypre_ParCSRBlockMatrixOffd(par_blk_matrix);
offd_i2 = hypre_CTAlloc(HYPRE_Int, local_size+1);
for (ii = 0; ii <= local_size; ii++) offd_i2[ii] = offd_i[ii];
hypre_CSRBlockMatrixI(offd) = offd_i2;
if (num_cols_offd)
{
offd_j2 = hypre_CTAlloc(HYPRE_Int, num_nonzeros_offd);
for (ii = 0; ii < num_nonzeros_offd; ii++) offd_j2[ii] = offd_j[ii];
hypre_CSRBlockMatrixJ(offd) = offd_j2;
offd_d2 = hypre_CTAlloc(double, num_nonzeros_offd*bnnz);
for (ii = 0; ii < num_nonzeros_offd; ii++)
{
for (jj = 0; jj < block_size; jj++)
for (kk = 0; kk < block_size; kk++)
{
if (jj <= kk)
offd_d2[ii*bnnz+jj*block_size+kk] = offd_d[ii];
else
offd_d2[ii*bnnz+jj*block_size+kk] = 0.0;
}
}
hypre_CSRBlockMatrixData(offd) = offd_d2;
}
else
{
hypre_CSRBlockMatrix *
hypre_ParCSRBlockMatrixExtractBExt(hypre_ParCSRBlockMatrix *B,
hypre_ParCSRBlockMatrix *A, HYPRE_Int data)
{
MPI_Comm comm = hypre_ParCSRBlockMatrixComm(B);
HYPRE_Int first_col_diag = hypre_ParCSRBlockMatrixFirstColDiag(B);
HYPRE_Int *col_map_offd = hypre_ParCSRBlockMatrixColMapOffd(B);
HYPRE_Int block_size = hypre_ParCSRBlockMatrixBlockSize(B);
hypre_ParCSRCommPkg *comm_pkg = hypre_ParCSRBlockMatrixCommPkg(A);
HYPRE_Int num_recvs = hypre_ParCSRCommPkgNumRecvs(comm_pkg);
HYPRE_Int *recv_vec_starts = hypre_ParCSRCommPkgRecvVecStarts(comm_pkg);
HYPRE_Int num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
HYPRE_Int *send_map_starts = hypre_ParCSRCommPkgSendMapStarts(comm_pkg);
HYPRE_Int *send_map_elmts = hypre_ParCSRCommPkgSendMapElmts(comm_pkg);
hypre_ParCSRCommHandle *comm_handle;
hypre_ParCSRCommPkg *tmp_comm_pkg;
hypre_CSRBlockMatrix *diag = hypre_ParCSRBlockMatrixDiag(B);
HYPRE_Int *diag_i = hypre_CSRBlockMatrixI(diag);
HYPRE_Int *diag_j = hypre_CSRBlockMatrixJ(diag);
HYPRE_Complex *diag_data = hypre_CSRBlockMatrixData(diag);
hypre_CSRBlockMatrix *offd = hypre_ParCSRBlockMatrixOffd(B);
HYPRE_Int *offd_i = hypre_CSRBlockMatrixI(offd);
HYPRE_Int *offd_j = hypre_CSRBlockMatrixJ(offd);
HYPRE_Complex *offd_data = hypre_CSRBlockMatrixData(offd);
HYPRE_Int *B_int_i;
HYPRE_Int *B_int_j;
HYPRE_Complex *B_int_data;
HYPRE_Int num_cols_B, num_nonzeros;
HYPRE_Int num_rows_B_ext;
HYPRE_Int num_procs, my_id;
hypre_CSRBlockMatrix *B_ext;
HYPRE_Int *B_ext_i;
HYPRE_Int *B_ext_j;
HYPRE_Complex *B_ext_data;
HYPRE_Int *jdata_recv_vec_starts;
HYPRE_Int *jdata_send_map_starts;
HYPRE_Int i, j, k, l, counter, bnnz;
HYPRE_Int start_index;
HYPRE_Int j_cnt, jrow;
hypre_MPI_Comm_size(comm,&num_procs);
hypre_MPI_Comm_rank(comm,&my_id);
bnnz = block_size * block_size;
num_cols_B = hypre_ParCSRMatrixGlobalNumCols(B);
num_rows_B_ext = recv_vec_starts[num_recvs];
B_int_i = hypre_CTAlloc(HYPRE_Int, send_map_starts[num_sends]+1);
B_ext_i = hypre_CTAlloc(HYPRE_Int, num_rows_B_ext+1);
/*--------------------------------------------------------------------------
* generate B_int_i through adding number of row-elements of offd and diag
* for corresponding rows. B_int_i[j+1] contains the number of elements of
* a row j (which is determined through send_map_elmts)
*--------------------------------------------------------------------------*/
B_int_i[0] = 0;
j_cnt = 0;
num_nonzeros = 0;
for (i=0; i < num_sends; i++)
{
for (j = send_map_starts[i]; j < send_map_starts[i+1]; j++)
{
jrow = send_map_elmts[j];
B_int_i[++j_cnt] = offd_i[jrow+1] - offd_i[jrow]
+ diag_i[jrow+1] - diag_i[jrow];
num_nonzeros += B_int_i[j_cnt];
}
}
/*--------------------------------------------------------------------------
* initialize communication
*--------------------------------------------------------------------------*/
comm_handle = hypre_ParCSRCommHandleCreate(11,comm_pkg,
&B_int_i[1],&B_ext_i[1]);
B_int_j = hypre_CTAlloc(HYPRE_Int, num_nonzeros);
if (data) B_int_data = hypre_CTAlloc(HYPRE_Complex, num_nonzeros*bnnz);
jdata_send_map_starts = hypre_CTAlloc(HYPRE_Int, num_sends+1);
jdata_recv_vec_starts = hypre_CTAlloc(HYPRE_Int, num_recvs+1);
start_index = B_int_i[0];
jdata_send_map_starts[0] = start_index;
counter = 0;
for (i=0; i < num_sends; i++)
{
num_nonzeros = counter;
for (j = send_map_starts[i]; j < send_map_starts[i+1]; j++)
{
jrow = send_map_elmts[j];
for (k=diag_i[jrow]; k < diag_i[jrow+1]; k++)
{
B_int_j[counter] = diag_j[k]+first_col_diag;
if (data) {
for(l = 0; l < bnnz; l++)
B_int_data[counter*bnnz+ l] = diag_data[k*bnnz+ l];
}
counter++;
}
for (k=offd_i[jrow]; k < offd_i[jrow+1]; k++)
{
B_int_j[counter] = col_map_offd[offd_j[k]];
if (data) {
for(l = 0; l < bnnz; l++)
B_int_data[counter*bnnz+ l] =
offd_data[k*bnnz+ l];
}
counter++;
}
}
num_nonzeros = counter - num_nonzeros;
start_index += num_nonzeros;
jdata_send_map_starts[i+1] = start_index;
}
tmp_comm_pkg = hypre_CTAlloc(hypre_ParCSRCommPkg,1);
hypre_ParCSRCommPkgComm(tmp_comm_pkg) = comm;
hypre_ParCSRCommPkgNumSends(tmp_comm_pkg) = num_sends;
hypre_ParCSRCommPkgNumRecvs(tmp_comm_pkg) = num_recvs;
hypre_ParCSRCommPkgSendProcs(tmp_comm_pkg) = hypre_ParCSRCommPkgSendProcs(comm_pkg);
hypre_ParCSRCommPkgRecvProcs(tmp_comm_pkg) = hypre_ParCSRCommPkgRecvProcs(comm_pkg);
hypre_ParCSRCommPkgSendMapStarts(tmp_comm_pkg) = jdata_send_map_starts;
hypre_ParCSRCommHandleDestroy(comm_handle);
comm_handle = NULL;
/*--------------------------------------------------------------------------
* after communication exchange B_ext_i[j+1] contains the number of elements
* of a row j !
* evaluate B_ext_i and compute num_nonzeros for B_ext
*--------------------------------------------------------------------------*/
for (i=0; i < num_recvs; i++)
for (j = recv_vec_starts[i]; j < recv_vec_starts[i+1]; j++)
B_ext_i[j+1] += B_ext_i[j];
num_nonzeros = B_ext_i[num_rows_B_ext];
B_ext = hypre_CSRBlockMatrixCreate(block_size, num_rows_B_ext, num_cols_B,
num_nonzeros);
B_ext_j = hypre_CTAlloc(HYPRE_Int, num_nonzeros);
if (data) B_ext_data = hypre_CTAlloc(HYPRE_Complex, num_nonzeros*bnnz);
for (i=0; i < num_recvs; i++)
{
start_index = B_ext_i[recv_vec_starts[i]];
num_nonzeros = B_ext_i[recv_vec_starts[i+1]]-start_index;
jdata_recv_vec_starts[i+1] = B_ext_i[recv_vec_starts[i+1]];
}
hypre_ParCSRCommPkgRecvVecStarts(tmp_comm_pkg) = jdata_recv_vec_starts;
comm_handle = hypre_ParCSRCommHandleCreate(11,tmp_comm_pkg,B_int_j,B_ext_j);
hypre_ParCSRCommHandleDestroy(comm_handle);
comm_handle = NULL;
if (data)
{
comm_handle = hypre_ParCSRBlockCommHandleCreate(1, bnnz,tmp_comm_pkg,
B_int_data, B_ext_data);
hypre_ParCSRBlockCommHandleDestroy(comm_handle);
comm_handle = NULL;
}
hypre_CSRBlockMatrixI(B_ext) = B_ext_i;
hypre_CSRBlockMatrixJ(B_ext) = B_ext_j;
if (data) hypre_CSRBlockMatrixData(B_ext) = B_ext_data;
hypre_TFree(B_int_i);
hypre_TFree(B_int_j);
if (data) hypre_TFree(B_int_data);
hypre_TFree(jdata_send_map_starts);
hypre_TFree(jdata_recv_vec_starts);
hypre_TFree(tmp_comm_pkg);
return B_ext;
}
hypre_ParCSRBlockMatrix *
hypre_ParCSRBlockMatrixConvertFromParCSRMatrix(hypre_ParCSRMatrix *matrix,
HYPRE_Int matrix_C_block_size )
{
MPI_Comm comm = hypre_ParCSRMatrixComm(matrix);
hypre_CSRMatrix *diag = hypre_ParCSRMatrixDiag(matrix);
hypre_CSRMatrix *offd = hypre_ParCSRMatrixOffd(matrix);
HYPRE_Int global_num_rows = hypre_ParCSRMatrixGlobalNumRows(matrix);
HYPRE_Int global_num_cols = hypre_ParCSRMatrixGlobalNumCols(matrix);
HYPRE_Int *row_starts = hypre_ParCSRMatrixRowStarts(matrix);
HYPRE_Int *col_starts = hypre_ParCSRMatrixColStarts(matrix);
HYPRE_Int num_cols_offd = hypre_CSRMatrixNumCols(offd);
HYPRE_Int *col_map_offd = hypre_ParCSRBlockMatrixColMapOffd(matrix);
HYPRE_Int *map_to_node=NULL, *counter=NULL, *col_in_j_map=NULL;
HYPRE_Int *matrix_C_col_map_offd = NULL;
HYPRE_Int matrix_C_num_cols_offd;
HYPRE_Int matrix_C_num_nonzeros_offd;
HYPRE_Int num_rows, num_nodes;
HYPRE_Int *offd_i = hypre_CSRMatrixI(offd);
HYPRE_Int *offd_j = hypre_CSRMatrixJ(offd);
HYPRE_Complex * offd_data = hypre_CSRMatrixData(offd);
hypre_ParCSRBlockMatrix *matrix_C;
HYPRE_Int *matrix_C_row_starts;
HYPRE_Int *matrix_C_col_starts;
hypre_CSRBlockMatrix *matrix_C_diag;
hypre_CSRBlockMatrix *matrix_C_offd;
HYPRE_Int *matrix_C_offd_i=NULL, *matrix_C_offd_j = NULL;
HYPRE_Complex *matrix_C_offd_data = NULL;
HYPRE_Int num_procs, i, j, k, k_map, count, index, start_index, pos, row;
hypre_MPI_Comm_size(comm,&num_procs);
#ifdef HYPRE_NO_GLOBAL_PARTITION
matrix_C_row_starts = hypre_CTAlloc(HYPRE_Int, 2);
matrix_C_col_starts = hypre_CTAlloc(HYPRE_Int, 2);
for(i = 0; i < 2; i++)
{
matrix_C_row_starts[i] = row_starts[i]/matrix_C_block_size;
matrix_C_col_starts[i] = col_starts[i]/matrix_C_block_size;
}
#else
matrix_C_row_starts = hypre_CTAlloc(HYPRE_Int, num_procs + 1);
matrix_C_col_starts = hypre_CTAlloc(HYPRE_Int, num_procs + 1);
for(i = 0; i < num_procs + 1; i++)
{
matrix_C_row_starts[i] = row_starts[i]/matrix_C_block_size;
matrix_C_col_starts[i] = col_starts[i]/matrix_C_block_size;
}
#endif
/************* create the diagonal part ************/
matrix_C_diag = hypre_CSRBlockMatrixConvertFromCSRMatrix(diag,
matrix_C_block_size);
/******* the offd part *******************/
/* can't use the same function for the offd part - because this isn't square
and the offd j entries aren't global numbering (have to consider the offd
map) - need to look at col_map_offd first */
/* figure out the new number of offd columns (num rows is same as diag) */
num_cols_offd = hypre_CSRMatrixNumCols(offd);
num_rows = hypre_CSRMatrixNumRows(diag);
num_nodes = num_rows/matrix_C_block_size;
matrix_C_offd_i = hypre_CTAlloc(HYPRE_Int, num_nodes + 1);
matrix_C_num_cols_offd = 0;
matrix_C_offd_i[0] = 0;
matrix_C_num_nonzeros_offd = 0;
if (num_cols_offd)
{
map_to_node = hypre_CTAlloc(HYPRE_Int, num_cols_offd);
matrix_C_num_cols_offd = 1;
map_to_node[0] = col_map_offd[0]/matrix_C_block_size;
for (i=1; i < num_cols_offd; i++)
{
map_to_node[i] = col_map_offd[i]/matrix_C_block_size;
if (map_to_node[i] > map_to_node[i-1]) matrix_C_num_cols_offd++;
}
matrix_C_col_map_offd = hypre_CTAlloc(HYPRE_Int, matrix_C_num_cols_offd);
col_in_j_map = hypre_CTAlloc(HYPRE_Int, num_cols_offd);
matrix_C_col_map_offd[0] = map_to_node[0];
col_in_j_map[0] = 0;
count = 1;
j = 1;
/* fill in the col_map_off_d - these are global numbers. Then we need to
map these to j entries (these have local numbers) */
for (i=1; i < num_cols_offd; i++)
{
if (map_to_node[i] > map_to_node[i-1])
{
matrix_C_col_map_offd[count++] = map_to_node[i];
}
col_in_j_map[j++] = count - 1;
}
/* now figure the nonzeros */
matrix_C_num_nonzeros_offd = 0;
counter = hypre_CTAlloc(HYPRE_Int, matrix_C_num_cols_offd);
for (i=0; i < matrix_C_num_cols_offd; i++)
counter[i] = -1;
for (i=0; i < num_nodes; i++) /* for each block row */
{
matrix_C_offd_i[i] = matrix_C_num_nonzeros_offd;
for (j=0; j < matrix_C_block_size; j++)
{
row = i*matrix_C_block_size+j;
for (k=offd_i[row]; k < offd_i[row+1]; k++) /* go through single row */
{
k_map = col_in_j_map[offd_j[k]]; /*nodal col - see if this has
been in this block row (i)
already*/
if (counter[k_map] < i) /* not yet counted for this nodal row */
{
counter[k_map] = i;
matrix_C_num_nonzeros_offd++;
}
}
}
}
/* fill in final i entry */
matrix_C_offd_i[num_nodes] = matrix_C_num_nonzeros_offd;
}
/* create offd matrix */
matrix_C_offd = hypre_CSRBlockMatrixCreate(matrix_C_block_size, num_nodes,
matrix_C_num_cols_offd,
matrix_C_num_nonzeros_offd);
/* assign i */
hypre_CSRBlockMatrixI(matrix_C_offd) = matrix_C_offd_i;
/* create (and allocate j and data) */
if (matrix_C_num_nonzeros_offd)
{
matrix_C_offd_j = hypre_CTAlloc(HYPRE_Int, matrix_C_num_nonzeros_offd);
matrix_C_offd_data =
hypre_CTAlloc(HYPRE_Complex,
matrix_C_num_nonzeros_offd*matrix_C_block_size*
matrix_C_block_size);
hypre_CSRBlockMatrixJ(matrix_C_offd) = matrix_C_offd_j;
hypre_CSRMatrixData(matrix_C_offd) = matrix_C_offd_data;
for (i=0; i < matrix_C_num_cols_offd; i++)
counter[i] = -1;
index = 0; /*keep track of entry in matrix_C_offd_j*/
start_index = 0;
for (i=0; i < num_nodes; i++) /* for each block row */
{
for (j=0; j < matrix_C_block_size; j++) /* for each row in block */
{
row = i*matrix_C_block_size+j;
for (k=offd_i[row]; k < offd_i[row+1]; k++) /* go through single row's cols */
{
k_map = col_in_j_map[offd_j[k]]; /*nodal col for off_d */
if (counter[k_map] < start_index) /* not yet counted for this nodal row */
{
counter[k_map] = index;
matrix_C_offd_j[index] = k_map;
/*copy the data: which position (corresponds to j array) + which row + which col */
pos = (index * matrix_C_block_size * matrix_C_block_size) + (j * matrix_C_block_size) +
col_map_offd[offd_j[k]]%matrix_C_block_size;
matrix_C_offd_data[pos] = offd_data[k];
index ++;
}
else /* this col has already been listed for this row */
{
/*copy the data: which position (corresponds to j array) + which row + which col */
pos = (counter[k_map]* matrix_C_block_size * matrix_C_block_size) + (j * matrix_C_block_size) +
col_map_offd[offd_j[k]]%matrix_C_block_size;
matrix_C_offd_data[pos] = offd_data[k];
}
}
}
start_index = index; /* first index for current nodal row */
}
}
/* *********create the new matrix *************/
matrix_C = hypre_ParCSRBlockMatrixCreate(comm, matrix_C_block_size,
global_num_rows/matrix_C_block_size,
global_num_cols/matrix_C_block_size, matrix_C_row_starts,
matrix_C_col_starts, matrix_C_num_cols_offd,
hypre_CSRBlockMatrixNumNonzeros(matrix_C_diag),
matrix_C_num_nonzeros_offd);
/* use the diag and off diag matrices we have already created */
hypre_CSRBlockMatrixDestroy(hypre_ParCSRMatrixDiag(matrix_C));
hypre_ParCSRBlockMatrixDiag(matrix_C) = matrix_C_diag;
hypre_CSRBlockMatrixDestroy(hypre_ParCSRMatrixOffd(matrix_C));
hypre_ParCSRBlockMatrixOffd(matrix_C) = matrix_C_offd;
hypre_ParCSRMatrixColMapOffd(matrix_C) = matrix_C_col_map_offd;
/* *********don't bother to copy the comm_pkg *************/
hypre_ParCSRBlockMatrixCommPkg(matrix_C) = NULL;
/* CLEAN UP !!!! */
hypre_TFree(map_to_node);
hypre_TFree(col_in_j_map);
hypre_TFree(counter);
return matrix_C;
}
HYPRE_Int
hypre_BoomerAMGBlockCreateNodalA(hypre_ParCSRBlockMatrix *A,
HYPRE_Int option,
HYPRE_Int diag_option,
hypre_ParCSRMatrix **AN_ptr)
{
MPI_Comm comm = hypre_ParCSRBlockMatrixComm(A);
hypre_CSRBlockMatrix *A_diag = hypre_ParCSRBlockMatrixDiag(A);
HYPRE_Int *A_diag_i = hypre_CSRBlockMatrixI(A_diag);
HYPRE_Real *A_diag_data = hypre_CSRBlockMatrixData(A_diag);
HYPRE_Int block_size = hypre_CSRBlockMatrixBlockSize(A_diag);
HYPRE_Int bnnz = block_size*block_size;
hypre_CSRBlockMatrix *A_offd = hypre_ParCSRMatrixOffd(A);
HYPRE_Int *A_offd_i = hypre_CSRBlockMatrixI(A_offd);
HYPRE_Real *A_offd_data = hypre_CSRBlockMatrixData(A_offd);
HYPRE_Int *A_diag_j = hypre_CSRBlockMatrixJ(A_diag);
HYPRE_Int *A_offd_j = hypre_CSRBlockMatrixJ(A_offd);
HYPRE_Int *row_starts = hypre_ParCSRBlockMatrixRowStarts(A);
HYPRE_Int *col_map_offd = hypre_ParCSRBlockMatrixColMapOffd(A);
HYPRE_Int num_nonzeros_diag;
HYPRE_Int num_nonzeros_offd = 0;
HYPRE_Int num_cols_offd = 0;
hypre_ParCSRMatrix *AN;
hypre_CSRMatrix *AN_diag;
HYPRE_Int *AN_diag_i;
HYPRE_Int *AN_diag_j=NULL;
HYPRE_Real *AN_diag_data = NULL;
hypre_CSRMatrix *AN_offd;
HYPRE_Int *AN_offd_i;
HYPRE_Int *AN_offd_j = NULL;
HYPRE_Real *AN_offd_data = NULL;
HYPRE_Int *col_map_offd_AN = NULL;
HYPRE_Int *row_starts_AN;
hypre_ParCSRCommPkg *comm_pkg = hypre_ParCSRBlockMatrixCommPkg(A);
HYPRE_Int num_sends;
HYPRE_Int num_recvs;
HYPRE_Int *send_procs;
HYPRE_Int *send_map_starts;
HYPRE_Int *send_map_elmts;
HYPRE_Int *recv_procs;
HYPRE_Int *recv_vec_starts;
hypre_ParCSRCommPkg *comm_pkg_AN = NULL;
HYPRE_Int *send_procs_AN = NULL;
HYPRE_Int *send_map_starts_AN = NULL;
HYPRE_Int *send_map_elmts_AN = NULL;
HYPRE_Int *recv_procs_AN = NULL;
HYPRE_Int *recv_vec_starts_AN = NULL;
HYPRE_Int i;
HYPRE_Int ierr = 0;
HYPRE_Int num_procs;
HYPRE_Int cnt;
HYPRE_Int norm_type;
HYPRE_Int global_num_nodes;
HYPRE_Int num_nodes;
HYPRE_Int index, k;
HYPRE_Real tmp;
HYPRE_Real sum;
hypre_MPI_Comm_size(comm,&num_procs);
if (!comm_pkg)
{
hypre_BlockMatvecCommPkgCreate(A);
comm_pkg = hypre_ParCSRBlockMatrixCommPkg(A);
}
norm_type = fabs(option);
/* Set up the new matrix AN */
#ifdef HYPRE_NO_GLOBAL_PARTITION
row_starts_AN = hypre_CTAlloc(HYPRE_Int, 2);
for (i=0; i < 2; i++)
{
row_starts_AN[i] = row_starts[i];
}
#else
row_starts_AN = hypre_CTAlloc(HYPRE_Int, num_procs+1);
for (i=0; i < num_procs+1; i++)
{
row_starts_AN[i] = row_starts[i];
}
#endif
global_num_nodes = hypre_ParCSRBlockMatrixGlobalNumRows(A);
num_nodes = hypre_CSRBlockMatrixNumRows(A_diag);
/* the diag part */
num_nonzeros_diag = A_diag_i[num_nodes];
AN_diag_i = hypre_CTAlloc(HYPRE_Int, num_nodes+1);
for (i=0; i <= num_nodes; i++)
{
AN_diag_i[i] = A_diag_i[i];
}
AN_diag_j = hypre_CTAlloc(HYPRE_Int, num_nonzeros_diag);
AN_diag_data = hypre_CTAlloc(HYPRE_Real, num_nonzeros_diag);
AN_diag = hypre_CSRMatrixCreate(num_nodes, num_nodes, num_nonzeros_diag);
hypre_CSRMatrixI(AN_diag) = AN_diag_i;
hypre_CSRMatrixJ(AN_diag) = AN_diag_j;
hypre_CSRMatrixData(AN_diag) = AN_diag_data;
for (i=0; i< num_nonzeros_diag; i++)
{
AN_diag_j[i] = A_diag_j[i];
hypre_CSRBlockMatrixBlockNorm(norm_type, &A_diag_data[i*bnnz],
&tmp, block_size);
AN_diag_data[i] = tmp;
}
if (diag_option ==1 )
{
/* make the diag entry the negative of the sum of off-diag entries (NEED
* to get more below!)*/
/* the diagonal is the first element listed in each row - */
for (i=0; i < num_nodes; i++)
{
index = AN_diag_i[i];
sum = 0.0;
for (k = AN_diag_i[i]+1; k < AN_diag_i[i+1]; k++)
{
sum += AN_diag_data[k];
}
AN_diag_data[index] = -sum;
}
}
else if (diag_option == 2)
{
/* make all diagonal entries negative */
/* the diagonal is the first element listed in each row - */
for (i=0; i < num_nodes; i++)
{
index = AN_diag_i[i];
AN_diag_data[index] = -AN_diag_data[index];
}
}
/* copy the commpkg */
if (comm_pkg)
{
comm_pkg_AN = hypre_CTAlloc(hypre_ParCSRCommPkg,1);
hypre_ParCSRCommPkgComm(comm_pkg_AN) = comm;
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
hypre_ParCSRCommPkgNumSends(comm_pkg_AN) = num_sends;
num_recvs = hypre_ParCSRCommPkgNumRecvs(comm_pkg);
hypre_ParCSRCommPkgNumRecvs(comm_pkg_AN) = num_recvs;
send_procs = hypre_ParCSRCommPkgSendProcs(comm_pkg);
send_map_starts = hypre_ParCSRCommPkgSendMapStarts(comm_pkg);
send_map_elmts = hypre_ParCSRCommPkgSendMapElmts(comm_pkg);
if (num_sends)
{
send_procs_AN = hypre_CTAlloc(HYPRE_Int, num_sends);
send_map_elmts_AN = hypre_CTAlloc(HYPRE_Int, send_map_starts[num_sends]);
}
send_map_starts_AN = hypre_CTAlloc(HYPRE_Int, num_sends+1);
send_map_starts_AN[0] = 0;
for (i=0; i < num_sends; i++)
{
send_procs_AN[i] = send_procs[i];
send_map_starts_AN[i+1] = send_map_starts[i+1];
}
cnt = send_map_starts_AN[num_sends];
for (i=0; i< cnt; i++)
{
send_map_elmts_AN[i] = send_map_elmts[i];
}
hypre_ParCSRCommPkgSendProcs(comm_pkg_AN) = send_procs_AN;
hypre_ParCSRCommPkgSendMapStarts(comm_pkg_AN) = send_map_starts_AN;
hypre_ParCSRCommPkgSendMapElmts(comm_pkg_AN) = send_map_elmts_AN;
recv_procs = hypre_ParCSRCommPkgRecvProcs(comm_pkg);
recv_vec_starts = hypre_ParCSRCommPkgRecvVecStarts(comm_pkg);
recv_vec_starts_AN = hypre_CTAlloc(HYPRE_Int, num_recvs+1);
if (num_recvs) recv_procs_AN = hypre_CTAlloc(HYPRE_Int, num_recvs);
recv_vec_starts_AN[0] = recv_vec_starts[0];
for (i=0; i < num_recvs; i++)
{
recv_procs_AN[i] = recv_procs[i];
recv_vec_starts_AN[i+1] = recv_vec_starts[i+1];
}
hypre_ParCSRCommPkgRecvProcs(comm_pkg_AN) = recv_procs_AN;
hypre_ParCSRCommPkgRecvVecStarts(comm_pkg_AN) = recv_vec_starts_AN;
}
/* the off-diag part */
num_cols_offd = hypre_CSRBlockMatrixNumCols(A_offd);
col_map_offd_AN = hypre_CTAlloc(HYPRE_Int, num_cols_offd);
for (i=0; i < num_cols_offd; i++)
{
col_map_offd_AN[i] = col_map_offd[i];
}
num_nonzeros_offd = A_offd_i[num_nodes];
AN_offd_i = hypre_CTAlloc(HYPRE_Int, num_nodes+1);
for (i=0; i <= num_nodes; i++)
{
AN_offd_i[i] = A_offd_i[i];
}
AN_offd_j = hypre_CTAlloc(HYPRE_Int, num_nonzeros_offd);
AN_offd_data = hypre_CTAlloc(HYPRE_Real, num_nonzeros_offd);
for (i=0; i< num_nonzeros_offd; i++)
{
AN_offd_j[i] = A_offd_j[i];
hypre_CSRBlockMatrixBlockNorm(norm_type, &A_offd_data[i*bnnz],
&tmp, block_size);
AN_offd_data[i] = tmp;
}
AN_offd = hypre_CSRMatrixCreate(num_nodes, num_cols_offd, num_nonzeros_offd);
hypre_CSRMatrixI(AN_offd) = AN_offd_i;
hypre_CSRMatrixJ(AN_offd) = AN_offd_j;
hypre_CSRMatrixData(AN_offd) = AN_offd_data;
if (diag_option ==1 )
{
/* make the diag entry the negative of the sum of off-diag entries (here
we are adding the off_diag contribution)*/
/* the diagonal is the first element listed in each row of AN_diag_data - */
for (i=0; i < num_nodes; i++)
{
sum = 0.0;
for (k = AN_offd_i[i]; k < AN_offd_i[i+1]; k++)
{
sum += AN_offd_data[k];
}
index = AN_diag_i[i];/* location of diag entry in data */
AN_diag_data[index] -= sum; /* subtract from current value */
}
}
/* now create AN */
AN = hypre_ParCSRMatrixCreate(comm, global_num_nodes, global_num_nodes,
row_starts_AN, row_starts_AN, num_cols_offd,
num_nonzeros_diag, num_nonzeros_offd);
/* we already created the diag and offd matrices - so we don't need the ones
created above */
hypre_CSRMatrixDestroy(hypre_ParCSRMatrixDiag(AN));
hypre_CSRMatrixDestroy(hypre_ParCSRMatrixOffd(AN));
hypre_ParCSRMatrixDiag(AN) = AN_diag;
hypre_ParCSRMatrixOffd(AN) = AN_offd;
hypre_ParCSRMatrixColMapOffd(AN) = col_map_offd_AN;
hypre_ParCSRMatrixCommPkg(AN) = comm_pkg_AN;
*AN_ptr = AN;
return (ierr);
}
HYPRE_Int
hypre_CSRBlockMatrixMatvec(double alpha, hypre_CSRBlockMatrix *A,
hypre_Vector *x, double beta, hypre_Vector *y)
{
double *A_data = hypre_CSRBlockMatrixData(A);
HYPRE_Int *A_i = hypre_CSRBlockMatrixI(A);
HYPRE_Int *A_j = hypre_CSRBlockMatrixJ(A);
HYPRE_Int num_rows = hypre_CSRBlockMatrixNumRows(A);
HYPRE_Int num_cols = hypre_CSRBlockMatrixNumCols(A);
HYPRE_Int blk_size = hypre_CSRBlockMatrixBlockSize(A);
double *x_data = hypre_VectorData(x);
double *y_data = hypre_VectorData(y);
HYPRE_Int x_size = hypre_VectorSize(x);
HYPRE_Int y_size = hypre_VectorSize(y);
HYPRE_Int i, b1, b2, jj, bnnz=blk_size*blk_size;
HYPRE_Int ierr = 0;
double temp;
/*---------------------------------------------------------------------
* Check for size compatibility. Matvec returns ierr = 1 if
* length of X doesn't equal the number of columns of A,
* ierr = 2 if the length of Y doesn't equal the number of rows
* of A, and ierr = 3 if both are true.
*
* Because temporary vectors are often used in Matvec, none of
* these conditions terminates processing, and the ierr flag
* is informational only.
*--------------------------------------------------------------------*/
if (num_cols*blk_size != x_size) ierr = 1;
if (num_rows*blk_size != y_size) ierr = 2;
if (num_cols*blk_size != x_size && num_rows*blk_size != y_size) ierr = 3;
/*-----------------------------------------------------------------------
* Do (alpha == 0.0) computation - RDF: USE MACHINE EPS
*-----------------------------------------------------------------------*/
if (alpha == 0.0)
{
#define HYPRE_SMP_PRIVATE i
#include "../utilities/hypre_smp_forloop.h"
for (i = 0; i < num_rows*blk_size; i++) y_data[i] *= beta;
return ierr;
}
/*-----------------------------------------------------------------------
* y = (beta/alpha)*y
*-----------------------------------------------------------------------*/
temp = beta / alpha;
if (temp != 1.0)
{
if (temp == 0.0)
{
#define HYPRE_SMP_PRIVATE i
#include "../utilities/hypre_smp_forloop.h"
for (i = 0; i < num_rows*blk_size; i++)
y_data[i] = 0.0;
}
else
{
#define HYPRE_SMP_PRIVATE i
#include "../utilities/hypre_smp_forloop.h"
for (i = 0; i < num_rows*blk_size; i++)
y_data[i] *= temp;
}
}
/*-----------------------------------------------------------------
* y += A*x
*-----------------------------------------------------------------*/
#define HYPRE_SMP_PRIVATE i,jj,b1,b2,temp
#include "../utilities/hypre_smp_forloop.h"
for (i = 0; i < num_rows; i++)
{
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
for (b1 = 0; b1 < blk_size; b1++)
{
temp = y_data[i*blk_size+b1];
for (b2 = 0; b2 < blk_size; b2++)
temp += A_data[jj*bnnz+b1*blk_size+b2] * x_data[A_j[jj]*blk_size+b2];
y_data[i*blk_size+b1] = temp;
}
}
}
/*-----------------------------------------------------------------
* y = alpha*y
*-----------------------------------------------------------------*/
if (alpha != 1.0)
{
#define HYPRE_SMP_PRIVATE i
#include "../utilities/hypre_smp_forloop.h"
for (i = 0; i < num_rows*blk_size; i++)
y_data[i] *= alpha;
}
return ierr;
}