HYPRE_Int
hypre_ParCSRMatrix_dof_func_offd(
hypre_ParCSRMatrix *A,
HYPRE_Int num_functions,
HYPRE_Int *dof_func,
HYPRE_Int **dof_func_offd )
{
hypre_ParCSRCommPkg *comm_pkg = hypre_ParCSRMatrixCommPkg(A);
hypre_ParCSRCommHandle *comm_handle;
hypre_CSRMatrix *A_offd = hypre_ParCSRMatrixOffd(A);
HYPRE_Int num_cols_offd = 0;
HYPRE_Int Solve_err_flag = 0;
HYPRE_Int num_sends;
HYPRE_Int *int_buf_data;
HYPRE_Int index, start, i, j;
num_cols_offd = hypre_CSRMatrixNumCols(A_offd);
*dof_func_offd = NULL;
if (num_cols_offd)
{
if (num_functions > 1)
*dof_func_offd = hypre_CTAlloc(HYPRE_Int, num_cols_offd);
}
/*-------------------------------------------------------------------
* Get the dof_func data for the off-processor columns
*-------------------------------------------------------------------*/
if (!comm_pkg)
{
hypre_MatvecCommPkgCreate(A);
comm_pkg = hypre_ParCSRMatrixCommPkg(A);
}
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
if (num_functions > 1)
{
int_buf_data = hypre_CTAlloc(HYPRE_Int,hypre_ParCSRCommPkgSendMapStart(comm_pkg,
num_sends));
index = 0;
for (i = 0; i < num_sends; i++)
{
start = hypre_ParCSRCommPkgSendMapStart(comm_pkg, i);
for (j=start; j < hypre_ParCSRCommPkgSendMapStart(comm_pkg, i+1); j++)
int_buf_data[index++]
= dof_func[hypre_ParCSRCommPkgSendMapElmt(comm_pkg,j)];
}
comm_handle = hypre_ParCSRCommHandleCreate( 11, comm_pkg, int_buf_data,
*dof_func_offd);
hypre_ParCSRCommHandleDestroy(comm_handle);
hypre_TFree(int_buf_data);
}
return(Solve_err_flag);
}
/* Based on hypre_ParCSRMatrixMatvec in par_csr_matvec.c */
void hypre_ParCSRMatrixBooleanMatvec(hypre_ParCSRMatrix *A,
HYPRE_Bool alpha,
HYPRE_Bool *x,
HYPRE_Bool beta,
HYPRE_Bool *y)
{
hypre_ParCSRCommHandle *comm_handle;
hypre_ParCSRCommPkg *comm_pkg = hypre_ParCSRMatrixCommPkg(A);
hypre_CSRMatrix *diag = hypre_ParCSRMatrixDiag(A);
hypre_CSRMatrix *offd = hypre_ParCSRMatrixOffd(A);
HYPRE_Int num_cols_offd = hypre_CSRMatrixNumCols(offd);
HYPRE_Int num_sends, i, j, index;
HYPRE_Bool *x_tmp, *x_buf;
x_tmp = hypre_CTAlloc(HYPRE_Bool, num_cols_offd);
/*---------------------------------------------------------------------
* If there exists no CommPkg for A, a CommPkg is generated using
* equally load balanced partitionings
*--------------------------------------------------------------------*/
if (!comm_pkg)
{
hypre_MatvecCommPkgCreate(A);
comm_pkg = hypre_ParCSRMatrixCommPkg(A);
}
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
x_buf = hypre_CTAlloc(HYPRE_Bool,
hypre_ParCSRCommPkgSendMapStart(comm_pkg, num_sends));
index = 0;
for (i = 0; i < num_sends; i++)
{
j = hypre_ParCSRCommPkgSendMapStart(comm_pkg, i);
for ( ; j < hypre_ParCSRCommPkgSendMapStart(comm_pkg, i+1); j++)
{
x_buf[index++] = x[hypre_ParCSRCommPkgSendMapElmt(comm_pkg, j)];
}
}
comm_handle = hypre_ParCSRCommHandleCreate_bool(1, comm_pkg, x_buf, x_tmp);
hypre_CSRMatrixBooleanMatvec(diag, alpha, x, beta, y);
hypre_ParCSRCommHandleDestroy(comm_handle);
if (num_cols_offd)
{
hypre_CSRMatrixBooleanMatvec(offd, alpha, x_tmp, 1, y);
}
hypre_TFree(x_buf);
hypre_TFree(x_tmp);
}
HYPRE_Int AmgCGCGraphAssemble (hypre_ParCSRMatrix *S,HYPRE_Int *vertexrange,HYPRE_Int *CF_marker,HYPRE_Int *CF_marker_offd,HYPRE_Int coarsen_type,
HYPRE_IJMatrix *ijG)
/* assemble a graph representing the connections between the grids
* ================================================================================================
* S : the strength matrix
* vertexrange : the parallel layout of the candidate coarse grid vertices
* CF_marker, CF_marker_offd : the coarse/fine markers
* coarsen_type : the coarsening type
* ijG : the created graph
* ================================================================================================*/
{
HYPRE_Int ierr=0;
HYPRE_Int i,/* ii,*/ip,j,jj,m,n,p;
HYPRE_Int mpisize,mpirank;
HYPRE_Real weight;
MPI_Comm comm = hypre_ParCSRMatrixComm(S);
/* hypre_MPI_Status status; */
HYPRE_IJMatrix ijmatrix;
hypre_CSRMatrix *S_diag = hypre_ParCSRMatrixDiag (S);
hypre_CSRMatrix *S_offd = hypre_ParCSRMatrixOffd (S);
/* HYPRE_Int *S_i = hypre_CSRMatrixI(S_diag); */
/* HYPRE_Int *S_j = hypre_CSRMatrixJ(S_diag); */
HYPRE_Int *S_offd_i = hypre_CSRMatrixI(S_offd);
HYPRE_Int *S_offd_j = NULL;
HYPRE_Int num_variables = hypre_CSRMatrixNumRows (S_diag);
HYPRE_Int num_cols_offd = hypre_CSRMatrixNumCols (S_offd);
HYPRE_Int *col_map_offd = hypre_ParCSRMatrixColMapOffd (S);
HYPRE_Int pointrange_start,pointrange_end;
HYPRE_Int *pointrange,*pointrange_nonlocal,*pointrange_strong=NULL;
HYPRE_Int vertexrange_start,vertexrange_end;
HYPRE_Int *vertexrange_strong= NULL;
HYPRE_Int *vertexrange_nonlocal;
HYPRE_Int num_recvs,num_recvs_strong;
HYPRE_Int *recv_procs,*recv_procs_strong=NULL;
HYPRE_Int /* *zeros,*rownz,*/*rownz_diag,*rownz_offd;
HYPRE_Int nz;
HYPRE_Int nlocal;
HYPRE_Int one=1;
hypre_ParCSRCommPkg *comm_pkg = hypre_ParCSRMatrixCommPkg (S);
hypre_MPI_Comm_size (comm,&mpisize);
hypre_MPI_Comm_rank (comm,&mpirank);
/* determine neighbor processors */
num_recvs = hypre_ParCSRCommPkgNumRecvs (comm_pkg);
recv_procs = hypre_ParCSRCommPkgRecvProcs (comm_pkg);
pointrange = hypre_ParCSRMatrixRowStarts (S);
pointrange_nonlocal = hypre_CTAlloc (HYPRE_Int, 2*num_recvs);
vertexrange_nonlocal = hypre_CTAlloc (HYPRE_Int, 2*num_recvs);
#ifdef HYPRE_NO_GLOBAL_PARTITION
{
HYPRE_Int num_sends = hypre_ParCSRCommPkgNumSends (comm_pkg);
HYPRE_Int *send_procs = hypre_ParCSRCommPkgSendProcs (comm_pkg);
HYPRE_Int *int_buf_data = hypre_CTAlloc (HYPRE_Int,4*num_sends);
HYPRE_Int *int_buf_data2 = int_buf_data + 2*num_sends;
hypre_MPI_Request *sendrequest,*recvrequest;
nlocal = vertexrange[1] - vertexrange[0];
pointrange_start = pointrange[0];
pointrange_end = pointrange[1];
vertexrange_start = vertexrange[0];
vertexrange_end = vertexrange[1];
sendrequest = hypre_CTAlloc (hypre_MPI_Request,2*(num_sends+num_recvs));
recvrequest = sendrequest+2*num_sends;
for (i=0;i<num_recvs;i++) {
hypre_MPI_Irecv (pointrange_nonlocal+2*i,2,HYPRE_MPI_INT,recv_procs[i],tag_pointrange,comm,&recvrequest[2*i]);
hypre_MPI_Irecv (vertexrange_nonlocal+2*i,2,HYPRE_MPI_INT,recv_procs[i],tag_vertexrange,comm,&recvrequest[2*i+1]);
}
for (i=0;i<num_sends;i++) {
int_buf_data[2*i] = pointrange_start;
int_buf_data[2*i+1] = pointrange_end;
int_buf_data2[2*i] = vertexrange_start;
int_buf_data2[2*i+1] = vertexrange_end;
hypre_MPI_Isend (int_buf_data+2*i,2,HYPRE_MPI_INT,send_procs[i],tag_pointrange,comm,&sendrequest[2*i]);
hypre_MPI_Isend (int_buf_data2+2*i,2,HYPRE_MPI_INT,send_procs[i],tag_vertexrange,comm,&sendrequest[2*i+1]);
}
hypre_MPI_Waitall (2*(num_sends+num_recvs),sendrequest,hypre_MPI_STATUSES_IGNORE);
hypre_TFree (int_buf_data);
hypre_TFree (sendrequest);
}
#else
nlocal = vertexrange[mpirank+1] - vertexrange[mpirank];
pointrange_start = pointrange[mpirank];
pointrange_end = pointrange[mpirank+1];
vertexrange_start = vertexrange[mpirank];
vertexrange_end = vertexrange[mpirank+1];
for (i=0;i<num_recvs;i++) {
pointrange_nonlocal[2*i] = pointrange[recv_procs[i]];
pointrange_nonlocal[2*i+1] = pointrange[recv_procs[i]+1];
vertexrange_nonlocal[2*i] = vertexrange[recv_procs[i]];
vertexrange_nonlocal[2*i+1] = vertexrange[recv_procs[i]+1];
}
#endif
/* now we have the array recv_procs. However, it may contain too many entries as it is
inherited from A. We now have to determine the subset which contains only the
strongly connected neighbors */
if (num_cols_offd) {
S_offd_j = hypre_CSRMatrixJ(S_offd);
recv_procs_strong = hypre_CTAlloc (HYPRE_Int,num_recvs);
memset (recv_procs_strong,0,num_recvs*sizeof(HYPRE_Int));
/* don't forget to shorten the pointrange and vertexrange arrays accordingly */
pointrange_strong = hypre_CTAlloc (HYPRE_Int,2*num_recvs);
memset (pointrange_strong,0,2*num_recvs*sizeof(HYPRE_Int));
vertexrange_strong = hypre_CTAlloc (HYPRE_Int,2*num_recvs);
memset (vertexrange_strong,0,2*num_recvs*sizeof(HYPRE_Int));
for (i=0;i<num_variables;i++)
for (j=S_offd_i[i];j<S_offd_i[i+1];j++) {
jj = col_map_offd[S_offd_j[j]];
for (p=0;p<num_recvs;p++) /* S_offd_j is NOT sorted! */
if (jj >= pointrange_nonlocal[2*p] && jj < pointrange_nonlocal[2*p+1]) break;
#if 0
hypre_printf ("Processor %d, remote point %d on processor %d\n",mpirank,jj,recv_procs[p]);
#endif
recv_procs_strong [p]=1;
}
for (p=0,num_recvs_strong=0;p<num_recvs;p++) {
if (recv_procs_strong[p]) {
recv_procs_strong[num_recvs_strong]=recv_procs[p];
pointrange_strong[2*num_recvs_strong] = pointrange_nonlocal[2*p];
pointrange_strong[2*num_recvs_strong+1] = pointrange_nonlocal[2*p+1];
vertexrange_strong[2*num_recvs_strong] = vertexrange_nonlocal[2*p];
vertexrange_strong[2*num_recvs_strong+1] = vertexrange_nonlocal[2*p+1];
num_recvs_strong++;
}
}
}
else num_recvs_strong=0;
hypre_TFree (pointrange_nonlocal);
hypre_TFree (vertexrange_nonlocal);
rownz_diag = hypre_CTAlloc (HYPRE_Int,2*nlocal);
rownz_offd = rownz_diag + nlocal;
for (p=0,nz=0;p<num_recvs_strong;p++) {
nz += vertexrange_strong[2*p+1]-vertexrange_strong[2*p];
}
for (m=0;m<nlocal;m++) {
rownz_diag[m]=nlocal-1;
rownz_offd[m]=nz;
}
HYPRE_IJMatrixCreate(comm, vertexrange_start, vertexrange_end-1, vertexrange_start, vertexrange_end-1, &ijmatrix);
HYPRE_IJMatrixSetObjectType(ijmatrix, HYPRE_PARCSR);
HYPRE_IJMatrixSetDiagOffdSizes (ijmatrix, rownz_diag, rownz_offd);
HYPRE_IJMatrixInitialize(ijmatrix);
hypre_TFree (rownz_diag);
/* initialize graph */
weight = -1;
for (m=vertexrange_start;m<vertexrange_end;m++) {
for (p=0;p<num_recvs_strong;p++) {
for (n=vertexrange_strong[2*p];n<vertexrange_strong[2*p+1];n++) {
ierr = HYPRE_IJMatrixAddToValues (ijmatrix,1,&one,&m,&n,&weight);
#if 0
if (ierr) hypre_printf ("Processor %d: error %d while initializing graphs at (%d, %d)\n",mpirank,ierr,m,n);
#endif
}
}
}
/* weight graph */
for (i=0;i<num_variables;i++) {
for (j=S_offd_i[i];j<S_offd_i[i+1];j++) {
jj = S_offd_j[j]; /* jj is not a global index!!! */
/* determine processor */
for (p=0;p<num_recvs_strong;p++)
if (col_map_offd[jj] >= pointrange_strong[2*p] && col_map_offd[jj] < pointrange_strong[2*p+1]) break;
ip=recv_procs_strong[p];
/* loop over all coarse grids constructed on this processor domain */
for (m=vertexrange_start;m<vertexrange_end;m++) {
/* loop over all coarse grids constructed on neighbor processor domain */
for (n=vertexrange_strong[2*p];n<vertexrange_strong[2*p+1];n++) {
/* coarse grid counting inside gridpartition->local/gridpartition->nonlocal starts with one
while counting inside range starts with zero */
if (CF_marker[i]-1==m && CF_marker_offd[jj]-1==n)
/* C-C-coupling */
weight = -1;
else if ( (CF_marker[i]-1==m && (CF_marker_offd[jj]==0 || CF_marker_offd[jj]-1!=n) )
|| ( (CF_marker[i]==0 || CF_marker[i]-1!=m) && CF_marker_offd[jj]-1==n ) )
/* C-F-coupling */
weight = 0;
else weight = -8; /* F-F-coupling */
ierr = HYPRE_IJMatrixAddToValues (ijmatrix,1,&one,&m,&n,&weight);
#if 0
if (ierr) hypre_printf ("Processor %d: error %d while adding %lf to entry (%d, %d)\n",mpirank,ierr,weight,m,n);
#endif
}
}
}
}
/* assemble */
HYPRE_IJMatrixAssemble (ijmatrix);
/*if (num_recvs_strong) {*/
hypre_TFree (recv_procs_strong);
hypre_TFree (pointrange_strong);
hypre_TFree (vertexrange_strong);
/*} */
*ijG = ijmatrix;
return (ierr);
}
HYPRE_Int AmgCGCPrepare (hypre_ParCSRMatrix *S,HYPRE_Int nlocal,HYPRE_Int *CF_marker,HYPRE_Int **CF_marker_offd,HYPRE_Int coarsen_type,HYPRE_Int **vrange)
/* assemble a graph representing the connections between the grids
* ================================================================================================
* S : the strength matrix
* nlocal : the number of locally created coarse grids
* CF_marker, CF_marker_offd : the coare/fine markers
* coarsen_type : the coarsening type
* vrange : the ranges of the vertices representing coarse grids
* ================================================================================================*/
{
HYPRE_Int ierr=0;
HYPRE_Int mpisize,mpirank;
HYPRE_Int num_sends;
HYPRE_Int *vertexrange=NULL;
HYPRE_Int vstart,vend;
HYPRE_Int *int_buf_data;
HYPRE_Int start;
HYPRE_Int i,ii,j;
HYPRE_Int num_variables = hypre_CSRMatrixNumRows (hypre_ParCSRMatrixDiag(S));
HYPRE_Int num_cols_offd = hypre_CSRMatrixNumCols (hypre_ParCSRMatrixOffd (S));
MPI_Comm comm = hypre_ParCSRMatrixComm(S);
/* hypre_MPI_Status status; */
hypre_ParCSRCommPkg *comm_pkg = hypre_ParCSRMatrixCommPkg (S);
hypre_ParCSRCommHandle *comm_handle;
hypre_MPI_Comm_size (comm,&mpisize);
hypre_MPI_Comm_rank (comm,&mpirank);
if (!comm_pkg) {
hypre_MatvecCommPkgCreate (S);
comm_pkg = hypre_ParCSRMatrixCommPkg (S);
}
num_sends = hypre_ParCSRCommPkgNumSends (comm_pkg);
if (coarsen_type % 2 == 0) nlocal++; /* even coarsen_type means allow_emptygrids */
#ifdef HYPRE_NO_GLOBAL_PARTITION
{
HYPRE_Int scan_recv;
vertexrange = hypre_CTAlloc(HYPRE_Int,2);
hypre_MPI_Scan(&nlocal, &scan_recv, 1, HYPRE_MPI_INT, hypre_MPI_SUM, comm);
/* first point in my range */
vertexrange[0] = scan_recv - nlocal;
/* first point in next proc's range */
vertexrange[1] = scan_recv;
vstart = vertexrange[0];
vend = vertexrange[1];
}
#else
vertexrange = hypre_CTAlloc (HYPRE_Int,mpisize+1);
hypre_MPI_Allgather (&nlocal,1,HYPRE_MPI_INT,vertexrange+1,1,HYPRE_MPI_INT,comm);
vertexrange[0]=0;
for (i=2;i<=mpisize;i++) vertexrange[i]+=vertexrange[i-1];
vstart = vertexrange[mpirank];
vend = vertexrange[mpirank+1];
#endif
/* Note: vstart uses 0-based indexing, while CF_marker uses 1-based indexing */
if (coarsen_type % 2 == 1) { /* see above */
for (i=0;i<num_variables;i++)
if (CF_marker[i]>0)
CF_marker[i]+=vstart;
}
else {
/* hypre_printf ("processor %d: empty grid allowed\n",mpirank); */
for (i=0;i<num_variables;i++) {
if (CF_marker[i]>0)
CF_marker[i]+=vstart+1; /* add one because vertexrange[mpirank]+1 denotes the empty grid.
Hence, vertexrange[mpirank]+2 is the first coarse grid denoted in
global indices, ... */
}
}
/* exchange data */
*CF_marker_offd = hypre_CTAlloc (HYPRE_Int,num_cols_offd);
int_buf_data = hypre_CTAlloc (HYPRE_Int,hypre_ParCSRCommPkgSendMapStart (comm_pkg,num_sends));
for (i=0,ii=0;i<num_sends;i++) {
start = hypre_ParCSRCommPkgSendMapStart (comm_pkg,i);
for (j=start;j<hypre_ParCSRCommPkgSendMapStart (comm_pkg,i+1);j++)
int_buf_data [ii++] = CF_marker[hypre_ParCSRCommPkgSendMapElmt(comm_pkg,j)];
}
if (mpisize>1) {
comm_handle = hypre_ParCSRCommHandleCreate (11,comm_pkg,int_buf_data,*CF_marker_offd);
hypre_ParCSRCommHandleDestroy (comm_handle);
}
hypre_TFree (int_buf_data);
*vrange=vertexrange;
return (ierr);
}
/**************************************************************
*
* CGC Coarsening routine
*
**************************************************************/
HYPRE_Int
hypre_BoomerAMGCoarsenCGCb( hypre_ParCSRMatrix *S,
hypre_ParCSRMatrix *A,
HYPRE_Int measure_type,
HYPRE_Int coarsen_type,
HYPRE_Int cgc_its,
HYPRE_Int debug_flag,
HYPRE_Int **CF_marker_ptr)
{
MPI_Comm comm = hypre_ParCSRMatrixComm(S);
hypre_ParCSRCommPkg *comm_pkg = hypre_ParCSRMatrixCommPkg(S);
hypre_ParCSRCommHandle *comm_handle;
hypre_CSRMatrix *S_diag = hypre_ParCSRMatrixDiag(S);
hypre_CSRMatrix *S_offd = hypre_ParCSRMatrixOffd(S);
HYPRE_Int *S_i = hypre_CSRMatrixI(S_diag);
HYPRE_Int *S_j = hypre_CSRMatrixJ(S_diag);
HYPRE_Int *S_offd_i = hypre_CSRMatrixI(S_offd);
HYPRE_Int *S_offd_j;
HYPRE_Int num_variables = hypre_CSRMatrixNumRows(S_diag);
HYPRE_Int num_cols_offd = hypre_CSRMatrixNumCols(S_offd);
hypre_CSRMatrix *S_ext;
HYPRE_Int *S_ext_i;
HYPRE_Int *S_ext_j;
hypre_CSRMatrix *ST;
HYPRE_Int *ST_i;
HYPRE_Int *ST_j;
HYPRE_Int *CF_marker;
HYPRE_Int *CF_marker_offd=NULL;
HYPRE_Int ci_tilde = -1;
HYPRE_Int ci_tilde_mark = -1;
HYPRE_Int *measure_array;
HYPRE_Int *measure_array_master;
HYPRE_Int *graph_array;
HYPRE_Int *int_buf_data=NULL;
/*HYPRE_Int *ci_array=NULL;*/
HYPRE_Int i, j, k, l, jS;
HYPRE_Int ji, jj, index;
HYPRE_Int set_empty = 1;
HYPRE_Int C_i_nonempty = 0;
HYPRE_Int num_nonzeros;
HYPRE_Int num_procs, my_id;
HYPRE_Int num_sends = 0;
HYPRE_Int first_col, start;
HYPRE_Int col_0, col_n;
hypre_LinkList LoL_head;
hypre_LinkList LoL_tail;
HYPRE_Int *lists, *where;
HYPRE_Int measure, new_meas;
HYPRE_Int num_left;
HYPRE_Int nabor, nabor_two;
HYPRE_Int ierr = 0;
HYPRE_Int use_commpkg_A = 0;
HYPRE_Real wall_time;
HYPRE_Int measure_max; /* BM Aug 30, 2006: maximal measure, needed for CGC */
if (coarsen_type < 0) coarsen_type = -coarsen_type;
/*-------------------------------------------------------
* Initialize the C/F marker, LoL_head, LoL_tail arrays
*-------------------------------------------------------*/
LoL_head = NULL;
LoL_tail = NULL;
lists = hypre_CTAlloc(HYPRE_Int, num_variables);
where = hypre_CTAlloc(HYPRE_Int, num_variables);
#if 0 /* debugging */
char filename[256];
FILE *fp;
HYPRE_Int iter = 0;
#endif
/*--------------------------------------------------------------
* Compute a CSR strength matrix, S.
*
* For now, the "strength" of dependence/influence is defined in
* the following way: i depends on j if
* aij > hypre_max (k != i) aik, aii < 0
* or
* aij < hypre_min (k != i) aik, aii >= 0
* Then S_ij = 1, else S_ij = 0.
*
* NOTE: the entries are negative initially, corresponding
* to "unaccounted-for" dependence.
*----------------------------------------------------------------*/
if (debug_flag == 3) wall_time = time_getWallclockSeconds();
hypre_MPI_Comm_size(comm,&num_procs);
hypre_MPI_Comm_rank(comm,&my_id);
if (!comm_pkg)
{
use_commpkg_A = 1;
comm_pkg = hypre_ParCSRMatrixCommPkg(A);
}
if (!comm_pkg)
{
hypre_MatvecCommPkgCreate(A);
comm_pkg = hypre_ParCSRMatrixCommPkg(A);
}
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
if (num_cols_offd) S_offd_j = hypre_CSRMatrixJ(S_offd);
jS = S_i[num_variables];
ST = hypre_CSRMatrixCreate(num_variables, num_variables, jS);
ST_i = hypre_CTAlloc(HYPRE_Int,num_variables+1);
ST_j = hypre_CTAlloc(HYPRE_Int,jS);
hypre_CSRMatrixI(ST) = ST_i;
hypre_CSRMatrixJ(ST) = ST_j;
/*----------------------------------------------------------
* generate transpose of S, ST
*----------------------------------------------------------*/
for (i=0; i <= num_variables; i++)
ST_i[i] = 0;
for (i=0; i < jS; i++)
{
ST_i[S_j[i]+1]++;
}
for (i=0; i < num_variables; i++)
{
ST_i[i+1] += ST_i[i];
}
for (i=0; i < num_variables; i++)
{
for (j=S_i[i]; j < S_i[i+1]; j++)
{
index = S_j[j];
ST_j[ST_i[index]] = i;
ST_i[index]++;
}
}
for (i = num_variables; i > 0; i--)
{
ST_i[i] = ST_i[i-1];
}
ST_i[0] = 0;
/*----------------------------------------------------------
* Compute the measures
*
* The measures are given by the row sums of ST.
* Hence, measure_array[i] is the number of influences
* of variable i.
* correct actual measures through adding influences from
* neighbor processors
*----------------------------------------------------------*/
measure_array_master = hypre_CTAlloc(HYPRE_Int, num_variables);
measure_array = hypre_CTAlloc(HYPRE_Int, num_variables);
for (i = 0; i < num_variables; i++)
{
measure_array_master[i] = ST_i[i+1]-ST_i[i];
}
if ((measure_type || (coarsen_type != 1 && coarsen_type != 11))
&& num_procs > 1)
{
if (use_commpkg_A)
S_ext = hypre_ParCSRMatrixExtractBExt(S,A,0);
else
S_ext = hypre_ParCSRMatrixExtractBExt(S,S,0);
S_ext_i = hypre_CSRMatrixI(S_ext);
S_ext_j = hypre_CSRMatrixJ(S_ext);
num_nonzeros = S_ext_i[num_cols_offd];
first_col = hypre_ParCSRMatrixFirstColDiag(S);
col_0 = first_col-1;
col_n = col_0+num_variables;
if (measure_type)
{
for (i=0; i < num_nonzeros; i++)
{
index = S_ext_j[i] - first_col;
if (index > -1 && index < num_variables)
measure_array_master[index]++;
}
}
}
/*---------------------------------------------------
* Loop until all points are either fine or coarse.
*---------------------------------------------------*/
if (debug_flag == 3) wall_time = time_getWallclockSeconds();
/* first coarsening phase */
/*************************************************************
*
* Initialize the lists
*
*************************************************************/
CF_marker = hypre_CTAlloc(HYPRE_Int, num_variables);
num_left = 0;
for (j = 0; j < num_variables; j++)
{
if ((S_i[j+1]-S_i[j])== 0 &&
(S_offd_i[j+1]-S_offd_i[j]) == 0)
{
CF_marker[j] = SF_PT;
measure_array_master[j] = 0;
}
else
{
CF_marker[j] = UNDECIDED;
/* num_left++; */ /* BM May 19, 2006: see below*/
}
}
if (coarsen_type==22) {
/* BM Sep 8, 2006: allow_emptygrids only if the following holds for all points j:
(a) the point has no strong connections at all, OR
(b) the point has a strong connection across a boundary */
for (j=0;j<num_variables;j++)
if (S_i[j+1]>S_i[j] && S_offd_i[j+1] == S_offd_i[j]) {coarsen_type=21;break;}
}
for (l = 1; l <= cgc_its; l++)
{
LoL_head = NULL;
LoL_tail = NULL;
num_left = 0; /* compute num_left before each RS coarsening loop */
memcpy (measure_array,measure_array_master,num_variables*sizeof(HYPRE_Int));
memset (lists,0,sizeof(HYPRE_Int)*num_variables);
memset (where,0,sizeof(HYPRE_Int)*num_variables);
for (j = 0; j < num_variables; j++)
{
measure = measure_array[j];
if (CF_marker[j] != SF_PT)
{
if (measure > 0)
{
enter_on_lists(&LoL_head, &LoL_tail, measure, j, lists, where);
num_left++; /* compute num_left before each RS coarsening loop */
}
else if (CF_marker[j] == 0) /* increase weight of strongly coupled neighbors only
if j is not conained in a previously constructed coarse grid.
Reason: these neighbors should start with the same initial weight
in each CGC iteration. BM Aug 30, 2006 */
{
if (measure < 0) hypre_printf("negative measure!\n");
/* CF_marker[j] = f_pnt; */
for (k = S_i[j]; k < S_i[j+1]; k++)
{
nabor = S_j[k];
/* if (CF_marker[nabor] != SF_PT) */
if (CF_marker[nabor] == 0) /* BM Aug 30, 2006: don't alter weights of points
contained in other candidate coarse grids */
{
if (nabor < j)
{
new_meas = measure_array[nabor];
if (new_meas > 0)
remove_point(&LoL_head, &LoL_tail, new_meas,
nabor, lists, where);
else num_left++; /* BM Aug 29, 2006 */
new_meas = ++(measure_array[nabor]);
enter_on_lists(&LoL_head, &LoL_tail, new_meas,
nabor, lists, where);
}
else
{
new_meas = ++(measure_array[nabor]);
}
}
}
/* --num_left; */ /* BM May 19, 2006 */
}
}
}
/* BM Aug 30, 2006: first iteration: determine maximal weight */
if (num_left && l==1) measure_max = measure_array[LoL_head->head];
/* BM Aug 30, 2006: break CGC iteration if no suitable
starting point is available any more */
if (!num_left || measure_array[LoL_head->head]<measure_max) {
while (LoL_head) {
hypre_LinkList list_ptr = LoL_head;
LoL_head = LoL_head->next_elt;
dispose_elt (list_ptr);
}
break;
}
/****************************************************************
*
* Main loop of Ruge-Stueben first coloring pass.
*
* WHILE there are still points to classify DO:
* 1) find first point, i, on list with max_measure
* make i a C-point, remove it from the lists
* 2) For each point, j, in S_i^T,
* a) Set j to be an F-point
* b) For each point, k, in S_j
* move k to the list in LoL with measure one
* greater than it occupies (creating new LoL
* entry if necessary)
* 3) For each point, j, in S_i,
* move j to the list in LoL with measure one
* smaller than it occupies (creating new LoL
* entry if necessary)
*
****************************************************************/
while (num_left > 0)
{
index = LoL_head -> head;
/* index = LoL_head -> tail; */
/* CF_marker[index] = C_PT; */
CF_marker[index] = l; /* BM Aug 18, 2006 */
measure = measure_array[index];
measure_array[index] = 0;
measure_array_master[index] = 0; /* BM May 19: for CGC */
--num_left;
remove_point(&LoL_head, &LoL_tail, measure, index, lists, where);
for (j = ST_i[index]; j < ST_i[index+1]; j++)
{
nabor = ST_j[j];
/* if (CF_marker[nabor] == UNDECIDED) */
if (measure_array[nabor]>0) /* undecided point */
{
/* CF_marker[nabor] = F_PT; */ /* BM Aug 18, 2006 */
measure = measure_array[nabor];
measure_array[nabor]=0;
remove_point(&LoL_head, &LoL_tail, measure, nabor, lists, where);
--num_left;
for (k = S_i[nabor]; k < S_i[nabor+1]; k++)
{
nabor_two = S_j[k];
/* if (CF_marker[nabor_two] == UNDECIDED) */
if (measure_array[nabor_two]>0) /* undecided point */
{
measure = measure_array[nabor_two];
remove_point(&LoL_head, &LoL_tail, measure,
nabor_two, lists, where);
new_meas = ++(measure_array[nabor_two]);
enter_on_lists(&LoL_head, &LoL_tail, new_meas,
nabor_two, lists, where);
}
}
}
}
for (j = S_i[index]; j < S_i[index+1]; j++)
{
nabor = S_j[j];
/* if (CF_marker[nabor] == UNDECIDED) */
if (measure_array[nabor]>0) /* undecided point */
{
measure = measure_array[nabor];
remove_point(&LoL_head, &LoL_tail, measure, nabor, lists, where);
measure_array[nabor] = --measure;
if (measure > 0)
enter_on_lists(&LoL_head, &LoL_tail, measure, nabor,
lists, where);
else
{
/* CF_marker[nabor] = F_PT; */ /* BM Aug 18, 2006 */
--num_left;
for (k = S_i[nabor]; k < S_i[nabor+1]; k++)
{
nabor_two = S_j[k];
/* if (CF_marker[nabor_two] == UNDECIDED) */
if (measure_array[nabor_two]>0)
{
new_meas = measure_array[nabor_two];
remove_point(&LoL_head, &LoL_tail, new_meas,
nabor_two, lists, where);
new_meas = ++(measure_array[nabor_two]);
enter_on_lists(&LoL_head, &LoL_tail, new_meas,
nabor_two, lists, where);
}
}
}
}
}
}
if (LoL_head) hypre_printf ("Linked list not empty! head: %d\n",LoL_head->head);
}
l--; /* BM Aug 15, 2006 */
hypre_TFree(measure_array);
hypre_TFree(measure_array_master);
hypre_CSRMatrixDestroy(ST);
if (debug_flag == 3)
{
wall_time = time_getWallclockSeconds() - wall_time;
hypre_printf("Proc = %d Coarsen 1st pass = %f\n",
my_id, wall_time);
}
hypre_TFree(lists);
hypre_TFree(where);
if (num_procs>1) {
if (debug_flag == 3) wall_time = time_getWallclockSeconds();
hypre_BoomerAMGCoarsenCGC (S,l,coarsen_type,CF_marker);
if (debug_flag == 3) {
wall_time = time_getWallclockSeconds() - wall_time;
hypre_printf("Proc = %d Coarsen CGC = %f\n",
my_id, wall_time);
}
}
else {
/* the first candiate coarse grid is the coarse grid */
for (j=0;j<num_variables;j++) {
if (CF_marker[j]==1) CF_marker[j]=C_PT;
else CF_marker[j]=F_PT;
}
}
/* BM May 19, 2006:
Set all undecided points to be fine grid points. */
for (j=0;j<num_variables;j++)
if (!CF_marker[j]) CF_marker[j]=F_PT;
/*---------------------------------------------------
* Initialize the graph array
*---------------------------------------------------*/
graph_array = hypre_CTAlloc(HYPRE_Int, num_variables);
for (i = 0; i < num_variables; i++)
{
graph_array[i] = -1;
}
if (debug_flag == 3) wall_time = time_getWallclockSeconds();
for (i=0; i < num_variables; i++)
{
if (ci_tilde_mark != i) ci_tilde = -1;
if (CF_marker[i] == -1)
{
for (ji = S_i[i]; ji < S_i[i+1]; ji++)
{
j = S_j[ji];
if (CF_marker[j] > 0)
graph_array[j] = i;
}
for (ji = S_i[i]; ji < S_i[i+1]; ji++)
{
j = S_j[ji];
if (CF_marker[j] == -1)
{
set_empty = 1;
for (jj = S_i[j]; jj < S_i[j+1]; jj++)
{
index = S_j[jj];
if (graph_array[index] == i)
{
set_empty = 0;
break;
}
}
if (set_empty)
{
if (C_i_nonempty)
{
CF_marker[i] = 1;
if (ci_tilde > -1)
{
CF_marker[ci_tilde] = -1;
ci_tilde = -1;
}
C_i_nonempty = 0;
break;
}
else
{
ci_tilde = j;
ci_tilde_mark = i;
CF_marker[j] = 1;
C_i_nonempty = 1;
i--;
break;
}
}
}
}
}
}
if (debug_flag == 3 && coarsen_type != 2)
{
wall_time = time_getWallclockSeconds() - wall_time;
hypre_printf("Proc = %d Coarsen 2nd pass = %f\n",
my_id, wall_time);
}
/* third pass, check boundary fine points for coarse neighbors */
/*------------------------------------------------
* Exchange boundary data for CF_marker
*------------------------------------------------*/
if (debug_flag == 3) wall_time = time_getWallclockSeconds();
CF_marker_offd = hypre_CTAlloc(HYPRE_Int, num_cols_offd);
int_buf_data = hypre_CTAlloc(HYPRE_Int, hypre_ParCSRCommPkgSendMapStart(comm_pkg,
num_sends));
index = 0;
for (i = 0; i < num_sends; i++)
{
start = hypre_ParCSRCommPkgSendMapStart(comm_pkg, i);
for (j = start; j < hypre_ParCSRCommPkgSendMapStart(comm_pkg, i+1); j++)
int_buf_data[index++]
= CF_marker[hypre_ParCSRCommPkgSendMapElmt(comm_pkg,j)];
}
if (num_procs > 1)
{
comm_handle = hypre_ParCSRCommHandleCreate(11, comm_pkg, int_buf_data,
CF_marker_offd);
hypre_ParCSRCommHandleDestroy(comm_handle);
}
AmgCGCBoundaryFix (S,CF_marker,CF_marker_offd);
if (debug_flag == 3)
{
wall_time = time_getWallclockSeconds() - wall_time;
hypre_printf("Proc = %d CGC boundary fix = %f\n",
my_id, wall_time);
}
/*---------------------------------------------------
* Clean up and return
*---------------------------------------------------*/
/*if (coarsen_type != 1)
{ */
if (CF_marker_offd) hypre_TFree(CF_marker_offd); /* BM Aug 21, 2006 */
if (int_buf_data) hypre_TFree(int_buf_data); /* BM Aug 21, 2006 */
/*if (ci_array) hypre_TFree(ci_array);*/ /* BM Aug 21, 2006 */
/*} */
hypre_TFree(graph_array);
if ((measure_type || (coarsen_type != 1 && coarsen_type != 11))
&& num_procs > 1)
hypre_CSRMatrixDestroy(S_ext);
*CF_marker_ptr = CF_marker;
return (ierr);
}
HYPRE_Int
hypre_GenerateSendMapAndCommPkg(MPI_Comm comm, HYPRE_Int num_sends, HYPRE_Int num_recvs,
HYPRE_Int *recv_procs, HYPRE_Int *send_procs,
HYPRE_Int *recv_vec_starts, hypre_ParCSRMatrix *A)
{
HYPRE_Int *send_map_starts;
HYPRE_Int *send_map_elmts;
HYPRE_Int i, j;
HYPRE_Int num_requests = num_sends+num_recvs;
hypre_MPI_Request *requests;
hypre_MPI_Status *status;
HYPRE_Int vec_len, vec_start;
hypre_ParCSRCommPkg *comm_pkg;
HYPRE_Int *col_map_offd = hypre_ParCSRMatrixColMapOffd(A);
HYPRE_Int first_col_diag = hypre_ParCSRMatrixFirstColDiag(A);
/*--------------------------------------------------------------------------
* generate send_map_starts and send_map_elmts
*--------------------------------------------------------------------------*/
requests = hypre_CTAlloc(hypre_MPI_Request,num_requests);
status = hypre_CTAlloc(hypre_MPI_Status,num_requests);
send_map_starts = hypre_CTAlloc(HYPRE_Int, num_sends+1);
j = 0;
for (i=0; i < num_sends; i++)
hypre_MPI_Irecv(&send_map_starts[i+1],1,HYPRE_MPI_INT,send_procs[i],0,comm,
&requests[j++]);
for (i=0; i < num_recvs; i++)
{
vec_len = recv_vec_starts[i+1] - recv_vec_starts[i];
hypre_MPI_Isend(&vec_len,1,HYPRE_MPI_INT, recv_procs[i],0,comm,&requests[j++]);
}
hypre_MPI_Waitall(j,requests,status);
send_map_starts[0] = 0;
for (i=0; i < num_sends; i++)
send_map_starts[i+1] += send_map_starts[i];
send_map_elmts = hypre_CTAlloc(HYPRE_Int,send_map_starts[num_sends]);
j = 0;
for (i=0; i < num_sends; i++)
{
vec_start = send_map_starts[i];
vec_len = send_map_starts[i+1]-vec_start;
hypre_MPI_Irecv(&send_map_elmts[vec_start],vec_len,HYPRE_MPI_INT,
send_procs[i],0,comm,&requests[j++]);
}
for (i=0; i < num_recvs; i++)
{
vec_start = recv_vec_starts[i];
vec_len = recv_vec_starts[i+1] - vec_start;
hypre_MPI_Isend(&col_map_offd[vec_start],vec_len,HYPRE_MPI_INT,
recv_procs[i],0,comm,&requests[j++]);
}
hypre_MPI_Waitall(j,requests,status);
for (i=0; i < send_map_starts[num_sends]; i++)
send_map_elmts[i] -= first_col_diag;
comm_pkg = hypre_CTAlloc(hypre_ParCSRCommPkg,1);
hypre_ParCSRCommPkgComm(comm_pkg) = comm;
hypre_ParCSRCommPkgNumSends(comm_pkg) = num_sends;
hypre_ParCSRCommPkgNumRecvs(comm_pkg) = num_recvs;
hypre_ParCSRCommPkgSendProcs(comm_pkg) = send_procs;
hypre_ParCSRCommPkgRecvProcs(comm_pkg) = recv_procs;
hypre_ParCSRCommPkgRecvVecStarts(comm_pkg) = recv_vec_starts;
hypre_ParCSRCommPkgSendMapStarts(comm_pkg) = send_map_starts;
hypre_ParCSRCommPkgSendMapElmts(comm_pkg) = send_map_elmts;
hypre_TFree(status);
hypre_TFree(requests);
hypre_ParCSRMatrixCommPkg(A) = comm_pkg;
return 0;
}
HYPRE_Int
hypre_BoomerAMGCreateScalarCFS(hypre_ParCSRMatrix *SN,
HYPRE_Int *CFN_marker,
HYPRE_Int *col_offd_SN_to_AN,
HYPRE_Int num_functions,
HYPRE_Int nodal,
HYPRE_Int data,
HYPRE_Int **dof_func_ptr,
HYPRE_Int **CF_marker_ptr,
HYPRE_Int **col_offd_S_to_A_ptr,
hypre_ParCSRMatrix **S_ptr)
{
MPI_Comm comm = hypre_ParCSRMatrixComm(SN);
hypre_ParCSRMatrix *S;
hypre_CSRMatrix *S_diag;
HYPRE_Int *S_diag_i;
HYPRE_Int *S_diag_j;
double *S_diag_data;
hypre_CSRMatrix *S_offd;
HYPRE_Int *S_offd_i;
HYPRE_Int *S_offd_j;
double *S_offd_data;
HYPRE_Int *row_starts_S;
HYPRE_Int *col_starts_S;
HYPRE_Int *row_starts_SN = hypre_ParCSRMatrixRowStarts(SN);
HYPRE_Int *col_starts_SN = hypre_ParCSRMatrixColStarts(SN);
hypre_CSRMatrix *SN_diag = hypre_ParCSRMatrixDiag(SN);
HYPRE_Int *SN_diag_i = hypre_CSRMatrixI(SN_diag);
HYPRE_Int *SN_diag_j = hypre_CSRMatrixJ(SN_diag);
double *SN_diag_data;
hypre_CSRMatrix *SN_offd = hypre_ParCSRMatrixOffd(SN);
HYPRE_Int *SN_offd_i = hypre_CSRMatrixI(SN_offd);
HYPRE_Int *SN_offd_j = hypre_CSRMatrixJ(SN_offd);
double *SN_offd_data;
HYPRE_Int *CF_marker;
HYPRE_Int *col_map_offd_SN = hypre_ParCSRMatrixColMapOffd(SN);
HYPRE_Int *col_map_offd_S;
HYPRE_Int *dof_func;
HYPRE_Int num_nodes = hypre_CSRMatrixNumRows(SN_diag);
HYPRE_Int num_variables;
hypre_ParCSRCommPkg *comm_pkg = hypre_ParCSRMatrixCommPkg(SN);
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_S;
HYPRE_Int *send_procs_S;
HYPRE_Int *send_map_starts_S;
HYPRE_Int *send_map_elmts_S;
HYPRE_Int *recv_procs_S;
HYPRE_Int *recv_vec_starts_S;
HYPRE_Int *col_offd_S_to_A = NULL;
HYPRE_Int num_coarse_nodes;
HYPRE_Int i,j,k,k1,jj,cnt;
HYPRE_Int row, start, end;
HYPRE_Int num_procs;
HYPRE_Int num_cols_offd_SN = hypre_CSRMatrixNumCols(SN_offd);
HYPRE_Int num_cols_offd_S;
HYPRE_Int SN_num_nonzeros_diag;
HYPRE_Int SN_num_nonzeros_offd;
HYPRE_Int S_num_nonzeros_diag;
HYPRE_Int S_num_nonzeros_offd;
HYPRE_Int global_num_vars;
HYPRE_Int global_num_cols;
HYPRE_Int global_num_nodes;
HYPRE_Int ierr = 0;
hypre_MPI_Comm_size(comm, &num_procs);
num_variables = num_functions*num_nodes;
CF_marker = hypre_CTAlloc(HYPRE_Int, num_variables);
if (nodal < 0)
{
cnt = 0;
num_coarse_nodes = 0;
for (i=0; i < num_nodes; i++)
{
if (CFN_marker[i] == 1) num_coarse_nodes++;
for (j=0; j < num_functions; j++)
CF_marker[cnt++] = CFN_marker[i];
}
dof_func = hypre_CTAlloc(HYPRE_Int,num_coarse_nodes*num_functions);
cnt = 0;
for (i=0; i < num_nodes; i++)
{
if (CFN_marker[i] == 1)
{
for (k=0; k < num_functions; k++)
dof_func[cnt++] = k;
}
}
*dof_func_ptr = dof_func;
}
else
{
cnt = 0;
for (i=0; i < num_nodes; i++)
for (j=0; j < num_functions; j++)
CF_marker[cnt++] = CFN_marker[i];
}
*CF_marker_ptr = CF_marker;
#ifdef HYPRE_NO_GLOBAL_PARTITION
row_starts_S = hypre_CTAlloc(HYPRE_Int,2);
for (i=0; i < 2; i++)
row_starts_S[i] = num_functions*row_starts_SN[i];
if (row_starts_SN != col_starts_SN)
{
col_starts_S = hypre_CTAlloc(HYPRE_Int,2);
for (i=0; i < 2; i++)
col_starts_S[i] = num_functions*col_starts_SN[i];
}
else
{
col_starts_S = row_starts_S;
}
#else
row_starts_S = hypre_CTAlloc(HYPRE_Int,num_procs+1);
for (i=0; i < num_procs+1; i++)
row_starts_S[i] = num_functions*row_starts_SN[i];
if (row_starts_SN != col_starts_SN)
{
col_starts_S = hypre_CTAlloc(HYPRE_Int,num_procs+1);
for (i=0; i < num_procs+1; i++)
col_starts_S[i] = num_functions*col_starts_SN[i];
}
else
{
col_starts_S = row_starts_S;
}
#endif
SN_num_nonzeros_diag = SN_diag_i[num_nodes];
SN_num_nonzeros_offd = SN_offd_i[num_nodes];
global_num_nodes = hypre_ParCSRMatrixGlobalNumRows(SN);
global_num_cols = hypre_ParCSRMatrixGlobalNumCols(SN)*num_functions;
global_num_vars = global_num_nodes*num_functions;
S_num_nonzeros_diag = num_functions*SN_num_nonzeros_diag;
S_num_nonzeros_offd = num_functions*SN_num_nonzeros_offd;
num_cols_offd_S = num_functions*num_cols_offd_SN;
S = hypre_ParCSRMatrixCreate(comm, global_num_vars, global_num_cols,
row_starts_S, col_starts_S, num_cols_offd_S,
S_num_nonzeros_diag, S_num_nonzeros_offd);
S_diag = hypre_ParCSRMatrixDiag(S);
S_offd = hypre_ParCSRMatrixOffd(S);
S_diag_i = hypre_CTAlloc(HYPRE_Int, num_variables+1);
S_offd_i = hypre_CTAlloc(HYPRE_Int, num_variables+1);
S_diag_j = hypre_CTAlloc(HYPRE_Int, S_num_nonzeros_diag);
hypre_CSRMatrixI(S_diag) = S_diag_i;
hypre_CSRMatrixJ(S_diag) = S_diag_j;
if (data)
{
SN_diag_data = hypre_CSRMatrixData(SN_diag);
S_diag_data = hypre_CTAlloc(double, S_num_nonzeros_diag);
hypre_CSRMatrixData(S_diag) = S_diag_data;
if (num_cols_offd_S)
{
SN_offd_data = hypre_CSRMatrixData(SN_offd);
S_offd_data = hypre_CTAlloc(double, S_num_nonzeros_offd);
hypre_CSRMatrixData(S_offd) = S_offd_data;
}
}
hypre_CSRMatrixI(S_offd) = S_offd_i;
if (comm_pkg)
{
comm_pkg_S = hypre_CTAlloc(hypre_ParCSRCommPkg,1);
hypre_ParCSRCommPkgComm(comm_pkg_S) = comm;
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
hypre_ParCSRCommPkgNumSends(comm_pkg_S) = num_sends;
num_recvs = hypre_ParCSRCommPkgNumRecvs(comm_pkg);
hypre_ParCSRCommPkgNumRecvs(comm_pkg_S) = num_recvs;
send_procs = hypre_ParCSRCommPkgSendProcs(comm_pkg);
send_map_starts = hypre_ParCSRCommPkgSendMapStarts(comm_pkg);
send_map_elmts = hypre_ParCSRCommPkgSendMapElmts(comm_pkg);
recv_procs = hypre_ParCSRCommPkgRecvProcs(comm_pkg);
recv_vec_starts = hypre_ParCSRCommPkgRecvVecStarts(comm_pkg);
send_procs_S = NULL;
send_map_elmts_S = NULL;
if (num_sends)
{
send_procs_S = hypre_CTAlloc(HYPRE_Int,num_sends);
send_map_elmts_S = hypre_CTAlloc(HYPRE_Int,
num_functions*send_map_starts[num_sends]);
}
send_map_starts_S = hypre_CTAlloc(HYPRE_Int,num_sends+1);
recv_vec_starts_S = hypre_CTAlloc(HYPRE_Int,num_recvs+1);
recv_procs_S = NULL;
if (num_recvs) recv_procs_S = hypre_CTAlloc(HYPRE_Int,num_recvs);
send_map_starts_S[0] = 0;
for (i=0; i < num_sends; i++)
{
send_procs_S[i] = send_procs[i];
send_map_starts_S[i+1] = num_functions*send_map_starts[i+1];
}
recv_vec_starts_S[0] = 0;
for (i=0; i < num_recvs; i++)
{
recv_procs_S[i] = recv_procs[i];
recv_vec_starts_S[i+1] = num_functions*recv_vec_starts[i+1];
}
cnt = 0;
for (i=0; i < send_map_starts[num_sends]; i++)
{
k1 = num_functions*send_map_elmts[i];
for (j=0; j < num_functions; j++)
{
send_map_elmts_S[cnt++] = k1+j;
}
}
hypre_ParCSRCommPkgSendProcs(comm_pkg_S) = send_procs_S;
hypre_ParCSRCommPkgSendMapStarts(comm_pkg_S) = send_map_starts_S;
hypre_ParCSRCommPkgSendMapElmts(comm_pkg_S) = send_map_elmts_S;
hypre_ParCSRCommPkgRecvProcs(comm_pkg_S) = recv_procs_S;
hypre_ParCSRCommPkgRecvVecStarts(comm_pkg_S) = recv_vec_starts_S;
hypre_ParCSRMatrixCommPkg(S) = comm_pkg_S;
}
if (num_cols_offd_S)
{
S_offd_j = hypre_CTAlloc(HYPRE_Int, S_num_nonzeros_offd);
hypre_CSRMatrixJ(S_offd) = S_offd_j;
col_map_offd_S = hypre_CTAlloc(HYPRE_Int, num_cols_offd_S);
cnt = 0;
for (i=0; i < num_cols_offd_SN; i++)
{
k1 = col_map_offd_SN[i]*num_functions;
for (j=0; j < num_functions; j++)
col_map_offd_S[cnt++] = k1+j;
}
hypre_ParCSRMatrixColMapOffd(S) = col_map_offd_S;
}
if (col_offd_SN_to_AN)
{
col_offd_S_to_A = hypre_CTAlloc(HYPRE_Int, num_cols_offd_S);
cnt = 0;
for (i=0; i < num_cols_offd_SN; i++)
{
k1 = col_offd_SN_to_AN[i]*num_functions;
for (j=0; j < num_functions; j++)
col_offd_S_to_A[cnt++] = k1+j;
}
*col_offd_S_to_A_ptr = col_offd_S_to_A;
}
cnt = 0;
row = 0;
for (i=0; i < num_nodes; i++)
{
row++;
start = cnt;
for (j=SN_diag_i[i]; j < SN_diag_i[i+1]; j++)
{
jj = SN_diag_j[j];
if (data) S_diag_data[cnt] = SN_diag_data[j];
S_diag_j[cnt++] = jj*num_functions;
}
end = cnt;
S_diag_i[row] = cnt;
for (k1=1; k1 < num_functions; k1++)
{
row++;
for (k=start; k < end; k++)
{
if (data) S_diag_data[cnt] = S_diag_data[k];
S_diag_j[cnt++] = S_diag_j[k]+k1;
}
S_diag_i[row] = cnt;
}
}
cnt = 0;
row = 0;
for (i=0; i < num_nodes; i++)
{
row++;
start = cnt;
for (j=SN_offd_i[i]; j < SN_offd_i[i+1]; j++)
{
jj = SN_offd_j[j];
if (data) S_offd_data[cnt] = SN_offd_data[j];
S_offd_j[cnt++] = jj*num_functions;
}
end = cnt;
S_offd_i[row] = cnt;
for (k1=1; k1 < num_functions; k1++)
{
row++;
for (k=start; k < end; k++)
{
if (data) S_offd_data[cnt] = S_offd_data[k];
S_offd_j[cnt++] = S_offd_j[k]+k1;
}
S_offd_i[row] = cnt;
}
}
*S_ptr = S;
return (ierr);
}
/*--------------------------------------------------------------------------
* hypre_ParCSRMatrixMatvec_FF
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_ParCSRMatrixMatvec_FF( HYPRE_Complex alpha,
hypre_ParCSRMatrix *A,
hypre_ParVector *x,
HYPRE_Complex beta,
hypre_ParVector *y,
HYPRE_Int *CF_marker,
HYPRE_Int fpt )
{
MPI_Comm comm = hypre_ParCSRMatrixComm(A);
hypre_ParCSRCommHandle *comm_handle;
hypre_ParCSRCommPkg *comm_pkg = hypre_ParCSRMatrixCommPkg(A);
hypre_CSRMatrix *diag = hypre_ParCSRMatrixDiag(A);
hypre_CSRMatrix *offd = hypre_ParCSRMatrixOffd(A);
hypre_Vector *x_local = hypre_ParVectorLocalVector(x);
hypre_Vector *y_local = hypre_ParVectorLocalVector(y);
HYPRE_Int num_rows = hypre_ParCSRMatrixGlobalNumRows(A);
HYPRE_Int num_cols = hypre_ParCSRMatrixGlobalNumCols(A);
hypre_Vector *x_tmp;
HYPRE_Int x_size = hypre_ParVectorGlobalSize(x);
HYPRE_Int y_size = hypre_ParVectorGlobalSize(y);
HYPRE_Int num_cols_offd = hypre_CSRMatrixNumCols(offd);
HYPRE_Int ierr = 0;
HYPRE_Int num_sends, i, j, index, start, num_procs;
HYPRE_Int *int_buf_data = NULL;
HYPRE_Int *CF_marker_offd = NULL;
HYPRE_Complex *x_tmp_data = NULL;
HYPRE_Complex *x_buf_data = NULL;
HYPRE_Complex *x_local_data = hypre_VectorData(x_local);
/*---------------------------------------------------------------------
* Check for size compatibility. ParMatvec returns ierr = 11 if
* length of X doesn't equal the number of columns of A,
* ierr = 12 if the length of Y doesn't equal the number of rows
* of A, and ierr = 13 if both are true.
*
* Because temporary vectors are often used in ParMatvec, none of
* these conditions terminates processing, and the ierr flag
* is informational only.
*--------------------------------------------------------------------*/
hypre_MPI_Comm_size(comm,&num_procs);
if (num_cols != x_size)
ierr = 11;
if (num_rows != y_size)
ierr = 12;
if (num_cols != x_size && num_rows != y_size)
ierr = 13;
if (num_procs > 1)
{
if (num_cols_offd)
{
x_tmp = hypre_SeqVectorCreate( num_cols_offd );
hypre_SeqVectorInitialize(x_tmp);
x_tmp_data = hypre_VectorData(x_tmp);
}
/*---------------------------------------------------------------------
* If there exists no CommPkg for A, a CommPkg is generated using
* equally load balanced partitionings
*--------------------------------------------------------------------*/
if (!comm_pkg)
{
hypre_MatvecCommPkgCreate(A);
comm_pkg = hypre_ParCSRMatrixCommPkg(A);
}
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
if (num_sends)
x_buf_data = hypre_CTAlloc(HYPRE_Complex, hypre_ParCSRCommPkgSendMapStart
(comm_pkg, num_sends));
index = 0;
for (i = 0; i < num_sends; i++)
{
start = hypre_ParCSRCommPkgSendMapStart(comm_pkg, i);
for (j = start; j < hypre_ParCSRCommPkgSendMapStart(comm_pkg, i+1); j++)
x_buf_data[index++]
= x_local_data[hypre_ParCSRCommPkgSendMapElmt(comm_pkg,j)];
}
comm_handle =
hypre_ParCSRCommHandleCreate ( 1, comm_pkg, x_buf_data, x_tmp_data );
}
hypre_CSRMatrixMatvec_FF( alpha, diag, x_local, beta, y_local, CF_marker,
CF_marker, fpt);
if (num_procs > 1)
{
hypre_ParCSRCommHandleDestroy(comm_handle);
comm_handle = NULL;
if (num_sends)
int_buf_data = hypre_CTAlloc(HYPRE_Int, hypre_ParCSRCommPkgSendMapStart
(comm_pkg, num_sends));
if (num_cols_offd) CF_marker_offd = hypre_CTAlloc(HYPRE_Int, num_cols_offd);
index = 0;
for (i = 0; i < num_sends; i++)
{
start = hypre_ParCSRCommPkgSendMapStart(comm_pkg, i);
for (j = start; j < hypre_ParCSRCommPkgSendMapStart(comm_pkg, i+1); j++)
int_buf_data[index++]
= CF_marker[hypre_ParCSRCommPkgSendMapElmt(comm_pkg,j)];
}
comm_handle =
hypre_ParCSRCommHandleCreate(11,comm_pkg,int_buf_data,CF_marker_offd );
hypre_ParCSRCommHandleDestroy(comm_handle);
comm_handle = NULL;
if (num_cols_offd) hypre_CSRMatrixMatvec_FF( alpha, offd, x_tmp, 1.0, y_local,
CF_marker, CF_marker_offd, fpt);
hypre_SeqVectorDestroy(x_tmp);
x_tmp = NULL;
hypre_TFree(x_buf_data);
hypre_TFree(int_buf_data);
hypre_TFree(CF_marker_offd);
}
return ierr;
}
void hypre_ParCSRMatrixSplit(hypre_ParCSRMatrix *A,
HYPRE_Int nr, HYPRE_Int nc,
hypre_ParCSRMatrix **blocks,
int interleaved_rows, int interleaved_cols)
{
HYPRE_Int i, j, k;
MPI_Comm comm = hypre_ParCSRMatrixComm(A);
hypre_CSRMatrix *Adiag = hypre_ParCSRMatrixDiag(A);
hypre_CSRMatrix *Aoffd = hypre_ParCSRMatrixOffd(A);
HYPRE_Int global_rows = hypre_ParCSRMatrixGlobalNumRows(A);
HYPRE_Int global_cols = hypre_ParCSRMatrixGlobalNumCols(A);
HYPRE_Int local_rows = hypre_CSRMatrixNumRows(Adiag);
HYPRE_Int local_cols = hypre_CSRMatrixNumCols(Adiag);
HYPRE_Int offd_cols = hypre_CSRMatrixNumCols(Aoffd);
hypre_assert(local_rows % nr == 0 && local_cols % nc == 0);
hypre_assert(global_rows % nr == 0 && global_cols % nc == 0);
HYPRE_Int block_rows = local_rows / nr;
HYPRE_Int block_cols = local_cols / nc;
HYPRE_Int num_blocks = nr * nc;
/* mark local rows and columns with block number */
HYPRE_Int *row_block_num = hypre_TAlloc(HYPRE_Int, local_rows);
HYPRE_Int *col_block_num = hypre_TAlloc(HYPRE_Int, local_cols);
for (i = 0; i < local_rows; i++)
{
row_block_num[i] = interleaved_rows ? (i % nr) : (i / block_rows);
}
for (i = 0; i < local_cols; i++)
{
col_block_num[i] = interleaved_cols ? (i % nc) : (i / block_cols);
}
/* determine the block numbers for offd columns */
HYPRE_Int* offd_col_block_num = hypre_TAlloc(HYPRE_Int, offd_cols);
hypre_ParCSRCommHandle *comm_handle;
HYPRE_Int *int_buf_data;
{
/* make sure A has a communication package */
hypre_ParCSRCommPkg *comm_pkg = hypre_ParCSRMatrixCommPkg(A);
if (!comm_pkg)
{
hypre_MatvecCommPkgCreate(A);
comm_pkg = hypre_ParCSRMatrixCommPkg(A);
}
/* calculate the final global column numbers for each block */
HYPRE_Int *count = hypre_CTAlloc(HYPRE_Int, nc);
HYPRE_Int *block_global_col = hypre_TAlloc(HYPRE_Int, local_cols);
HYPRE_Int first_col = hypre_ParCSRMatrixFirstColDiag(A) / nc;
for (i = 0; i < local_cols; i++)
{
block_global_col[i] = first_col + count[col_block_num[i]]++;
}
hypre_TFree(count);
/* use a Matvec communication pattern to determine offd_col_block_num */
HYPRE_Int num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
int_buf_data = hypre_CTAlloc(HYPRE_Int,
hypre_ParCSRCommPkgSendMapStart(comm_pkg,
num_sends));
HYPRE_Int start, index = 0;
for (i = 0; i < num_sends; i++)
{
start = hypre_ParCSRCommPkgSendMapStart(comm_pkg, i);
for (j = start; j < hypre_ParCSRCommPkgSendMapStart(comm_pkg, i+1); j++)
{
k = hypre_ParCSRCommPkgSendMapElmt(comm_pkg, j);
int_buf_data[index++] = col_block_num[k] + nc*block_global_col[k];
}
}
hypre_TFree(block_global_col);
comm_handle = hypre_ParCSRCommHandleCreate(11, comm_pkg, int_buf_data,
offd_col_block_num);
}
/* create the block matrices */
HYPRE_Int num_procs = 1;
if (!hypre_ParCSRMatrixAssumedPartition(A))
{
hypre_MPI_Comm_size(comm, &num_procs);
}
HYPRE_Int *row_starts = hypre_TAlloc(HYPRE_Int, num_procs+1);
HYPRE_Int *col_starts = hypre_TAlloc(HYPRE_Int, num_procs+1);
for (i = 0; i <= num_procs; i++)
{
row_starts[i] = hypre_ParCSRMatrixRowStarts(A)[i] / nr;
col_starts[i] = hypre_ParCSRMatrixColStarts(A)[i] / nc;
}
for (i = 0; i < num_blocks; i++)
{
blocks[i] = hypre_ParCSRMatrixCreate(comm,
global_rows/nr, global_cols/nc,
row_starts, col_starts, 0, 0, 0);
}
/* split diag part */
hypre_CSRMatrix **csr_blocks = hypre_TAlloc(hypre_CSRMatrix*, nr*nc);
hypre_CSRMatrixSplit(Adiag, nr, nc, row_block_num, col_block_num,
csr_blocks);
for (i = 0; i < num_blocks; i++)
{
hypre_TFree(hypre_ParCSRMatrixDiag(blocks[i]));
hypre_ParCSRMatrixDiag(blocks[i]) = csr_blocks[i];
}
/* finish communication, receive offd_col_block_num */
hypre_ParCSRCommHandleDestroy(comm_handle);
hypre_TFree(int_buf_data);
/* decode global offd column numbers */
HYPRE_Int* offd_global_col = hypre_TAlloc(HYPRE_Int, offd_cols);
for (i = 0; i < offd_cols; i++)
{
offd_global_col[i] = offd_col_block_num[i] / nc;
offd_col_block_num[i] %= nc;
}
/* split offd part */
hypre_CSRMatrixSplit(Aoffd, nr, nc, row_block_num, offd_col_block_num,
csr_blocks);
for (i = 0; i < num_blocks; i++)
{
hypre_TFree(hypre_ParCSRMatrixOffd(blocks[i]));
hypre_ParCSRMatrixOffd(blocks[i]) = csr_blocks[i];
}
hypre_TFree(csr_blocks);
hypre_TFree(col_block_num);
hypre_TFree(row_block_num);
/* update block col-maps */
for (int bi = 0; bi < nr; bi++)
{
for (int bj = 0; bj < nc; bj++)
{
hypre_ParCSRMatrix *block = blocks[bi*nc + bj];
hypre_CSRMatrix *block_offd = hypre_ParCSRMatrixOffd(block);
HYPRE_Int block_offd_cols = hypre_CSRMatrixNumCols(block_offd);
HYPRE_Int *block_col_map = hypre_TAlloc(HYPRE_Int, block_offd_cols);
for (i = j = 0; i < offd_cols; i++)
{
HYPRE_Int bn = offd_col_block_num[i];
if (bn == bj) {
block_col_map[j++] = offd_global_col[i];
}
}
hypre_assert(j == block_offd_cols);
hypre_ParCSRMatrixColMapOffd(block) = block_col_map;
}
}
hypre_TFree(offd_global_col);
hypre_TFree(offd_col_block_num);
/* finish the new matrices, make them own all the stuff */
for (i = 0; i < num_blocks; i++)
{
hypre_ParCSRMatrixSetNumNonzeros(blocks[i]);
hypre_MatvecCommPkgCreate(blocks[i]);
hypre_ParCSRMatrixOwnsData(blocks[i]) = 1;
/* only the first block will own the row/col_starts */
hypre_ParCSRMatrixOwnsRowStarts(blocks[i]) = !i;
hypre_ParCSRMatrixOwnsColStarts(blocks[i]) = !i;
}
}
/*
Function: hypre_ParCSRMatrixEliminateAAe
(input) (output)
/ A_ii | A_ib \ / A_ii | 0 \
A = | -----+----- | ---> | -----+----- |
\ A_bi | A_bb / \ 0 | I /
/ 0 | A_ib \
Ae = | -----+--------- |
\ A_bi | A_bb - I /
*/
void hypre_ParCSRMatrixEliminateAAe(hypre_ParCSRMatrix *A,
hypre_ParCSRMatrix **Ae,
HYPRE_Int num_rowscols_to_elim,
HYPRE_Int *rowscols_to_elim)
{
HYPRE_Int i, j, k;
hypre_CSRMatrix *A_diag = hypre_ParCSRMatrixDiag(A);
hypre_CSRMatrix *A_offd = hypre_ParCSRMatrixOffd(A);
HYPRE_Int A_diag_nrows = hypre_CSRMatrixNumRows(A_diag);
HYPRE_Int A_offd_ncols = hypre_CSRMatrixNumCols(A_offd);
*Ae = hypre_ParCSRMatrixCreate(hypre_ParCSRMatrixComm(A),
hypre_ParCSRMatrixGlobalNumRows(A),
hypre_ParCSRMatrixGlobalNumCols(A),
hypre_ParCSRMatrixRowStarts(A),
hypre_ParCSRMatrixColStarts(A),
0, 0, 0);
hypre_ParCSRMatrixSetRowStartsOwner(*Ae, 0);
hypre_ParCSRMatrixSetColStartsOwner(*Ae, 0);
hypre_CSRMatrix *Ae_diag = hypre_ParCSRMatrixDiag(*Ae);
hypre_CSRMatrix *Ae_offd = hypre_ParCSRMatrixOffd(*Ae);
HYPRE_Int Ae_offd_ncols;
HYPRE_Int num_offd_cols_to_elim;
HYPRE_Int *offd_cols_to_elim;
HYPRE_Int *A_col_map_offd = hypre_ParCSRMatrixColMapOffd(A);
HYPRE_Int *Ae_col_map_offd;
HYPRE_Int *col_mark;
HYPRE_Int *col_remap;
/* figure out which offd cols should be eliminated */
{
hypre_ParCSRCommHandle *comm_handle;
hypre_ParCSRCommPkg *comm_pkg;
HYPRE_Int num_sends, *int_buf_data;
HYPRE_Int index, start;
HYPRE_Int *eliminate_row = hypre_CTAlloc(HYPRE_Int, A_diag_nrows);
HYPRE_Int *eliminate_col = hypre_CTAlloc(HYPRE_Int, A_offd_ncols);
/* make sure A has a communication package */
comm_pkg = hypre_ParCSRMatrixCommPkg(A);
if (!comm_pkg)
{
hypre_MatvecCommPkgCreate(A);
comm_pkg = hypre_ParCSRMatrixCommPkg(A);
}
/* which of the local rows are to be eliminated */
for (i = 0; i < A_diag_nrows; i++)
{
eliminate_row[i] = 0;
}
for (i = 0; i < num_rowscols_to_elim; i++)
{
eliminate_row[rowscols_to_elim[i]] = 1;
}
/* use a Matvec communication pattern to find (in eliminate_col)
which of the local offd columns are to be eliminated */
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
int_buf_data = hypre_CTAlloc(HYPRE_Int,
hypre_ParCSRCommPkgSendMapStart(comm_pkg,
num_sends));
index = 0;
for (i = 0; i < num_sends; i++)
{
start = hypre_ParCSRCommPkgSendMapStart(comm_pkg, i);
for (j = start; j < hypre_ParCSRCommPkgSendMapStart(comm_pkg, i+1); j++)
{
k = hypre_ParCSRCommPkgSendMapElmt(comm_pkg, j);
int_buf_data[index++] = eliminate_row[k];
}
}
comm_handle = hypre_ParCSRCommHandleCreate(11, comm_pkg,
int_buf_data, eliminate_col);
/* eliminate diagonal part, overlapping it with communication */
hypre_CSRMatrixElimCreate(A_diag, Ae_diag,
num_rowscols_to_elim, rowscols_to_elim,
num_rowscols_to_elim, rowscols_to_elim,
NULL);
hypre_CSRMatrixEliminateRowsCols(A_diag, Ae_diag,
num_rowscols_to_elim, rowscols_to_elim,
num_rowscols_to_elim, rowscols_to_elim,
1, NULL);
hypre_CSRMatrixReorder(Ae_diag);
/* finish the communication */
hypre_ParCSRCommHandleDestroy(comm_handle);
/* received eliminate_col[], count offd columns to eliminate */
num_offd_cols_to_elim = 0;
for (i = 0; i < A_offd_ncols; i++)
{
if (eliminate_col[i]) {
num_offd_cols_to_elim++;
}
}
offd_cols_to_elim = hypre_CTAlloc(HYPRE_Int, num_offd_cols_to_elim);
/* get a list of offd column indices and coefs */
num_offd_cols_to_elim = 0;
for (i = 0; i < A_offd_ncols; i++)
{
if (eliminate_col[i])
{
offd_cols_to_elim[num_offd_cols_to_elim++] = i;
}
}
hypre_TFree(int_buf_data);
hypre_TFree(eliminate_row);
hypre_TFree(eliminate_col);
}
/* eliminate the off-diagonal part */
col_mark = hypre_CTAlloc(HYPRE_Int, A_offd_ncols);
col_remap = hypre_CTAlloc(HYPRE_Int, A_offd_ncols);
hypre_CSRMatrixElimCreate(A_offd, Ae_offd,
num_rowscols_to_elim, rowscols_to_elim,
num_offd_cols_to_elim, offd_cols_to_elim,
col_mark);
for (i = k = 0; i < A_offd_ncols; i++)
{
if (col_mark[i]) {
col_remap[i] = k++;
}
}
hypre_CSRMatrixEliminateRowsCols(A_offd, Ae_offd,
num_rowscols_to_elim, rowscols_to_elim,
num_offd_cols_to_elim, offd_cols_to_elim,
0, col_remap);
/* create col_map_offd for Ae */
Ae_offd_ncols = 0;
for (i = 0; i < A_offd_ncols; i++)
{
if (col_mark[i]) {
Ae_offd_ncols++;
}
}
Ae_col_map_offd = hypre_CTAlloc(HYPRE_Int, Ae_offd_ncols);
Ae_offd_ncols = 0;
for (i = 0; i < A_offd_ncols; i++)
{
if (col_mark[i])
{
Ae_col_map_offd[Ae_offd_ncols++] = A_col_map_offd[i];
}
}
hypre_ParCSRMatrixColMapOffd(*Ae) = Ae_col_map_offd;
hypre_CSRMatrixNumCols(Ae_offd) = Ae_offd_ncols;
hypre_TFree(col_remap);
hypre_TFree(col_mark);
hypre_TFree(offd_cols_to_elim);
hypre_ParCSRMatrixSetNumNonzeros(*Ae);
hypre_MatvecCommPkgCreate(*Ae);
}
/*
Function: hypre_ParCSRMatrixEliminateAXB
This function eliminates the global rows and columns of a matrix
A corresponding to given lists of sorted (!) local row numbers,
so that the solution to the system A*X = B is X_b for the given rows.
The elimination is done as follows:
(input) (output)
/ A_ii | A_ib \ / A_ii | 0 \
A = | -----+----- | ---> | -----+----- |
\ A_bi | A_bb / \ 0 | I /
/ X_i \ / X_i \
X = | --- | ---> | --- | (no change)
\ X_b / \ X_b /
/ B_i \ / B_i - A_ib * X_b \
B = | --- | ---> | ---------------- |
\ B_b / \ X_b /
*/
void hypre_ParCSRMatrixEliminateAXB(hypre_ParCSRMatrix *A,
HYPRE_Int num_rowscols_to_elim,
HYPRE_Int *rowscols_to_elim,
hypre_ParVector *X,
hypre_ParVector *B)
{
hypre_CSRMatrix *diag = hypre_ParCSRMatrixDiag(A);
hypre_CSRMatrix *offd = hypre_ParCSRMatrixOffd(A);
HYPRE_Int diag_nrows = hypre_CSRMatrixNumRows(diag);
HYPRE_Int offd_ncols = hypre_CSRMatrixNumCols(offd);
hypre_Vector *Xlocal = hypre_ParVectorLocalVector(X);
hypre_Vector *Blocal = hypre_ParVectorLocalVector(B);
HYPRE_Real *Bdata = hypre_VectorData(Blocal);
HYPRE_Real *Xdata = hypre_VectorData(Xlocal);
HYPRE_Int num_offd_cols_to_elim;
HYPRE_Int *offd_cols_to_elim;
HYPRE_Real *eliminate_coefs;
/* figure out which offd cols should be eliminated and with what coef */
hypre_ParCSRCommHandle *comm_handle;
hypre_ParCSRCommPkg *comm_pkg;
HYPRE_Int num_sends;
HYPRE_Int index, start;
HYPRE_Int i, j, k, irow;
HYPRE_Real *eliminate_row = hypre_CTAlloc(HYPRE_Real, diag_nrows);
HYPRE_Real *eliminate_col = hypre_CTAlloc(HYPRE_Real, offd_ncols);
HYPRE_Real *buf_data, coef;
/* make sure A has a communication package */
comm_pkg = hypre_ParCSRMatrixCommPkg(A);
if (!comm_pkg)
{
hypre_MatvecCommPkgCreate(A);
comm_pkg = hypre_ParCSRMatrixCommPkg(A);
}
/* HACK: rows that shouldn't be eliminated are marked with quiet NaN;
those that should are set to the boundary value from X; this is to
avoid sending complex type (int+double) or communicating twice. */
for (i = 0; i < diag_nrows; i++)
{
eliminate_row[i] = std::numeric_limits<HYPRE_Real>::quiet_NaN();
}
for (i = 0; i < num_rowscols_to_elim; i++)
{
irow = rowscols_to_elim[i];
eliminate_row[irow] = Xdata[irow];
}
/* use a Matvec communication pattern to find (in eliminate_col)
which of the local offd columns are to be eliminated */
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
buf_data = hypre_CTAlloc(HYPRE_Real,
hypre_ParCSRCommPkgSendMapStart(comm_pkg,
num_sends));
index = 0;
for (i = 0; i < num_sends; i++)
{
start = hypre_ParCSRCommPkgSendMapStart(comm_pkg, i);
for (j = start; j < hypre_ParCSRCommPkgSendMapStart(comm_pkg, i+1); j++)
{
k = hypre_ParCSRCommPkgSendMapElmt(comm_pkg,j);
buf_data[index++] = eliminate_row[k];
}
}
comm_handle = hypre_ParCSRCommHandleCreate(1, comm_pkg,
buf_data, eliminate_col);
/* do sequential part of the elimination while stuff is getting sent */
hypre_CSRMatrixEliminateAXB(diag, num_rowscols_to_elim, rowscols_to_elim,
Xlocal, Blocal);
/* finish the communication */
hypre_ParCSRCommHandleDestroy(comm_handle);
/* received eliminate_col[], count offd columns to eliminate */
num_offd_cols_to_elim = 0;
for (i = 0; i < offd_ncols; i++)
{
coef = eliminate_col[i];
if (coef == coef) // test for NaN
{
num_offd_cols_to_elim++;
}
}
offd_cols_to_elim = hypre_CTAlloc(HYPRE_Int, num_offd_cols_to_elim);
eliminate_coefs = hypre_CTAlloc(HYPRE_Real, num_offd_cols_to_elim);
/* get a list of offd column indices and coefs */
num_offd_cols_to_elim = 0;
for (i = 0; i < offd_ncols; i++)
{
coef = eliminate_col[i];
if (coef == coef) // test for NaN
{
offd_cols_to_elim[num_offd_cols_to_elim] = i;
eliminate_coefs[num_offd_cols_to_elim] = coef;
num_offd_cols_to_elim++;
}
}
hypre_TFree(buf_data);
hypre_TFree(eliminate_row);
hypre_TFree(eliminate_col);
/* eliminate the off-diagonal part */
hypre_CSRMatrixEliminateOffdColsAXB(offd, num_offd_cols_to_elim,
offd_cols_to_elim,
eliminate_coefs, Blocal);
hypre_CSRMatrixEliminateOffdRowsAXB(offd, num_rowscols_to_elim,
rowscols_to_elim);
/* set boundary values in the rhs */
for (int i = 0; i < num_rowscols_to_elim; i++)
{
irow = rowscols_to_elim[i];
Bdata[irow] = Xdata[irow];
}
hypre_TFree(offd_cols_to_elim);
hypre_TFree(eliminate_coefs);
}
hypre_ParCSRMatrix *hypre_ParCSRAAt( hypre_ParCSRMatrix *A )
{
MPI_Comm comm = hypre_ParCSRMatrixComm(A);
hypre_CSRMatrix *A_diag = hypre_ParCSRMatrixDiag(A);
HYPRE_Complex *A_diag_data = hypre_CSRMatrixData(A_diag);
HYPRE_Int *A_diag_i = hypre_CSRMatrixI(A_diag);
HYPRE_Int *A_diag_j = hypre_CSRMatrixJ(A_diag);
hypre_CSRMatrix *A_offd = hypre_ParCSRMatrixOffd(A);
HYPRE_Complex *A_offd_data = hypre_CSRMatrixData(A_offd);
HYPRE_Int *A_offd_i = hypre_CSRMatrixI(A_offd);
HYPRE_Int *A_offd_j = hypre_CSRMatrixJ(A_offd);
HYPRE_Int *A_col_map_offd = hypre_ParCSRMatrixColMapOffd(A);
HYPRE_Int *A_ext_row_map;
HYPRE_Int *row_starts_A = hypre_ParCSRMatrixRowStarts(A);
HYPRE_Int num_rows_diag_A = hypre_CSRMatrixNumRows(A_diag);
HYPRE_Int num_cols_offd_A = hypre_CSRMatrixNumCols(A_offd);
hypre_ParCSRMatrix *C;
HYPRE_Int *col_map_offd_C;
hypre_CSRMatrix *C_diag;
HYPRE_Complex *C_diag_data;
HYPRE_Int *C_diag_i;
HYPRE_Int *C_diag_j;
hypre_CSRMatrix *C_offd;
HYPRE_Complex *C_offd_data=NULL;
HYPRE_Int *C_offd_i=NULL;
HYPRE_Int *C_offd_j=NULL;
HYPRE_Int *new_C_offd_j;
HYPRE_Int C_diag_size;
HYPRE_Int C_offd_size;
HYPRE_Int last_col_diag_C;
HYPRE_Int num_cols_offd_C;
hypre_CSRMatrix *A_ext;
HYPRE_Complex *A_ext_data;
HYPRE_Int *A_ext_i;
HYPRE_Int *A_ext_j;
HYPRE_Int num_rows_A_ext=0;
HYPRE_Int first_row_index_A = hypre_ParCSRMatrixFirstRowIndex(A);
HYPRE_Int first_col_diag_A = hypre_ParCSRMatrixFirstColDiag(A);
HYPRE_Int *B_marker;
HYPRE_Int i;
HYPRE_Int i1, i2, i3;
HYPRE_Int jj2, jj3;
HYPRE_Int jj_count_diag, jj_count_offd;
HYPRE_Int jj_row_begin_diag, jj_row_begin_offd;
HYPRE_Int start_indexing = 0; /* start indexing for C_data at 0 */
HYPRE_Int count;
HYPRE_Int n_rows_A, n_cols_A;
HYPRE_Complex a_entry;
HYPRE_Complex a_b_product;
HYPRE_Complex zero = 0.0;
n_rows_A = hypre_ParCSRMatrixGlobalNumRows(A);
n_cols_A = hypre_ParCSRMatrixGlobalNumCols(A);
if (n_cols_A != n_rows_A)
{
hypre_printf(" Error! Incompatible matrix dimensions!\n");
return NULL;
}
/*-----------------------------------------------------------------------
* Extract A_ext, i.e. portion of A that is stored on neighbor procs
* and needed locally for A^T in the matrix matrix product A*A^T
*-----------------------------------------------------------------------*/
if (num_rows_diag_A != n_rows_A)
{
/*---------------------------------------------------------------------
* If there exists no CommPkg for A, a CommPkg is generated using
* equally load balanced partitionings
*--------------------------------------------------------------------*/
if (!hypre_ParCSRMatrixCommPkg(A))
{
hypre_MatTCommPkgCreate(A);
}
A_ext = hypre_ParCSRMatrixExtractAExt( A, 1, &A_ext_row_map );
A_ext_data = hypre_CSRMatrixData(A_ext);
A_ext_i = hypre_CSRMatrixI(A_ext);
A_ext_j = hypre_CSRMatrixJ(A_ext);
num_rows_A_ext = hypre_CSRMatrixNumRows(A_ext);
}
/*-----------------------------------------------------------------------
* Allocate marker array.
*-----------------------------------------------------------------------*/
B_marker = hypre_CTAlloc(HYPRE_Int, num_rows_diag_A+num_rows_A_ext );
/*-----------------------------------------------------------------------
* Initialize some stuff.
*-----------------------------------------------------------------------*/
for ( i1=0; i1<num_rows_diag_A+num_rows_A_ext; ++i1 )
{
B_marker[i1] = -1;
}
hypre_ParAat_RowSizes(
&C_diag_i, &C_offd_i, B_marker,
A_diag_i, A_diag_j,
A_offd_i, A_offd_j, A_col_map_offd,
A_ext_i, A_ext_j, A_ext_row_map,
&C_diag_size, &C_offd_size,
num_rows_diag_A, num_cols_offd_A,
num_rows_A_ext,
first_col_diag_A, first_row_index_A
);
#if 0
/* debugging output: */
hypre_printf("A_ext_row_map (%i):",num_rows_A_ext);
for ( i1=0; i1<num_rows_A_ext; ++i1 ) hypre_printf(" %i",A_ext_row_map[i1] );
hypre_printf("\nC_diag_i (%i):",C_diag_size);
for ( i1=0; i1<=num_rows_diag_A; ++i1 ) hypre_printf(" %i",C_diag_i[i1] );
hypre_printf("\nC_offd_i (%i):",C_offd_size);
for ( i1=0; i1<=num_rows_diag_A; ++i1 ) hypre_printf(" %i",C_offd_i[i1] );
hypre_printf("\n");
#endif
/*-----------------------------------------------------------------------
* Allocate C_diag_data and C_diag_j arrays.
* Allocate C_offd_data and C_offd_j arrays.
*-----------------------------------------------------------------------*/
last_col_diag_C = first_row_index_A + num_rows_diag_A - 1;
C_diag_data = hypre_CTAlloc(HYPRE_Complex, C_diag_size);
C_diag_j = hypre_CTAlloc(HYPRE_Int, C_diag_size);
if (C_offd_size)
{
C_offd_data = hypre_CTAlloc(HYPRE_Complex, C_offd_size);
C_offd_j = hypre_CTAlloc(HYPRE_Int, C_offd_size);
}
/*-----------------------------------------------------------------------
* Second Pass: Fill in C_diag_data and C_diag_j.
* Second Pass: Fill in C_offd_data and C_offd_j.
*-----------------------------------------------------------------------*/
/*-----------------------------------------------------------------------
* Initialize some stuff.
*-----------------------------------------------------------------------*/
jj_count_diag = start_indexing;
jj_count_offd = start_indexing;
for ( i1=0; i1<num_rows_diag_A+num_rows_A_ext; ++i1 )
{
B_marker[i1] = -1;
}
/*-----------------------------------------------------------------------
* Loop over interior c-points.
*-----------------------------------------------------------------------*/
for (i1 = 0; i1 < num_rows_diag_A; i1++)
{
/*--------------------------------------------------------------------
* Create diagonal entry, C_{i1,i1}
*--------------------------------------------------------------------*/
B_marker[i1] = jj_count_diag;
jj_row_begin_diag = jj_count_diag;
jj_row_begin_offd = jj_count_offd;
C_diag_data[jj_count_diag] = zero;
C_diag_j[jj_count_diag] = i1;
jj_count_diag++;
/*-----------------------------------------------------------------
* Loop over entries in row i1 of A_offd.
*-----------------------------------------------------------------*/
/* There are 3 CSRMatrix or CSRBooleanMatrix objects here:
ext*ext, ext*diag, and ext*offd belong to another processor.
diag*offd and offd*diag don't count - never share a column by definition.
So we have to do 4 cases:
diag*ext, offd*ext, diag*diag, and offd*offd.
*/
for (jj2 = A_diag_i[i1]; jj2 < A_diag_i[i1+1]; jj2++)
{
i2 = A_diag_j[jj2];
a_entry = A_diag_data[jj2];
/* diag*ext */
/*-----------------------------------------------------------
* Loop over entries (columns) i3 in row i2 of (A_ext)^T
* That is, rows i3 having a column i2 of A_ext.
* For now, for each row i3 of A_ext we crudely check _all_
* columns to see whether one matches i2.
* For each entry (i2,i3) of (A_ext)^T, add A(i1,i2)*A(i3,i2)
* to C(i1,i3) . This contributes to both the diag and offd
* blocks of C.
*-----------------------------------------------------------*/
for ( i3=0; i3<num_rows_A_ext; i3++ ) {
for ( jj3=A_ext_i[i3]; jj3<A_ext_i[i3+1]; jj3++ ) {
if ( A_ext_j[jj3]==i2+first_col_diag_A ) {
/* row i3, column i2 of A_ext; or,
row i2, column i3 of (A_ext)^T */
a_b_product = a_entry * A_ext_data[jj3];
/*--------------------------------------------------------
* Check B_marker to see that C_{i1,i3} has not already
* been accounted for. If it has not, create a new entry.
* If it has, add new contribution.
*--------------------------------------------------------*/
if ( A_ext_row_map[i3] < first_row_index_A ||
A_ext_row_map[i3] > last_col_diag_C ) { /* offd */
if (B_marker[i3+num_rows_diag_A] < jj_row_begin_offd) {
B_marker[i3+num_rows_diag_A] = jj_count_offd;
C_offd_data[jj_count_offd] = a_b_product;
C_offd_j[jj_count_offd] = i3;
jj_count_offd++;
}
else
C_offd_data[B_marker[i3+num_rows_diag_A]] += a_b_product;
}
else { /* diag */
if (B_marker[i3+num_rows_diag_A] < jj_row_begin_diag) {
B_marker[i3+num_rows_diag_A] = jj_count_diag;
C_diag_data[jj_count_diag] = a_b_product;
C_diag_j[jj_count_diag] = i3-first_col_diag_A;
jj_count_diag++;
}
else
C_diag_data[B_marker[i3+num_rows_diag_A]] += a_b_product;
}
}
}
}
}
if (num_cols_offd_A)
{
for (jj2 = A_offd_i[i1]; jj2 < A_offd_i[i1+1]; jj2++)
{
i2 = A_offd_j[jj2];
a_entry = A_offd_data[jj2];
/* offd * ext */
/*-----------------------------------------------------------
* Loop over entries (columns) i3 in row i2 of (A_ext)^T
* That is, rows i3 having a column i2 of A_ext.
* For now, for each row i3 of A_ext we crudely check _all_
* columns to see whether one matches i2.
* For each entry (i2,i3) of (A_ext)^T, add A(i1,i2)*A(i3,i2)
* to C(i1,i3) . This contributes to both the diag and offd
* blocks of C.
*-----------------------------------------------------------*/
for ( i3=0; i3<num_rows_A_ext; i3++ ) {
for ( jj3=A_ext_i[i3]; jj3<A_ext_i[i3+1]; jj3++ ) {
if ( A_ext_j[jj3]==A_col_map_offd[i2] ) {
/* row i3, column i2 of A_ext; or,
row i2, column i3 of (A_ext)^T */
a_b_product = a_entry * A_ext_data[jj3];
/*--------------------------------------------------------
* Check B_marker to see that C_{i1,i3} has not already
* been accounted for. If it has not, create a new entry.
* If it has, add new contribution.
*--------------------------------------------------------*/
if ( A_ext_row_map[i3] < first_row_index_A ||
A_ext_row_map[i3] > last_col_diag_C ) { /* offd */
if (B_marker[i3+num_rows_diag_A] < jj_row_begin_offd) {
B_marker[i3+num_rows_diag_A] = jj_count_offd;
C_offd_data[jj_count_offd] = a_b_product;
C_offd_j[jj_count_offd] = i3;
jj_count_offd++;
}
else
C_offd_data[B_marker[i3+num_rows_diag_A]] += a_b_product;
}
else { /* diag */
if (B_marker[i3+num_rows_diag_A] < jj_row_begin_diag) {
B_marker[i3+num_rows_diag_A] = jj_count_diag;
C_diag_data[jj_count_diag] = a_b_product;
C_diag_j[jj_count_diag] = i3-first_row_index_A;
jj_count_diag++;
}
else
C_diag_data[B_marker[i3+num_rows_diag_A]] += a_b_product;
}
}
}
}
}
}
/* diag * diag */
/*-----------------------------------------------------------------
* Loop over entries (columns) i2 in row i1 of A_diag.
* For each such column we will find the contributions of the
* corresponding rows i2 of A^T to C=A*A^T . Now we only look
* at the local part of A^T - with columns (rows of A) living
* on this processor.
*-----------------------------------------------------------------*/
for (jj2 = A_diag_i[i1]; jj2 < A_diag_i[i1+1]; jj2++)
{
i2 = A_diag_j[jj2];
a_entry = A_diag_data[jj2];
/*-----------------------------------------------------------
* Loop over entries (columns) i3 in row i2 of A^T
* That is, rows i3 having a column i2 of A (local part).
* For now, for each row i3 of A we crudely check _all_
* columns to see whether one matches i2.
* This i3-loop is for the diagonal block of A.
* It contributes to the diagonal block of C.
* For each entry (i2,i3) of A^T, add A(i1,i2)*A(i3,i2)
* to C(i1,i3)
*-----------------------------------------------------------*/
for ( i3=0; i3<num_rows_diag_A; i3++ ) {
for ( jj3=A_diag_i[i3]; jj3<A_diag_i[i3+1]; jj3++ ) {
if ( A_diag_j[jj3]==i2 ) {
/* row i3, column i2 of A; or,
row i2, column i3 of A^T */
a_b_product = a_entry * A_diag_data[jj3];
/*--------------------------------------------------------
* Check B_marker to see that C_{i1,i3} has not already
* been accounted for. If it has not, mark it and increment
* counter.
*--------------------------------------------------------*/
if (B_marker[i3] < jj_row_begin_diag)
{
B_marker[i3] = jj_count_diag;
C_diag_data[jj_count_diag] = a_b_product;
C_diag_j[jj_count_diag] = i3;
jj_count_diag++;
}
else
{
C_diag_data[B_marker[i3]] += a_b_product;
}
}
}
} /* end of i3 loop */
} /* end of third i2 loop */
/* offd * offd */
/*-----------------------------------------------------------
* Loop over offd columns i2 of A in A*A^T. Then
* loop over offd entries (columns) i3 in row i2 of A^T
* That is, rows i3 having a column i2 of A (local part).
* For now, for each row i3 of A we crudely check _all_
* columns to see whether one matches i2.
* This i3-loop is for the off-diagonal block of A.
* It contributes to the diag block of C.
* For each entry (i2,i3) of A^T, add A*A^T to C
*-----------------------------------------------------------*/
if (num_cols_offd_A) {
for (jj2 = A_offd_i[i1]; jj2 < A_offd_i[i1+1]; jj2++)
{
i2 = A_offd_j[jj2];
a_entry = A_offd_data[jj2];
for ( i3=0; i3<num_rows_diag_A; i3++ ) {
/* ... note that num_rows_diag_A == num_rows_offd_A */
for ( jj3=A_offd_i[i3]; jj3<A_offd_i[i3+1]; jj3++ ) {
if ( A_offd_j[jj3]==i2 ) {
/* row i3, column i2 of A; or,
row i2, column i3 of A^T */
a_b_product = a_entry * A_offd_data[jj3];
/*--------------------------------------------------------
* Check B_marker to see that C_{i1,i3} has not already
* been accounted for. If it has not, create a new entry.
* If it has, add new contribution
*--------------------------------------------------------*/
if (B_marker[i3] < jj_row_begin_diag)
{
B_marker[i3] = jj_count_diag;
C_diag_data[jj_count_diag] = a_b_product;
C_diag_j[jj_count_diag] = i3;
jj_count_diag++;
}
else
{
C_diag_data[B_marker[i3]] += a_b_product;
}
}
}
} /* end of last i3 loop */
} /* end of if (num_cols_offd_A) */
} /* end of fourth and last i2 loop */
#if 0 /* debugging printout */
hypre_printf("end of i1 loop: i1=%i jj_count_diag=%i\n", i1, jj_count_diag );
hypre_printf(" C_diag_j=");
for ( jj3=0; jj3<jj_count_diag; ++jj3) hypre_printf("%i ",C_diag_j[jj3]);
hypre_printf(" C_diag_data=");
for ( jj3=0; jj3<jj_count_diag; ++jj3) hypre_printf("%f ",C_diag_data[jj3]);
hypre_printf("\n");
hypre_printf(" C_offd_j=");
for ( jj3=0; jj3<jj_count_offd; ++jj3) hypre_printf("%i ",C_offd_j[jj3]);
hypre_printf(" C_offd_data=");
for ( jj3=0; jj3<jj_count_offd; ++jj3) hypre_printf("%f ",C_offd_data[jj3]);
hypre_printf("\n");
hypre_printf( " B_marker =" );
for ( it=0; it<num_rows_diag_A+num_rows_A_ext; ++it )
hypre_printf(" %i", B_marker[it] );
hypre_printf( "\n" );
#endif
} /* end of i1 loop */
/*-----------------------------------------------------------------------
* Delete 0-columns in C_offd, i.e. generate col_map_offd and reset
* C_offd_j. Note that (with the indexing we have coming into this
* block) col_map_offd_C[i3]==A_ext_row_map[i3].
*-----------------------------------------------------------------------*/
for ( i=0; i<num_rows_diag_A+num_rows_A_ext; ++i )
B_marker[i] = -1;
for ( i=0; i<C_offd_size; i++ )
B_marker[ C_offd_j[i] ] = -2;
count = 0;
for (i=0; i < num_rows_diag_A + num_rows_A_ext; i++) {
if (B_marker[i] == -2) {
B_marker[i] = count;
count++;
}
}
num_cols_offd_C = count;
if (num_cols_offd_C) {
col_map_offd_C = hypre_CTAlloc(HYPRE_Int,num_cols_offd_C);
new_C_offd_j = hypre_CTAlloc(HYPRE_Int,C_offd_size);
/* ... a bit big, but num_cols_offd_C is too small. It might be worth
computing the correct size, which is sum( no. columns in row i, over all rows i )
*/
for (i=0; i < C_offd_size; i++) {
new_C_offd_j[i] = B_marker[C_offd_j[i]];
col_map_offd_C[ new_C_offd_j[i] ] = A_ext_row_map[ C_offd_j[i] ];
}
hypre_TFree(C_offd_j);
C_offd_j = new_C_offd_j;
}
/*----------------------------------------------------------------
* Create C
*----------------------------------------------------------------*/
C = hypre_ParCSRMatrixCreate(comm, n_rows_A, n_rows_A, row_starts_A,
row_starts_A, num_cols_offd_C,
C_diag_size, C_offd_size);
/* Note that C does not own the partitionings */
hypre_ParCSRMatrixSetRowStartsOwner(C,0);
hypre_ParCSRMatrixSetColStartsOwner(C,0);
C_diag = hypre_ParCSRMatrixDiag(C);
hypre_CSRMatrixData(C_diag) = C_diag_data;
hypre_CSRMatrixI(C_diag) = C_diag_i;
hypre_CSRMatrixJ(C_diag) = C_diag_j;
if (num_cols_offd_C)
{
C_offd = hypre_ParCSRMatrixOffd(C);
hypre_CSRMatrixData(C_offd) = C_offd_data;
hypre_CSRMatrixI(C_offd) = C_offd_i;
hypre_CSRMatrixJ(C_offd) = C_offd_j;
hypre_ParCSRMatrixOffd(C) = C_offd;
hypre_ParCSRMatrixColMapOffd(C) = col_map_offd_C;
}
else
hypre_TFree(C_offd_i);
/*-----------------------------------------------------------------------
* Free B_ext and marker array.
*-----------------------------------------------------------------------*/
if (num_cols_offd_A)
{
hypre_CSRMatrixDestroy(A_ext);
A_ext = NULL;
}
hypre_TFree(B_marker);
if ( num_rows_diag_A != n_rows_A )
hypre_TFree(A_ext_row_map);
return C;
}
/******************************************************************************
* hypre_BoomerAMGFitInterpVectors
*
This routine for updating the interp operator to interpolate the
supplied smooth vectors with a L.S. fitting. This code (varient 0)
was used for the Baker, Kolev and Yang elasticity paper in section 3
to evaluate the least squares fitting methed proposed by Stuben in
his talk (see paper for details). So this code is basically a
post-processing step that performs the LS fit (the size and sparsity
of P do not change).
Note: truncation only works correctly for 1 processor - needs to
just use the other truncation rouitne
Variant = 0: do L.S. fit to existing interp weights (default)
Variant = 1: extends the neighborhood to incl. other unknowns on the
same node - ASSUMES A NODAL COARSENING, ASSUMES VARIABLES ORDERED
GRID POINT, THEN UNKNOWN (e.g., u0, v0, u1, v1, etc. ), AND AT MOST
3 FCNS (NOTE: **only** works with 1 processor)
This code is not compiled or accessible through hypre at this time
(it was not particularly effective - compared to the LN and GM
approaches), but is checked-in in case there is interest in the
future.
******************************************************************************/
HYPRE_Int hypre_BoomerAMGFitInterpVectors( hypre_ParCSRMatrix *A,
hypre_ParCSRMatrix **P,
HYPRE_Int num_smooth_vecs,
hypre_ParVector **smooth_vecs,
hypre_ParVector **coarse_smooth_vecs,
double delta,
HYPRE_Int num_functions,
HYPRE_Int *dof_func,
HYPRE_Int *CF_marker,
HYPRE_Int max_elmts,
double trunc_factor,
HYPRE_Int variant, HYPRE_Int level)
{
HYPRE_Int i,j, k;
HYPRE_Int one_i = 1;
HYPRE_Int info;
HYPRE_Int coarse_index;;
HYPRE_Int num_coarse_diag;
HYPRE_Int num_coarse_offd;
HYPRE_Int num_nonzeros = 0;
HYPRE_Int coarse_point = 0;
HYPRE_Int k_size;
HYPRE_Int k_alloc;
HYPRE_Int counter;
HYPRE_Int *piv;
HYPRE_Int tmp_int;
HYPRE_Int num_sends;
double *alpha;
double *Beta;
double *w;
double *w_old;
double *B_s;
double tmp_double;
double one = 1.0;
double mone = -1.0;;
double *vec_data;
hypre_CSRMatrix *P_diag = hypre_ParCSRMatrixDiag(*P);
hypre_CSRMatrix *P_offd = hypre_ParCSRMatrixOffd(*P);
double *P_diag_data = hypre_CSRMatrixData(P_diag);
HYPRE_Int *P_diag_i = hypre_CSRMatrixI(P_diag);
HYPRE_Int *P_diag_j = hypre_CSRMatrixJ(P_diag);
double *P_offd_data = hypre_CSRMatrixData(P_offd);
HYPRE_Int *P_offd_i = hypre_CSRMatrixI(P_offd);
HYPRE_Int *P_offd_j = hypre_CSRMatrixJ(P_offd);
HYPRE_Int num_rows_P = hypre_CSRMatrixNumRows(P_diag);
HYPRE_Int P_diag_size = P_diag_i[num_rows_P];
HYPRE_Int P_offd_size = P_offd_i[num_rows_P];
HYPRE_Int num_cols_P_offd = hypre_CSRMatrixNumCols(P_offd);
HYPRE_Int *col_map_offd_P;
hypre_CSRMatrix *A_offd = hypre_ParCSRMatrixOffd(A);
HYPRE_Int num_cols_A_offd = hypre_CSRMatrixNumCols(A_offd);
hypre_ParCSRCommPkg *comm_pkg = hypre_ParCSRMatrixCommPkg(*P);
hypre_ParCSRCommHandle *comm_handle;
MPI_Comm comm;
double *dbl_buf_data;
double *smooth_vec_offd = NULL;
double *offd_vec_data;
HYPRE_Int index, start;
HYPRE_Int *P_marker;
HYPRE_Int num_procs;
hypre_ParVector *vector;
HYPRE_Int new_nnz, orig_start, j_pos, fcn_num, num_elements;
HYPRE_Int *P_diag_j_new;
double *P_diag_data_new;
HYPRE_Int adjust_3D[] = {1, 2, -1, 1, -2, -1};
HYPRE_Int adjust_2D[] = {1, -1};
HYPRE_Int *adjust_list;
if (variant ==1 && num_functions > 1)
{
/* First add new entries to P with value 0.0 corresponding to weights from
other unknowns on the same grid point */
/* Loop through each row */
new_nnz = P_diag_size*num_functions; /* this is an over-estimate */
P_diag_j_new = hypre_CTAlloc(HYPRE_Int, new_nnz);
P_diag_data_new = hypre_CTAlloc (double, new_nnz);
if (num_functions ==2)
adjust_list = adjust_2D;
else if (num_functions ==3)
adjust_list = adjust_3D;
j_pos = 0;
orig_start = 0;
/* loop through rows */
for (i=0; i < num_rows_P; i++)
{
fcn_num = (HYPRE_Int) fmod(i, num_functions);
if (fcn_num != dof_func[i])
printf("WARNING - ROWS incorrectly ordered!\n");
/* loop through elements */
num_elements = P_diag_i[i+1] - orig_start;
/* add zeros corrresponding to other unknowns */
if (num_elements > 1)
{
for (j=0; j < num_elements; j++)
{
P_diag_j_new[j_pos] = P_diag_j[orig_start+j];
P_diag_data_new[j_pos++] = P_diag_data[orig_start+j];
for (k=0; k < num_functions-1; k++)
{
P_diag_j_new[j_pos] = P_diag_j[orig_start+j]+ ADJUST(fcn_num,k);
P_diag_data_new[j_pos++] = 0.0;
}
}
}
else if (num_elements == 1)/* only one element - just copy to new */
{
P_diag_j_new[j_pos] = P_diag_j[orig_start];
P_diag_data_new[j_pos++] = P_diag_data[orig_start];
}
orig_start = P_diag_i[i+1];
if (num_elements > 1)
P_diag_i[i+1] = P_diag_i[i] + num_elements*num_functions;
else
P_diag_i[i+1] = P_diag_i[i] + num_elements;
if (j_pos != P_diag_i[i+1]) printf("Problem!\n");
}/* end loop through rows */
/* modify P */
hypre_TFree(P_diag_j);
hypre_TFree(P_diag_data);
hypre_CSRMatrixJ(P_diag) = P_diag_j_new;
hypre_CSRMatrixData(P_diag) = P_diag_data_new;
hypre_CSRMatrixNumNonzeros(P_diag) = P_diag_i[num_rows_P];
P_diag_j = P_diag_j_new;
P_diag_data = P_diag_data_new;
/* check if there is already a comm pkg - if so, destroy*/
if (comm_pkg)
{
hypre_MatvecCommPkgDestroy(comm_pkg );
comm_pkg = NULL;
}
} /* end variant == 1 and num functions > 0 */
HYPRE_Int hypre_CreateLambda(void *amg_vdata)
{
hypre_ParAMGData *amg_data = amg_vdata;
/* Data Structure variables */
MPI_Comm comm;
hypre_ParCSRMatrix **A_array;
hypre_ParVector **F_array;
hypre_ParVector **U_array;
hypre_ParCSRMatrix *A_tmp;
hypre_ParCSRMatrix *Lambda;
hypre_CSRMatrix *L_diag;
hypre_CSRMatrix *L_offd;
hypre_CSRMatrix *A_tmp_diag;
hypre_CSRMatrix *A_tmp_offd;
hypre_ParVector *Xtilde;
hypre_ParVector *Rtilde;
hypre_Vector *Xtilde_local;
hypre_Vector *Rtilde_local;
hypre_ParCSRCommPkg *comm_pkg;
hypre_ParCSRCommPkg *L_comm_pkg = NULL;
hypre_ParCSRCommHandle *comm_handle;
HYPRE_Real *L_diag_data;
HYPRE_Real *L_offd_data;
HYPRE_Real *buf_data = NULL;
HYPRE_Real *tmp_data;
HYPRE_Real *x_data;
HYPRE_Real *r_data;
HYPRE_Real *l1_norms;
HYPRE_Real *A_tmp_diag_data;
HYPRE_Real *A_tmp_offd_data;
HYPRE_Real *D_data = NULL;
HYPRE_Real *D_data_offd = NULL;
HYPRE_Int *L_diag_i;
HYPRE_Int *L_diag_j;
HYPRE_Int *L_offd_i;
HYPRE_Int *L_offd_j;
HYPRE_Int *A_tmp_diag_i;
HYPRE_Int *A_tmp_offd_i;
HYPRE_Int *A_tmp_diag_j;
HYPRE_Int *A_tmp_offd_j;
HYPRE_Int *L_recv_ptr = NULL;
HYPRE_Int *L_send_ptr = NULL;
HYPRE_Int *L_recv_procs = NULL;
HYPRE_Int *L_send_procs = NULL;
HYPRE_Int *L_send_map_elmts = NULL;
HYPRE_Int *recv_procs;
HYPRE_Int *send_procs;
HYPRE_Int *send_map_elmts;
HYPRE_Int *send_map_starts;
HYPRE_Int *recv_vec_starts;
HYPRE_Int *all_send_procs = NULL;
HYPRE_Int *all_recv_procs = NULL;
HYPRE_Int *remap = NULL;
HYPRE_Int *level_start;
HYPRE_Int addlvl;
HYPRE_Int additive;
HYPRE_Int mult_additive;
HYPRE_Int num_levels;
HYPRE_Int num_add_lvls;
HYPRE_Int num_procs;
HYPRE_Int num_sends, num_recvs;
HYPRE_Int num_sends_L = 0;
HYPRE_Int num_recvs_L = 0;
HYPRE_Int send_data_L = 0;
HYPRE_Int num_rows_L = 0;
HYPRE_Int num_rows_tmp = 0;
HYPRE_Int num_cols_offd_L = 0;
HYPRE_Int num_cols_offd = 0;
HYPRE_Int level, i, j, k;
HYPRE_Int this_proc, cnt, cnt_diag, cnt_offd;
HYPRE_Int cnt_recv, cnt_send, cnt_row, row_start;
HYPRE_Int start_diag, start_offd, indx, cnt_map;
HYPRE_Int start, j_indx, index, cnt_level;
HYPRE_Int max_sends, max_recvs;
/* Local variables */
HYPRE_Int Solve_err_flag = 0;
HYPRE_Int num_threads;
HYPRE_Int num_nonzeros_diag;
HYPRE_Int num_nonzeros_offd;
HYPRE_Real **l1_norms_ptr = NULL;
HYPRE_Real *relax_weight = NULL;
HYPRE_Real relax_type;
/* 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);
additive = hypre_ParAMGDataAdditive(amg_data);
mult_additive = hypre_ParAMGDataMultAdditive(amg_data);
num_levels = hypre_ParAMGDataNumLevels(amg_data);
relax_weight = hypre_ParAMGDataRelaxWeight(amg_data);
relax_type = hypre_ParAMGDataGridRelaxType(amg_data)[1];
comm = hypre_ParCSRMatrixComm(A_array[0]);
hypre_MPI_Comm_size(comm,&num_procs);
l1_norms_ptr = hypre_ParAMGDataL1Norms(amg_data);
addlvl = hypre_max(additive, mult_additive);
num_add_lvls = num_levels+1-addlvl;
level_start = hypre_CTAlloc(HYPRE_Int, num_add_lvls+1);
send_data_L = 0;
num_rows_L = 0;
num_cols_offd_L = 0;
num_nonzeros_diag = 0;
num_nonzeros_offd = 0;
level_start[0] = 0;
cnt = 1;
max_sends = 0;
max_recvs = 0;
for (i=addlvl; i < num_levels; i++)
{
A_tmp = A_array[i];
A_tmp_diag = hypre_ParCSRMatrixDiag(A_tmp);
A_tmp_offd = hypre_ParCSRMatrixOffd(A_tmp);
A_tmp_diag_i = hypre_CSRMatrixI(A_tmp_diag);
A_tmp_offd_i = hypre_CSRMatrixI(A_tmp_offd);
num_rows_tmp = hypre_CSRMatrixNumRows(A_tmp_diag);
num_cols_offd = hypre_CSRMatrixNumCols(A_tmp_offd);
num_rows_L += num_rows_tmp;
level_start[cnt] = level_start[cnt-1] + num_rows_tmp;
cnt++;
num_cols_offd_L += num_cols_offd;
num_nonzeros_diag += A_tmp_diag_i[num_rows_tmp];
num_nonzeros_offd += A_tmp_offd_i[num_rows_tmp];
comm_pkg = hypre_ParCSRMatrixCommPkg(A_tmp);
if (comm_pkg)
{
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
max_sends += num_sends;
if (num_sends)
send_data_L += hypre_ParCSRCommPkgSendMapStart(comm_pkg,num_sends);
max_recvs += hypre_ParCSRCommPkgNumRecvs(comm_pkg);
}
}
if (max_sends >= num_procs ||max_recvs >= num_procs)
{
max_sends = num_procs;
max_recvs = num_procs;
}
if (max_sends) all_send_procs = hypre_CTAlloc(HYPRE_Int, max_sends);
if (max_recvs) all_recv_procs = hypre_CTAlloc(HYPRE_Int, max_recvs);
cnt_send = 0;
cnt_recv = 0;
if (max_sends || max_recvs)
{
if (max_sends < num_procs && max_recvs < num_procs)
{
for (i=addlvl; i < num_levels; i++)
{
A_tmp = A_array[i];
comm_pkg = hypre_ParCSRMatrixCommPkg(A_tmp);
if (comm_pkg)
{
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
num_recvs = hypre_ParCSRCommPkgNumRecvs(comm_pkg);
send_procs = hypre_ParCSRCommPkgSendProcs(comm_pkg);
recv_procs = hypre_ParCSRCommPkgRecvProcs(comm_pkg);
for (j = 0; j < num_sends; j++)
all_send_procs[cnt_send++] = send_procs[j];
for (j = 0; j < num_recvs; j++)
all_recv_procs[cnt_recv++] = recv_procs[j];
}
}
if (max_sends)
{
qsort0(all_send_procs, 0, max_sends-1);
num_sends_L = 1;
this_proc = all_send_procs[0];
for (i=1; i < max_sends; i++)
{
if (all_send_procs[i] > this_proc)
{
this_proc = all_send_procs[i];
all_send_procs[num_sends_L++] = this_proc;
}
}
L_send_procs = hypre_CTAlloc(HYPRE_Int, num_sends_L);
for (j=0; j < num_sends_L; j++)
L_send_procs[j] = all_send_procs[j];
hypre_TFree(all_send_procs);
}
if (max_recvs)
{
qsort0(all_recv_procs, 0, max_recvs-1);
num_recvs_L = 1;
this_proc = all_recv_procs[0];
for (i=1; i < max_recvs; i++)
{
if (all_recv_procs[i] > this_proc)
{
this_proc = all_recv_procs[i];
all_recv_procs[num_recvs_L++] = this_proc;
}
}
L_recv_procs = hypre_CTAlloc(HYPRE_Int, num_recvs_L);
for (j=0; j < num_recvs_L; j++)
L_recv_procs[j] = all_recv_procs[j];
hypre_TFree(all_recv_procs);
}
L_recv_ptr = hypre_CTAlloc(HYPRE_Int, num_recvs_L+1);
L_send_ptr = hypre_CTAlloc(HYPRE_Int, num_sends_L+1);
for (i=addlvl; i < num_levels; i++)
{
A_tmp = A_array[i];
comm_pkg = hypre_ParCSRMatrixCommPkg(A_tmp);
if (comm_pkg)
{
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
num_recvs = hypre_ParCSRCommPkgNumRecvs(comm_pkg);
send_procs = hypre_ParCSRCommPkgSendProcs(comm_pkg);
recv_procs = hypre_ParCSRCommPkgRecvProcs(comm_pkg);
send_map_starts = hypre_ParCSRCommPkgSendMapStarts(comm_pkg);
recv_vec_starts = hypre_ParCSRCommPkgRecvVecStarts(comm_pkg);
}
else
{
num_sends = 0;
num_recvs = 0;
}
for (k = 0; k < num_sends; k++)
{
this_proc = hypre_BinarySearch(L_send_procs,send_procs[k],num_sends_L);
L_send_ptr[this_proc+1] += send_map_starts[k+1]-send_map_starts[k];
}
for (k = 0; k < num_recvs; k++)
{
this_proc = hypre_BinarySearch(L_recv_procs,recv_procs[k],num_recvs_L);
L_recv_ptr[this_proc+1] += recv_vec_starts[k+1]-recv_vec_starts[k];
}
}
L_recv_ptr[0] = 0;
for (i=1; i < num_recvs_L; i++)
L_recv_ptr[i+1] += L_recv_ptr[i];
L_send_ptr[0] = 0;
for (i=1; i < num_sends_L; i++)
L_send_ptr[i+1] += L_send_ptr[i];
}
else
{
num_recvs_L = 0;
num_sends_L = 0;
for (i=addlvl; i < num_levels; i++)
{
A_tmp = A_array[i];
comm_pkg = hypre_ParCSRMatrixCommPkg(A_tmp);
if (comm_pkg)
{
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
num_recvs = hypre_ParCSRCommPkgNumRecvs(comm_pkg);
send_procs = hypre_ParCSRCommPkgSendProcs(comm_pkg);
recv_procs = hypre_ParCSRCommPkgRecvProcs(comm_pkg);
send_map_starts = hypre_ParCSRCommPkgSendMapStarts(comm_pkg);
recv_vec_starts = hypre_ParCSRCommPkgRecvVecStarts(comm_pkg);
for (j = 0; j < num_sends; j++)
{
this_proc = send_procs[j];
if (all_send_procs[this_proc] == 0)
num_sends_L++;
all_send_procs[this_proc] += send_map_starts[j+1]-send_map_starts[j];
}
for (j = 0; j < num_recvs; j++)
{
this_proc = recv_procs[j];
if (all_recv_procs[this_proc] == 0)
num_recvs_L++;
all_recv_procs[this_proc] += recv_vec_starts[j+1]-recv_vec_starts[j];
}
}
}
if (max_sends)
{
L_send_procs = hypre_CTAlloc(HYPRE_Int, num_sends_L);
L_send_ptr = hypre_CTAlloc(HYPRE_Int, num_sends_L+1);
num_sends_L = 0;
for (j=0; j < num_procs; j++)
{
this_proc = all_send_procs[j];
if (this_proc)
{
L_send_procs[num_sends_L++] = j;
L_send_ptr[num_sends_L] = this_proc + L_send_ptr[num_sends_L-1];
}
}
}
if (max_recvs)
{
L_recv_procs = hypre_CTAlloc(HYPRE_Int, num_recvs_L);
L_recv_ptr = hypre_CTAlloc(HYPRE_Int, num_recvs_L+1);
num_recvs_L = 0;
for (j=0; j < num_procs; j++)
{
this_proc = all_recv_procs[j];
if (this_proc)
{
L_recv_procs[num_recvs_L++] = j;
L_recv_ptr[num_recvs_L] = this_proc + L_recv_ptr[num_recvs_L-1];
}
}
}
}
}
if (max_sends) hypre_TFree(all_send_procs);
if (max_recvs) hypre_TFree(all_recv_procs);
L_diag = hypre_CSRMatrixCreate(num_rows_L, num_rows_L, num_nonzeros_diag);
L_offd = hypre_CSRMatrixCreate(num_rows_L, num_cols_offd_L, num_nonzeros_offd);
hypre_CSRMatrixInitialize(L_diag);
hypre_CSRMatrixInitialize(L_offd);
if (num_nonzeros_diag)
{
L_diag_data = hypre_CSRMatrixData(L_diag);
L_diag_j = hypre_CSRMatrixJ(L_diag);
}
L_diag_i = hypre_CSRMatrixI(L_diag);
if (num_nonzeros_offd)
{
L_offd_data = hypre_CSRMatrixData(L_offd);
L_offd_j = hypre_CSRMatrixJ(L_offd);
}
L_offd_i = hypre_CSRMatrixI(L_offd);
if (num_rows_L) D_data = hypre_CTAlloc(HYPRE_Real,num_rows_L);
if (send_data_L)
{
L_send_map_elmts = hypre_CTAlloc(HYPRE_Int, send_data_L);
buf_data = hypre_CTAlloc(HYPRE_Real,send_data_L);
}
if (num_cols_offd_L)
{
D_data_offd = hypre_CTAlloc(HYPRE_Real,num_cols_offd_L);
/*L_col_map_offd = hypre_CTAlloc(HYPRE_Int, num_cols_offd_L);*/
remap = hypre_CTAlloc(HYPRE_Int, num_cols_offd_L);
}
Rtilde = hypre_CTAlloc(hypre_ParVector, 1);
Rtilde_local = hypre_SeqVectorCreate(num_rows_L);
hypre_SeqVectorInitialize(Rtilde_local);
hypre_ParVectorLocalVector(Rtilde) = Rtilde_local;
hypre_ParVectorOwnsData(Rtilde) = 1;
Xtilde = hypre_CTAlloc(hypre_ParVector, 1);
Xtilde_local = hypre_SeqVectorCreate(num_rows_L);
hypre_SeqVectorInitialize(Xtilde_local);
hypre_ParVectorLocalVector(Xtilde) = Xtilde_local;
hypre_ParVectorOwnsData(Xtilde) = 1;
x_data = hypre_VectorData(hypre_ParVectorLocalVector(Xtilde));
r_data = hypre_VectorData(hypre_ParVectorLocalVector(Rtilde));
cnt = 0;
cnt_level = 0;
cnt_diag = 0;
cnt_offd = 0;
cnt_row = 1;
L_diag_i[0] = 0;
L_offd_i[0] = 0;
for (level=addlvl; level < num_levels; level++)
{
row_start = level_start[cnt_level];
if (level != 0)
{
tmp_data = hypre_VectorData(hypre_ParVectorLocalVector(F_array[level]));
if (tmp_data) hypre_TFree(tmp_data);
hypre_VectorData(hypre_ParVectorLocalVector(F_array[level])) = &r_data[row_start];
hypre_VectorOwnsData(hypre_ParVectorLocalVector(F_array[level])) = 0;
tmp_data = hypre_VectorData(hypre_ParVectorLocalVector(U_array[level]));
if (tmp_data) hypre_TFree(tmp_data);
hypre_VectorData(hypre_ParVectorLocalVector(U_array[level])) = &x_data[row_start];
hypre_VectorOwnsData(hypre_ParVectorLocalVector(U_array[level])) = 0;
}
cnt_level++;
start_diag = L_diag_i[cnt_row-1];
start_offd = L_offd_i[cnt_row-1];
A_tmp = A_array[level];
A_tmp_diag = hypre_ParCSRMatrixDiag(A_tmp);
A_tmp_offd = hypre_ParCSRMatrixOffd(A_tmp);
comm_pkg = hypre_ParCSRMatrixCommPkg(A_tmp);
A_tmp_diag_i = hypre_CSRMatrixI(A_tmp_diag);
A_tmp_offd_i = hypre_CSRMatrixI(A_tmp_offd);
A_tmp_diag_j = hypre_CSRMatrixJ(A_tmp_diag);
A_tmp_offd_j = hypre_CSRMatrixJ(A_tmp_offd);
A_tmp_diag_data = hypre_CSRMatrixData(A_tmp_diag);
A_tmp_offd_data = hypre_CSRMatrixData(A_tmp_offd);
num_rows_tmp = hypre_CSRMatrixNumRows(A_tmp_diag);
if (comm_pkg)
{
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
num_recvs = hypre_ParCSRCommPkgNumRecvs(comm_pkg);
send_procs = hypre_ParCSRCommPkgSendProcs(comm_pkg);
recv_procs = hypre_ParCSRCommPkgRecvProcs(comm_pkg);
send_map_starts = hypre_ParCSRCommPkgSendMapStarts(comm_pkg);
send_map_elmts = hypre_ParCSRCommPkgSendMapElmts(comm_pkg);
recv_vec_starts = hypre_ParCSRCommPkgRecvVecStarts(comm_pkg);
}
else
{
num_sends = 0;
num_recvs = 0;
}
/* Compute new combined communication package */
for (i=0; i < num_sends; i++)
{
this_proc = hypre_BinarySearch(L_send_procs,send_procs[i],num_sends_L);
indx = L_send_ptr[this_proc];
for (j=send_map_starts[i]; j < send_map_starts[i+1]; j++)
{
L_send_map_elmts[indx++] = row_start + send_map_elmts[j];
}
L_send_ptr[this_proc] = indx;
}
cnt_map = 0;
for (i = 0; i < num_recvs; i++)
{
this_proc = hypre_BinarySearch(L_recv_procs,recv_procs[i],num_recvs_L);
indx = L_recv_ptr[this_proc];
for (j=recv_vec_starts[i]; j < recv_vec_starts[i+1]; j++)
{
remap[cnt_map++] = indx++;
}
L_recv_ptr[this_proc] = indx;
}
/* Compute Lambda */
if (relax_type == 0)
{
HYPRE_Real rlx_wt = relax_weight[level];
#ifdef HYPRE_USING_OPENMP
#pragma omp for private(i) HYPRE_SMP_SCHEDULE
#endif
for (i=0; i < num_rows_tmp; i++)
{
D_data[i] = rlx_wt/A_tmp_diag_data[A_tmp_diag_i[i]];
L_diag_i[cnt_row+i] = start_diag + A_tmp_diag_i[i+1];
L_offd_i[cnt_row+i] = start_offd + A_tmp_offd_i[i+1];
}
}
else
{
l1_norms = l1_norms_ptr[level];
#ifdef HYPRE_USING_OPENMP
#pragma omp for private(i) HYPRE_SMP_SCHEDULE
#endif
for (i=0; i < num_rows_tmp; i++)
{
D_data[i] = 1.0/l1_norms[i];
L_diag_i[cnt_row+i] = start_diag + A_tmp_diag_i[i+1];
L_offd_i[cnt_row+i] = start_offd + A_tmp_offd_i[i+1];
}
}
if (num_procs > 1)
{
index = 0;
for (i=0; i < num_sends; i++)
{
start = send_map_starts[i];
for (j=start; j < send_map_starts[i+1]; j++)
buf_data[index++] = D_data[send_map_elmts[j]];
}
comm_handle = hypre_ParCSRCommHandleCreate(1, comm_pkg,
buf_data, D_data_offd);
hypre_ParCSRCommHandleDestroy(comm_handle);
}
for (i = 0; i < num_rows_tmp; i++)
{
j_indx = A_tmp_diag_i[i];
L_diag_data[cnt_diag] = (2.0 - A_tmp_diag_data[j_indx]*D_data[i])*D_data[i];
L_diag_j[cnt_diag++] = i+row_start;
for (j=A_tmp_diag_i[i]+1; j < A_tmp_diag_i[i+1]; j++)
{
j_indx = A_tmp_diag_j[j];
L_diag_data[cnt_diag] = (- A_tmp_diag_data[j]*D_data[j_indx])*D_data[i];
L_diag_j[cnt_diag++] = j_indx+row_start;
}
for (j=A_tmp_offd_i[i]; j < A_tmp_offd_i[i+1]; j++)
{
j_indx = A_tmp_offd_j[j];
L_offd_data[cnt_offd] = (- A_tmp_offd_data[j]*D_data_offd[j_indx])*D_data[i];
L_offd_j[cnt_offd++] = remap[j_indx];
}
}
cnt_row += num_rows_tmp;
}
if (L_send_ptr)
{
for (i=num_sends_L-1; i > 0; i--)
L_send_ptr[i] = L_send_ptr[i-1];
L_send_ptr[0] = 0;
}
else
L_send_ptr = hypre_CTAlloc(HYPRE_Int,1);
if (L_recv_ptr)
{
for (i=num_recvs_L-1; i > 0; i--)
L_recv_ptr[i] = L_recv_ptr[i-1];
L_recv_ptr[0] = 0;
}
else
L_recv_ptr = hypre_CTAlloc(HYPRE_Int,1);
L_comm_pkg = hypre_CTAlloc(hypre_ParCSRCommPkg,1);
hypre_ParCSRCommPkgNumRecvs(L_comm_pkg) = num_recvs_L;
hypre_ParCSRCommPkgNumSends(L_comm_pkg) = num_sends_L;
hypre_ParCSRCommPkgRecvProcs(L_comm_pkg) = L_recv_procs;
hypre_ParCSRCommPkgSendProcs(L_comm_pkg) = L_send_procs;
hypre_ParCSRCommPkgRecvVecStarts(L_comm_pkg) = L_recv_ptr;
hypre_ParCSRCommPkgSendMapStarts(L_comm_pkg) = L_send_ptr;
hypre_ParCSRCommPkgSendMapElmts(L_comm_pkg) = L_send_map_elmts;
hypre_ParCSRCommPkgComm(L_comm_pkg) = comm;
Lambda = hypre_CTAlloc(hypre_ParCSRMatrix, 1);
hypre_ParCSRMatrixDiag(Lambda) = L_diag;
hypre_ParCSRMatrixOffd(Lambda) = L_offd;
hypre_ParCSRMatrixCommPkg(Lambda) = L_comm_pkg;
hypre_ParCSRMatrixComm(Lambda) = comm;
hypre_ParCSRMatrixOwnsData(Lambda) = 1;
hypre_ParAMGDataLambda(amg_data) = Lambda;
hypre_ParAMGDataRtilde(amg_data) = Rtilde;
hypre_ParAMGDataXtilde(amg_data) = Xtilde;
hypre_TFree(D_data_offd);
hypre_TFree(D_data);
if (num_procs > 1) hypre_TFree(buf_data);
hypre_TFree(remap);
hypre_TFree(buf_data);
hypre_TFree(level_start);
return Solve_err_flag;
}
HYPRE_Int
hypre_ParCSRMatrixMatvecT( HYPRE_Complex alpha,
hypre_ParCSRMatrix *A,
hypre_ParVector *x,
HYPRE_Complex beta,
hypre_ParVector *y )
{
hypre_ParCSRCommHandle **comm_handle;
hypre_ParCSRCommPkg *comm_pkg = hypre_ParCSRMatrixCommPkg(A);
hypre_CSRMatrix *diag = hypre_ParCSRMatrixDiag(A);
hypre_CSRMatrix *offd = hypre_ParCSRMatrixOffd(A);
hypre_Vector *x_local = hypre_ParVectorLocalVector(x);
hypre_Vector *y_local = hypre_ParVectorLocalVector(y);
hypre_Vector *y_tmp;
HYPRE_Int vecstride = hypre_VectorVectorStride( y_local );
HYPRE_Int idxstride = hypre_VectorIndexStride( y_local );
HYPRE_Complex *y_tmp_data, **y_buf_data;
HYPRE_Complex *y_local_data = hypre_VectorData(y_local);
HYPRE_Int num_rows = hypre_ParCSRMatrixGlobalNumRows(A);
HYPRE_Int num_cols = hypre_ParCSRMatrixGlobalNumCols(A);
HYPRE_Int num_cols_offd = hypre_CSRMatrixNumCols(offd);
HYPRE_Int x_size = hypre_ParVectorGlobalSize(x);
HYPRE_Int y_size = hypre_ParVectorGlobalSize(y);
HYPRE_Int num_vectors = hypre_VectorNumVectors(y_local);
HYPRE_Int i, j, jv, index, start, num_sends;
HYPRE_Int ierr = 0;
/*---------------------------------------------------------------------
* Check for size compatibility. MatvecT returns ierr = 1 if
* length of X doesn't equal the number of rows of A,
* ierr = 2 if the length of Y doesn't equal the number of
* columns of A, and ierr = 3 if both are true.
*
* Because temporary vectors are often used in MatvecT, none of
* these conditions terminates processing, and the ierr flag
* is informational only.
*--------------------------------------------------------------------*/
if (num_rows != x_size)
ierr = 1;
if (num_cols != y_size)
ierr = 2;
if (num_rows != x_size && num_cols != y_size)
ierr = 3;
/*-----------------------------------------------------------------------
*-----------------------------------------------------------------------*/
comm_handle = hypre_CTAlloc(hypre_ParCSRCommHandle*,num_vectors);
if ( num_vectors==1 )
{
y_tmp = hypre_SeqVectorCreate(num_cols_offd);
}
else
{
y_tmp = hypre_SeqMultiVectorCreate(num_cols_offd,num_vectors);
}
hypre_SeqVectorInitialize(y_tmp);
/*---------------------------------------------------------------------
* If there exists no CommPkg for A, a CommPkg is generated using
* equally load balanced partitionings
*--------------------------------------------------------------------*/
if (!comm_pkg)
{
hypre_MatvecCommPkgCreate(A);
comm_pkg = hypre_ParCSRMatrixCommPkg(A);
}
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
y_buf_data = hypre_CTAlloc( HYPRE_Complex*, num_vectors );
for ( jv=0; jv<num_vectors; ++jv )
y_buf_data[jv] = hypre_CTAlloc(HYPRE_Complex, hypre_ParCSRCommPkgSendMapStart
(comm_pkg, num_sends));
y_tmp_data = hypre_VectorData(y_tmp);
y_local_data = hypre_VectorData(y_local);
hypre_assert( idxstride==1 ); /* only 'column' storage of multivectors
* implemented so far */
if (num_cols_offd) hypre_CSRMatrixMatvecT(alpha, offd, x_local, 0.0, y_tmp);
for ( jv=0; jv<num_vectors; ++jv )
{
/* this is where we assume multivectors are 'column' storage */
comm_handle[jv] = hypre_ParCSRCommHandleCreate
( 2, comm_pkg, &(y_tmp_data[jv*num_cols_offd]), y_buf_data[jv] );
}
hypre_CSRMatrixMatvecT(alpha, diag, x_local, beta, y_local);
for ( jv=0; jv<num_vectors; ++jv )
{
hypre_ParCSRCommHandleDestroy(comm_handle[jv]);
comm_handle[jv] = NULL;
}
hypre_TFree(comm_handle);
if ( num_vectors==1 )
{
index = 0;
for (i = 0; i < num_sends; i++)
{
start = hypre_ParCSRCommPkgSendMapStart(comm_pkg, i);
for (j = start; j < hypre_ParCSRCommPkgSendMapStart(comm_pkg, i+1); j++)
y_local_data[hypre_ParCSRCommPkgSendMapElmt(comm_pkg,j)]
+= y_buf_data[0][index++];
}
}
else
for ( jv=0; jv<num_vectors; ++jv )
{
index = 0;
for (i = 0; i < num_sends; i++)
{
start = hypre_ParCSRCommPkgSendMapStart(comm_pkg, i);
for (j = start; j < hypre_ParCSRCommPkgSendMapStart(comm_pkg, i+1); j++)
y_local_data[ jv*vecstride +
idxstride*hypre_ParCSRCommPkgSendMapElmt(comm_pkg,j) ]
+= y_buf_data[jv][index++];
}
}
hypre_SeqVectorDestroy(y_tmp);
y_tmp = NULL;
for ( jv=0; jv<num_vectors; ++jv ) hypre_TFree(y_buf_data[jv]);
hypre_TFree(y_buf_data);
return ierr;
}
HYPRE_Int hypre_AMESetup(void *esolver)
{
HYPRE_Int ne, *edge_bc;
hypre_AMEData *ame_data = esolver;
hypre_AMSData *ams_data = ame_data -> precond;
if (ams_data -> beta_is_zero)
{
ame_data -> t1 = hypre_ParVectorInDomainOf(ams_data -> G);
ame_data -> t2 = hypre_ParVectorInDomainOf(ams_data -> G);
}
else
{
ame_data -> t1 = ams_data -> r1;
ame_data -> t2 = ams_data -> g1;
}
ame_data -> t3 = ams_data -> r0;
/* Eliminate boundary conditions in G = [Gii, Gib; 0, Gbb], i.e.,
compute [Gii, 0; 0, 0] */
{
HYPRE_Int i, j, k, nv;
HYPRE_Int *offd_edge_bc;
hypre_ParCSRMatrix *Gt;
nv = hypre_ParCSRMatrixNumCols(ams_data -> G);
ne = hypre_ParCSRMatrixNumRows(ams_data -> G);
edge_bc = hypre_TAlloc(HYPRE_Int, ne);
for (i = 0; i < ne; i++)
edge_bc[i] = 0;
/* Find boundary (eliminated) edges */
{
hypre_CSRMatrix *Ad = hypre_ParCSRMatrixDiag(ams_data -> A);
HYPRE_Int *AdI = hypre_CSRMatrixI(Ad);
HYPRE_Int *AdJ = hypre_CSRMatrixJ(Ad);
HYPRE_Real *AdA = hypre_CSRMatrixData(Ad);
hypre_CSRMatrix *Ao = hypre_ParCSRMatrixOffd(ams_data -> A);
HYPRE_Int *AoI = hypre_CSRMatrixI(Ao);
HYPRE_Real *AoA = hypre_CSRMatrixData(Ao);
HYPRE_Real l1_norm;
/* A row (edge) is boundary if its off-diag l1 norm is less than eps */
HYPRE_Real eps = DBL_EPSILON * 1e+4;
for (i = 0; i < ne; i++)
{
l1_norm = 0.0;
for (j = AdI[i]; j < AdI[i+1]; j++)
if (AdJ[j] != i)
l1_norm += fabs(AdA[j]);
if (AoI)
for (j = AoI[i]; j < AoI[i+1]; j++)
l1_norm += fabs(AoA[j]);
if (l1_norm < eps)
edge_bc[i] = 1;
}
}
hypre_ParCSRMatrixTranspose(ams_data -> G, &Gt, 1);
/* Use a Matvec communication to find which of the edges
connected to local vertices are on the boundary */
{
hypre_ParCSRCommHandle *comm_handle;
hypre_ParCSRCommPkg *comm_pkg;
HYPRE_Int num_sends, *int_buf_data;
HYPRE_Int index, start;
offd_edge_bc = hypre_CTAlloc(HYPRE_Int, hypre_CSRMatrixNumCols(hypre_ParCSRMatrixOffd(Gt)));
hypre_MatvecCommPkgCreate(Gt);
comm_pkg = hypre_ParCSRMatrixCommPkg(Gt);
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
int_buf_data = hypre_CTAlloc(HYPRE_Int,
hypre_ParCSRCommPkgSendMapStart(comm_pkg,
num_sends));
index = 0;
for (i = 0; i < num_sends; i++)
{
start = hypre_ParCSRCommPkgSendMapStart(comm_pkg, i);
for (j = start; j < hypre_ParCSRCommPkgSendMapStart(comm_pkg, i+1); j++)
{
k = hypre_ParCSRCommPkgSendMapElmt(comm_pkg,j);
int_buf_data[index++] = edge_bc[k];
}
}
comm_handle = hypre_ParCSRCommHandleCreate(11, comm_pkg,
int_buf_data, offd_edge_bc);
hypre_ParCSRCommHandleDestroy(comm_handle);
hypre_TFree(int_buf_data);
}
/* Eliminate boundary vertex entries in G^t */
{
hypre_CSRMatrix *Gtd = hypre_ParCSRMatrixDiag(Gt);
HYPRE_Int *GtdI = hypre_CSRMatrixI(Gtd);
HYPRE_Int *GtdJ = hypre_CSRMatrixJ(Gtd);
HYPRE_Real *GtdA = hypre_CSRMatrixData(Gtd);
hypre_CSRMatrix *Gto = hypre_ParCSRMatrixOffd(Gt);
HYPRE_Int *GtoI = hypre_CSRMatrixI(Gto);
HYPRE_Int *GtoJ = hypre_CSRMatrixJ(Gto);
HYPRE_Real *GtoA = hypre_CSRMatrixData(Gto);
HYPRE_Int bdr;
for (i = 0; i < nv; i++)
{
bdr = 0;
/* A vertex is boundary if it belongs to a boundary edge */
for (j = GtdI[i]; j < GtdI[i+1]; j++)
if (edge_bc[GtdJ[j]]) { bdr = 1; break; }
if (!bdr && GtoI)
for (j = GtoI[i]; j < GtoI[i+1]; j++)
if (offd_edge_bc[GtoJ[j]]) { bdr = 1; break; }
if (bdr)
{
for (j = GtdI[i]; j < GtdI[i+1]; j++)
/* if (!edge_bc[GtdJ[j]]) */
GtdA[j] = 0.0;
if (GtoI)
for (j = GtoI[i]; j < GtoI[i+1]; j++)
/* if (!offd_edge_bc[GtoJ[j]]) */
GtoA[j] = 0.0;
}
}
}
hypre_ParCSRMatrixTranspose(Gt, &ame_data -> G, 1);
hypre_ParCSRMatrixDestroy(Gt);
hypre_TFree(offd_edge_bc);
}
/* Compute G^t M G */
{
if (!hypre_ParCSRMatrixCommPkg(ame_data -> G))
hypre_MatvecCommPkgCreate(ame_data -> G);
if (!hypre_ParCSRMatrixCommPkg(ame_data -> M))
hypre_MatvecCommPkgCreate(ame_data -> M);
hypre_BoomerAMGBuildCoarseOperator(ame_data -> G,
ame_data -> M,
ame_data -> G,
&ame_data -> A_G);
hypre_ParCSRMatrixFixZeroRows(ame_data -> A_G);
}
/* Create AMG preconditioner and PCG-AMG solver for G^tMG */
{
HYPRE_BoomerAMGCreate(&ame_data -> B1_G);
HYPRE_BoomerAMGSetCoarsenType(ame_data -> B1_G, ams_data -> B_G_coarsen_type);
HYPRE_BoomerAMGSetAggNumLevels(ame_data -> B1_G, ams_data -> B_G_agg_levels);
HYPRE_BoomerAMGSetRelaxType(ame_data -> B1_G, ams_data -> B_G_relax_type);
HYPRE_BoomerAMGSetNumSweeps(ame_data -> B1_G, 1);
HYPRE_BoomerAMGSetMaxLevels(ame_data -> B1_G, 25);
HYPRE_BoomerAMGSetTol(ame_data -> B1_G, 0.0);
HYPRE_BoomerAMGSetMaxIter(ame_data -> B1_G, 1);
HYPRE_BoomerAMGSetStrongThreshold(ame_data -> B1_G, ams_data -> B_G_theta);
/* don't use exact solve on the coarsest level (matrix may be singular) */
HYPRE_BoomerAMGSetCycleRelaxType(ame_data -> B1_G,
ams_data -> B_G_relax_type,
3);
HYPRE_ParCSRPCGCreate(hypre_ParCSRMatrixComm(ame_data->A_G),
&ame_data -> B2_G);
HYPRE_PCGSetPrintLevel(ame_data -> B2_G, 0);
HYPRE_PCGSetTol(ame_data -> B2_G, 1e-12);
HYPRE_PCGSetMaxIter(ame_data -> B2_G, 20);
HYPRE_PCGSetPrecond(ame_data -> B2_G,
(HYPRE_PtrToSolverFcn) HYPRE_BoomerAMGSolve,
(HYPRE_PtrToSolverFcn) HYPRE_BoomerAMGSetup,
ame_data -> B1_G);
HYPRE_ParCSRPCGSetup(ame_data -> B2_G,
(HYPRE_ParCSRMatrix)ame_data->A_G,
(HYPRE_ParVector)ame_data->t1,
(HYPRE_ParVector)ame_data->t2);
}
/* Setup LOBPCG */
{
HYPRE_Int seed = 75;
mv_InterfaceInterpreter* interpreter;
mv_MultiVectorPtr eigenvectors;
ame_data -> interpreter = hypre_CTAlloc(mv_InterfaceInterpreter,1);
interpreter = (mv_InterfaceInterpreter*) ame_data -> interpreter;
HYPRE_ParCSRSetupInterpreter(interpreter);
ame_data -> eigenvalues = hypre_CTAlloc(HYPRE_Real, ame_data -> block_size);
ame_data -> eigenvectors =
mv_MultiVectorCreateFromSampleVector(interpreter,
ame_data -> block_size,
ame_data -> t3);
eigenvectors = (mv_MultiVectorPtr) ame_data -> eigenvectors;
mv_MultiVectorSetRandom (eigenvectors, seed);
/* Make the initial vectors discretely divergence free */
{
HYPRE_Int i, j;
HYPRE_Real *data;
mv_TempMultiVector* tmp = mv_MultiVectorGetData(eigenvectors);
HYPRE_ParVector *v = (HYPRE_ParVector*)(tmp -> vector);
hypre_ParVector *vi;
for (i = 0; i < ame_data -> block_size; i++)
{
vi = (hypre_ParVector*) v[i];
data = hypre_VectorData(hypre_ParVectorLocalVector(vi));
for (j = 0; j < ne; j++)
if (edge_bc[j])
data[j] = 0.0;
hypre_AMEDiscrDivFreeComponent(esolver, vi);
}
}
}
hypre_TFree(edge_bc);
return hypre_error_flag;
}
HYPRE_Int
hypre_ParCSRMatrixMatvec( HYPRE_Complex alpha,
hypre_ParCSRMatrix *A,
hypre_ParVector *x,
HYPRE_Complex beta,
hypre_ParVector *y )
{
hypre_ParCSRCommHandle **comm_handle;
hypre_ParCSRCommPkg *comm_pkg = hypre_ParCSRMatrixCommPkg(A);
hypre_CSRMatrix *diag = hypre_ParCSRMatrixDiag(A);
hypre_CSRMatrix *offd = hypre_ParCSRMatrixOffd(A);
hypre_Vector *x_local = hypre_ParVectorLocalVector(x);
hypre_Vector *y_local = hypre_ParVectorLocalVector(y);
HYPRE_Int num_rows = hypre_ParCSRMatrixGlobalNumRows(A);
HYPRE_Int num_cols = hypre_ParCSRMatrixGlobalNumCols(A);
hypre_Vector *x_tmp;
HYPRE_Int x_size = hypre_ParVectorGlobalSize(x);
HYPRE_Int y_size = hypre_ParVectorGlobalSize(y);
HYPRE_Int num_vectors = hypre_VectorNumVectors(x_local);
HYPRE_Int num_cols_offd = hypre_CSRMatrixNumCols(offd);
HYPRE_Int ierr = 0;
HYPRE_Int num_sends, i, j, jv, index, start;
HYPRE_Int vecstride = hypre_VectorVectorStride( x_local );
HYPRE_Int idxstride = hypre_VectorIndexStride( x_local );
HYPRE_Complex *x_tmp_data, **x_buf_data;
HYPRE_Complex *x_local_data = hypre_VectorData(x_local);
/*---------------------------------------------------------------------
* Check for size compatibility. ParMatvec returns ierr = 11 if
* length of X doesn't equal the number of columns of A,
* ierr = 12 if the length of Y doesn't equal the number of rows
* of A, and ierr = 13 if both are true.
*
* Because temporary vectors are often used in ParMatvec, none of
* these conditions terminates processing, and the ierr flag
* is informational only.
*--------------------------------------------------------------------*/
hypre_assert( idxstride>0 );
if (num_cols != x_size)
ierr = 11;
if (num_rows != y_size)
ierr = 12;
if (num_cols != x_size && num_rows != y_size)
ierr = 13;
hypre_assert( hypre_VectorNumVectors(y_local)==num_vectors );
if ( num_vectors==1 )
x_tmp = hypre_SeqVectorCreate( num_cols_offd );
else
{
hypre_assert( num_vectors>1 );
x_tmp = hypre_SeqMultiVectorCreate( num_cols_offd, num_vectors );
}
hypre_SeqVectorInitialize(x_tmp);
x_tmp_data = hypre_VectorData(x_tmp);
comm_handle = hypre_CTAlloc(hypre_ParCSRCommHandle*,num_vectors);
/*---------------------------------------------------------------------
* If there exists no CommPkg for A, a CommPkg is generated using
* equally load balanced partitionings
*--------------------------------------------------------------------*/
if (!comm_pkg)
{
hypre_MatvecCommPkgCreate(A);
comm_pkg = hypre_ParCSRMatrixCommPkg(A);
}
num_sends = hypre_ParCSRCommPkgNumSends(comm_pkg);
x_buf_data = hypre_CTAlloc( HYPRE_Complex*, num_vectors );
for ( jv=0; jv<num_vectors; ++jv )
x_buf_data[jv] = hypre_CTAlloc(HYPRE_Complex, hypre_ParCSRCommPkgSendMapStart
(comm_pkg, num_sends));
if ( num_vectors==1 )
{
index = 0;
for (i = 0; i < num_sends; i++)
{
start = hypre_ParCSRCommPkgSendMapStart(comm_pkg, i);
for (j = start; j < hypre_ParCSRCommPkgSendMapStart(comm_pkg, i+1); j++)
x_buf_data[0][index++]
= x_local_data[hypre_ParCSRCommPkgSendMapElmt(comm_pkg,j)];
}
}
else
for ( jv=0; jv<num_vectors; ++jv )
{
index = 0;
for (i = 0; i < num_sends; i++)
{
start = hypre_ParCSRCommPkgSendMapStart(comm_pkg, i);
for (j = start; j < hypre_ParCSRCommPkgSendMapStart(comm_pkg, i+1); j++)
x_buf_data[jv][index++]
= x_local_data[
jv*vecstride +
idxstride*hypre_ParCSRCommPkgSendMapElmt(comm_pkg,j) ];
}
}
hypre_assert( idxstride==1 );
/* ... The assert is because the following loop only works for 'column'
storage of a multivector. This needs to be fixed to work more generally,
at least for 'row' storage. This in turn, means either change CommPkg so
num_sends is no.zones*no.vectors (not no.zones) or, less dangerously, put
a stride in the logic of CommHandleCreate (stride either from a new arg or
a new variable inside CommPkg). Or put the num_vector iteration inside
CommHandleCreate (perhaps a new multivector variant of it).
*/
for ( jv=0; jv<num_vectors; ++jv )
{
comm_handle[jv] = hypre_ParCSRCommHandleCreate
( 1, comm_pkg, x_buf_data[jv], &(x_tmp_data[jv*num_cols_offd]) );
}
hypre_CSRMatrixMatvec( alpha, diag, x_local, beta, y_local);
for ( jv=0; jv<num_vectors; ++jv )
{
hypre_ParCSRCommHandleDestroy(comm_handle[jv]);
comm_handle[jv] = NULL;
}
hypre_TFree(comm_handle);
if (num_cols_offd) hypre_CSRMatrixMatvec( alpha, offd, x_tmp, 1.0, y_local);
hypre_SeqVectorDestroy(x_tmp);
x_tmp = NULL;
for ( jv=0; jv<num_vectors; ++jv ) hypre_TFree(x_buf_data[jv]);
hypre_TFree(x_buf_data);
return ierr;
}
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_BoomerAMGCreateNodalA(hypre_ParCSRMatrix *A,
HYPRE_Int num_functions,
HYPRE_Int *dof_func,
HYPRE_Int option,
HYPRE_Int diag_option,
hypre_ParCSRMatrix **AN_ptr)
{
MPI_Comm comm = hypre_ParCSRMatrixComm(A);
hypre_CSRMatrix *A_diag = hypre_ParCSRMatrixDiag(A);
HYPRE_Int *A_diag_i = hypre_CSRMatrixI(A_diag);
double *A_diag_data = hypre_CSRMatrixData(A_diag);
hypre_CSRMatrix *A_offd = hypre_ParCSRMatrixOffd(A);
HYPRE_Int *A_offd_i = hypre_CSRMatrixI(A_offd);
double *A_offd_data = hypre_CSRMatrixData(A_offd);
HYPRE_Int *A_diag_j = hypre_CSRMatrixJ(A_diag);
HYPRE_Int *A_offd_j = hypre_CSRMatrixJ(A_offd);
HYPRE_Int *row_starts = hypre_ParCSRMatrixRowStarts(A);
HYPRE_Int *col_map_offd = hypre_ParCSRMatrixColMapOffd(A);
HYPRE_Int num_variables = hypre_CSRMatrixNumRows(A_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;
double *AN_diag_data;
hypre_CSRMatrix *AN_offd;
HYPRE_Int *AN_offd_i;
HYPRE_Int *AN_offd_j;
double *AN_offd_data;
HYPRE_Int *col_map_offd_AN;
HYPRE_Int *new_col_map_offd;
HYPRE_Int *row_starts_AN;
HYPRE_Int AN_num_nonzeros_diag = 0;
HYPRE_Int AN_num_nonzeros_offd = 0;
HYPRE_Int num_cols_offd_AN;
HYPRE_Int new_num_cols_offd;
hypre_ParCSRCommPkg *comm_pkg = hypre_ParCSRMatrixCommPkg(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 *new_send_map_elmts;
HYPRE_Int *recv_procs;
HYPRE_Int *recv_vec_starts;
hypre_ParCSRCommPkg *comm_pkg_AN;
HYPRE_Int *send_procs_AN;
HYPRE_Int *send_map_starts_AN;
HYPRE_Int *send_map_elmts_AN;
HYPRE_Int *recv_procs_AN;
HYPRE_Int *recv_vec_starts_AN;
HYPRE_Int i, j, k, k_map;
HYPRE_Int ierr = 0;
HYPRE_Int index, row;
HYPRE_Int start_index;
HYPRE_Int num_procs;
HYPRE_Int node, cnt;
HYPRE_Int mode;
HYPRE_Int new_send_elmts_size;
HYPRE_Int global_num_nodes;
HYPRE_Int num_nodes;
HYPRE_Int num_fun2;
HYPRE_Int *map_to_node;
HYPRE_Int *map_to_map;
HYPRE_Int *counter;
double sum;
double *data;
hypre_MPI_Comm_size(comm,&num_procs);
if (!comm_pkg)
{
hypre_MatvecCommPkgCreate(A);
comm_pkg = hypre_ParCSRMatrixCommPkg(A);
}
mode = fabs(option);
comm_pkg_AN = NULL;
col_map_offd_AN = NULL;
#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]/num_functions;
if (row_starts_AN[i]*num_functions < row_starts[i])
{
hypre_printf("nodes not properly aligned or incomplete info!\n");
return (87);
}
}
global_num_nodes = hypre_ParCSRMatrixGlobalNumRows(A)/num_functions;
#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]/num_functions;
if (row_starts_AN[i]*num_functions < row_starts[i])
{
hypre_printf("nodes not properly aligned or incomplete info!\n");
return (87);
}
}
global_num_nodes = row_starts_AN[num_procs];
#endif
num_nodes = num_variables/num_functions;
num_fun2 = num_functions*num_functions;
map_to_node = hypre_CTAlloc(HYPRE_Int, num_variables);
AN_diag_i = hypre_CTAlloc(HYPRE_Int, num_nodes+1);
counter = hypre_CTAlloc(HYPRE_Int, num_nodes);
for (i=0; i < num_variables; i++)
map_to_node[i] = i/num_functions;
for (i=0; i < num_nodes; i++)
counter[i] = -1;
AN_num_nonzeros_diag = 0;
row = 0;
for (i=0; i < num_nodes; i++)
{
AN_diag_i[i] = AN_num_nonzeros_diag;
for (j=0; j < num_functions; j++)
{
for (k=A_diag_i[row]; k < A_diag_i[row+1]; k++)
{
k_map = map_to_node[A_diag_j[k]];
if (counter[k_map] < i)
{
counter[k_map] = i;
AN_num_nonzeros_diag++;
}
}
row++;
}
}
AN_diag_i[num_nodes] = AN_num_nonzeros_diag;
AN_diag_j = hypre_CTAlloc(HYPRE_Int, AN_num_nonzeros_diag);
AN_diag_data = hypre_CTAlloc(double, AN_num_nonzeros_diag);
AN_diag = hypre_CSRMatrixCreate(num_nodes,num_nodes,AN_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_nodes; i++)
counter[i] = -1;
index = 0;
start_index = 0;
row = 0;
switch (mode)
{
case 1: /* frobenius norm */
{
for (i=0; i < num_nodes; i++)
{
for (j=0; j < num_functions; j++)
{
for (k=A_diag_i[row]; k < A_diag_i[row+1]; k++)
{
k_map = map_to_node[A_diag_j[k]];
if (counter[k_map] < start_index)
{
counter[k_map] = index;
AN_diag_j[index] = k_map;
AN_diag_data[index] = A_diag_data[k]*A_diag_data[k];
index++;
}
else
{
AN_diag_data[counter[k_map]] +=
A_diag_data[k]*A_diag_data[k];
}
}
row++;
}
start_index = index;
}
for (i=0; i < AN_num_nonzeros_diag; i++)
AN_diag_data[i] = sqrt(AN_diag_data[i]);
}
break;
case 2: /* sum of abs. value of all elements in each block */
{
for (i=0; i < num_nodes; i++)
{
for (j=0; j < num_functions; j++)
{
for (k=A_diag_i[row]; k < A_diag_i[row+1]; k++)
{
k_map = map_to_node[A_diag_j[k]];
if (counter[k_map] < start_index)
{
counter[k_map] = index;
AN_diag_j[index] = k_map;
AN_diag_data[index] = fabs(A_diag_data[k]);
index++;
}
else
{
AN_diag_data[counter[k_map]] += fabs(A_diag_data[k]);
}
}
row++;
}
start_index = index;
}
for (i=0; i < AN_num_nonzeros_diag; i++)
AN_diag_data[i] /= num_fun2;
}
break;
case 3: /* largest element of each block (sets true value - not abs. value) */
{
for (i=0; i < num_nodes; i++)
{
for (j=0; j < num_functions; j++)
{
for (k=A_diag_i[row]; k < A_diag_i[row+1]; k++)
{
k_map = map_to_node[A_diag_j[k]];
if (counter[k_map] < start_index)
{
counter[k_map] = index;
AN_diag_j[index] = k_map;
AN_diag_data[index] = A_diag_data[k];
index++;
}
else
{
if (fabs(A_diag_data[k]) >
fabs(AN_diag_data[counter[k_map]]))
AN_diag_data[counter[k_map]] = A_diag_data[k];
}
}
row++;
}
start_index = index;
}
}
break;
case 4: /* inf. norm (row-sum) */
{
data = hypre_CTAlloc(double, AN_num_nonzeros_diag*num_functions);
for (i=0; i < num_nodes; i++)
{
for (j=0; j < num_functions; j++)
{
for (k=A_diag_i[row]; k < A_diag_i[row+1]; k++)
{
k_map = map_to_node[A_diag_j[k]];
if (counter[k_map] < start_index)
{
counter[k_map] = index;
AN_diag_j[index] = k_map;
data[index*num_functions + j] = fabs(A_diag_data[k]);
index++;
}
else
{
data[(counter[k_map])*num_functions + j] += fabs(A_diag_data[k]);
}
}
row++;
}
start_index = index;
}
for (i=0; i < AN_num_nonzeros_diag; i++)
{
AN_diag_data[i] = data[i*num_functions];
for (j=1; j< num_functions; j++)
{
AN_diag_data[i] = hypre_max( AN_diag_data[i],data[i*num_functions+j]);
}
}
hypre_TFree(data);
}
break;
case 6: /* sum of all elements in each block */
{
for (i=0; i < num_nodes; i++)
{
for (j=0; j < num_functions; j++)
{
for (k=A_diag_i[row]; k < A_diag_i[row+1]; k++)
{
k_map = map_to_node[A_diag_j[k]];
if (counter[k_map] < start_index)
{
counter[k_map] = index;
AN_diag_j[index] = k_map;
AN_diag_data[index] = (A_diag_data[k]);
index++;
}
else
{
AN_diag_data[counter[k_map]] += (A_diag_data[k]);
}
}
row++;
}
start_index = index;
}
}
break;
}
if (diag_option ==1 )
{
/* make the diag entry the negative of the sum of off-diag entries (DO MORE BELOW) */
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];
}
}
num_nonzeros_offd = A_offd_i[num_variables];
AN_offd_i = hypre_CTAlloc(HYPRE_Int, num_nodes+1);
num_cols_offd_AN = 0;
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);
recv_procs = hypre_ParCSRCommPkgRecvProcs(comm_pkg);
recv_vec_starts = hypre_ParCSRCommPkgRecvVecStarts(comm_pkg);
send_procs_AN = NULL;
send_map_elmts_AN = NULL;
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);
recv_vec_starts_AN = hypre_CTAlloc(HYPRE_Int,num_recvs+1);
recv_procs_AN = NULL;
if (num_recvs) recv_procs_AN = hypre_CTAlloc(HYPRE_Int,num_recvs);
for (i=0; i < num_sends; i++)
send_procs_AN[i] = send_procs[i];
for (i=0; i < num_recvs; i++)
recv_procs_AN[i] = recv_procs[i];
send_map_starts_AN[0] = 0;
cnt = 0;
for (i=0; i < num_sends; i++)
{
k_map = send_map_starts[i];
if (send_map_starts[i+1]-k_map)
send_map_elmts_AN[cnt++] = send_map_elmts[k_map]/num_functions;
for (j=send_map_starts[i]+1; j < send_map_starts[i+1]; j++)
{
node = send_map_elmts[j]/num_functions;
if (node > send_map_elmts_AN[cnt-1])
send_map_elmts_AN[cnt++] = node;
}
send_map_starts_AN[i+1] = cnt;
}
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;
hypre_ParCSRCommPkgRecvProcs(comm_pkg_AN) = recv_procs_AN;
hypre_ParCSRCommPkgRecvVecStarts(comm_pkg_AN) = recv_vec_starts_AN;
}
num_cols_offd = hypre_CSRMatrixNumCols(A_offd);
if (num_cols_offd)
{
if (num_cols_offd > num_variables)
{
hypre_TFree(map_to_node);
map_to_node = hypre_CTAlloc(HYPRE_Int,num_cols_offd);
}
num_cols_offd_AN = 1;
map_to_node[0] = col_map_offd[0]/num_functions;
for (i=1; i < num_cols_offd; i++)
{
map_to_node[i] = col_map_offd[i]/num_functions;
if (map_to_node[i] > map_to_node[i-1]) num_cols_offd_AN++;
}
if (num_cols_offd_AN > num_nodes)
{
hypre_TFree(counter);
counter = hypre_CTAlloc(HYPRE_Int,num_cols_offd_AN);
}
map_to_map = NULL;
col_map_offd_AN = NULL;
map_to_map = hypre_CTAlloc(HYPRE_Int, num_cols_offd);
col_map_offd_AN = hypre_CTAlloc(HYPRE_Int,num_cols_offd_AN);
col_map_offd_AN[0] = map_to_node[0];
recv_vec_starts_AN[0] = 0;
cnt = 1;
for (i=0; i < num_recvs; i++)
{
for (j=recv_vec_starts[i]; j < recv_vec_starts[i+1]; j++)
{
node = map_to_node[j];
if (node > col_map_offd_AN[cnt-1])
{
col_map_offd_AN[cnt++] = node;
}
map_to_map[j] = cnt-1;
}
recv_vec_starts_AN[i+1] = cnt;
}
for (i=0; i < num_cols_offd_AN; i++)
counter[i] = -1;
AN_num_nonzeros_offd = 0;
row = 0;
for (i=0; i < num_nodes; i++)
{
AN_offd_i[i] = AN_num_nonzeros_offd;
for (j=0; j < num_functions; j++)
{
for (k=A_offd_i[row]; k < A_offd_i[row+1]; k++)
{
k_map = map_to_map[A_offd_j[k]];
if (counter[k_map] < i)
{
counter[k_map] = i;
AN_num_nonzeros_offd++;
}
}
row++;
}
}
AN_offd_i[num_nodes] = AN_num_nonzeros_offd;
}
AN_offd = hypre_CSRMatrixCreate(num_nodes,num_cols_offd_AN,
AN_num_nonzeros_offd);
hypre_CSRMatrixI(AN_offd) = AN_offd_i;
if (AN_num_nonzeros_offd)
{
AN_offd_j = hypre_CTAlloc(HYPRE_Int, AN_num_nonzeros_offd);
AN_offd_data = hypre_CTAlloc(double, AN_num_nonzeros_offd);
hypre_CSRMatrixJ(AN_offd) = AN_offd_j;
hypre_CSRMatrixData(AN_offd) = AN_offd_data;
for (i=0; i < num_cols_offd_AN; i++)
counter[i] = -1;
index = 0;
row = 0;
AN_offd_i[0] = 0;
start_index = 0;
switch (mode)
{
case 1: /* frobenius norm */
{
for (i=0; i < num_nodes; i++)
{
for (j=0; j < num_functions; j++)
{
for (k=A_offd_i[row]; k < A_offd_i[row+1]; k++)
{
k_map = map_to_map[A_offd_j[k]];
if (counter[k_map] < start_index)
{
counter[k_map] = index;
AN_offd_j[index] = k_map;
AN_offd_data[index] = A_offd_data[k]*A_offd_data[k];
index++;
}
else
{
AN_offd_data[counter[k_map]] +=
A_offd_data[k]*A_offd_data[k];
}
}
row++;
}
start_index = index;
}
for (i=0; i < AN_num_nonzeros_offd; i++)
AN_offd_data[i] = sqrt(AN_offd_data[i]);
}
break;
case 2: /* sum of abs. value of all elements in block */
{
for (i=0; i < num_nodes; i++)
{
for (j=0; j < num_functions; j++)
{
for (k=A_offd_i[row]; k < A_offd_i[row+1]; k++)
{
k_map = map_to_map[A_offd_j[k]];
if (counter[k_map] < start_index)
{
counter[k_map] = index;
AN_offd_j[index] = k_map;
AN_offd_data[index] = fabs(A_offd_data[k]);
index++;
}
else
{
AN_offd_data[counter[k_map]] += fabs(A_offd_data[k]);
}
}
row++;
}
start_index = index;
}
for (i=0; i < AN_num_nonzeros_offd; i++)
AN_offd_data[i] /= num_fun2;
}
break;
case 3: /* largest element in each block (not abs. value ) */
{
for (i=0; i < num_nodes; i++)
{
for (j=0; j < num_functions; j++)
{
for (k=A_offd_i[row]; k < A_offd_i[row+1]; k++)
{
k_map = map_to_map[A_offd_j[k]];
if (counter[k_map] < start_index)
{
counter[k_map] = index;
AN_offd_j[index] = k_map;
AN_offd_data[index] = A_offd_data[k];
index++;
}
else
{
if (fabs(A_offd_data[k]) >
fabs(AN_offd_data[counter[k_map]]))
AN_offd_data[counter[k_map]] = A_offd_data[k];
}
}
row++;
}
start_index = index;
}
}
break;
case 4: /* inf. norm (row-sum) */
{
data = hypre_CTAlloc(double, AN_num_nonzeros_offd*num_functions);
for (i=0; i < num_nodes; i++)
{
for (j=0; j < num_functions; j++)
{
for (k=A_offd_i[row]; k < A_offd_i[row+1]; k++)
{
k_map = map_to_map[A_offd_j[k]];
if (counter[k_map] < start_index)
{
counter[k_map] = index;
AN_offd_j[index] = k_map;
data[index*num_functions + j] = fabs(A_offd_data[k]);
index++;
}
else
{
data[(counter[k_map])*num_functions + j] += fabs(A_offd_data[k]);
}
}
row++;
}
start_index = index;
}
for (i=0; i < AN_num_nonzeros_offd; i++)
{
AN_offd_data[i] = data[i*num_functions];
for (j=1; j< num_functions; j++)
{
AN_offd_data[i] = hypre_max( AN_offd_data[i],data[i*num_functions+j]);
}
}
hypre_TFree(data);
}
break;
case 6: /* sum of value of all elements in block */
{
for (i=0; i < num_nodes; i++)
{
for (j=0; j < num_functions; j++)
{
for (k=A_offd_i[row]; k < A_offd_i[row+1]; k++)
{
k_map = map_to_map[A_offd_j[k]];
if (counter[k_map] < start_index)
{
counter[k_map] = index;
AN_offd_j[index] = k_map;
AN_offd_data[index] = (A_offd_data[k]);
index++;
}
else
{
AN_offd_data[counter[k_map]] += (A_offd_data[k]);
}
}
row++;
}
start_index = index;
}
}
break;
}
hypre_TFree(map_to_map);
}
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 */
}
}
AN = hypre_ParCSRMatrixCreate(comm, global_num_nodes, global_num_nodes,
row_starts_AN, row_starts_AN, num_cols_offd_AN,
AN_num_nonzeros_diag, AN_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;
new_num_cols_offd = num_functions*num_cols_offd_AN;
if (new_num_cols_offd > num_cols_offd)
{
new_col_map_offd = hypre_CTAlloc(HYPRE_Int, new_num_cols_offd);
cnt = 0;
for (i=0; i < num_cols_offd_AN; i++)
{
for (j=0; j < num_functions; j++)
{
new_col_map_offd[cnt++] = num_functions*col_map_offd_AN[i]+j;
}
}
cnt = 0;
for (i=0; i < num_cols_offd; i++)
{
while (col_map_offd[i] > new_col_map_offd[cnt])
cnt++;
col_map_offd[i] = cnt++;
}
for (i=0; i < num_recvs+1; i++)
{
recv_vec_starts[i] = num_functions*recv_vec_starts_AN[i];
}
for (i=0; i < num_nonzeros_offd; i++)
{
j = A_offd_j[i];
A_offd_j[i] = col_map_offd[j];
}
hypre_ParCSRMatrixColMapOffd(A) = new_col_map_offd;
hypre_CSRMatrixNumCols(A_offd) = new_num_cols_offd;
hypre_TFree(col_map_offd);
}
hypre_TFree(map_to_node);
new_send_elmts_size = send_map_starts_AN[num_sends]*num_functions;
if (new_send_elmts_size > send_map_starts[num_sends])
{
new_send_map_elmts = hypre_CTAlloc(HYPRE_Int,new_send_elmts_size);
cnt = 0;
send_map_starts[0] = 0;
for (i=0; i < num_sends; i++)
{
send_map_starts[i+1] = send_map_starts_AN[i+1]*num_functions;
for (j=send_map_starts_AN[i]; j < send_map_starts_AN[i+1]; j++)
{
for (k=0; k < num_functions; k++)
new_send_map_elmts[cnt++] = send_map_elmts_AN[j]*num_functions+k;
}
}
hypre_TFree(send_map_elmts);
hypre_ParCSRCommPkgSendMapElmts(comm_pkg) = new_send_map_elmts;
}
*AN_ptr = AN;
hypre_TFree(counter);
return (ierr);
}
hypre_ParCSRMatrix *
hypre_ParCSRBlockMatrixConvertToParCSRMatrix(hypre_ParCSRBlockMatrix *matrix)
{
MPI_Comm comm = hypre_ParCSRBlockMatrixComm(matrix);
hypre_CSRBlockMatrix *diag = hypre_ParCSRBlockMatrixDiag(matrix);
hypre_CSRBlockMatrix *offd = hypre_ParCSRBlockMatrixOffd(matrix);
HYPRE_Int block_size = hypre_ParCSRBlockMatrixBlockSize(matrix);
HYPRE_Int global_num_rows = hypre_ParCSRBlockMatrixGlobalNumRows(matrix);
HYPRE_Int global_num_cols = hypre_ParCSRBlockMatrixGlobalNumCols(matrix);
HYPRE_Int *row_starts = hypre_ParCSRBlockMatrixRowStarts(matrix);
HYPRE_Int *col_starts = hypre_ParCSRBlockMatrixColStarts(matrix);
HYPRE_Int num_cols_offd = hypre_CSRBlockMatrixNumCols(offd);
HYPRE_Int num_nonzeros_diag = hypre_CSRBlockMatrixNumNonzeros(diag);
HYPRE_Int num_nonzeros_offd = hypre_CSRBlockMatrixNumNonzeros(offd);
hypre_ParCSRMatrix *matrix_C;
HYPRE_Int *matrix_C_row_starts;
HYPRE_Int *matrix_C_col_starts;
HYPRE_Int *counter, *new_j_map;
HYPRE_Int size_j, size_map, index, new_num_cols, removed = 0;
HYPRE_Int *offd_j, *col_map_offd, *new_col_map_offd;
HYPRE_Int num_procs, i, j;
hypre_CSRMatrix *diag_nozeros, *offd_nozeros;
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]*block_size;
matrix_C_col_starts[i] = col_starts[i]*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]*block_size;
matrix_C_col_starts[i] = col_starts[i]*block_size;
}
#endif
matrix_C = hypre_ParCSRMatrixCreate(comm, global_num_rows*block_size,
global_num_cols*block_size, matrix_C_row_starts,
matrix_C_col_starts, num_cols_offd*block_size,
num_nonzeros_diag*block_size*block_size,
num_nonzeros_offd*block_size*block_size);
hypre_ParCSRMatrixInitialize(matrix_C);
/* DIAG */
hypre_CSRMatrixDestroy(hypre_ParCSRMatrixDiag(matrix_C));
hypre_ParCSRMatrixDiag(matrix_C) =
hypre_CSRBlockMatrixConvertToCSRMatrix(diag);
/* AB - added to delete zeros */
diag_nozeros = hypre_CSRMatrixDeleteZeros(
hypre_ParCSRMatrixDiag(matrix_C), 1e-14);
if(diag_nozeros)
{
hypre_CSRMatrixDestroy(hypre_ParCSRMatrixDiag(matrix_C));
hypre_ParCSRMatrixDiag(matrix_C) = diag_nozeros;
}
/* OFF-DIAG */
hypre_CSRMatrixDestroy(hypre_ParCSRMatrixOffd(matrix_C));
hypre_ParCSRMatrixOffd(matrix_C) =
hypre_CSRBlockMatrixConvertToCSRMatrix(offd);
/* AB - added to delete zeros - this just deletes from data and j arrays */
offd_nozeros = hypre_CSRMatrixDeleteZeros(
hypre_ParCSRMatrixOffd(matrix_C), 1e-14);
if(offd_nozeros)
{
hypre_CSRMatrixDestroy(hypre_ParCSRMatrixOffd(matrix_C));
hypre_ParCSRMatrixOffd(matrix_C) = offd_nozeros;
removed = 1;
}
/* now convert the col_map_offd */
for (i = 0; i < num_cols_offd; i++)
for (j = 0; j < block_size; j++)
hypre_ParCSRMatrixColMapOffd(matrix_C)[i*block_size + j] =
hypre_ParCSRBlockMatrixColMapOffd(matrix)[i]*block_size + j;
/* if we deleted zeros, then it is possible that col_map_offd can be
compressed as well - this requires some amount of work that could be skipped... */
if (removed)
{
size_map = num_cols_offd*block_size;
counter = hypre_CTAlloc(HYPRE_Int, size_map);
new_j_map = hypre_CTAlloc(HYPRE_Int, size_map);
offd_j = hypre_CSRMatrixJ(hypre_ParCSRMatrixOffd(matrix_C));
col_map_offd = hypre_ParCSRMatrixColMapOffd(matrix_C);
size_j = hypre_CSRMatrixNumNonzeros(hypre_ParCSRMatrixOffd(matrix_C));
/* mark which off_d entries are found in j */
for (i=0; i < size_j; i++)
{
counter[offd_j[i]] = 1;
}
/*now find new numbering for columns (we will delete the
cols where counter = 0*/
index = 0;
for (i=0; i < size_map; i++)
{
if (counter[i]) new_j_map[i] = index++;
}
new_num_cols = index;
/* if there are some col entries to remove: */
if (!(index == size_map))
{
/* go thru j and adjust entries */
for (i=0; i < size_j; i++)
{
offd_j[i] = new_j_map[offd_j[i]];
}
/*now go thru col map and get rid of non-needed entries */
new_col_map_offd = hypre_CTAlloc(HYPRE_Int, new_num_cols);
index = 0;
for (i=0; i < size_map; i++)
{
if (counter[i])
{
new_col_map_offd[index++] = col_map_offd[i];
}
}
/* set the new col map */
hypre_TFree(col_map_offd);
hypre_ParCSRMatrixColMapOffd(matrix_C) = new_col_map_offd;
/* modify the number of cols */
hypre_CSRMatrixNumCols(hypre_ParCSRMatrixOffd(matrix_C)) = new_num_cols;
}
hypre_TFree(new_j_map);
hypre_TFree(counter);
}
hypre_ParCSRMatrixSetNumNonzeros( matrix_C );
hypre_ParCSRMatrixSetDNumNonzeros( matrix_C );
/* we will not copy the comm package */
hypre_ParCSRMatrixCommPkg(matrix_C) = NULL;
return matrix_C;
}
HYPRE_Int
main( HYPRE_Int argc,
char *argv[] )
{
HYPRE_Int num_procs, myid;
HYPRE_Int verbose = 0, build_matrix_type = 1;
HYPRE_Int index, matrix_arg_index, commpkg_flag=3;
HYPRE_Int i, k, ierr=0;
HYPRE_Int row_start, row_end;
HYPRE_Int col_start, col_end, global_num_rows;
HYPRE_Int *row_part, *col_part;
char *csrfilename;
HYPRE_Int preload = 0, loop = 0, loop2 = LOOP2;
HYPRE_Int bcast_rows[2], *info;
hypre_ParCSRMatrix *parcsr_A, *small_A;
HYPRE_ParCSRMatrix A_temp, A_temp_small;
hypre_CSRMatrix *A_CSR;
hypre_ParCSRCommPkg *comm_pkg;
HYPRE_Int nx, ny, nz;
HYPRE_Int P, Q, R;
HYPRE_Int p, q, r;
HYPRE_Real values[4];
hypre_ParVector *x_new;
hypre_ParVector *y_new, *y;
HYPRE_Int *row_starts;
HYPRE_Real ans;
HYPRE_Real start_time, end_time, total_time, *loop_times;
HYPRE_Real T_avg, T_std;
HYPRE_Int noparmprint = 0;
#if mydebug
HYPRE_Int j, tmp_int;
#endif
/*-----------------------------------------------------------
* 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, &myid );
/*-----------------------------------------------------------
* default - is 27pt laplace
*-----------------------------------------------------------*/
build_matrix_type = 2;
matrix_arg_index = argc;
/*-----------------------------------------------------------
* Parse command line
*-----------------------------------------------------------*/
index = 1;
while ( index < argc)
{
if ( strcmp(argv[index], "-verbose") == 0 )
{
index++;
verbose = 1;
}
else if ( strcmp(argv[index], "-fromonecsrfile") == 0 )
{
index++;
build_matrix_type = 1;
matrix_arg_index = index; /*this tells where the name is*/
}
else if ( strcmp(argv[index], "-commpkg") == 0 )
{
index++;
commpkg_flag = atoi(argv[index++]);
}
else if ( strcmp(argv[index], "-laplacian") == 0 )
{
index++;
build_matrix_type = 2;
matrix_arg_index = index;
}
else if ( strcmp(argv[index], "-27pt") == 0 )
{
index++;
build_matrix_type = 4;
matrix_arg_index = index;
}
/*
else if ( strcmp(argv[index], "-nopreload") == 0 )
{
index++;
preload = 0;
}
*/
else if ( strcmp(argv[index], "-loop") == 0 )
{
index++;
loop = atoi(argv[index++]);
}
else if ( strcmp(argv[index], "-noparmprint") == 0 )
{
index++;
noparmprint = 1;
}
else
{
index++;
/*hypre_printf("Warning: Unrecogized option '%s'\n",argv[index++] );*/
}
}
/*-----------------------------------------------------------
* Setup the Matrix problem
*-----------------------------------------------------------*/
/*-----------------------------------------------------------
* Get actual partitioning-
* read in an actual csr matrix.
*-----------------------------------------------------------*/
if (build_matrix_type ==1) /*read in a csr matrix from one file */
{
if (matrix_arg_index < argc)
{
csrfilename = argv[matrix_arg_index];
}
else
{
hypre_printf("Error: No filename specified \n");
exit(1);
}
if (myid == 0)
{
/*hypre_printf(" FromFile: %s\n", csrfilename);*/
A_CSR = hypre_CSRMatrixRead(csrfilename);
}
row_part = NULL;
col_part = NULL;
parcsr_A = hypre_CSRMatrixToParCSRMatrix(hypre_MPI_COMM_WORLD, A_CSR,
row_part, col_part);
if (myid == 0) hypre_CSRMatrixDestroy(A_CSR);
}
else if (build_matrix_type ==2)
{
myBuildParLaplacian(argc, argv, matrix_arg_index, &A_temp, !noparmprint);
parcsr_A = (hypre_ParCSRMatrix *) A_temp;
}
else if (build_matrix_type ==4)
{
myBuildParLaplacian27pt(argc, argv, matrix_arg_index, &A_temp, !noparmprint);
parcsr_A = (hypre_ParCSRMatrix *) A_temp;
}
/*-----------------------------------------------------------
* create a small problem so that timings are more accurate -
* code gets run twice (small laplace)
*-----------------------------------------------------------*/
/*this is no longer being used - preload = 0 is set at the beginning */
if (preload == 1)
{
/*hypre_printf("preload!\n");*/
values[1] = -1;
values[2] = -1;
values[3] = -1;
values[0] = - 6.0 ;
nx = 2;
ny = num_procs;
nz = 2;
P = 1;
Q = num_procs;
R = 1;
p = myid % P;
q = (( myid - p)/P) % Q;
r = ( myid - p - P*q)/( P*Q );
A_temp_small = (HYPRE_ParCSRMatrix) GenerateLaplacian(hypre_MPI_COMM_WORLD, nx, ny, nz,
P, Q, R, p, q, r, values);
small_A = (hypre_ParCSRMatrix *) A_temp_small;
/*do comm packages*/
hypre_NewCommPkgCreate(small_A);
hypre_NewCommPkgDestroy(small_A);
hypre_MatvecCommPkgCreate(small_A);
hypre_ParCSRMatrixDestroy(small_A);
}
/*-----------------------------------------------------------
* Prepare for timing
*-----------------------------------------------------------*/
/* instead of preloading, let's not time the first one if more than one*/
if (!loop)
{
loop = 1;
/* and don't do any timings */
}
else
{
loop +=1;
if (loop < 2) loop = 2;
}
loop_times = hypre_CTAlloc(HYPRE_Real, loop);
/******************************************************************************************/
hypre_MPI_Barrier(hypre_MPI_COMM_WORLD);
if (commpkg_flag == 1 || commpkg_flag ==3 )
{
/*-----------------------------------------------------------
* Create new comm package
*-----------------------------------------------------------*/
if (!myid) hypre_printf("********************************************************\n" );
/*do loop times*/
for (i=0; i< loop; i++)
{
loop_times[i] = 0.0;
for (k=0; k< loop2; k++)
{
hypre_MPI_Barrier(hypre_MPI_COMM_WORLD);
start_time = hypre_MPI_Wtime();
#if mpip_on
if (i==(loop-1)) hypre_MPI_Pcontrol(1);
#endif
hypre_NewCommPkgCreate(parcsr_A);
#if mpip_on
if (i==(loop-1)) hypre_MPI_Pcontrol(0);
#endif
end_time = hypre_MPI_Wtime();
end_time = end_time - start_time;
hypre_MPI_Allreduce(&end_time, &total_time, 1,
HYPRE_MPI_REAL, hypre_MPI_MAX, hypre_MPI_COMM_WORLD);
loop_times[i] += total_time;
if ( !((i+1)== loop && (k+1) == loop2)) hypre_NewCommPkgDestroy(parcsr_A);
}/*end of loop2 */
} /*end of loop*/
/* calculate the avg and std. */
if (loop > 1)
{
/* calculate the avg and std. */
stats_mo(loop_times, loop, &T_avg, &T_std);
if (!myid) hypre_printf(" NewCommPkgCreate: AVG. wall clock time = %f seconds\n", T_avg);
if (!myid) hypre_printf(" STD. for %d runs = %f\n", loop-1, T_std);
if (!myid) hypre_printf(" (Note: avg./std. timings exclude run 0.)\n");
if (!myid) hypre_printf("********************************************************\n" );
for (i=0; i< loop; i++)
{
if (!myid) hypre_printf(" run %d = %f sec.\n", i, loop_times[i]);
}
if (!myid) hypre_printf("********************************************************\n" );
}
else
{
if (!myid) hypre_printf("********************************************************\n" );
if (!myid) hypre_printf(" NewCommPkgCreate:\n");
if (!myid) hypre_printf(" run time = %f sec.\n", loop_times[0]);
if (!myid) hypre_printf("********************************************************\n" );
}
/*-----------------------------------------------------------
* Verbose printing
*-----------------------------------------------------------*/
/*some verification*/
global_num_rows = hypre_ParCSRMatrixGlobalNumRows(parcsr_A);
if (verbose)
{
ierr = hypre_ParCSRMatrixGetLocalRange( parcsr_A,
&row_start, &row_end ,
&col_start, &col_end );
comm_pkg = hypre_ParCSRMatrixCommPkg(parcsr_A);
hypre_printf("myid = %i, my ACTUAL local range: [%i, %i]\n", myid,
row_start, row_end);
ierr = hypre_GetAssumedPartitionRowRange( myid, global_num_rows, &row_start,
&row_end);
hypre_printf("myid = %i, my assumed local range: [%i, %i]\n", myid,
row_start, row_end);
hypre_printf("myid = %d, num_recvs = %d\n", myid,
hypre_ParCSRCommPkgNumRecvs(comm_pkg) );
#if mydebug
for (i=0; i < hypre_ParCSRCommPkgNumRecvs(comm_pkg); i++)
{
hypre_printf("myid = %d, recv proc = %d, vec_starts = [%d : %d]\n",
myid, hypre_ParCSRCommPkgRecvProcs(comm_pkg)[i],
hypre_ParCSRCommPkgRecvVecStarts(comm_pkg)[i],
hypre_ParCSRCommPkgRecvVecStarts(comm_pkg)[i+1]-1);
}
#endif
hypre_printf("myid = %d, num_sends = %d\n", myid,
hypre_ParCSRCommPkgNumSends(comm_pkg) );
#if mydebug
for (i=0; i <hypre_ParCSRCommPkgNumSends(comm_pkg) ; i++)
{
tmp_int = hypre_ParCSRCommPkgSendMapStarts(comm_pkg)[i+1] -
hypre_ParCSRCommPkgSendMapStarts(comm_pkg)[i];
index = hypre_ParCSRCommPkgSendMapStarts(comm_pkg)[i];
for (j=0; j< tmp_int; j++)
{
hypre_printf("myid = %d, send proc = %d, send element = %d\n",myid,
hypre_ParCSRCommPkgSendProcs(comm_pkg)[i],
hypre_ParCSRCommPkgSendMapElmts(comm_pkg)[index+j]);
}
}
#endif
}
/*-----------------------------------------------------------
* To verify correctness (if commpkg_flag = 3)
*-----------------------------------------------------------*/
if (commpkg_flag == 3 )
{
/*do a matvec - we are assuming a square matrix */
row_starts = hypre_ParCSRMatrixRowStarts(parcsr_A);
x_new = hypre_ParVectorCreate(hypre_MPI_COMM_WORLD, global_num_rows, row_starts);
hypre_ParVectorSetPartitioningOwner(x_new, 0);
hypre_ParVectorInitialize(x_new);
hypre_ParVectorSetRandomValues(x_new, 1);
y_new = hypre_ParVectorCreate(hypre_MPI_COMM_WORLD, global_num_rows, row_starts);
hypre_ParVectorSetPartitioningOwner(y_new, 0);
hypre_ParVectorInitialize(y_new);
hypre_ParVectorSetConstantValues(y_new, 0.0);
/*y = 1.0*A*x+1.0*y */
hypre_ParCSRMatrixMatvec (1.0, parcsr_A, x_new, 1.0, y_new);
}
/*-----------------------------------------------------------
* Clean up after MyComm
*-----------------------------------------------------------*/
hypre_NewCommPkgDestroy(parcsr_A);
}
/******************************************************************************************/
/******************************************************************************************/
hypre_MPI_Barrier(hypre_MPI_COMM_WORLD);
if (commpkg_flag > 1 )
{
/*-----------------------------------------------------------
* Set up standard comm package
*-----------------------------------------------------------*/
bcast_rows[0] = 23;
bcast_rows[1] = 1789;
if (!myid) hypre_printf("********************************************************\n" );
/*do loop times*/
for (i=0; i< loop; i++)
{
loop_times[i] = 0.0;
for (k=0; k< loop2; k++)
{
hypre_MPI_Barrier(hypre_MPI_COMM_WORLD);
start_time = hypre_MPI_Wtime();
#if time_gather
info = hypre_CTAlloc(HYPRE_Int, num_procs);
hypre_MPI_Allgather(bcast_rows, 1, HYPRE_MPI_INT, info, 1, HYPRE_MPI_INT, hypre_MPI_COMM_WORLD);
#endif
hypre_MatvecCommPkgCreate(parcsr_A);
end_time = hypre_MPI_Wtime();
end_time = end_time - start_time;
hypre_MPI_Allreduce(&end_time, &total_time, 1,
HYPRE_MPI_REAL, hypre_MPI_MAX, hypre_MPI_COMM_WORLD);
loop_times[i] += total_time;
if ( !((i+1)== loop && (k+1) == loop2)) hypre_MatvecCommPkgDestroy(hypre_ParCSRMatrixCommPkg(parcsr_A));
}/* end of loop 2*/
} /*end of loop*/
/* calculate the avg and std. */
if (loop > 1)
{
stats_mo(loop_times, loop, &T_avg, &T_std);
if (!myid) hypre_printf("Current CommPkgCreate: AVG. wall clock time = %f seconds\n", T_avg);
if (!myid) hypre_printf(" STD. for %d runs = %f\n", loop-1, T_std);
if (!myid) hypre_printf(" (Note: avg./std. timings exclude run 0.)\n");
if (!myid) hypre_printf("********************************************************\n" );
for (i=0; i< loop; i++)
{
if (!myid) hypre_printf(" run %d = %f sec.\n", i, loop_times[i]);
}
if (!myid) hypre_printf("********************************************************\n" );
}
else
{
if (!myid) hypre_printf("********************************************************\n" );
if (!myid) hypre_printf(" Current CommPkgCreate:\n");
if (!myid) hypre_printf(" run time = %f sec.\n", loop_times[0]);
if (!myid) hypre_printf("********************************************************\n" );
}
/*-----------------------------------------------------------
* Verbose printing
*-----------------------------------------------------------*/
/*some verification*/
if (verbose)
{
ierr = hypre_ParCSRMatrixGetLocalRange( parcsr_A,
&row_start, &row_end ,
&col_start, &col_end );
comm_pkg = hypre_ParCSRMatrixCommPkg(parcsr_A);
hypre_printf("myid = %i, std - my local range: [%i, %i]\n", myid,
row_start, row_end);
ierr = hypre_ParCSRMatrixGetLocalRange( parcsr_A,
&row_start, &row_end ,
&col_start, &col_end );
hypre_printf("myid = %d, std - num_recvs = %d\n", myid,
hypre_ParCSRCommPkgNumRecvs(comm_pkg) );
#if mydebug
for (i=0; i < hypre_ParCSRCommPkgNumRecvs(comm_pkg); i++)
{
hypre_printf("myid = %d, std - recv proc = %d, vec_starts = [%d : %d]\n",
myid, hypre_ParCSRCommPkgRecvProcs(comm_pkg)[i],
hypre_ParCSRCommPkgRecvVecStarts(comm_pkg)[i],
hypre_ParCSRCommPkgRecvVecStarts(comm_pkg)[i+1]-1);
}
#endif
hypre_printf("myid = %d, std - num_sends = %d\n", myid,
hypre_ParCSRCommPkgNumSends(comm_pkg));
#if mydebug
for (i=0; i <hypre_ParCSRCommPkgNumSends(comm_pkg) ; i++)
{
tmp_int = hypre_ParCSRCommPkgSendMapStarts(comm_pkg)[i+1] -
hypre_ParCSRCommPkgSendMapStarts(comm_pkg)[i];
index = hypre_ParCSRCommPkgSendMapStarts(comm_pkg)[i];
for (j=0; j< tmp_int; j++)
{
hypre_printf("myid = %d, std - send proc = %d, send element = %d\n",myid,
hypre_ParCSRCommPkgSendProcs(comm_pkg)[i],
hypre_ParCSRCommPkgSendMapElmts(comm_pkg)[index+j]);
}
}
#endif
}
/*-----------------------------------------------------------
* Verify correctness
*-----------------------------------------------------------*/
if (commpkg_flag == 3 )
{
global_num_rows = hypre_ParCSRMatrixGlobalNumRows(parcsr_A);
row_starts = hypre_ParCSRMatrixRowStarts(parcsr_A);
y = hypre_ParVectorCreate(hypre_MPI_COMM_WORLD, global_num_rows,row_starts);
hypre_ParVectorSetPartitioningOwner(y, 0);
hypre_ParVectorInitialize(y);
hypre_ParVectorSetConstantValues(y, 0.0);
hypre_ParCSRMatrixMatvec (1.0, parcsr_A, x_new, 1.0, y);
}
}
/*-----------------------------------------------------------
* Compare matvecs for both comm packages (3)
*-----------------------------------------------------------*/
if (commpkg_flag == 3 )
{
/*make sure that y and y_new are the same - now y_new should=0*/
hypre_ParVectorAxpy( -1.0, y, y_new );
hypre_ParVectorSetRandomValues(y, 1);
ans = hypre_ParVectorInnerProd( y, y_new );
if (!myid)
{
if ( fabs(ans) > 1e-8 )
{
hypre_printf("!!!!! WARNING !!!!! should be zero if correct = %6.10f\n",
ans);
}
else
{
hypre_printf("Matvecs match ( should be zero = %6.10f )\n",
ans);
}
}
}
/*-----------------------------------------------------------
* Clean up
*-----------------------------------------------------------*/
hypre_ParCSRMatrixDestroy(parcsr_A); /*this calls the standard comm
package destroy - but we'll destroy
ours separately until it is
incorporated */
if (commpkg_flag == 3 )
{
hypre_ParVectorDestroy(x_new);
hypre_ParVectorDestroy(y);
hypre_ParVectorDestroy(y_new);
}
hypre_MPI_Finalize();
return(ierr);
}
HYPRE_Int
hypre_GetCommPkgRTFromCommPkgA( hypre_ParCSRMatrix *RT,
hypre_ParCSRMatrix *A,
HYPRE_Int *fine_to_coarse_offd)
{
MPI_Comm comm = hypre_ParCSRMatrixComm(RT);
hypre_ParCSRCommPkg *comm_pkg_A = hypre_ParCSRMatrixCommPkg(A);
HYPRE_Int num_recvs_A = hypre_ParCSRCommPkgNumRecvs(comm_pkg_A);
HYPRE_Int *recv_procs_A = hypre_ParCSRCommPkgRecvProcs(comm_pkg_A);
HYPRE_Int *recv_vec_starts_A = hypre_ParCSRCommPkgRecvVecStarts(comm_pkg_A);
HYPRE_Int num_sends_A = hypre_ParCSRCommPkgNumSends(comm_pkg_A);
HYPRE_Int *send_procs_A = hypre_ParCSRCommPkgSendProcs(comm_pkg_A);
hypre_ParCSRCommPkg *comm_pkg;
HYPRE_Int num_recvs_RT;
HYPRE_Int *recv_procs_RT;
HYPRE_Int *recv_vec_starts_RT;
HYPRE_Int num_sends_RT;
HYPRE_Int *send_procs_RT;
HYPRE_Int *send_map_starts_RT;
HYPRE_Int *send_map_elmts_RT;
HYPRE_Int *col_map_offd_RT = hypre_ParCSRMatrixColMapOffd(RT);
HYPRE_Int num_cols_offd_RT = hypre_CSRMatrixNumCols( hypre_ParCSRMatrixOffd(RT));
HYPRE_Int first_col_diag = hypre_ParCSRMatrixFirstColDiag(RT);
HYPRE_Int i, j;
HYPRE_Int vec_len, vec_start;
HYPRE_Int num_procs, my_id;
HYPRE_Int ierr = 0;
HYPRE_Int num_requests;
HYPRE_Int offd_col, proc_num;
HYPRE_Int *proc_mark;
HYPRE_Int *change_array;
hypre_MPI_Request *requests;
hypre_MPI_Status *status;
hypre_MPI_Comm_size(comm,&num_procs);
hypre_MPI_Comm_rank(comm,&my_id);
/*--------------------------------------------------------------------------
* determine num_recvs, recv_procs and recv_vec_starts for RT
*--------------------------------------------------------------------------*/
proc_mark = hypre_CTAlloc(HYPRE_Int, num_recvs_A);
for (i=0; i < num_recvs_A; i++)
proc_mark[i] = 0;
proc_num = 0;
num_recvs_RT = 0;
if (num_cols_offd_RT)
{
for (i=0; i < num_recvs_A; i++)
{
for (j=recv_vec_starts_A[i]; j<recv_vec_starts_A[i+1]; j++)
{
offd_col = col_map_offd_RT[proc_num];
if (offd_col == j)
{
proc_mark[i]++;
proc_num++;
if (proc_num == num_cols_offd_RT) break;
}
}
if (proc_mark[i]) num_recvs_RT++;
if (proc_num == num_cols_offd_RT) break;
}
}
for (i=0; i < num_cols_offd_RT; i++)
col_map_offd_RT[i] = fine_to_coarse_offd[col_map_offd_RT[i]];
recv_procs_RT = hypre_CTAlloc(HYPRE_Int,num_recvs_RT);
recv_vec_starts_RT = hypre_CTAlloc(HYPRE_Int, num_recvs_RT+1);
j = 0;
recv_vec_starts_RT[0] = 0;
for (i=0; i < num_recvs_A; i++)
if (proc_mark[i])
{
recv_procs_RT[j] = recv_procs_A[i];
recv_vec_starts_RT[j+1] = recv_vec_starts_RT[j]+proc_mark[i];
j++;
}
/*--------------------------------------------------------------------------
* send num_changes to recv_procs_A and receive change_array from send_procs_A
*--------------------------------------------------------------------------*/
num_requests = num_recvs_A+num_sends_A;
requests = hypre_CTAlloc(hypre_MPI_Request, num_requests);
status = hypre_CTAlloc(hypre_MPI_Status, num_requests);
change_array = hypre_CTAlloc(HYPRE_Int, num_sends_A);
j = 0;
for (i=0; i < num_sends_A; i++)
hypre_MPI_Irecv(&change_array[i],1,HYPRE_MPI_INT,send_procs_A[i],0,comm,
&requests[j++]);
for (i=0; i < num_recvs_A; i++)
hypre_MPI_Isend(&proc_mark[i],1,HYPRE_MPI_INT,recv_procs_A[i],0,comm,
&requests[j++]);
hypre_MPI_Waitall(num_requests,requests,status);
hypre_TFree(proc_mark);
/*--------------------------------------------------------------------------
* if change_array[i] is 0 , omit send_procs_A[i] in send_procs_RT
*--------------------------------------------------------------------------*/
num_sends_RT = 0;
for (i=0; i < num_sends_A; i++)
if (change_array[i])
{
num_sends_RT++;
}
send_procs_RT = hypre_CTAlloc(HYPRE_Int, num_sends_RT);
send_map_starts_RT = hypre_CTAlloc(HYPRE_Int, num_sends_RT+1);
j = 0;
send_map_starts_RT[0] = 0;
for (i=0; i < num_sends_A; i++)
if (change_array[i])
{
send_procs_RT[j] = send_procs_A[i];
send_map_starts_RT[j+1] = send_map_starts_RT[j]+change_array[i];
j++;
}
/*--------------------------------------------------------------------------
* generate send_map_elmts
*--------------------------------------------------------------------------*/
send_map_elmts_RT = hypre_CTAlloc(HYPRE_Int,send_map_starts_RT[num_sends_RT]);
j = 0;
for (i=0; i < num_sends_RT; i++)
{
vec_start = send_map_starts_RT[i];
vec_len = send_map_starts_RT[i+1]-vec_start;
hypre_MPI_Irecv(&send_map_elmts_RT[vec_start],vec_len,HYPRE_MPI_INT,
send_procs_RT[i],0,comm,&requests[j++]);
}
for (i=0; i < num_recvs_RT; i++)
{
vec_start = recv_vec_starts_RT[i];
vec_len = recv_vec_starts_RT[i+1] - vec_start;
hypre_MPI_Isend(&col_map_offd_RT[vec_start],vec_len,HYPRE_MPI_INT,
recv_procs_RT[i],0,comm,&requests[j++]);
}
hypre_MPI_Waitall(j,requests,status);
for (i=0; i < send_map_starts_RT[num_sends_RT]; i++)
send_map_elmts_RT[i] -= first_col_diag;
comm_pkg = hypre_CTAlloc(hypre_ParCSRCommPkg,1);
hypre_ParCSRCommPkgComm(comm_pkg) = comm;
hypre_ParCSRCommPkgNumSends(comm_pkg) = num_sends_RT;
hypre_ParCSRCommPkgNumRecvs(comm_pkg) = num_recvs_RT;
hypre_ParCSRCommPkgSendProcs(comm_pkg) = send_procs_RT;
hypre_ParCSRCommPkgRecvProcs(comm_pkg) = recv_procs_RT;
hypre_ParCSRCommPkgRecvVecStarts(comm_pkg) = recv_vec_starts_RT;
hypre_ParCSRCommPkgSendMapStarts(comm_pkg) = send_map_starts_RT;
hypre_ParCSRCommPkgSendMapElmts(comm_pkg) = send_map_elmts_RT;
hypre_TFree(status);
hypre_TFree(requests);
hypre_ParCSRMatrixCommPkg(RT) = comm_pkg;
hypre_TFree(change_array);
return ierr;
}