HYPRE_Int
HYPRE_IJMatrixDestroy( HYPRE_IJMatrix matrix )
{
HYPRE_Int ierr = 0;
hypre_IJMatrix *ijmatrix = (hypre_IJMatrix *) matrix;
if (!ijmatrix)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (ijmatrix)
{
if (hypre_IJMatrixRowPartitioning(ijmatrix) ==
hypre_IJMatrixColPartitioning(ijmatrix))
hypre_TFree(hypre_IJMatrixRowPartitioning(ijmatrix));
else
{
hypre_TFree(hypre_IJMatrixRowPartitioning(ijmatrix));
hypre_TFree(hypre_IJMatrixColPartitioning(ijmatrix));
}
if ( hypre_IJMatrixObjectType(ijmatrix) == HYPRE_PARCSR )
ierr = hypre_IJMatrixDestroyParCSR( ijmatrix );
else if ( hypre_IJMatrixObjectType(ijmatrix) != -1 )
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
}
hypre_TFree(ijmatrix);
return hypre_error_flag;
}
HYPRE_Int
HYPRE_IJMatrixGetLocalRange( HYPRE_IJMatrix matrix,
HYPRE_Int *ilower,
HYPRE_Int *iupper,
HYPRE_Int *jlower,
HYPRE_Int *jupper )
{
hypre_IJMatrix *ijmatrix = (hypre_IJMatrix *) matrix;
MPI_Comm comm;
HYPRE_Int *row_partitioning;
HYPRE_Int *col_partitioning;
HYPRE_Int my_id;
if (!ijmatrix)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
comm = hypre_IJMatrixComm(ijmatrix);
row_partitioning = hypre_IJMatrixRowPartitioning(ijmatrix);
col_partitioning = hypre_IJMatrixColPartitioning(ijmatrix);
hypre_MPI_Comm_rank(comm, &my_id);
#ifdef HYPRE_NO_GLOBAL_PARTITION
*ilower = row_partitioning[0];
*iupper = row_partitioning[1]-1;
*jlower = col_partitioning[0];
*jupper = col_partitioning[1]-1;
#else
*ilower = row_partitioning[my_id];
*iupper = row_partitioning[my_id+1]-1;
*jlower = col_partitioning[my_id];
*jupper = col_partitioning[my_id+1]-1;
#endif
return hypre_error_flag;
}
/*
Assume that we are given a fine and coarse topology and the
coarse degrees of freedom (DOFs) have been chosen. Assume also,
that the global interpolation matrix dof_DOF has a prescribed
nonzero pattern. Then, the fine degrees of freedom can be split
into 4 groups (here "i" stands for "interior"):
NODEidof - dofs which are interpolated only from the DOF
in one coarse vertex
EDGEidof - dofs which are interpolated only from the DOFs
in one coarse edge
FACEidof - dofs which are interpolated only from the DOFs
in one coarse face
ELEMidof - dofs which are interpolated only from the DOFs
in one coarse element
The interpolation operator dof_DOF can be build in 4 steps, by
consequently filling-in the rows corresponding to the above groups.
The code below uses harmonic extension to extend the interpolation
from one group to the next.
*/
HYPRE_Int hypre_ND1AMGeInterpolation (hypre_ParCSRMatrix * Aee,
hypre_ParCSRMatrix * ELEM_idof,
hypre_ParCSRMatrix * FACE_idof,
hypre_ParCSRMatrix * EDGE_idof,
hypre_ParCSRMatrix * ELEM_FACE,
hypre_ParCSRMatrix * ELEM_EDGE,
HYPRE_Int num_OffProcRows,
hypre_MaxwellOffProcRow ** OffProcRows,
hypre_IJMatrix * IJ_dof_DOF)
{
HYPRE_Int ierr = 0;
HYPRE_Int i, j, k;
HYPRE_Int *offproc_rnums, *swap;
hypre_ParCSRMatrix * dof_DOF = hypre_IJMatrixObject(IJ_dof_DOF);
hypre_ParCSRMatrix * ELEM_DOF = ELEM_EDGE;
hypre_ParCSRMatrix * ELEM_FACEidof;
hypre_ParCSRMatrix * ELEM_EDGEidof;
hypre_CSRMatrix *A, *P;
HYPRE_Int numELEM = hypre_CSRMatrixNumRows(hypre_ParCSRMatrixDiag(ELEM_EDGE));
HYPRE_Int getrow_ierr;
HYPRE_Int three_dimensional_problem;
MPI_Comm comm= hypre_ParCSRMatrixComm(Aee);
HYPRE_Int myproc;
hypre_MPI_Comm_rank(comm, &myproc);
#if 0
hypre_IJMatrix * ij_dof_DOF = hypre_CTAlloc(hypre_IJMatrix, 1);
/* Convert dof_DOF to IJ matrix, so we can use AddToValues */
hypre_IJMatrixComm(ij_dof_DOF) = hypre_ParCSRMatrixComm(dof_DOF);
hypre_IJMatrixRowPartitioning(ij_dof_DOF) =
hypre_ParCSRMatrixRowStarts(dof_DOF);
hypre_IJMatrixColPartitioning(ij_dof_DOF) =
hypre_ParCSRMatrixColStarts(dof_DOF);
hypre_IJMatrixObject(ij_dof_DOF) = dof_DOF;
hypre_IJMatrixAssembleFlag(ij_dof_DOF) = 1;
#endif
/* sort the offproc rows to get quicker comparison for later */
if (num_OffProcRows)
{
offproc_rnums= hypre_TAlloc(HYPRE_Int, num_OffProcRows);
swap = hypre_TAlloc(HYPRE_Int, num_OffProcRows);
for (i= 0; i< num_OffProcRows; i++)
{
offproc_rnums[i]=(OffProcRows[i] -> row);
swap[i] = i;
}
}
if (num_OffProcRows > 1)
{
hypre_qsort2i(offproc_rnums, swap, 0, num_OffProcRows-1);
}
if (FACE_idof == EDGE_idof)
three_dimensional_problem = 0;
else
three_dimensional_problem = 1;
/* ELEM_FACEidof = ELEM_FACE x FACE_idof */
if (three_dimensional_problem)
ELEM_FACEidof = hypre_ParMatmul(ELEM_FACE, FACE_idof);
/* ELEM_EDGEidof = ELEM_EDGE x EDGE_idof */
ELEM_EDGEidof = hypre_ParMatmul(ELEM_EDGE, EDGE_idof);
/* Loop over local coarse elements */
k = hypre_ParCSRMatrixFirstRowIndex(ELEM_EDGE);
for (i = 0; i < numELEM; i++, k++)
{
HYPRE_Int size1, size2;
HYPRE_Int *col_ind0, *col_ind1, *col_ind2;
HYPRE_Int num_DOF, *DOF0, *DOF;
HYPRE_Int num_idof, *idof0, *idof;
HYPRE_Int num_bdof, *bdof;
double *boolean_data;
/* Determine the coarse DOFs */
hypre_ParCSRMatrixGetRow (ELEM_DOF, k, &num_DOF, &DOF0, &boolean_data);
DOF= hypre_TAlloc(HYPRE_Int, num_DOF);
for (j= 0; j< num_DOF; j++)
{
DOF[j]= DOF0[j];
}
hypre_ParCSRMatrixRestoreRow (ELEM_DOF, k, &num_DOF, &DOF0, &boolean_data);
qsort0(DOF,0,num_DOF-1);
/* Find the fine dofs interior for the current coarse element */
hypre_ParCSRMatrixGetRow (ELEM_idof, k, &num_idof, &idof0, &boolean_data);
idof= hypre_TAlloc(HYPRE_Int, num_idof);
for (j= 0; j< num_idof; j++)
{
idof[j]= idof0[j];
}
hypre_ParCSRMatrixRestoreRow (ELEM_idof, k, &num_idof, &idof0, &boolean_data);
/* Sort the interior dofs according to their global number */
qsort0(idof,0,num_idof-1);
/* Find the fine dofs on the boundary of the current coarse element */
if (three_dimensional_problem)
{
hypre_ParCSRMatrixGetRow (ELEM_FACEidof, k, &size1, &col_ind0, &boolean_data);
col_ind1= hypre_TAlloc(HYPRE_Int, size1);
for (j= 0; j< size1; j++)
{
col_ind1[j]= col_ind0[j];
}
hypre_ParCSRMatrixRestoreRow (ELEM_FACEidof, k, &size1, &col_ind0, &boolean_data);
}
else
size1 = 0;
hypre_ParCSRMatrixGetRow (ELEM_EDGEidof, k, &size2, &col_ind0, &boolean_data);
col_ind2= hypre_TAlloc(HYPRE_Int, size2);
for (j= 0; j< size2; j++)
{
col_ind2[j]= col_ind0[j];
}
hypre_ParCSRMatrixRestoreRow (ELEM_EDGEidof, k, &size2, &col_ind0, &boolean_data);
/* Merge and sort the boundary dofs according to their global number */
num_bdof = size1 + size2;
bdof = hypre_CTAlloc(HYPRE_Int, num_bdof);
if (three_dimensional_problem)
memcpy(bdof, col_ind1, size1*sizeof(HYPRE_Int));
memcpy(bdof+size1, col_ind2, size2*sizeof(HYPRE_Int));
qsort0(bdof,0,num_bdof-1);
/* A = extract_rows(Aee, idof) */
A = hypre_CSRMatrixCreate (num_idof, num_idof + num_bdof,
num_idof * (num_idof + num_bdof));
hypre_CSRMatrixInitialize(A);
{
HYPRE_Int *I = hypre_CSRMatrixI(A);
HYPRE_Int *J = hypre_CSRMatrixJ(A);
double *data = hypre_CSRMatrixData(A);
HYPRE_Int *tmp_J;
double *tmp_data;
I[0] = 0;
for (j = 0; j < num_idof; j++)
{
getrow_ierr= hypre_ParCSRMatrixGetRow (Aee, idof[j], &I[j+1], &tmp_J, &tmp_data);
if (getrow_ierr <0)
hypre_printf("getrow Aee off proc[%d] = \n",myproc);
memcpy(J, tmp_J, I[j+1]*sizeof(HYPRE_Int));
memcpy(data, tmp_data, I[j+1]*sizeof(double));
J+= I[j+1];
data+= I[j+1];
hypre_ParCSRMatrixRestoreRow (Aee, idof[j], &I[j+1], &tmp_J, &tmp_data);
I[j+1] += I[j];
}
}
/* P = extract_rows(dof_DOF, idof+bdof) */
P = hypre_CSRMatrixCreate (num_idof + num_bdof, num_DOF,
(num_idof + num_bdof) * num_DOF);
hypre_CSRMatrixInitialize(P);
{
HYPRE_Int *I = hypre_CSRMatrixI(P);
HYPRE_Int *J = hypre_CSRMatrixJ(P);
double *data = hypre_CSRMatrixData(P);
HYPRE_Int m;
HYPRE_Int *tmp_J;
double *tmp_data;
I[0] = 0;
for (j = 0; j < num_idof; j++)
{
getrow_ierr= hypre_ParCSRMatrixGetRow (dof_DOF, idof[j], &I[j+1], &tmp_J, &tmp_data);
if (getrow_ierr >= 0)
{
memcpy(J, tmp_J, I[j+1]*sizeof(HYPRE_Int));
memcpy(data, tmp_data, I[j+1]*sizeof(double));
J+= I[j+1];
data+= I[j+1];
hypre_ParCSRMatrixRestoreRow (dof_DOF, idof[j], &I[j+1], &tmp_J, &tmp_data);
I[j+1] += I[j];
}
else /* row offproc */
{
hypre_ParCSRMatrixRestoreRow (dof_DOF, idof[j], &I[j+1], &tmp_J, &tmp_data);
/* search for OffProcRows */
m= 0;
while (m < num_OffProcRows)
{
if (offproc_rnums[m] == idof[j])
{
break;
}
else
{
m++;
}
}
I[j+1]= (OffProcRows[swap[m]] -> ncols);
tmp_J = (OffProcRows[swap[m]] -> cols);
tmp_data= (OffProcRows[swap[m]] -> data);
memcpy(J, tmp_J, I[j+1]*sizeof(HYPRE_Int));
memcpy(data, tmp_data, I[j+1]*sizeof(double));
J+= I[j+1];
data+= I[j+1];
I[j+1] += I[j];
}
}
for ( ; j < num_idof + num_bdof; j++)
{
getrow_ierr= hypre_ParCSRMatrixGetRow (dof_DOF, bdof[j-num_idof], &I[j+1], &tmp_J, &tmp_data);
if (getrow_ierr >= 0)
{
memcpy(J, tmp_J, I[j+1]*sizeof(HYPRE_Int));
memcpy(data, tmp_data, I[j+1]*sizeof(double));
J+= I[j+1];
data+= I[j+1];
hypre_ParCSRMatrixRestoreRow (dof_DOF, bdof[j-num_idof], &I[j+1], &tmp_J, &tmp_data);
I[j+1] += I[j];
}
else /* row offproc */
{
hypre_ParCSRMatrixRestoreRow (dof_DOF, bdof[j-num_idof], &I[j+1], &tmp_J, &tmp_data);
/* search for OffProcRows */
m= 0;
while (m < num_OffProcRows)
{
if (offproc_rnums[m] == bdof[j-num_idof])
{
break;
}
else
{
m++;
}
}
if (m>= num_OffProcRows)hypre_printf("here the mistake\n");
I[j+1]= (OffProcRows[swap[m]] -> ncols);
tmp_J = (OffProcRows[swap[m]] -> cols);
tmp_data= (OffProcRows[swap[m]] -> data);
memcpy(J, tmp_J, I[j+1]*sizeof(HYPRE_Int));
memcpy(data, tmp_data, I[j+1]*sizeof(double));
J+= I[j+1];
data+= I[j+1];
I[j+1] += I[j];
}
}
}
/* Pi = Aii^{-1} Aib Pb */
hypre_HarmonicExtension (A, P, num_DOF, DOF,
num_idof, idof, num_bdof, bdof);
/* Insert Pi in dof_DOF */
{
HYPRE_Int * ncols = hypre_CTAlloc(HYPRE_Int, num_idof);
for (j = 0; j < num_idof; j++)
ncols[j] = num_DOF;
hypre_IJMatrixAddToValuesParCSR (IJ_dof_DOF,
num_idof, ncols, idof,
hypre_CSRMatrixJ(P),
hypre_CSRMatrixData(P));
hypre_TFree(ncols);
}
hypre_TFree(DOF);
hypre_TFree(idof);
if (three_dimensional_problem)
{
hypre_TFree(col_ind1);
}
hypre_TFree(col_ind2);
hypre_TFree(bdof);
hypre_CSRMatrixDestroy(A);
hypre_CSRMatrixDestroy(P);
}
#if 0
hypre_TFree(ij_dof_DOF);
#endif
if (three_dimensional_problem)
hypre_ParCSRMatrixDestroy(ELEM_FACEidof);
hypre_ParCSRMatrixDestroy(ELEM_EDGEidof);
if (num_OffProcRows)
{
hypre_TFree(offproc_rnums);
hypre_TFree(swap);
}
return ierr;
}
HYPRE_Int
HYPRE_IJMatrixPrint( HYPRE_IJMatrix matrix,
const char *filename )
{
MPI_Comm comm;
HYPRE_Int *row_partitioning;
HYPRE_Int *col_partitioning;
HYPRE_Int ilower, iupper, jlower, jupper;
HYPRE_Int i, j, ii;
HYPRE_Int ncols, *cols;
HYPRE_Complex *values;
HYPRE_Int myid;
char new_filename[255];
FILE *file;
void *object;
if (!matrix)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if ( (hypre_IJMatrixObjectType(matrix) != HYPRE_PARCSR) )
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
comm = hypre_IJMatrixComm(matrix);
hypre_MPI_Comm_rank(comm, &myid);
hypre_sprintf(new_filename,"%s.%05d", filename, myid);
if ((file = fopen(new_filename, "w")) == NULL)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
row_partitioning = hypre_IJMatrixRowPartitioning(matrix);
col_partitioning = hypre_IJMatrixColPartitioning(matrix);
#ifdef HYPRE_NO_GLOBAL_PARTITION
ilower = row_partitioning[0];
iupper = row_partitioning[1] - 1;
jlower = col_partitioning[0];
jupper = col_partitioning[1] - 1;
#else
ilower = row_partitioning[myid];
iupper = row_partitioning[myid+1] - 1;
jlower = col_partitioning[myid];
jupper = col_partitioning[myid+1] - 1;
#endif
hypre_fprintf(file, "%d %d %d %d\n", ilower, iupper, jlower, jupper);
HYPRE_IJMatrixGetObject(matrix, &object);
for (i = ilower; i <= iupper; i++)
{
if ( hypre_IJMatrixObjectType(matrix) == HYPRE_PARCSR )
{
#ifdef HYPRE_NO_GLOBAL_PARTITION
ii = i - hypre_IJMatrixGlobalFirstRow(matrix);
#else
ii = i - row_partitioning[0];
#endif
HYPRE_ParCSRMatrixGetRow((HYPRE_ParCSRMatrix) object,
ii, &ncols, &cols, &values);
for (j = 0; j < ncols; j++)
{
#ifdef HYPRE_NO_GLOBAL_PARTITION
cols[j] += hypre_IJMatrixGlobalFirstCol(matrix);
#else
cols[j] += col_partitioning[0];
#endif
}
}
for (j = 0; j < ncols; j++)
{
hypre_fprintf(file, "%d %d %.14e\n", i, cols[j], values[j]);
}
if ( hypre_IJMatrixObjectType(matrix) == HYPRE_PARCSR )
{
for (j = 0; j < ncols; j++)
{
#ifdef HYPRE_NO_GLOBAL_PARTITION
cols[j] -= hypre_IJMatrixGlobalFirstCol(matrix);
#else
cols[j] -= col_partitioning[0];
#endif
}
HYPRE_ParCSRMatrixRestoreRow((HYPRE_ParCSRMatrix) object,
ii, &ncols, &cols, &values);
}
}
fclose(file);
return hypre_error_flag;
}
HYPRE_Int
HYPRE_IJMatrixCreate( MPI_Comm comm,
HYPRE_Int ilower,
HYPRE_Int iupper,
HYPRE_Int jlower,
HYPRE_Int jupper,
HYPRE_IJMatrix *matrix )
{
HYPRE_Int *row_partitioning;
HYPRE_Int *col_partitioning;
HYPRE_Int *info;
HYPRE_Int num_procs;
HYPRE_Int myid;
hypre_IJMatrix *ijmatrix;
#ifdef HYPRE_NO_GLOBAL_PARTITION
HYPRE_Int row0, col0, rowN, colN;
#else
HYPRE_Int *recv_buf;
HYPRE_Int i, i4;
HYPRE_Int square;
#endif
ijmatrix = hypre_CTAlloc(hypre_IJMatrix, 1);
hypre_IJMatrixComm(ijmatrix) = comm;
hypre_IJMatrixObject(ijmatrix) = NULL;
hypre_IJMatrixTranslator(ijmatrix) = NULL;
hypre_IJMatrixObjectType(ijmatrix) = HYPRE_UNITIALIZED;
hypre_IJMatrixAssembleFlag(ijmatrix) = 0;
hypre_IJMatrixPrintLevel(ijmatrix) = 0;
hypre_MPI_Comm_size(comm,&num_procs);
hypre_MPI_Comm_rank(comm, &myid);
if (ilower > iupper+1 || ilower < 0)
{
hypre_error_in_arg(2);
hypre_TFree(ijmatrix);
return hypre_error_flag;
}
if (iupper < -1)
{
hypre_error_in_arg(3);
hypre_TFree(ijmatrix);
return hypre_error_flag;
}
if (jlower > jupper+1 || jlower < 0)
{
hypre_error_in_arg(4);
hypre_TFree(ijmatrix);
return hypre_error_flag;
}
if (jupper < -1)
{
hypre_error_in_arg(5);
hypre_TFree(ijmatrix);
return hypre_error_flag;
}
#ifdef HYPRE_NO_GLOBAL_PARTITION
info = hypre_CTAlloc(HYPRE_Int,2);
row_partitioning = hypre_CTAlloc(HYPRE_Int, 2);
col_partitioning = hypre_CTAlloc(HYPRE_Int, 2);
row_partitioning[0] = ilower;
row_partitioning[1] = iupper+1;
col_partitioning[0] = jlower;
col_partitioning[1] = jupper+1;
/* now we need the global number of rows and columns as well
as the global first row and column index */
/* proc 0 has the first row and col */
if (myid==0)
{
info[0] = ilower;
info[1] = jlower;
}
hypre_MPI_Bcast(info, 2, HYPRE_MPI_INT, 0, comm);
row0 = info[0];
col0 = info[1];
/* proc (num_procs-1) has the last row and col */
if (myid == (num_procs-1))
{
info[0] = iupper;
info[1] = jupper;
}
hypre_MPI_Bcast(info, 2, HYPRE_MPI_INT, num_procs-1, comm);
rowN = info[0];
colN = info[1];
hypre_IJMatrixGlobalFirstRow(ijmatrix) = row0;
hypre_IJMatrixGlobalFirstCol(ijmatrix) = col0;
hypre_IJMatrixGlobalNumRows(ijmatrix) = rowN - row0 + 1;
hypre_IJMatrixGlobalNumCols(ijmatrix) = colN - col0 + 1;
hypre_TFree(info);
#else
info = hypre_CTAlloc(HYPRE_Int,4);
recv_buf = hypre_CTAlloc(HYPRE_Int,4*num_procs);
row_partitioning = hypre_CTAlloc(HYPRE_Int, num_procs+1);
info[0] = ilower;
info[1] = iupper;
info[2] = jlower;
info[3] = jupper;
/* Generate row- and column-partitioning through information exchange
across all processors, check whether the matrix is square, and
if the partitionings match. i.e. no overlaps or gaps,
if there are overlaps or gaps in the row partitioning or column
partitioning , ierr will be set to -9 or -10, respectively */
hypre_MPI_Allgather(info,4,HYPRE_MPI_INT,recv_buf,4,HYPRE_MPI_INT,comm);
row_partitioning[0] = recv_buf[0];
square = 1;
for (i=0; i < num_procs-1; i++)
{
i4 = 4*i;
if ( recv_buf[i4+1] != (recv_buf[i4+4]-1) )
{
hypre_error(HYPRE_ERROR_GENERIC);
hypre_TFree(ijmatrix);
hypre_TFree(info);
hypre_TFree(recv_buf);
hypre_TFree(row_partitioning);
return hypre_error_flag;
}
else
row_partitioning[i+1] = recv_buf[i4+4];
if ((square && (recv_buf[i4] != recv_buf[i4+2])) ||
(recv_buf[i4+1] != recv_buf[i4+3]) )
{
square = 0;
}
}
i4 = (num_procs-1)*4;
row_partitioning[num_procs] = recv_buf[i4+1]+1;
if ((recv_buf[i4] != recv_buf[i4+2]) || (recv_buf[i4+1] != recv_buf[i4+3]))
square = 0;
if (square)
col_partitioning = row_partitioning;
else
{
col_partitioning = hypre_CTAlloc(HYPRE_Int,num_procs+1);
col_partitioning[0] = recv_buf[2];
for (i=0; i < num_procs-1; i++)
{
i4 = 4*i;
if (recv_buf[i4+3] != recv_buf[i4+6]-1)
{
hypre_error(HYPRE_ERROR_GENERIC);
hypre_TFree(ijmatrix);
hypre_TFree(info);
hypre_TFree(recv_buf);
hypre_TFree(row_partitioning);
hypre_TFree(col_partitioning);
return hypre_error_flag;
}
else
col_partitioning[i+1] = recv_buf[i4+6];
}
col_partitioning[num_procs] = recv_buf[num_procs*4-1]+1;
}
hypre_IJMatrixGlobalFirstRow(ijmatrix) = row_partitioning[0];
hypre_IJMatrixGlobalFirstCol(ijmatrix) = col_partitioning[0];
hypre_IJMatrixGlobalNumRows(ijmatrix) = row_partitioning[num_procs] -
row_partitioning[0];
hypre_IJMatrixGlobalNumCols(ijmatrix) = col_partitioning[num_procs] -
col_partitioning[0];
hypre_TFree(info);
hypre_TFree(recv_buf);
#endif
hypre_IJMatrixRowPartitioning(ijmatrix) = row_partitioning;
hypre_IJMatrixColPartitioning(ijmatrix) = col_partitioning;
*matrix = (HYPRE_IJMatrix) ijmatrix;
return hypre_error_flag;
}