static PetscErrorCode PCSetUp_LU(PC pc)
{
PetscErrorCode ierr;
PC_LU *dir = (PC_LU*)pc->data;
PetscFunctionBegin;
if (dir->reusefill && pc->setupcalled) ((PC_Factor*)dir)->info.fill = dir->actualfill;
if (dir->inplace) {
if (dir->row && dir->col && dir->row != dir->col) {ierr = ISDestroy(dir->row);CHKERRQ(ierr);}
if (dir->col) {ierr = ISDestroy(dir->col);CHKERRQ(ierr);}
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)dir)->ordering,&dir->row,&dir->col);CHKERRQ(ierr);
if (dir->row) {
ierr = PetscLogObjectParent(pc,dir->row);CHKERRQ(ierr);
ierr = PetscLogObjectParent(pc,dir->col);CHKERRQ(ierr);
}
ierr = MatLUFactor(pc->pmat,dir->row,dir->col,&((PC_Factor*)dir)->info);CHKERRQ(ierr);
((PC_Factor*)dir)->fact = pc->pmat;
} else {
MatInfo info;
if (!pc->setupcalled) {
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)dir)->ordering,&dir->row,&dir->col);CHKERRQ(ierr);
if (dir->nonzerosalongdiagonal) {
ierr = MatReorderForNonzeroDiagonal(pc->pmat,dir->nonzerosalongdiagonaltol,dir->row,dir->col);CHKERRQ(ierr);
}
if (dir->row) {
ierr = PetscLogObjectParent(pc,dir->row);CHKERRQ(ierr);
ierr = PetscLogObjectParent(pc,dir->col);CHKERRQ(ierr);
}
ierr = MatGetFactor(pc->pmat,((PC_Factor*)dir)->solvertype,MAT_FACTOR_LU,&((PC_Factor*)dir)->fact);CHKERRQ(ierr);
ierr = MatLUFactorSymbolic(((PC_Factor*)dir)->fact,pc->pmat,dir->row,dir->col,&((PC_Factor*)dir)->info);CHKERRQ(ierr);
ierr = MatGetInfo(((PC_Factor*)dir)->fact,MAT_LOCAL,&info);CHKERRQ(ierr);
dir->actualfill = info.fill_ratio_needed;
ierr = PetscLogObjectParent(pc,((PC_Factor*)dir)->fact);CHKERRQ(ierr);
} else if (pc->flag != SAME_NONZERO_PATTERN) {
if (!dir->reuseordering) {
if (dir->row && dir->col && dir->row != dir->col) {ierr = ISDestroy(dir->row);CHKERRQ(ierr);}
if (dir->col) {ierr = ISDestroy(dir->col);CHKERRQ(ierr);}
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)dir)->ordering,&dir->row,&dir->col);CHKERRQ(ierr);
if (dir->nonzerosalongdiagonal) {
ierr = MatReorderForNonzeroDiagonal(pc->pmat,dir->nonzerosalongdiagonaltol,dir->row,dir->col);CHKERRQ(ierr);
}
if (dir->row) {
ierr = PetscLogObjectParent(pc,dir->row);CHKERRQ(ierr);
ierr = PetscLogObjectParent(pc,dir->col);CHKERRQ(ierr);
}
}
ierr = MatDestroy(((PC_Factor*)dir)->fact);CHKERRQ(ierr);
ierr = MatGetFactor(pc->pmat,((PC_Factor*)dir)->solvertype,MAT_FACTOR_LU,&((PC_Factor*)dir)->fact);CHKERRQ(ierr);
ierr = MatLUFactorSymbolic(((PC_Factor*)dir)->fact,pc->pmat,dir->row,dir->col,&((PC_Factor*)dir)->info);CHKERRQ(ierr);
ierr = MatGetInfo(((PC_Factor*)dir)->fact,MAT_LOCAL,&info);CHKERRQ(ierr);
dir->actualfill = info.fill_ratio_needed;
ierr = PetscLogObjectParent(pc,((PC_Factor*)dir)->fact);CHKERRQ(ierr);
}
ierr = MatLUFactorNumeric(((PC_Factor*)dir)->fact,pc->pmat,&((PC_Factor*)dir)->info);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
void MultigridSolver_RestrictMatrix( MultigridSolver* self, MultigridSolver_Level* level, Mat* dstMatrix ) {
Mat srcMat;
PetscInt nSrcRows, nSrcCols;
PetscInt nRRows, nRCols;
#if( PETSC_VERSION_MAJOR > 2 )
PetscInt dummy;
#endif
PetscScalar fillRatio;
MatInfo mInfo;
PetscScalar nRowsA, nRowsC;
PetscScalar nzA, nzP, nzC;
assert( self );
assert( level );
assert( dstMatrix );
srcMat = level->downSolver->matrix;
MatGetSize( srcMat, &nSrcRows, &nSrcCols );
MatGetSize( level->R, &nRRows, &nRCols );
if( nRCols == nSrcRows ) {
//Matrix_PAPt( srcMat, level->R, (void**)dstMatrix );
/* this function implementation was commented out in the PETScMatrix function - not sure if it should
* be implemented here?? */
MatGetInfo( srcMat, MAT_GLOBAL_SUM, &mInfo );
#if( PETSC_VERSION_MAJOR <= 2 )
nRowsA = mInfo.rows_global;
#else
MatGetSize( srcMat, &nRowsA, &dummy );
#endif
nzA = mInfo.nz_used;
MatGetInfo( level->R, MAT_GLOBAL_SUM, &mInfo );
#if( PETSC_VERSION_MAJOR <= 2 )
nRowsC = mInfo.columns_global;
#else
MatGetSize( level->R, &dummy, &nRowsC );
#endif
nzP = mInfo.nz_used;
nzC = ( nRowsC / nRowsA ) * nzA;
fillRatio = nzC / ( nzA + nzP );
/* this function doesn't exist! */
//MatPAPt( srcMat, level->R, MAT_REUSE_MATRIX, fillRatio, dstMatrix );
}
else {
//Matrix_PtAP( srcMat, level->R, (void**)dstMatrix );
if( dstMatrix )
MatPtAP( srcMat, level->R, MAT_REUSE_MATRIX, 1.0, dstMatrix );
else
MatPtAP( srcMat, level->R, MAT_INITIAL_MATRIX, 1.0, dstMatrix );
}
}
PetscErrorCode printMatInfo(const char *label, Mat m){
PetscErrorCode err;
MatInfo info;
err = MatGetInfo(m, MAT_GLOBAL_SUM, &info); CHKERRQ(err);
err = PetscPrintf(PETSC_COMM_WORLD, "%s nnz: %f\n", label, info.nz_used); CHKERRQ(err);
return err;
}
PetscErrorCode PCView_Factor(PC pc,PetscViewer viewer)
{
PC_Factor *factor = (PC_Factor*)pc->data;
PetscErrorCode ierr;
PetscBool isstring,iascii;
PetscFunctionBegin;
ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSTRING,&isstring);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr);
if (iascii) {
if (factor->factortype == MAT_FACTOR_ILU || factor->factortype == MAT_FACTOR_ICC) {
if (factor->info.dt > 0) {
ierr = PetscViewerASCIIPrintf(viewer," drop tolerance %G\n",factor->info.dt);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer," max nonzeros per row %D\n",factor->info.dtcount);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer," column permutation tolerance %G\n",(PetscInt)factor->info.dtcol);CHKERRQ(ierr);
} else if (factor->info.levels == 1) {
ierr = PetscViewerASCIIPrintf(viewer," %D level of fill\n",(PetscInt)factor->info.levels);CHKERRQ(ierr);
} else {
ierr = PetscViewerASCIIPrintf(viewer," %D levels of fill\n",(PetscInt)factor->info.levels);CHKERRQ(ierr);
}
}
ierr = PetscViewerASCIIPrintf(viewer," tolerance for zero pivot %G\n",factor->info.zeropivot);CHKERRQ(ierr);
if (factor->info.shifttype==(PetscReal)MAT_SHIFT_POSITIVE_DEFINITE) {
ierr = PetscViewerASCIIPrintf(viewer," using Manteuffel shift\n");CHKERRQ(ierr);
}
if (factor->info.shifttype==(PetscReal)MAT_SHIFT_NONZERO) {
ierr = PetscViewerASCIIPrintf(viewer," using diagonal shift to prevent zero pivot\n");CHKERRQ(ierr);
}
if (factor->info.shifttype==(PetscReal)MAT_SHIFT_INBLOCKS) {
ierr = PetscViewerASCIIPrintf(viewer," using diagonal shift on blocks to prevent zero pivot\n");CHKERRQ(ierr);
}
ierr = PetscViewerASCIIPrintf(viewer," matrix ordering: %s\n",factor->ordering);CHKERRQ(ierr);
if (factor->fact) {
MatInfo info;
ierr = MatGetInfo(factor->fact,MAT_LOCAL,&info);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer," factor fill ratio given %G, needed %G\n",info.fill_ratio_given,info.fill_ratio_needed);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer," Factored matrix follows:\n");CHKERRQ(ierr);
ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr);
ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr);
ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr);
ierr = PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_INFO);CHKERRQ(ierr);
ierr = MatView(factor->fact,viewer);CHKERRQ(ierr);
ierr = PetscViewerPopFormat(viewer);CHKERRQ(ierr);
ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr);
ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr);
ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr);
}
} else if (isstring) {
MatFactorType t;
ierr = MatGetFactorType(factor->fact,&t);CHKERRQ(ierr);
if (t == MAT_FACTOR_ILU || t == MAT_FACTOR_ICC) {
ierr = PetscViewerStringSPrintf(viewer," lvls=%D,order=%s",(PetscInt)factor->info.levels,factor->ordering);CHKERRQ(ierr);CHKERRQ(ierr);
}
}
PetscFunctionReturn(0);
}
static PetscErrorCode PCSetup_ICC(PC pc)
{
PC_ICC *icc = (PC_ICC*)pc->data;
IS perm,cperm;
PetscErrorCode ierr;
MatInfo info;
PetscFunctionBegin;
ierr = MatGetOrdering(pc->pmat, ((PC_Factor*)icc)->ordering,&perm,&cperm);CHKERRQ(ierr);
if (!pc->setupcalled) {
if (!((PC_Factor*)icc)->fact) {
ierr = MatGetFactor(pc->pmat,((PC_Factor*)icc)->solvertype,MAT_FACTOR_ICC,&((PC_Factor*)icc)->fact);CHKERRQ(ierr);
}
ierr = MatICCFactorSymbolic(((PC_Factor*)icc)->fact,pc->pmat,perm,&((PC_Factor*)icc)->info);CHKERRQ(ierr);
} else if (pc->flag != SAME_NONZERO_PATTERN) {
ierr = MatDestroy(&((PC_Factor*)icc)->fact);CHKERRQ(ierr);
ierr = MatGetFactor(pc->pmat,((PC_Factor*)icc)->solvertype,MAT_FACTOR_ICC,&((PC_Factor*)icc)->fact);CHKERRQ(ierr);
ierr = MatICCFactorSymbolic(((PC_Factor*)icc)->fact,pc->pmat,perm,&((PC_Factor*)icc)->info);CHKERRQ(ierr);
}
ierr = MatGetInfo(((PC_Factor*)icc)->fact,MAT_LOCAL,&info);CHKERRQ(ierr);
icc->actualfill = info.fill_ratio_needed;
ierr = ISDestroy(&cperm);CHKERRQ(ierr);
ierr = ISDestroy(&perm);CHKERRQ(ierr);
ierr = MatCholeskyFactorNumeric(((PC_Factor*)icc)->fact,pc->pmat,&((PC_Factor*)icc)->info);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
MatSchurComplementComputeExplicitOperator - Compute the Schur complement matrix explicitly
Collective on Mat
Input Parameter:
. M - the matrix obtained with MatCreateSchurComplement()
Output Parameter:
. S - the Schur complement matrix
Note: This can be expensive, so it is mainly for testing
Level: advanced
.seealso: MatCreateSchurComplement(), MatSchurComplementUpdate()
@*/
PetscErrorCode MatSchurComplementComputeExplicitOperator(Mat M, Mat *S)
{
Mat B, C, D;
KSP ksp;
PC pc;
PetscBool isLU, isILU;
PetscReal fill = 2.0;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = MatSchurComplementGetSubMatrices(M, NULL, NULL, &B, &C, &D);CHKERRQ(ierr);
ierr = MatSchurComplementGetKSP(M, &ksp);CHKERRQ(ierr);
ierr = KSPGetPC(ksp, &pc);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject) pc, PCLU, &isLU);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject) pc, PCILU, &isILU);CHKERRQ(ierr);
if (isLU || isILU) {
Mat fact, Bd, AinvB, AinvBd;
PetscReal eps = 1.0e-10;
/* This can be sped up for banded LU */
ierr = KSPSetUp(ksp);CHKERRQ(ierr);
ierr = PCFactorGetMatrix(pc, &fact);CHKERRQ(ierr);
ierr = MatConvert(B, MATDENSE, MAT_INITIAL_MATRIX, &Bd);CHKERRQ(ierr);
ierr = MatDuplicate(Bd, MAT_DO_NOT_COPY_VALUES, &AinvBd);CHKERRQ(ierr);
ierr = MatMatSolve(fact, Bd, AinvBd);CHKERRQ(ierr);
ierr = MatDestroy(&Bd);CHKERRQ(ierr);
ierr = MatChop(AinvBd, eps);CHKERRQ(ierr);
ierr = MatConvert(AinvBd, MATAIJ, MAT_INITIAL_MATRIX, &AinvB);CHKERRQ(ierr);
ierr = MatDestroy(&AinvBd);CHKERRQ(ierr);
ierr = MatMatMult(C, AinvB, MAT_INITIAL_MATRIX, fill, S);CHKERRQ(ierr);
ierr = MatDestroy(&AinvB);CHKERRQ(ierr);
} else {
Mat Ainvd, Ainv;
ierr = PCComputeExplicitOperator(pc, &Ainvd);CHKERRQ(ierr);
ierr = MatConvert(Ainvd, MATAIJ, MAT_INITIAL_MATRIX, &Ainv);CHKERRQ(ierr);
ierr = MatDestroy(&Ainvd);CHKERRQ(ierr);
#if 0
/* Symmetric version */
ierr = MatPtAP(Ainv, B, MAT_INITIAL_MATRIX, fill, S);CHKERRQ(ierr);
#else
/* Nonsymmetric version */
ierr = MatMatMatMult(C, Ainv, B, MAT_INITIAL_MATRIX, fill, S);CHKERRQ(ierr);
#endif
ierr = MatDestroy(&Ainv);CHKERRQ(ierr);
}
ierr = PetscViewerPushFormat(PETSC_VIEWER_STDOUT_WORLD, PETSC_VIEWER_ASCII_INFO);CHKERRQ(ierr);
ierr = MatView(*S, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = PetscViewerPopFormat(PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
if (D) {
MatInfo info;
ierr = MatGetInfo(D, MAT_GLOBAL_SUM, &info);CHKERRQ(ierr);
if (info.nz_used) SETERRQ(PetscObjectComm((PetscObject) M), PETSC_ERR_SUP, "Not yet implemented");
}
PetscFunctionReturn(0);
}
void BSSCR_get_number_nonzeros_AIJ( Mat A, PetscInt *nnz )
{
MatInfo info;
MatGetInfo( A, MAT_GLOBAL_SUM, &info );
*nnz = info.nz_used;
}
double
SparseGp_percentNonzero (SparseGp *gp)
{
MatInfo info;
MatGetInfo (gp->_K, MAT_GLOBAL_SUM, &info);
PetscLogDouble nzUsed = info.nz_used;
PetscInt N = gp->trainLabels->size;
return (nzUsed / (N*N)) * 100;
}
PetscErrorCode PCView_Factor(PC pc,PetscViewer viewer)
{
PC_Factor *factor = (PC_Factor*)pc->data;
PetscErrorCode ierr;
PetscBool isstring,iascii;
PetscFunctionBegin;
ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSTRING,&isstring);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr);
if (iascii) {
if (factor->factortype == MAT_FACTOR_ILU || factor->factortype == MAT_FACTOR_ICC) {
if (factor->info.dt > 0) {
ierr = PetscViewerASCIIPrintf(viewer," drop tolerance %G\n",factor->info.dt);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer," max nonzeros per row %D\n",factor->info.dtcount);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer," column permutation tolerance %G\n",(PetscInt)factor->info.dtcol);CHKERRQ(ierr);
} else if (factor->info.levels == 1) {
ierr = PetscViewerASCIIPrintf(viewer," %D level of fill\n",(PetscInt)factor->info.levels);CHKERRQ(ierr);
} else {
ierr = PetscViewerASCIIPrintf(viewer," %D levels of fill\n",(PetscInt)factor->info.levels);CHKERRQ(ierr);
}
}
ierr = PetscViewerASCIIPrintf(viewer," tolerance for zero pivot %G\n",factor->info.zeropivot);CHKERRQ(ierr);
if (MatFactorShiftTypesDetail[(int)factor->info.shifttype]) { /* Only print when using a nontrivial shift */
ierr = PetscViewerASCIIPrintf(viewer," using %s [%s]\n",MatFactorShiftTypesDetail[(int)factor->info.shifttype],MatFactorShiftTypes[(int)factor->info.shifttype]);CHKERRQ(ierr);
}
ierr = PetscViewerASCIIPrintf(viewer," matrix ordering: %s\n",factor->ordering);CHKERRQ(ierr);
if (factor->fact) {
MatInfo info;
ierr = MatGetInfo(factor->fact,MAT_LOCAL,&info);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer," factor fill ratio given %G, needed %G\n",info.fill_ratio_given,info.fill_ratio_needed);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer," Factored matrix follows:\n");CHKERRQ(ierr);
ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr);
ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr);
ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr);
ierr = PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_INFO);CHKERRQ(ierr);
ierr = MatView(factor->fact,viewer);CHKERRQ(ierr);
ierr = PetscViewerPopFormat(viewer);CHKERRQ(ierr);
ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr);
ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr);
ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr);
}
} else if (isstring) {
MatFactorType t;
ierr = MatGetFactorType(factor->fact,&t);CHKERRQ(ierr);
if (t == MAT_FACTOR_ILU || t == MAT_FACTOR_ICC) {
ierr = PetscViewerStringSPrintf(viewer," lvls=%D,order=%s",(PetscInt)factor->info.levels,factor->ordering);CHKERRQ(ierr);CHKERRQ(ierr);
}
}
PetscFunctionReturn(0);
}
/* Displays basic information for a matrix (PETSc) */
void Display_matrix_info(Mat A, const char *name) {
MatInfo info;
MatGetInfo(A, MAT_GLOBAL_SUM, &info);
int mal = (int) info.mallocs;
int memory = (int) info.memory;
int nz_allocated = (int) info.nz_allocated;
int nz_used = (int) info.nz_allocated;
int nz_unneeded = (int) info.nz_unneeded;
PetscPrintf(PCW, "Display.c/ printing information for the %s matrix. \n", name);
PetscPrintf(PCW, "Display.c/ allocated non-zeros:%d used non-zeros:%d unneeded non-zeros:%d\n", nz_allocated, nz_used, nz_unneeded);
PetscPrintf(PCW, "Display.c/ memory (bytes):%d number of extra mallocs:%d \n", memory, mal);
}
/*
name[] is operator name
*/
PetscErrorCode BSSCR_MatInfoLog(PetscViewer v,Mat A,const char name[])
{
MatInfo i;
PetscReal nrm_1,nrm_f,nrm_inf;
MatType mtype;
PetscInt M,N;
PetscViewerType vtype;
PetscTruth isascii;
PetscViewerGetType( v, &vtype );
Stg_PetscObjectTypeCompare( (PetscObject)v,PETSC_VIEWER_ASCII,&isascii );
if (!isascii) { PetscFunctionReturn(0); }
MatGetSize( A, &M,&N );
MatGetInfo(A,MAT_GLOBAL_SUM,&i);
MatGetType( A, &mtype );
MatNorm( A, NORM_1, &nrm_1 );
MatNorm( A, NORM_FROBENIUS, &nrm_f );
MatNorm( A, NORM_INFINITY, &nrm_inf );
PetscViewerASCIIPrintf( v, "MatInfo: %s \n", name );
PetscViewerASCIIPushTab(v);
PetscViewerASCIIPrintf( v, "type=%s \n", mtype );
PetscViewerASCIIPrintf( v, "dimension=%Dx%D \n", M,N );
PetscViewerASCIIPrintf( v, "nnz=%D (total)\n", (PetscInt)i.nz_used );
PetscViewerASCIIPrintf( v, "nnz=%D (allocated)\n", (PetscInt)i.nz_allocated );
PetscViewerASCIIPrintf( v, "|A|_1 = %1.12e\n", nrm_1 );
PetscViewerASCIIPrintf( v, "|A|_frobenius = %1.12e\n", nrm_f );
PetscViewerASCIIPrintf( v, "|A|_inf = %1.12e\n", nrm_inf );
PetscViewerASCIIPopTab(v);
PetscFunctionReturn(0);
}
/*
PEPBuildDiagonalScaling - compute two diagonal matrices to be applied for balancing
in polynomial eigenproblems.
*/
PetscErrorCode PEPBuildDiagonalScaling(PEP pep)
{
PetscErrorCode ierr;
PetscInt it,i,j,k,nmat,nr,e,nz,lst,lend,nc=0,*cols,emax,emin,emaxl,eminl;
const PetscInt *cidx,*ridx;
Mat M,*T,A;
PetscMPIInt n;
PetscBool cont=PETSC_TRUE,flg=PETSC_FALSE;
PetscScalar *array,*Dr,*Dl,t;
PetscReal l2,d,*rsum,*aux,*csum,w=1.0;
MatStructure str;
MatInfo info;
PetscFunctionBegin;
l2 = 2*PetscLogReal(2.0);
nmat = pep->nmat;
ierr = PetscMPIIntCast(pep->n,&n);
ierr = STGetMatStructure(pep->st,&str);CHKERRQ(ierr);
ierr = PetscMalloc1(nmat,&T);CHKERRQ(ierr);
for (k=0;k<nmat;k++) {
ierr = STGetTOperators(pep->st,k,&T[k]);CHKERRQ(ierr);
}
/* Form local auxiliar matrix M */
ierr = PetscObjectTypeCompareAny((PetscObject)T[0],&cont,MATMPIAIJ,MATSEQAIJ);CHKERRQ(ierr);
if (!cont) SETERRQ(PetscObjectComm((PetscObject)T[0]),PETSC_ERR_SUP,"Only for MPIAIJ or SEQAIJ matrix types");
ierr = PetscObjectTypeCompare((PetscObject)T[0],MATMPIAIJ,&cont);CHKERRQ(ierr);
if (cont) {
ierr = MatMPIAIJGetLocalMat(T[0],MAT_INITIAL_MATRIX,&M);CHKERRQ(ierr);
flg = PETSC_TRUE;
} else {
ierr = MatDuplicate(T[0],MAT_COPY_VALUES,&M);CHKERRQ(ierr);
}
ierr = MatGetInfo(M,MAT_LOCAL,&info);CHKERRQ(ierr);
nz = info.nz_used;
ierr = MatSeqAIJGetArray(M,&array);CHKERRQ(ierr);
for (i=0;i<nz;i++) {
t = PetscAbsScalar(array[i]);
array[i] = t*t;
}
ierr = MatSeqAIJRestoreArray(M,&array);CHKERRQ(ierr);
for (k=1;k<nmat;k++) {
if (flg) {
ierr = MatMPIAIJGetLocalMat(T[k],MAT_INITIAL_MATRIX,&A);CHKERRQ(ierr);
} else {
if (str==SAME_NONZERO_PATTERN) {
ierr = MatCopy(T[k],A,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
} else {
ierr = MatDuplicate(T[k],MAT_COPY_VALUES,&A);CHKERRQ(ierr);
}
}
ierr = MatGetInfo(A,MAT_LOCAL,&info);CHKERRQ(ierr);
nz = info.nz_used;
ierr = MatSeqAIJGetArray(A,&array);CHKERRQ(ierr);
for (i=0;i<nz;i++) {
t = PetscAbsScalar(array[i]);
array[i] = t*t;
}
ierr = MatSeqAIJRestoreArray(A,&array);CHKERRQ(ierr);
w *= pep->slambda*pep->slambda*pep->sfactor;
ierr = MatAXPY(M,w,A,str);CHKERRQ(ierr);
if (flg || str!=SAME_NONZERO_PATTERN || k==nmat-2) {
ierr = MatDestroy(&A);CHKERRQ(ierr);
}
}
ierr = MatGetRowIJ(M,0,PETSC_FALSE,PETSC_FALSE,&nr,&ridx,&cidx,&cont);CHKERRQ(ierr);
if (!cont) SETERRQ(PetscObjectComm((PetscObject)T[0]), PETSC_ERR_SUP,"It is not possible to compute scaling diagonals for these PEP matrices");
ierr = MatGetInfo(M,MAT_LOCAL,&info);CHKERRQ(ierr);
nz = info.nz_used;
ierr = VecGetOwnershipRange(pep->Dl,&lst,&lend);CHKERRQ(ierr);
ierr = PetscMalloc4(nr,&rsum,pep->n,&csum,pep->n,&aux,PetscMin(pep->n-lend+lst,nz),&cols);CHKERRQ(ierr);
ierr = VecSet(pep->Dr,1.0);CHKERRQ(ierr);
ierr = VecSet(pep->Dl,1.0);CHKERRQ(ierr);
ierr = VecGetArray(pep->Dl,&Dl);CHKERRQ(ierr);
ierr = VecGetArray(pep->Dr,&Dr);CHKERRQ(ierr);
ierr = MatSeqAIJGetArray(M,&array);CHKERRQ(ierr);
ierr = PetscMemzero(aux,pep->n*sizeof(PetscReal));CHKERRQ(ierr);
for (j=0;j<nz;j++) {
/* Search non-zero columns outsize lst-lend */
if (aux[cidx[j]]==0 && (cidx[j]<lst || lend<=cidx[j])) cols[nc++] = cidx[j];
/* Local column sums */
aux[cidx[j]] += PetscAbsScalar(array[j]);
}
for (it=0;it<pep->sits && cont;it++) {
emaxl = 0; eminl = 0;
/* Column sum */
if (it>0) { /* it=0 has been already done*/
ierr = MatSeqAIJGetArray(M,&array);CHKERRQ(ierr);
ierr = PetscMemzero(aux,pep->n*sizeof(PetscReal));CHKERRQ(ierr);
for (j=0;j<nz;j++) aux[cidx[j]] += PetscAbsScalar(array[j]);
ierr = MatSeqAIJRestoreArray(M,&array);CHKERRQ(ierr);
}
ierr = MPI_Allreduce(aux,csum,n,MPIU_REAL,MPIU_SUM,PetscObjectComm((PetscObject)pep->Dr));
/* Update Dr */
for (j=lst;j<lend;j++) {
d = PetscLogReal(csum[j])/l2;
e = -(PetscInt)((d < 0)?(d-0.5):(d+0.5));
d = PetscPowReal(2.0,e);
Dr[j-lst] *= d;
aux[j] = d*d;
emaxl = PetscMax(emaxl,e);
eminl = PetscMin(eminl,e);
}
for (j=0;j<nc;j++) {
d = PetscLogReal(csum[cols[j]])/l2;
e = -(PetscInt)((d < 0)?(d-0.5):(d+0.5));
d = PetscPowReal(2.0,e);
aux[cols[j]] = d*d;
emaxl = PetscMax(emaxl,e);
eminl = PetscMin(eminl,e);
}
/* Scale M */
ierr = MatSeqAIJGetArray(M,&array);CHKERRQ(ierr);
for (j=0;j<nz;j++) {
array[j] *= aux[cidx[j]];
}
ierr = MatSeqAIJRestoreArray(M,&array);CHKERRQ(ierr);
/* Row sum */
ierr = PetscMemzero(rsum,nr*sizeof(PetscReal));CHKERRQ(ierr);
ierr = MatSeqAIJGetArray(M,&array);CHKERRQ(ierr);
for (i=0;i<nr;i++) {
for (j=ridx[i];j<ridx[i+1];j++) rsum[i] += PetscAbsScalar(array[j]);
/* Update Dl */
d = PetscLogReal(rsum[i])/l2;
e = -(PetscInt)((d < 0)?(d-0.5):(d+0.5));
d = PetscPowReal(2.0,e);
Dl[i] *= d;
/* Scale M */
for (j=ridx[i];j<ridx[i+1];j++) array[j] *= d*d;
emaxl = PetscMax(emaxl,e);
eminl = PetscMin(eminl,e);
}
ierr = MatSeqAIJRestoreArray(M,&array);CHKERRQ(ierr);
/* Compute global max and min */
ierr = MPI_Allreduce(&emaxl,&emax,1,MPIU_INT,MPIU_MAX,PetscObjectComm((PetscObject)pep->Dl));
ierr = MPI_Allreduce(&eminl,&emin,1,MPIU_INT,MPIU_MIN,PetscObjectComm((PetscObject)pep->Dl));
if (emax<=emin+2) cont = PETSC_FALSE;
}
ierr = VecRestoreArray(pep->Dr,&Dr);CHKERRQ(ierr);
ierr = VecRestoreArray(pep->Dl,&Dl);CHKERRQ(ierr);
/* Free memory*/
ierr = MatDestroy(&M);CHKERRQ(ierr);
ierr = PetscFree4(rsum,csum,aux,cols);CHKERRQ(ierr);
ierr = PetscFree(T);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int
main(int argc, char *argv[])
{
GRID *g;
DOF *u_h;
MAT *A, *A0, *B;
MAP *map;
INT i;
size_t nnz, mem, mem_peak;
VEC *x, *y0, *y1, *y2;
double t0, t1, dnz, dnz1, mflops, mop;
char *fn = "../test/cube.dat";
FLOAT mem_max = 300;
INT refine = 0;
phgOptionsRegisterFilename("-mesh_file", "Mesh file", (char **)&fn);
phgOptionsRegisterInt("-loop_count", "Loop count", &loop_count);
phgOptionsRegisterInt("-refine", "Refinement level", &refine);
phgOptionsRegisterFloat("-mem_max", "Maximum memory", &mem_max);
phgInit(&argc, &argv);
g = phgNewGrid(-1);
if (!phgImport(g, fn, FALSE))
phgError(1, "can't read file \"%s\".\n", fn);
phgRefineAllElements(g, refine);
u_h = phgDofNew(g, DOF_DEFAULT, 1, "u_h", DofNoAction);
while (TRUE) {
phgPrintf("\n");
if (phgBalanceGrid(g, 1.2, 1, NULL, 0.))
phgPrintf("Repartition mesh, %d submeshes, load imbalance: %lg\n",
g->nprocs, (double)g->lif);
map = phgMapCreate(u_h, NULL);
A = phgMapCreateMat(map, map);
A->handle_bdry_eqns = TRUE;
build_matrix(A, u_h);
phgMatAssemble(A);
/* Note: A is unsymmetric (A' != A) if boundary entries not removed */
phgMatRemoveBoundaryEntries(A);
#if 0
/* test block matrix operation */
A0 = phgMatCreateBlockMatrix(g->comm, 1, 1, &A, NULL);
#else
A0 = A;
#endif
phgPrintf("%d DOF, %d elems, %d submeshes, matrix size: %d, LIF: %lg\n",
DofGetDataCountGlobal(u_h), g->nleaf_global,
g->nprocs, A->rmap->nglobal, (double)g->lif);
/* test PHG mat-vec multiply */
x = phgMapCreateVec(A->cmap, 1);
y1 = phgMapCreateVec(A->rmap, 1);
phgVecRandomize(x, 123);
phgMatVec(MAT_OP_N, 1.0, A0, x, 0.0, &y1);
phgPerfGetMflops(g, NULL, NULL); /* reset flops counter */
t0 = phgGetTime(NULL);
for (i = 0; i < loop_count; i++) {
phgMatVec(MAT_OP_N, 1.0, A0, x, 0.0, &y1);
}
t1 = phgGetTime(NULL);
mflops = phgPerfGetMflops(g, NULL, NULL);
y0 = phgVecCopy(y1, NULL);
nnz = A->nnz_d + A->nnz_o;
#if USE_MPI
dnz1 = nnz;
MPI_Reduce(&dnz1, &dnz, 1, MPI_DOUBLE, MPI_SUM, 0, g->comm);
#else
dnz = nnz;
#endif
mop = loop_count * (dnz + dnz - A->rmap->nlocal) * 1e-6;
phgPrintf("\n");
t1 -= t0;
phgPrintf(" PHG: time %0.4lf, nnz %0.16lg, %0.2lfMF (%0.2lfMF)\n",
t1, dnz, mop / (t1 == 0 ? 1. : t1), mflops);
/* test trans(A)*x */
phgPerfGetMflops(g, NULL, NULL); /* reset flops counter */
t0 = phgGetTime(NULL);
for (i = 0; i < loop_count; i++) {
phgMatVec(MAT_OP_T, 1.0, A0, x, 0.0, &y1);
}
t1 = phgGetTime(NULL);
mflops = phgPerfGetMflops(g, NULL, NULL);
t1 -= t0;
phgPrintf(" A'*x: time %0.4lf, nnz %0.16lg, %0.2lfMF (%0.2lfMF), "
"err: %le\n", t1, dnz, mop / (t1 == 0 ? 1. : t1), mflops,
(double)phgVecNorm2(phgVecAXPBY(-1.0, y0, 1.0, &y1), 0, NULL));
/* time A * trans(A) */
phgPerfGetMflops(g, NULL, NULL); /* reset flops counter */
t0 = phgGetTime(NULL);
B = phgMatMat(MAT_OP_N, MAT_OP_N, 1.0, A, A, 0.0, NULL);
t1 = phgGetTime(NULL);
mflops = phgPerfGetMflops(g, NULL, NULL);
nnz = B->nnz_d + B->nnz_o;
#if USE_MPI
dnz1 = nnz;
MPI_Reduce(&dnz1, &dnz, 1, MPI_DOUBLE, MPI_SUM, 0, g->comm);
#else
dnz = nnz;
#endif
/* compare B*x <--> A*A*x */
y2 = phgMatVec(MAT_OP_N, 1.0, B, x, 0.0, NULL);
phgMatVec(MAT_OP_N, 1.0, A0, y0, 0.0, &y1);
phgMatDestroy(&B);
t1 -= t0;
phgPrintf(" A*A: time %0.4lf, nnz %0.16lg, %0.2lfMF, err: %le\n",
t1, dnz, mflops,
(double)phgVecNorm2(phgVecAXPBY(-1.0, y1, 1.0, &y2), 0, NULL));
#if USE_PETSC
{
Mat ma, mb;
MatInfo info;
Vec va, vb, vc;
PetscScalar *vec;
ma = phgPetscCreateMatAIJ(A);
MatGetVecs(ma, PETSC_NULL, &va);
VecDuplicate(va, &vb);
VecGetArray(va, &vec);
memcpy(vec, x->data, x->map->nlocal * sizeof(*vec));
VecRestoreArray(va, &vec);
MatMult(ma, va, vb);
phgPerfGetMflops(g, NULL, NULL); /* reset flops counter */
t0 = phgGetTime(NULL);
for (i = 0; i < loop_count; i++) {
MatMult(ma, va, vb);
}
t1 = phgGetTime(NULL);
mflops = phgPerfGetMflops(g, NULL, NULL);
VecGetArray(vb, &vec);
memcpy(y1->data, vec, x->map->nlocal * sizeof(*vec));
VecRestoreArray(vb, &vec);
MatGetInfo(ma, MAT_GLOBAL_SUM, &info);
/*phgPrintf(" --------------------------------------------"
"-------------------------\n");*/
phgPrintf("\n");
t1 -= t0;
dnz = info.nz_used;
phgPrintf(" PETSc: time %0.4lf, nnz %0.16lg, %0.2lfMF (%0.2lfMF), "
"err: %le\n", t1, dnz, mop / (t1==0 ? 1.:t1), mflops,
(double)phgVecNorm2(phgVecAXPBY(-1.0, y0, 1.0, &y1), 0, NULL));
phgPerfGetMflops(g, NULL, NULL); /* reset flops counter */
t0 = phgGetTime(NULL);
for (i = 0; i < loop_count; i++) {
MatMultTranspose(ma, va, vb);
}
t1 = phgGetTime(NULL);
mflops = phgPerfGetMflops(g, NULL, NULL);
VecGetArray(vb, &vec);
memcpy(y1->data, vec, x->map->nlocal * sizeof(*vec));
VecRestoreArray(vb, &vec);
t1 -= t0;
phgPrintf(" A'*x: time %0.4lf, nnz %0.16lg, %0.2lfMF (%0.2lfMF), "
"err: %le\n", t1, dnz, mop / (t1==0 ? 1.:t1), mflops,
(double)phgVecNorm2(phgVecAXPBY(-1.0, y0, 1.0, &y1), 0, NULL));
phgPerfGetMflops(g, NULL, NULL); /* reset flops counter */
t0 = phgGetTime(NULL);
MatMatMult(ma, ma, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &mb);
t1 = phgGetTime(NULL);
mflops = phgPerfGetMflops(g, NULL, NULL);
t1 -= t0;
MatGetInfo(mb, MAT_GLOBAL_SUM, &info);
dnz = info.nz_used;
VecDuplicate(va, &vc);
/* compare B*x <--> A*A*x */
MatMult(ma, vb, vc);
MatMult(mb, va, vb);
VecGetArray(vb, &vec);
memcpy(y1->data, vec, x->map->nlocal * sizeof(*vec));
VecRestoreArray(vb, &vec);
VecGetArray(vc, &vec);
memcpy(y2->data, vec, x->map->nlocal * sizeof(*vec));
VecRestoreArray(vc, &vec);
phgPrintf(" A*A: time %0.4lf, nnz %0.16lg, %0.2lfMF, err: %le\n",
t1, dnz, mflops,
(double)phgVecNorm2(phgVecAXPBY(-1.0, y1, 1.0, &y2), 0, NULL));
phgPetscMatDestroy(&mb);
phgPetscMatDestroy(&ma);
phgPetscVecDestroy(&va);
phgPetscVecDestroy(&vb);
phgPetscVecDestroy(&vc);
}
#endif /* USE_PETSC */
#if USE_HYPRE
{
HYPRE_IJMatrix ma;
HYPRE_IJVector va, vb, vc;
HYPRE_ParCSRMatrix par_ma;
hypre_ParCSRMatrix *par_mb;
HYPRE_ParVector par_va, par_vb, par_vc;
HYPRE_Int offset, *ni, start, end;
assert(sizeof(INT)==sizeof(int) && sizeof(FLOAT)==sizeof(double));
setup_hypre_mat(A, &ma);
ni = phgAlloc(2 * A->rmap->nlocal * sizeof(*ni));
offset = A->cmap->partition[A->cmap->rank];
for (i = 0; i < A->rmap->nlocal; i++)
ni[i] = i + offset;
HYPRE_IJVectorCreate(g->comm, offset, offset + A->rmap->nlocal - 1,
&va);
HYPRE_IJVectorCreate(g->comm, offset, offset + A->rmap->nlocal - 1,
&vb);
HYPRE_IJVectorCreate(g->comm, offset, offset + A->rmap->nlocal - 1,
&vc);
HYPRE_IJVectorSetObjectType(va, HYPRE_PARCSR);
HYPRE_IJVectorSetObjectType(vb, HYPRE_PARCSR);
HYPRE_IJVectorSetObjectType(vc, HYPRE_PARCSR);
HYPRE_IJVectorSetMaxOffProcElmts(va, 0);
HYPRE_IJVectorSetMaxOffProcElmts(vb, 0);
HYPRE_IJVectorSetMaxOffProcElmts(vc, 0);
HYPRE_IJVectorInitialize(va);
HYPRE_IJVectorInitialize(vb);
HYPRE_IJVectorInitialize(vc);
HYPRE_IJMatrixGetObject(ma, (void **)(void *)&par_ma);
HYPRE_IJVectorGetObject(va, (void **)(void *)&par_va);
HYPRE_IJVectorGetObject(vb, (void **)(void *)&par_vb);
HYPRE_IJVectorGetObject(vc, (void **)(void *)&par_vc);
HYPRE_IJVectorSetValues(va, A->cmap->nlocal, ni, (double *)x->data);
HYPRE_IJVectorAssemble(va);
HYPRE_IJVectorAssemble(vb);
HYPRE_IJVectorAssemble(vc);
HYPRE_IJMatrixGetRowCounts(ma, A->cmap->nlocal,
ni, ni + A->rmap->nlocal);
for (i = 0, nnz = 0; i < A->rmap->nlocal; i++)
nnz += ni[A->rmap->nlocal + i];
#if USE_MPI
dnz1 = nnz;
MPI_Reduce(&dnz1, &dnz, 1, MPI_DOUBLE, MPI_SUM, 0, g->comm);
#else
dnz = nnz;
#endif
HYPRE_ParCSRMatrixMatvec(1.0, par_ma, par_va, 0.0, par_vb);
phgPerfGetMflops(g, NULL, NULL); /* reset flops counter */
t0 = phgGetTime(NULL);
for (i = 0; i < loop_count; i++) {
HYPRE_ParCSRMatrixMatvec(1.0, par_ma, par_va, 0.0, par_vb);
}
t1 = phgGetTime(NULL);
mflops = phgPerfGetMflops(g, NULL, NULL);
HYPRE_IJVectorGetValues(vb, A->rmap->nlocal, ni, (double*)y1->data);
/*phgPrintf(" --------------------------------------------"
"-------------------------\n");*/
phgPrintf("\n");
t1 -= t0;
phgPrintf(" HYPRE: time %0.4lf, nnz %0.16lg, %0.2lfMF (%0.2lfMF), "
"err: %le\n", t1, dnz, mop / (t1==0 ? 1.:t1), mflops,
(double)phgVecNorm2(phgVecAXPBY(-1.0, y0, 1.0, &y1), 0, NULL));
phgPerfGetMflops(g, NULL, NULL); /* reset flops counter */
t0 = phgGetTime(NULL);
for (i = 0; i < loop_count; i++) {
HYPRE_ParCSRMatrixMatvecT(1.0, par_ma, par_va, 0.0, par_vb);
}
t1 = phgGetTime(NULL);
mflops = phgPerfGetMflops(g, NULL, NULL);
HYPRE_IJVectorGetValues(vb, A->rmap->nlocal, ni, (double*)y1->data);
t1 -= t0;
phgPrintf(" A'*x: time %0.4lf, nnz %0.16lg, %0.2lfMF (%0.2lfMF), "
"err: %le\n", t1, dnz, mop / (t1==0 ? 1.:t1), mflops,
(double)phgVecNorm2(phgVecAXPBY(-1.0, y0, 1.0, &y1), 0, NULL));
phgPerfGetMflops(g, NULL, NULL); /* reset flops counter */
t0 = phgGetTime(NULL);
/* Note: 'HYPRE_ParCSRMatrix' is currently typedef'ed to
* 'hypre_ParCSRMatrix *' */
par_mb = hypre_ParMatmul((hypre_ParCSRMatrix *)par_ma,
(hypre_ParCSRMatrix *)par_ma);
t1 = phgGetTime(NULL);
mflops = phgPerfGetMflops(g, NULL, NULL);
start = hypre_ParCSRMatrixFirstRowIndex(par_mb);
end = hypre_ParCSRMatrixLastRowIndex(par_mb) + 1;
for (i = start, nnz = 0; i < end; i++) {
HYPRE_Int ncols;
hypre_ParCSRMatrixGetRow(par_mb, i, &ncols, NULL, NULL);
hypre_ParCSRMatrixRestoreRow(par_mb, i, &ncols, NULL, NULL);
nnz += ncols;
}
#if USE_MPI
dnz1 = nnz;
MPI_Reduce(&dnz1, &dnz, 1, MPI_DOUBLE, MPI_SUM, 0, g->comm);
#else
dnz = nnz;
#endif
/* compare B*x <--> A*A*x */
HYPRE_ParCSRMatrixMatvec(1.0, par_ma, par_vb, 0.0, par_vc);
HYPRE_ParCSRMatrixMatvec(1.0, (void *)par_mb, par_va, 0.0, par_vb);
HYPRE_IJVectorGetValues(vb, A->rmap->nlocal, ni, (double*)y1->data);
HYPRE_IJVectorGetValues(vc, A->rmap->nlocal, ni, (double*)y2->data);
hypre_ParCSRMatrixDestroy((par_mb));
t1 -= t0;
phgPrintf(" A*A: time %0.4lf, nnz %0.16lg, %0.2lfMF, err: %le\n",
t1, dnz, mflops,
(double)phgVecNorm2(phgVecAXPBY(-1.0, y1, 1.0, &y2), 0, NULL));
phgFree(ni);
HYPRE_IJMatrixDestroy(ma);
HYPRE_IJVectorDestroy(va);
HYPRE_IJVectorDestroy(vb);
HYPRE_IJVectorDestroy(vc);
}
#endif /* USE_HYPRE */
if (A0 != A)
phgMatDestroy(&A0);
#if 0
if (A->rmap->nglobal > 1000) {
VEC *v = phgMapCreateVec(A->rmap, 3);
for (i = 0; i < v->map->nlocal; i++) {
v->data[i + 0 * v->map->nlocal] = 1 * (i + v->map->partition[g->rank]);
v->data[i + 1 * v->map->nlocal] = 2 * (i + v->map->partition[g->rank]);
v->data[i + 2 * v->map->nlocal] = 3 * (i + v->map->partition[g->rank]);
}
phgMatDumpMATLAB(A, "A", "A.m");
phgVecDumpMATLAB(v, "v", "v.m");
phgFinalize();
exit(0);
}
#endif
phgMatDestroy(&A);
phgVecDestroy(&x);
phgVecDestroy(&y0);
phgVecDestroy(&y1);
phgVecDestroy(&y2);
phgMapDestroy(&map);
mem = phgMemoryUsage(g, &mem_peak);
dnz = mem / (1024.0 * 1024.0);
dnz1 = mem_peak / (1024.0 * 1024.0);
/*phgPrintf(" --------------------------------------------"
"-------------------------\n");*/
phgPrintf("\n");
phgPrintf(" Memory: current %0.4lgMB, peak %0.4lgMB\n", dnz, dnz1);
#if 0
{
static int loop_count = 0;
if (++loop_count == 4)
break;
}
#endif
if (mem_peak > 1024 * (size_t)1024 * mem_max)
break;
phgRefineAllElements(g, 1);
}
phgDofFree(&u_h);
phgFreeGrid(&g);
phgFinalize();
return 0;
}
int main(int argc,char **args)
{
Mat C,Credundant;
MatInfo info;
PetscMPIInt rank,size,subsize;
PetscInt i,j,m = 3,n = 2,low,high,iglobal;
PetscInt Ii,J,ldim,nsubcomms;
PetscErrorCode ierr;
PetscBool flg_info,flg_mat;
PetscScalar v,one = 1.0;
Vec x,y;
MPI_Comm subcomm;
ierr = PetscInitialize(&argc,&args,(char*)0,help);if (ierr) return ierr;
ierr = PetscOptionsGetInt(NULL,NULL,"-m",&m,NULL);CHKERRQ(ierr);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
n = 2*size;
ierr = MatCreate(PETSC_COMM_WORLD,&C);CHKERRQ(ierr);
ierr = MatSetSizes(C,PETSC_DECIDE,PETSC_DECIDE,m*n,m*n);CHKERRQ(ierr);
ierr = MatSetFromOptions(C);CHKERRQ(ierr);
ierr = MatSetUp(C);CHKERRQ(ierr);
/* Create the matrix for the five point stencil, YET AGAIN */
for (i=0; i<m; i++) {
for (j=2*rank; j<2*rank+2; j++) {
v = -1.0; Ii = j + n*i;
if (i>0) {J = Ii - n; ierr = MatSetValues(C,1,&Ii,1,&J,&v,INSERT_VALUES);CHKERRQ(ierr);}
if (i<m-1) {J = Ii + n; ierr = MatSetValues(C,1,&Ii,1,&J,&v,INSERT_VALUES);CHKERRQ(ierr);}
if (j>0) {J = Ii - 1; ierr = MatSetValues(C,1,&Ii,1,&J,&v,INSERT_VALUES);CHKERRQ(ierr);}
if (j<n-1) {J = Ii + 1; ierr = MatSetValues(C,1,&Ii,1,&J,&v,INSERT_VALUES);CHKERRQ(ierr);}
v = 4.0; ierr = MatSetValues(C,1,&Ii,1,&Ii,&v,INSERT_VALUES);CHKERRQ(ierr);
}
}
/* Add extra elements (to illustrate variants of MatGetInfo) */
Ii = n; J = n-2; v = 100.0;
ierr = MatSetValues(C,1,&Ii,1,&J,&v,INSERT_VALUES);CHKERRQ(ierr);
Ii = n-2; J = n; v = 100.0;
ierr = MatSetValues(C,1,&Ii,1,&J,&v,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatAssemblyBegin(C,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(C,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* Form vectors */
ierr = MatCreateVecs(C,&x,&y);CHKERRQ(ierr);
ierr = VecGetLocalSize(x,&ldim);CHKERRQ(ierr);
ierr = VecGetOwnershipRange(x,&low,&high);CHKERRQ(ierr);
for (i=0; i<ldim; i++) {
iglobal = i + low;
v = one*((PetscReal)i) + 100.0*rank;
ierr = VecSetValues(x,1,&iglobal,&v,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(x);CHKERRQ(ierr);
ierr = VecAssemblyEnd(x);CHKERRQ(ierr);
ierr = MatMult(C,x,y);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,NULL,"-view_info",&flg_info);CHKERRQ(ierr);
if (flg_info) {
ierr = PetscViewerPushFormat(PETSC_VIEWER_STDOUT_WORLD,PETSC_VIEWER_ASCII_INFO);CHKERRQ(ierr);
ierr = MatView(C,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = MatGetInfo(C,MAT_GLOBAL_SUM,&info);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(PETSC_VIEWER_STDOUT_WORLD,"matrix information (global sums):\nnonzeros = %D, allocated nonzeros = %D\n",(PetscInt)info.nz_used,(PetscInt)info.nz_allocated);CHKERRQ(ierr);
ierr = MatGetInfo (C,MAT_GLOBAL_MAX,&info);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(PETSC_VIEWER_STDOUT_WORLD,"matrix information (global max):\nnonzeros = %D, allocated nonzeros = %D\n",(PetscInt)info.nz_used,(PetscInt)info.nz_allocated);CHKERRQ(ierr);
}
ierr = PetscOptionsHasName(NULL,NULL,"-view_mat",&flg_mat);CHKERRQ(ierr);
if (flg_mat) {
ierr = MatView(C,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
/* Test MatCreateRedundantMatrix() */
nsubcomms = size;
ierr = PetscOptionsGetInt(NULL,NULL,"-nsubcomms",&nsubcomms,NULL);CHKERRQ(ierr);
ierr = MatCreateRedundantMatrix(C,nsubcomms,MPI_COMM_NULL,MAT_INITIAL_MATRIX,&Credundant);CHKERRQ(ierr);
ierr = MatCreateRedundantMatrix(C,nsubcomms,MPI_COMM_NULL,MAT_REUSE_MATRIX,&Credundant);CHKERRQ(ierr);
ierr = PetscObjectGetComm((PetscObject)Credundant,&subcomm);CHKERRQ(ierr);
ierr = MPI_Comm_size(subcomm,&subsize);CHKERRQ(ierr);
if (subsize==2 && flg_mat) {
ierr = PetscViewerASCIIPrintf(PETSC_VIEWER_STDOUT_(subcomm),"\n[%d] Credundant:\n",rank);CHKERRQ(ierr);
ierr = MatView(Credundant,PETSC_VIEWER_STDOUT_(subcomm));CHKERRQ(ierr);
}
ierr = MatDestroy(&Credundant);CHKERRQ(ierr);
/* Test MatCreateRedundantMatrix() with user-provided subcomm */
{
PetscSubcomm psubcomm;
ierr = PetscSubcommCreate(PETSC_COMM_WORLD,&psubcomm);CHKERRQ(ierr);
ierr = PetscSubcommSetNumber(psubcomm,nsubcomms);CHKERRQ(ierr);
ierr = PetscSubcommSetType(psubcomm,PETSC_SUBCOMM_CONTIGUOUS);CHKERRQ(ierr);
/* enable runtime switch of psubcomm type, e.g., '-psubcomm_type interlaced */
ierr = PetscSubcommSetFromOptions(psubcomm);CHKERRQ(ierr);
ierr = MatCreateRedundantMatrix(C,nsubcomms,PetscSubcommChild(psubcomm),MAT_INITIAL_MATRIX,&Credundant);CHKERRQ(ierr);
ierr = MatCreateRedundantMatrix(C,nsubcomms,PetscSubcommChild(psubcomm),MAT_REUSE_MATRIX,&Credundant);CHKERRQ(ierr);
ierr = PetscSubcommDestroy(&psubcomm);CHKERRQ(ierr);
ierr = MatDestroy(&Credundant);CHKERRQ(ierr);
}
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = MatDestroy(&C);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
//==============================================================================
Epetra_PETScAIJMatrix::Epetra_PETScAIJMatrix(Mat Amat)
: Epetra_Object("Epetra::PETScAIJMatrix"),
Amat_(Amat),
Values_(0),
Indices_(0),
MaxNumEntries_(-1),
ImportVector_(0),
NormInf_(-1.0),
NormOne_(-1.0)
{
#ifdef HAVE_MPI
MPI_Comm comm;
PetscObjectGetComm( (PetscObject)Amat, &comm);
Comm_ = new Epetra_MpiComm(comm);
#else
Comm_ = new Epetra_SerialComm();
#endif
int ierr;
char errMsg[80];
MatGetType(Amat, &MatType_);
if ( strcmp(MatType_,MATSEQAIJ) != 0 && strcmp(MatType_,MATMPIAIJ) != 0 ) {
sprintf(errMsg,"PETSc matrix must be either seqaij or mpiaij (but it is %s)",MatType_);
throw Comm_->ReportError(errMsg,-1);
}
petscMatrixType mt;
Mat_MPIAIJ* aij=0;
if (strcmp(MatType_,MATMPIAIJ) == 0) {
mt = PETSC_MPI_AIJ;
aij = (Mat_MPIAIJ*)Amat->data;
}
else if (strcmp(MatType_,MATSEQAIJ) == 0) {
mt = PETSC_SEQ_AIJ;
}
int numLocalRows, numLocalCols;
ierr = MatGetLocalSize(Amat,&numLocalRows,&numLocalCols);
if (ierr) {
sprintf(errMsg,"EpetraExt_PETScAIJMatrix.cpp, line %d, MatGetLocalSize() returned error code %d",__LINE__,ierr);
throw Comm_->ReportError(errMsg,-1);
}
NumMyRows_ = numLocalRows;
NumMyCols_ = numLocalCols; //numLocalCols is the total # of unique columns in the local matrix (the diagonal block)
//TODO what happens if some columns are empty?
if (mt == PETSC_MPI_AIJ)
NumMyCols_ += aij->B->cmap->n;
MatInfo info;
ierr = MatGetInfo(Amat,MAT_LOCAL,&info);
if (ierr) {
sprintf(errMsg,"EpetraExt_PETScAIJMatrix.cpp, line %d, MatGetInfo() returned error code %d",__LINE__,ierr);
throw Comm_->ReportError(errMsg,-1);
}
NumMyNonzeros_ = (int) info.nz_used; //PETSc stores nnz as double
Comm_->SumAll(&(info.nz_used), &NumGlobalNonzeros_, 1);
//The PETSc documentation warns that this may not be robust.
//In particular, this will break if the ordering is not contiguous!
int rowStart, rowEnd;
ierr = MatGetOwnershipRange(Amat,&rowStart,&rowEnd);
if (ierr) {
sprintf(errMsg,"EpetraExt_PETScAIJMatrix.cpp, line %d, MatGetOwnershipRange() returned error code %d",__LINE__,ierr);
throw Comm_->ReportError(errMsg,-1);
}
PetscRowStart_ = rowStart;
PetscRowEnd_ = rowEnd;
int* MyGlobalElements = new int[rowEnd-rowStart];
for (int i=0; i<rowEnd-rowStart; i++)
MyGlobalElements[i] = rowStart+i;
ierr = MatGetInfo(Amat,MAT_GLOBAL_SUM,&info);
if (ierr) {
sprintf(errMsg,"EpetraExt_PETScAIJMatrix.cpp, line %d, MatGetInfo() returned error code %d",__LINE__,ierr);
throw Comm_->ReportError(errMsg,-1);
}
int tmp;
ierr = MatGetSize(Amat,&NumGlobalRows_,&tmp);
DomainMap_ = new Epetra_Map(NumGlobalRows_, NumMyRows_, MyGlobalElements, 0, *Comm_);
// get the GIDs of the non-local columns
//FIXME what if the matrix is sequential?
int * ColGIDs = new int[NumMyCols_];
for (int i=0; i<numLocalCols; i++) ColGIDs[i] = MyGlobalElements[i];
for (int i=numLocalCols; i<NumMyCols_; i++) ColGIDs[i] = aij->garray[i-numLocalCols];
ColMap_ = new Epetra_Map(-1, NumMyCols_, ColGIDs, 0, *Comm_);
Importer_ = new Epetra_Import(*ColMap_, *DomainMap_);
delete [] MyGlobalElements;
delete [] ColGIDs;
} //Epetra_PETScAIJMatrix(Mat Amat)
int main(int argc,char **args)
{
Mat A,Asp;
PetscViewer fd; /* viewer */
char file[PETSC_MAX_PATH_LEN]; /* input file name */
PetscErrorCode ierr;
PetscInt m,n,rstart,rend;
PetscBool flg;
PetscInt row,ncols,j,nrows,nnzA=0,nnzAsp=0;
const PetscInt *cols;
const PetscScalar *vals;
PetscReal norm,percent,val,dtol=1.e-16;
PetscMPIInt rank;
MatInfo matinfo;
PetscInt Dnnz,Onnz;
PetscInitialize(&argc,&args,(char *)0,help);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
/* Determine files from which we read the linear systems. */
ierr = PetscOptionsGetString(PETSC_NULL,"-f",file,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (!flg) SETERRQ(PETSC_COMM_WORLD,1,"Must indicate binary file with the -f option");
/* Open binary file. Note that we use FILE_MODE_READ to indicate
reading from this file. */
ierr = PetscViewerBinaryOpen(PETSC_COMM_WORLD,file,FILE_MODE_READ,&fd);CHKERRQ(ierr);
/* Load the matrix; then destroy the viewer. */
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatSetOptionsPrefix(A,"a_");CHKERRQ(ierr);
ierr = MatSetFromOptions(A);CHKERRQ(ierr);
ierr = MatLoad(A,fd);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&fd);CHKERRQ(ierr);
ierr = MatGetSize(A,&m,&n);CHKERRQ(ierr);
ierr = MatGetInfo(A,MAT_LOCAL,&matinfo);CHKERRQ(ierr);
//printf("matinfo.nz_used %g\n",matinfo.nz_used);
/* Get a sparse matrix Asp by dumping zero entries of A */
ierr = MatCreate(PETSC_COMM_WORLD,&Asp);CHKERRQ(ierr);
ierr = MatSetSizes(Asp,m,n,PETSC_DECIDE,PETSC_DECIDE);CHKERRQ(ierr);
ierr = MatSetOptionsPrefix(Asp,"asp_");CHKERRQ(ierr);
ierr = MatSetFromOptions(Asp);CHKERRQ(ierr);
Dnnz = (PetscInt)matinfo.nz_used/m + 1;
Onnz = Dnnz/2;
printf("Dnnz %d %d\n",Dnnz,Onnz);
ierr = MatSeqAIJSetPreallocation(Asp,Dnnz,PETSC_NULL);CHKERRQ(ierr);
ierr = MatMPIAIJSetPreallocation(Asp,Dnnz,PETSC_NULL,Onnz,PETSC_NULL);CHKERRQ(ierr);
/* Check zero rows */
ierr = MatGetOwnershipRange(A,&rstart,&rend);CHKERRQ(ierr);
nrows = 0;
for (row=rstart; row<rend; row++){
ierr = MatGetRow(A,row,&ncols,&cols,&vals);CHKERRQ(ierr);
nnzA += ncols;
norm = 0.0;
for (j=0; j<ncols; j++){
val = PetscAbsScalar(vals[j]);
if (norm < val) norm = norm;
if (val > dtol){
ierr = MatSetValues(Asp,1,&row,1,&cols[j],&vals[j],INSERT_VALUES);CHKERRQ(ierr);
nnzAsp++;
}
}
if (!norm) nrows++;
ierr = MatRestoreRow(A,row,&ncols,&cols,&vals);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(Asp,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(Asp,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
percent=(PetscReal)nnzA*100/(m*n);
ierr = PetscPrintf(PETSC_COMM_SELF," [%d] Matrix A local size %d,%d; nnzA %d, %g percent; No. of zero rows: %d\n",rank,m,n,nnzA,percent,nrows);
percent=(PetscReal)nnzAsp*100/(m*n);
ierr = PetscPrintf(PETSC_COMM_SELF," [%d] Matrix Asp nnzAsp %d, %g percent\n",rank,nnzAsp,percent);
/* investigate matcoloring for Asp */
PetscBool Asp_coloring = PETSC_FALSE;
ierr = PetscOptionsHasName(PETSC_NULL,"-Asp_color",&Asp_coloring);CHKERRQ(ierr);
if (Asp_coloring){
ISColoring iscoloring;
MatFDColoring matfdcoloring;
ierr = PetscPrintf(PETSC_COMM_WORLD," Create coloring of Asp...\n");
ierr = MatGetColoring(Asp,MATCOLORINGSL,&iscoloring);CHKERRQ(ierr);
ierr = MatFDColoringCreate(Asp,iscoloring,&matfdcoloring);CHKERRQ(ierr);
ierr = MatFDColoringSetFromOptions(matfdcoloring);CHKERRQ(ierr);
//ierr = MatFDColoringView(matfdcoloring,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = ISColoringDestroy(&iscoloring);CHKERRQ(ierr);
ierr = MatFDColoringDestroy(&matfdcoloring);CHKERRQ(ierr);
}
/* Write Asp in binary for study - see ~petsc/src/mat/examples/tests/ex124.c */
PetscBool Asp_write = PETSC_FALSE;
ierr = PetscOptionsHasName(PETSC_NULL,"-Asp_write",&Asp_write);CHKERRQ(ierr);
if (Asp_write){
PetscViewer viewer;
ierr = PetscPrintf(PETSC_COMM_SELF,"Write Asp into file Asp.dat ...\n");
ierr = PetscViewerBinaryOpen(PETSC_COMM_WORLD,"Asp.dat",FILE_MODE_WRITE,&viewer);CHKERRQ(ierr);
ierr = MatView(Asp,viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
}
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = MatDestroy(&Asp);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
static PetscErrorCode PCSetUp_PARMS(PC pc)
{
Mat pmat;
PC_PARMS *parms = (PC_PARMS*)pc->data;
const PetscInt *mapptr0;
PetscInt n, lsize, low, high, i, pos, ncols, length;
int *maptmp, *mapptr, *ia, *ja, *ja1, *im;
PetscScalar *aa, *aa1;
const PetscInt *cols;
PetscInt meth[8];
const PetscScalar *values;
PetscErrorCode ierr;
MatInfo matinfo;
PetscMPIInt rank, npro;
PetscFunctionBegin;
/* Get preconditioner matrix from PETSc and setup pARMS structs */
ierr = PCGetOperators(pc,PETSC_NULL,&pmat,PETSC_NULL);CHKERRQ(ierr);
MPI_Comm_size(((PetscObject)pmat)->comm,&npro);
MPI_Comm_rank(((PetscObject)pmat)->comm,&rank);
ierr = MatGetSize(pmat,&n,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscMalloc((npro+1)*sizeof(int),&mapptr);CHKERRQ(ierr);
ierr = PetscMalloc(n*sizeof(int),&maptmp);CHKERRQ(ierr);
ierr = MatGetOwnershipRanges(pmat,&mapptr0);CHKERRQ(ierr);
low = mapptr0[rank];
high = mapptr0[rank+1];
lsize = high - low;
for (i=0; i<npro+1; i++)
mapptr[i] = mapptr0[i]+1;
for (i = 0; i<n; i++)
maptmp[i] = i+1;
/* if created, destroy the previous map */
if (parms->map) {
parms_MapFree(&parms->map);
parms->map = PETSC_NULL;
}
/* create pARMS map object */
parms_MapCreateFromPtr(&parms->map,(int)n,maptmp,mapptr,((PetscObject)pmat)->comm,1,NONINTERLACED);
/* if created, destroy the previous pARMS matrix */
if (parms->A) {
parms_MatFree(&parms->A);
parms->A = PETSC_NULL;
}
/* create pARMS mat object */
parms_MatCreate(&parms->A,parms->map);
/* setup and copy csr data structure for pARMS */
ierr = PetscMalloc((lsize+1)*sizeof(int),&ia);CHKERRQ(ierr);
ia[0] = 1;
ierr = MatGetInfo(pmat,MAT_LOCAL,&matinfo);CHKERRQ(ierr);
length = matinfo.nz_used;
ierr = PetscMalloc(length*sizeof(int),&ja);CHKERRQ(ierr);
ierr = PetscMalloc(length*sizeof(PetscScalar),&aa);CHKERRQ(ierr);
for (i = low; i<high; i++) {
pos = ia[i-low]-1;
ierr = MatGetRow(pmat,i,&ncols,&cols,&values);CHKERRQ(ierr);
ia[i-low+1] = ia[i-low] + ncols;
if (ia[i-low+1] >= length) {
length += ncols;
ierr = PetscMalloc(length*sizeof(int),&ja1);CHKERRQ(ierr);
ierr = PetscMemcpy(ja1,ja,(ia[i-low]-1)*sizeof(int));CHKERRQ(ierr);
ierr = PetscFree(ja);CHKERRQ(ierr);
ja = ja1;
ierr = PetscMalloc(length*sizeof(PetscScalar),&aa1);CHKERRQ(ierr);
ierr = PetscMemcpy(aa1,aa,(ia[i-low]-1)*sizeof(PetscScalar));CHKERRQ(ierr);
ierr = PetscFree(aa);CHKERRQ(ierr);
aa = aa1;
}
ierr = PetscMemcpy(&ja[pos],cols,ncols*sizeof(int));CHKERRQ(ierr);
ierr = PetscMemcpy(&aa[pos],values,ncols*sizeof(PetscScalar));CHKERRQ(ierr);
ierr = MatRestoreRow(pmat,i,&ncols,&cols,&values);CHKERRQ(ierr);
}
/* csr info is for local matrix so initialize im[] locally */
ierr = PetscMalloc(lsize*sizeof(int),&im);CHKERRQ(ierr);
ierr = PetscMemcpy(im,&maptmp[mapptr[rank]-1],lsize*sizeof(int));CHKERRQ(ierr);
/* 1-based indexing */
for (i=0; i<ia[lsize]-1; i++)
ja[i] = ja[i]+1;
/* Now copy csr matrix to parms_mat object */
parms_MatSetValues(parms->A,(int)lsize,im,ia,ja,aa,INSERT);
/* free memory */
ierr = PetscFree(maptmp);CHKERRQ(ierr);
ierr = PetscFree(mapptr);CHKERRQ(ierr);
ierr = PetscFree(aa);CHKERRQ(ierr);
ierr = PetscFree(ja);CHKERRQ(ierr);
ierr = PetscFree(ia);CHKERRQ(ierr);
ierr = PetscFree(im);CHKERRQ(ierr);
/* setup parms matrix */
parms_MatSetup(parms->A);
/* if created, destroy the previous pARMS pc */
if (parms->pc) {
parms_PCFree(&parms->pc);
parms->pc = PETSC_NULL;
}
/* Now create pARMS preconditioner object based on A */
parms_PCCreate(&parms->pc,parms->A);
/* Transfer options from PC to pARMS */
switch(parms->global) {
case 0: parms_PCSetType(parms->pc, PCRAS); break;
case 1: parms_PCSetType(parms->pc, PCSCHUR); break;
case 2: parms_PCSetType(parms->pc, PCBJ); break;
}
switch(parms->local) {
case 0: parms_PCSetILUType(parms->pc, PCILU0); break;
case 1: parms_PCSetILUType(parms->pc, PCILUK); break;
case 2: parms_PCSetILUType(parms->pc, PCILUT); break;
case 3: parms_PCSetILUType(parms->pc, PCARMS); break;
}
parms_PCSetInnerEps(parms->pc, parms->solvetol);
parms_PCSetNlevels(parms->pc, parms->levels);
parms_PCSetPermType(parms->pc, parms->nonsymperm?1:0);
parms_PCSetBsize(parms->pc, parms->blocksize);
parms_PCSetTolInd(parms->pc, parms->indtol);
parms_PCSetInnerKSize(parms->pc, parms->maxdim);
parms_PCSetInnerMaxits(parms->pc, parms->maxits);
for (i=0; i<8; i++) meth[i] = parms->meth[i]?1:0;
parms_PCSetPermScalOptions(parms->pc, &meth[0], 1);
parms_PCSetPermScalOptions(parms->pc, &meth[4], 0);
parms_PCSetFill(parms->pc, parms->lfil);
parms_PCSetTol(parms->pc, parms->droptol);
parms_PCSetup(parms->pc);
/* Allocate two auxiliary vector of length lsize */
if (parms->lvec0) { ierr = PetscFree(parms->lvec0);CHKERRQ(ierr); }
ierr = PetscMalloc(lsize*sizeof(PetscScalar), &parms->lvec0);CHKERRQ(ierr);
if (parms->lvec1) { ierr = PetscFree(parms->lvec1);CHKERRQ(ierr); }
ierr = PetscMalloc(lsize*sizeof(PetscScalar), &parms->lvec1);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
For MATSEQDENSE matrix, the factorization is just a thin wrapper to LAPACK \n\n";
#include <petscmat.h>
#undef __FUNCT__
#define __FUNCT__ "main"
int main(int argc,char **argv)
{
Mat mat,F,RHS,SOLU;
MatInfo info;
PetscErrorCode ierr;
PetscInt m = 10,n = 10,i,j,rstart,rend,nrhs=2;
PetscScalar value = 1.0;
Vec x,y,b,ytmp;
PetscReal norm,tol=1.e-15;
PetscMPIInt size;
PetscScalar *rhs_array,*solu_array;
PetscRandom rand;
PetscScalar *array,rval;
PetscInitialize(&argc,&argv,(char*) 0,help);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
if (size != 1) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"This is a uniprocessor example only!");
/* create single vectors */
ierr = VecCreate(PETSC_COMM_WORLD,&y);CHKERRQ(ierr);
ierr = VecSetSizes(y,PETSC_DECIDE,m);CHKERRQ(ierr);
ierr = VecSetFromOptions(y);CHKERRQ(ierr);
ierr = VecDuplicate(y,&x);CHKERRQ(ierr);
ierr = VecDuplicate(y,&ytmp);CHKERRQ(ierr);
ierr = VecSet(x,value);CHKERRQ(ierr);
ierr = VecCreate(PETSC_COMM_WORLD,&b);CHKERRQ(ierr);
ierr = VecSetSizes(b,PETSC_DECIDE,n);CHKERRQ(ierr);
ierr = VecSetFromOptions(b);CHKERRQ(ierr);
/* create multiple vectors RHS and SOLU */
ierr = MatCreate(PETSC_COMM_WORLD,&RHS);CHKERRQ(ierr);
ierr = MatSetSizes(RHS,PETSC_DECIDE,PETSC_DECIDE,n,nrhs);CHKERRQ(ierr);
ierr = MatSetType(RHS,MATDENSE);CHKERRQ(ierr);
ierr = MatSetFromOptions(RHS);CHKERRQ(ierr);
ierr = MatSeqDenseSetPreallocation(RHS,NULL);CHKERRQ(ierr);
ierr = PetscRandomCreate(PETSC_COMM_WORLD,&rand);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(rand);CHKERRQ(ierr);
ierr = MatDenseGetArray(RHS,&array);CHKERRQ(ierr);
for (j=0; j<nrhs; j++) {
for (i=0; i<n; i++) {
ierr = PetscRandomGetValue(rand,&rval);CHKERRQ(ierr);
array[n*j+i] = rval;
}
}
ierr = MatDenseRestoreArray(RHS,&array);CHKERRQ(ierr);
ierr = MatDuplicate(RHS,MAT_DO_NOT_COPY_VALUES,&SOLU);CHKERRQ(ierr);
/* create matrix */
ierr = MatCreateSeqDense(PETSC_COMM_WORLD,m,n,NULL,&mat);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(mat,&rstart,&rend);CHKERRQ(ierr);
for (i=rstart; i<rend; i++) {
value = (PetscReal)i+1;
ierr = MatSetValues(mat,1,&i,1,&i,&value,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(mat,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(mat,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatGetInfo(mat,MAT_LOCAL,&info);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"matrix nonzeros = %D, allocated nonzeros = %D\n",
(PetscInt)info.nz_used,(PetscInt)info.nz_allocated);CHKERRQ(ierr);
/* Cholesky factorization - perm and factinfo are ignored by LAPACK */
/* in-place Cholesky */
ierr = MatMult(mat,x,b);CHKERRQ(ierr);
ierr = MatDuplicate(mat,MAT_COPY_VALUES,&F);CHKERRQ(ierr);
ierr = MatCholeskyFactor(F,0,0);CHKERRQ(ierr);
ierr = MatSolve(F,b,y);CHKERRQ(ierr);
ierr = MatDestroy(&F);CHKERRQ(ierr);
value = -1.0; ierr = VecAXPY(y,value,x);CHKERRQ(ierr);
ierr = VecNorm(y,NORM_2,&norm);CHKERRQ(ierr);
if (norm > tol) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Warning: Norm of error for Cholesky %G\n",norm);CHKERRQ(ierr);
}
/* out-place Cholesky */
ierr = MatGetFactor(mat,MATSOLVERPETSC,MAT_FACTOR_CHOLESKY,&F);CHKERRQ(ierr);
ierr = MatCholeskyFactorSymbolic(F,mat,0,0);CHKERRQ(ierr);
ierr = MatCholeskyFactorNumeric(F,mat,0);CHKERRQ(ierr);
ierr = MatSolve(F,b,y);CHKERRQ(ierr);
value = -1.0; ierr = VecAXPY(y,value,x);CHKERRQ(ierr);
ierr = VecNorm(y,NORM_2,&norm);CHKERRQ(ierr);
if (norm > tol) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Warning: Norm of error for Cholesky %G\n",norm);CHKERRQ(ierr);
}
ierr = MatDestroy(&F);CHKERRQ(ierr);
/* LU factorization - perms and factinfo are ignored by LAPACK */
i = m-1; value = 1.0;
ierr = MatSetValues(mat,1,&i,1,&i,&value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatAssemblyBegin(mat,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(mat,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatMult(mat,x,b);CHKERRQ(ierr);
ierr = MatDuplicate(mat,MAT_COPY_VALUES,&F);CHKERRQ(ierr);
/* in-place LU */
ierr = MatLUFactor(F,0,0,0);CHKERRQ(ierr);
ierr = MatSolve(F,b,y);CHKERRQ(ierr);
value = -1.0; ierr = VecAXPY(y,value,x);CHKERRQ(ierr);
ierr = VecNorm(y,NORM_2,&norm);CHKERRQ(ierr);
if (norm > tol) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Warning: Norm of error for LU %G\n",norm);CHKERRQ(ierr);
}
ierr = MatMatSolve(F,RHS,SOLU);CHKERRQ(ierr);
ierr = MatDenseGetArray(SOLU,&solu_array);CHKERRQ(ierr);
ierr = MatDenseGetArray(RHS,&rhs_array);CHKERRQ(ierr);
for (j=0; j<nrhs; j++) {
ierr = VecPlaceArray(y,solu_array+j*m);CHKERRQ(ierr);
ierr = VecPlaceArray(b,rhs_array+j*m);CHKERRQ(ierr);
ierr = MatMult(mat,y,ytmp);CHKERRQ(ierr);
ierr = VecAXPY(ytmp,-1.0,b);CHKERRQ(ierr); /* ytmp = mat*SOLU[:,j] - RHS[:,j] */
ierr = VecNorm(ytmp,NORM_2,&norm);CHKERRQ(ierr);
if (norm > tol) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Error: Norm of residual for LU %G\n",norm);CHKERRQ(ierr);
}
ierr = VecResetArray(b);CHKERRQ(ierr);
ierr = VecResetArray(y);CHKERRQ(ierr);
}
ierr = MatDenseRestoreArray(RHS,&rhs_array);CHKERRQ(ierr);
ierr = MatDenseRestoreArray(SOLU,&solu_array);CHKERRQ(ierr);
ierr = MatDestroy(&F);CHKERRQ(ierr);
/* out-place LU */
ierr = MatGetFactor(mat,MATSOLVERPETSC,MAT_FACTOR_LU,&F);CHKERRQ(ierr);
ierr = MatLUFactorSymbolic(F,mat,0,0,0);CHKERRQ(ierr);
ierr = MatLUFactorNumeric(F,mat,0);CHKERRQ(ierr);
ierr = MatSolve(F,b,y);CHKERRQ(ierr);
value = -1.0; ierr = VecAXPY(y,value,x);CHKERRQ(ierr);
ierr = VecNorm(y,NORM_2,&norm);CHKERRQ(ierr);
if (norm > tol) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Warning: Norm of error for LU %G\n",norm);CHKERRQ(ierr);
}
/* free space */
ierr = MatDestroy(&F);CHKERRQ(ierr);
ierr = MatDestroy(&mat);CHKERRQ(ierr);
ierr = MatDestroy(&RHS);CHKERRQ(ierr);
ierr = MatDestroy(&SOLU);CHKERRQ(ierr);
ierr = PetscRandomDestroy(&rand);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&b);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = VecDestroy(&ytmp);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
static PetscErrorCode PCSetUp_Cholesky(PC pc)
{
PetscErrorCode ierr;
PetscBool flg;
PC_Cholesky *dir = (PC_Cholesky*)pc->data;
PetscFunctionBegin;
if (dir->reusefill && pc->setupcalled) ((PC_Factor*)dir)->info.fill = dir->actualfill;
if (dir->inplace) {
if (dir->row && dir->col && (dir->row != dir->col)) {
ierr = ISDestroy(&dir->row);CHKERRQ(ierr);
}
ierr = ISDestroy(&dir->col);CHKERRQ(ierr);
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)dir)->ordering,&dir->row,&dir->col);CHKERRQ(ierr);
if (dir->col && (dir->row != dir->col)) { /* only use row ordering for SBAIJ */
ierr = ISDestroy(&dir->col);CHKERRQ(ierr);
}
if (dir->row) {ierr = PetscLogObjectParent(pc,dir->row);CHKERRQ(ierr);}
ierr = MatCholeskyFactor(pc->pmat,dir->row,&((PC_Factor*)dir)->info);CHKERRQ(ierr);
((PC_Factor*)dir)->fact = pc->pmat;
} else {
MatInfo info;
if (!pc->setupcalled) {
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)dir)->ordering,&dir->row,&dir->col);CHKERRQ(ierr);
/* check if dir->row == dir->col */
ierr = ISEqual(dir->row,dir->col,&flg);CHKERRQ(ierr);
if (!flg) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_INCOMP,"row and column permutations must equal");
ierr = ISDestroy(&dir->col);CHKERRQ(ierr); /* only pass one ordering into CholeskyFactor */
flg = PETSC_FALSE;
ierr = PetscOptionsGetBool(((PetscObject)pc)->prefix,"-pc_factor_nonzeros_along_diagonal",&flg,PETSC_NULL);CHKERRQ(ierr);
if (flg) {
PetscReal tol = 1.e-10;
ierr = PetscOptionsGetReal(((PetscObject)pc)->prefix,"-pc_factor_nonzeros_along_diagonal",&tol,PETSC_NULL);CHKERRQ(ierr);
ierr = MatReorderForNonzeroDiagonal(pc->pmat,tol,dir->row,dir->row);CHKERRQ(ierr);
}
if (dir->row) {ierr = PetscLogObjectParent(pc,dir->row);CHKERRQ(ierr);}
if (!((PC_Factor*)dir)->fact){
ierr = MatGetFactor(pc->pmat,((PC_Factor*)dir)->solvertype,MAT_FACTOR_CHOLESKY,&((PC_Factor*)dir)->fact);CHKERRQ(ierr);
}
ierr = MatCholeskyFactorSymbolic(((PC_Factor*)dir)->fact,pc->pmat,dir->row,&((PC_Factor*)dir)->info);CHKERRQ(ierr);
ierr = MatGetInfo(((PC_Factor*)dir)->fact,MAT_LOCAL,&info);CHKERRQ(ierr);
dir->actualfill = info.fill_ratio_needed;
ierr = PetscLogObjectParent(pc,((PC_Factor*)dir)->fact);CHKERRQ(ierr);
} else if (pc->flag != SAME_NONZERO_PATTERN) {
if (!dir->reuseordering) {
ierr = ISDestroy(&dir->row);CHKERRQ(ierr);
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)dir)->ordering,&dir->row,&dir->col);CHKERRQ(ierr);
ierr = ISDestroy(&dir->col);CHKERRQ(ierr); /* only use dir->row ordering in CholeskyFactor */
flg = PETSC_FALSE;
ierr = PetscOptionsGetBool(((PetscObject)pc)->prefix,"-pc_factor_nonzeros_along_diagonal",&flg,PETSC_NULL);CHKERRQ(ierr);
if (flg) {
PetscReal tol = 1.e-10;
ierr = PetscOptionsGetReal(((PetscObject)pc)->prefix,"-pc_factor_nonzeros_along_diagonal",&tol,PETSC_NULL);CHKERRQ(ierr);
ierr = MatReorderForNonzeroDiagonal(pc->pmat,tol,dir->row,dir->row);CHKERRQ(ierr);
}
if (dir->row) {ierr = PetscLogObjectParent(pc,dir->row);CHKERRQ(ierr);}
}
ierr = MatDestroy(&((PC_Factor*)dir)->fact);CHKERRQ(ierr);
ierr = MatGetFactor(pc->pmat,((PC_Factor*)dir)->solvertype,MAT_FACTOR_CHOLESKY,&((PC_Factor*)dir)->fact);CHKERRQ(ierr);
ierr = MatCholeskyFactorSymbolic(((PC_Factor*)dir)->fact,pc->pmat,dir->row,&((PC_Factor*)dir)->info);CHKERRQ(ierr);
ierr = MatGetInfo(((PC_Factor*)dir)->fact,MAT_LOCAL,&info);CHKERRQ(ierr);
dir->actualfill = info.fill_ratio_needed;
ierr = PetscLogObjectParent(pc,((PC_Factor*)dir)->fact);CHKERRQ(ierr);
}
ierr = MatCholeskyFactorNumeric(((PC_Factor*)dir)->fact,pc->pmat,&((PC_Factor*)dir)->info);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
static PetscErrorCode PCSetUp_ILU(PC pc)
{
PetscErrorCode ierr;
PC_ILU *ilu = (PC_ILU*)pc->data;
MatInfo info;
PetscBool flg;
PetscFunctionBegin;
/* ugly hack to change default, since it is not support by some matrix types */
if (((PC_Factor*)ilu)->info.shifttype == (PetscReal)MAT_SHIFT_NONZERO) {
ierr = PetscObjectTypeCompare((PetscObject)pc->pmat,MATSEQAIJ,&flg);CHKERRQ(ierr);
if (!flg) {
ierr = PetscObjectTypeCompare((PetscObject)pc->pmat,MATMPIAIJ,&flg);CHKERRQ(ierr);
if (!flg) {
((PC_Factor*)ilu)->info.shifttype = (PetscReal)MAT_SHIFT_INBLOCKS;
PetscInfo(pc,"Changing shift type from NONZERO to INBLOCKS because block matrices do not support NONZERO");CHKERRQ(ierr);
}
}
}
if (ilu->inplace) {
CHKMEMQ;
if (!pc->setupcalled) {
/* In-place factorization only makes sense with the natural ordering,
so we only need to get the ordering once, even if nonzero structure changes */
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)ilu)->ordering,&ilu->row,&ilu->col);CHKERRQ(ierr);
if (ilu->row) {ierr = PetscLogObjectParent(pc,ilu->row);CHKERRQ(ierr);}
if (ilu->col) {ierr = PetscLogObjectParent(pc,ilu->col);CHKERRQ(ierr);}
}
/* In place ILU only makes sense with fill factor of 1.0 because
cannot have levels of fill */
((PC_Factor*)ilu)->info.fill = 1.0;
((PC_Factor*)ilu)->info.diagonal_fill = 0.0;
ierr = MatILUFactor(pc->pmat,ilu->row,ilu->col,&((PC_Factor*)ilu)->info);CHKERRQ(ierr);CHKMEMQ;
((PC_Factor*)ilu)->fact = pc->pmat;
} else {
if (!pc->setupcalled) {
/* first time in so compute reordering and symbolic factorization */
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)ilu)->ordering,&ilu->row,&ilu->col);CHKERRQ(ierr);
if (ilu->row) {ierr = PetscLogObjectParent(pc,ilu->row);CHKERRQ(ierr);}
if (ilu->col) {ierr = PetscLogObjectParent(pc,ilu->col);CHKERRQ(ierr);}
/* Remove zeros along diagonal? */
if (ilu->nonzerosalongdiagonal) {
ierr = MatReorderForNonzeroDiagonal(pc->pmat,ilu->nonzerosalongdiagonaltol,ilu->row,ilu->col);CHKERRQ(ierr);
}
if (!((PC_Factor*)ilu)->fact){
ierr = MatGetFactor(pc->pmat,((PC_Factor*)ilu)->solvertype,MAT_FACTOR_ILU,&((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
}
ierr = MatILUFactorSymbolic(((PC_Factor*)ilu)->fact,pc->pmat,ilu->row,ilu->col,&((PC_Factor*)ilu)->info);CHKERRQ(ierr);
ierr = MatGetInfo(((PC_Factor*)ilu)->fact,MAT_LOCAL,&info);CHKERRQ(ierr);
ilu->actualfill = info.fill_ratio_needed;
ierr = PetscLogObjectParent(pc,((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
} else if (pc->flag != SAME_NONZERO_PATTERN) {
if (!ilu->reuseordering) {
/* compute a new ordering for the ILU */
ierr = ISDestroy(&ilu->row);CHKERRQ(ierr);
ierr = ISDestroy(&ilu->col);CHKERRQ(ierr);
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)ilu)->ordering,&ilu->row,&ilu->col);CHKERRQ(ierr);
if (ilu->row) {ierr = PetscLogObjectParent(pc,ilu->row);CHKERRQ(ierr);}
if (ilu->col) {ierr = PetscLogObjectParent(pc,ilu->col);CHKERRQ(ierr);}
/* Remove zeros along diagonal? */
if (ilu->nonzerosalongdiagonal) {
ierr = MatReorderForNonzeroDiagonal(pc->pmat,ilu->nonzerosalongdiagonaltol,ilu->row,ilu->col);CHKERRQ(ierr);
}
}
ierr = MatDestroy(&((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
ierr = MatGetFactor(pc->pmat,((PC_Factor*)ilu)->solvertype,MAT_FACTOR_ILU,&((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
ierr = MatILUFactorSymbolic(((PC_Factor*)ilu)->fact,pc->pmat,ilu->row,ilu->col,&((PC_Factor*)ilu)->info);CHKERRQ(ierr);
ierr = MatGetInfo(((PC_Factor*)ilu)->fact,MAT_LOCAL,&info);CHKERRQ(ierr);
ilu->actualfill = info.fill_ratio_needed;
ierr = PetscLogObjectParent(pc,((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
}
CHKMEMQ;
ierr = MatLUFactorNumeric(((PC_Factor*)ilu)->fact,pc->pmat,&((PC_Factor*)ilu)->info);CHKERRQ(ierr);
CHKMEMQ;
}
PetscFunctionReturn(0);
}
static PetscErrorCode PCSetUp_ILU(PC pc)
{
PetscErrorCode ierr;
PC_ILU *ilu = (PC_ILU*)pc->data;
MatInfo info;
PetscBool flg;
const MatSolverPackage stype;
MatFactorError err;
PetscFunctionBegin;
pc->failedreason = PC_NOERROR;
/* ugly hack to change default, since it is not support by some matrix types */
if (((PC_Factor*)ilu)->info.shifttype == (PetscReal)MAT_SHIFT_NONZERO) {
ierr = PetscObjectTypeCompare((PetscObject)pc->pmat,MATSEQAIJ,&flg);CHKERRQ(ierr);
if (!flg) {
ierr = PetscObjectTypeCompare((PetscObject)pc->pmat,MATMPIAIJ,&flg);CHKERRQ(ierr);
if (!flg) {
((PC_Factor*)ilu)->info.shifttype = (PetscReal)MAT_SHIFT_INBLOCKS;
PetscInfo(pc,"Changing shift type from NONZERO to INBLOCKS because block matrices do not support NONZERO\n");CHKERRQ(ierr);
}
}
}
ierr = MatSetErrorIfFailure(pc->pmat,pc->erroriffailure);CHKERRQ(ierr);
if (ilu->hdr.inplace) {
if (!pc->setupcalled) {
/* In-place factorization only makes sense with the natural ordering,
so we only need to get the ordering once, even if nonzero structure changes */
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)ilu)->ordering,&ilu->row,&ilu->col);CHKERRQ(ierr);
if (ilu->row) {ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)ilu->row);CHKERRQ(ierr);}
if (ilu->col) {ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)ilu->col);CHKERRQ(ierr);}
}
/* In place ILU only makes sense with fill factor of 1.0 because
cannot have levels of fill */
((PC_Factor*)ilu)->info.fill = 1.0;
((PC_Factor*)ilu)->info.diagonal_fill = 0.0;
ierr = MatILUFactor(pc->pmat,ilu->row,ilu->col,&((PC_Factor*)ilu)->info);CHKERRQ(ierr);CHKERRQ(ierr);
ierr = MatFactorGetError(pc->pmat,&err);CHKERRQ(ierr);
if (err) { /* Factor() fails */
pc->failedreason = (PCFailedReason)err;
PetscFunctionReturn(0);
}
((PC_Factor*)ilu)->fact = pc->pmat;
/* must update the pc record of the matrix state or the PC will attempt to run PCSetUp() yet again */
ierr = PetscObjectStateGet((PetscObject)pc->pmat,&pc->matstate);CHKERRQ(ierr);
} else {
if (!pc->setupcalled) {
/* first time in so compute reordering and symbolic factorization */
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)ilu)->ordering,&ilu->row,&ilu->col);CHKERRQ(ierr);
if (ilu->row) {ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)ilu->row);CHKERRQ(ierr);}
if (ilu->col) {ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)ilu->col);CHKERRQ(ierr);}
/* Remove zeros along diagonal? */
if (ilu->nonzerosalongdiagonal) {
ierr = MatReorderForNonzeroDiagonal(pc->pmat,ilu->nonzerosalongdiagonaltol,ilu->row,ilu->col);CHKERRQ(ierr);
}
if (!((PC_Factor*)ilu)->fact) {
ierr = MatGetFactor(pc->pmat,((PC_Factor*)ilu)->solvertype,MAT_FACTOR_ILU,&((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
}
ierr = MatILUFactorSymbolic(((PC_Factor*)ilu)->fact,pc->pmat,ilu->row,ilu->col,&((PC_Factor*)ilu)->info);CHKERRQ(ierr);
ierr = MatGetInfo(((PC_Factor*)ilu)->fact,MAT_LOCAL,&info);CHKERRQ(ierr);
ilu->hdr.actualfill = info.fill_ratio_needed;
ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
} else if (pc->flag != SAME_NONZERO_PATTERN) {
if (!ilu->hdr.reuseordering) {
/* compute a new ordering for the ILU */
ierr = ISDestroy(&ilu->row);CHKERRQ(ierr);
ierr = ISDestroy(&ilu->col);CHKERRQ(ierr);
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)ilu)->ordering,&ilu->row,&ilu->col);CHKERRQ(ierr);
if (ilu->row) {ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)ilu->row);CHKERRQ(ierr);}
if (ilu->col) {ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)ilu->col);CHKERRQ(ierr);}
/* Remove zeros along diagonal? */
if (ilu->nonzerosalongdiagonal) {
ierr = MatReorderForNonzeroDiagonal(pc->pmat,ilu->nonzerosalongdiagonaltol,ilu->row,ilu->col);CHKERRQ(ierr);
}
}
ierr = MatDestroy(&((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
ierr = MatGetFactor(pc->pmat,((PC_Factor*)ilu)->solvertype,MAT_FACTOR_ILU,&((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
ierr = MatILUFactorSymbolic(((PC_Factor*)ilu)->fact,pc->pmat,ilu->row,ilu->col,&((PC_Factor*)ilu)->info);CHKERRQ(ierr);
ierr = MatGetInfo(((PC_Factor*)ilu)->fact,MAT_LOCAL,&info);CHKERRQ(ierr);
ilu->hdr.actualfill = info.fill_ratio_needed;
ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
}
ierr = MatFactorGetError(((PC_Factor*)ilu)->fact,&err);CHKERRQ(ierr);
if (err) { /* FactorSymbolic() fails */
pc->failedreason = (PCFailedReason)err;
PetscFunctionReturn(0);
}
ierr = MatLUFactorNumeric(((PC_Factor*)ilu)->fact,pc->pmat,&((PC_Factor*)ilu)->info);CHKERRQ(ierr);
ierr = MatFactorGetError(((PC_Factor*)ilu)->fact,&err);CHKERRQ(ierr);
if (err) { /* FactorNumeric() fails */
pc->failedreason = (PCFailedReason)err;
}
}
ierr = PCFactorGetMatSolverPackage(pc,&stype);CHKERRQ(ierr);
if (!stype) {
const MatSolverPackage solverpackage;
ierr = MatFactorGetSolverPackage(((PC_Factor*)ilu)->fact,&solverpackage);CHKERRQ(ierr);
ierr = PCFactorSetMatSolverPackage(pc,solverpackage);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
static PetscErrorCode PCSetUp_Cholesky(PC pc)
{
PetscErrorCode ierr;
PetscBool flg;
PC_Cholesky *dir = (PC_Cholesky*)pc->data;
const MatSolverPackage stype;
MatFactorError err;
PetscFunctionBegin;
pc->failedreason = PC_NOERROR;
if (dir->hdr.reusefill && pc->setupcalled) ((PC_Factor*)dir)->info.fill = dir->hdr.actualfill;
ierr = MatSetErrorIfFailure(pc->pmat,pc->erroriffailure);
CHKERRQ(ierr);
if (dir->hdr.inplace) {
if (dir->row && dir->col && (dir->row != dir->col)) {
ierr = ISDestroy(&dir->row);
CHKERRQ(ierr);
}
ierr = ISDestroy(&dir->col);
CHKERRQ(ierr);
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)dir)->ordering,&dir->row,&dir->col);
CHKERRQ(ierr);
if (dir->col && (dir->row != dir->col)) { /* only use row ordering for SBAIJ */
ierr = ISDestroy(&dir->col);
CHKERRQ(ierr);
}
if (dir->row) {
ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)dir->row);
CHKERRQ(ierr);
}
ierr = MatCholeskyFactor(pc->pmat,dir->row,&((PC_Factor*)dir)->info);
CHKERRQ(ierr);
ierr = MatFactorGetError(pc->pmat,&err);
CHKERRQ(ierr);
if (err) { /* Factor() fails */
pc->failedreason = (PCFailedReason)err;
PetscFunctionReturn(0);
}
((PC_Factor*)dir)->fact = pc->pmat;
} else {
MatInfo info;
if (!pc->setupcalled) {
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)dir)->ordering,&dir->row,&dir->col);
CHKERRQ(ierr);
/* check if dir->row == dir->col */
ierr = ISEqual(dir->row,dir->col,&flg);
CHKERRQ(ierr);
if (!flg) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_INCOMP,"row and column permutations must equal");
ierr = ISDestroy(&dir->col);
CHKERRQ(ierr); /* only pass one ordering into CholeskyFactor */
flg = PETSC_FALSE;
ierr = PetscOptionsGetBool(((PetscObject)pc)->options,((PetscObject)pc)->prefix,"-pc_factor_nonzeros_along_diagonal",&flg,NULL);
CHKERRQ(ierr);
if (flg) {
PetscReal tol = 1.e-10;
ierr = PetscOptionsGetReal(((PetscObject)pc)->options,((PetscObject)pc)->prefix,"-pc_factor_nonzeros_along_diagonal",&tol,NULL);
CHKERRQ(ierr);
ierr = MatReorderForNonzeroDiagonal(pc->pmat,tol,dir->row,dir->row);
CHKERRQ(ierr);
}
if (dir->row) {
ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)dir->row);
CHKERRQ(ierr);
}
if (!((PC_Factor*)dir)->fact) {
ierr = MatGetFactor(pc->pmat,((PC_Factor*)dir)->solvertype,MAT_FACTOR_CHOLESKY,&((PC_Factor*)dir)->fact);
CHKERRQ(ierr);
}
ierr = MatCholeskyFactorSymbolic(((PC_Factor*)dir)->fact,pc->pmat,dir->row,&((PC_Factor*)dir)->info);
CHKERRQ(ierr);
ierr = MatGetInfo(((PC_Factor*)dir)->fact,MAT_LOCAL,&info);
CHKERRQ(ierr);
dir->hdr.actualfill = info.fill_ratio_needed;
ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)((PC_Factor*)dir)->fact);
CHKERRQ(ierr);
} else if (pc->flag != SAME_NONZERO_PATTERN) {
if (!dir->hdr.reuseordering) {
ierr = ISDestroy(&dir->row);
CHKERRQ(ierr);
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)dir)->ordering,&dir->row,&dir->col);
CHKERRQ(ierr);
ierr = ISDestroy(&dir->col);
CHKERRQ(ierr); /* only use dir->row ordering in CholeskyFactor */
flg = PETSC_FALSE;
ierr = PetscOptionsGetBool(((PetscObject)pc)->options,((PetscObject)pc)->prefix,"-pc_factor_nonzeros_along_diagonal",&flg,NULL);
CHKERRQ(ierr);
if (flg) {
PetscReal tol = 1.e-10;
ierr = PetscOptionsGetReal(((PetscObject)pc)->options,((PetscObject)pc)->prefix,"-pc_factor_nonzeros_along_diagonal",&tol,NULL);
CHKERRQ(ierr);
ierr = MatReorderForNonzeroDiagonal(pc->pmat,tol,dir->row,dir->row);
CHKERRQ(ierr);
}
if (dir->row) {
ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)dir->row);
CHKERRQ(ierr);
}
}
ierr = MatDestroy(&((PC_Factor*)dir)->fact);
CHKERRQ(ierr);
ierr = MatGetFactor(pc->pmat,((PC_Factor*)dir)->solvertype,MAT_FACTOR_CHOLESKY,&((PC_Factor*)dir)->fact);
CHKERRQ(ierr);
ierr = MatCholeskyFactorSymbolic(((PC_Factor*)dir)->fact,pc->pmat,dir->row,&((PC_Factor*)dir)->info);
CHKERRQ(ierr);
ierr = MatGetInfo(((PC_Factor*)dir)->fact,MAT_LOCAL,&info);
CHKERRQ(ierr);
dir->hdr.actualfill = info.fill_ratio_needed;
ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)((PC_Factor*)dir)->fact);
CHKERRQ(ierr);
} else {
ierr = MatFactorGetError(((PC_Factor*)dir)->fact,&err);
CHKERRQ(ierr);
if (err == MAT_FACTOR_NUMERIC_ZEROPIVOT) {
ierr = MatFactorClearError(((PC_Factor*)dir)->fact);
CHKERRQ(ierr);
pc->failedreason = PC_NOERROR;
}
}
ierr = MatFactorGetError(((PC_Factor*)dir)->fact,&err);
CHKERRQ(ierr);
if (err) { /* FactorSymbolic() fails */
pc->failedreason = (PCFailedReason)err;
PetscFunctionReturn(0);
}
ierr = MatCholeskyFactorNumeric(((PC_Factor*)dir)->fact,pc->pmat,&((PC_Factor*)dir)->info);
CHKERRQ(ierr);
ierr = MatFactorGetError(((PC_Factor*)dir)->fact,&err);
CHKERRQ(ierr);
if (err) { /* FactorNumeric() fails */
pc->failedreason = (PCFailedReason)err;
}
}
ierr = PCFactorGetMatSolverPackage(pc,&stype);
CHKERRQ(ierr);
if (!stype) {
const MatSolverPackage solverpackage;
ierr = MatFactorGetSolverPackage(((PC_Factor*)dir)->fact,&solverpackage);
CHKERRQ(ierr);
ierr = PCFactorSetMatSolverPackage(pc,solverpackage);
CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/*@C
PCGAMGFilterGraph - filter (remove zero and possibly small values from the) graph and make it symmetric if requested
Collective on Mat
Input Parameter:
+ a_Gmat - the graph
. vfilter - threshold paramter [0,1)
- symm - make the result symmetric
Level: developer
Notes:
This is called before graph coarsers are called.
.seealso: PCGAMGSetThreshold()
@*/
PetscErrorCode PCGAMGFilterGraph(Mat *a_Gmat,PetscReal vfilter,PetscBool symm)
{
PetscErrorCode ierr;
PetscInt Istart,Iend,Ii,jj,ncols,nnz0,nnz1, NN, MM, nloc;
PetscMPIInt rank;
Mat Gmat = *a_Gmat, tGmat, matTrans;
MPI_Comm comm;
const PetscScalar *vals;
const PetscInt *idx;
PetscInt *d_nnz, *o_nnz;
Vec diag;
MatType mtype;
PetscFunctionBegin;
#if defined PETSC_GAMG_USE_LOG
ierr = PetscLogEventBegin(petsc_gamg_setup_events[GRAPH],0,0,0,0);CHKERRQ(ierr);
#endif
/* scale Gmat for all values between -1 and 1 */
ierr = MatCreateVecs(Gmat, &diag, 0);CHKERRQ(ierr);
ierr = MatGetDiagonal(Gmat, diag);CHKERRQ(ierr);
ierr = VecReciprocal(diag);CHKERRQ(ierr);
ierr = VecSqrtAbs(diag);CHKERRQ(ierr);
ierr = MatDiagonalScale(Gmat, diag, diag);CHKERRQ(ierr);
ierr = VecDestroy(&diag);CHKERRQ(ierr);
if (vfilter < 0.0 && !symm) {
/* Just use the provided matrix as the graph but make all values positive */
MatInfo info;
PetscScalar *avals;
PetscBool isaij,ismpiaij;
ierr = PetscObjectBaseTypeCompare((PetscObject)Gmat,MATSEQAIJ,&isaij);CHKERRQ(ierr);
ierr = PetscObjectBaseTypeCompare((PetscObject)Gmat,MATMPIAIJ,&ismpiaij);CHKERRQ(ierr);
if (!isaij && !ismpiaij) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_USER,"Require (MPI)AIJ matrix type");
if (isaij) {
ierr = MatGetInfo(Gmat,MAT_LOCAL,&info);CHKERRQ(ierr);
ierr = MatSeqAIJGetArray(Gmat,&avals);CHKERRQ(ierr);
for (jj = 0; jj<info.nz_used; jj++) avals[jj] = PetscAbsScalar(avals[jj]);
ierr = MatSeqAIJRestoreArray(Gmat,&avals);CHKERRQ(ierr);
} else {
Mat_MPIAIJ *aij = (Mat_MPIAIJ*)Gmat->data;
ierr = MatGetInfo(aij->A,MAT_LOCAL,&info);CHKERRQ(ierr);
ierr = MatSeqAIJGetArray(aij->A,&avals);CHKERRQ(ierr);
for (jj = 0; jj<info.nz_used; jj++) avals[jj] = PetscAbsScalar(avals[jj]);
ierr = MatSeqAIJRestoreArray(aij->A,&avals);CHKERRQ(ierr);
ierr = MatGetInfo(aij->B,MAT_LOCAL,&info);CHKERRQ(ierr);
ierr = MatSeqAIJGetArray(aij->B,&avals);CHKERRQ(ierr);
for (jj = 0; jj<info.nz_used; jj++) avals[jj] = PetscAbsScalar(avals[jj]);
ierr = MatSeqAIJRestoreArray(aij->B,&avals);CHKERRQ(ierr);
}
#if defined PETSC_GAMG_USE_LOG
ierr = PetscLogEventEnd(petsc_gamg_setup_events[GRAPH],0,0,0,0);CHKERRQ(ierr);
#endif
PetscFunctionReturn(0);
}
ierr = PetscObjectGetComm((PetscObject)Gmat,&comm);CHKERRQ(ierr);
ierr = MPI_Comm_rank(comm,&rank);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(Gmat, &Istart, &Iend);CHKERRQ(ierr);
nloc = Iend - Istart;
ierr = MatGetSize(Gmat, &MM, &NN);CHKERRQ(ierr);
if (symm) {
ierr = MatTranspose(Gmat, MAT_INITIAL_MATRIX, &matTrans);CHKERRQ(ierr);
}
/* Determine upper bound on nonzeros needed in new filtered matrix */
ierr = PetscMalloc2(nloc, &d_nnz,nloc, &o_nnz);CHKERRQ(ierr);
for (Ii = Istart, jj = 0; Ii < Iend; Ii++, jj++) {
ierr = MatGetRow(Gmat,Ii,&ncols,NULL,NULL);CHKERRQ(ierr);
d_nnz[jj] = ncols;
o_nnz[jj] = ncols;
ierr = MatRestoreRow(Gmat,Ii,&ncols,NULL,NULL);CHKERRQ(ierr);
if (symm) {
ierr = MatGetRow(matTrans,Ii,&ncols,NULL,NULL);CHKERRQ(ierr);
d_nnz[jj] += ncols;
o_nnz[jj] += ncols;
ierr = MatRestoreRow(matTrans,Ii,&ncols,NULL,NULL);CHKERRQ(ierr);
}
if (d_nnz[jj] > nloc) d_nnz[jj] = nloc;
if (o_nnz[jj] > (MM-nloc)) o_nnz[jj] = MM - nloc;
}
ierr = MatGetType(Gmat,&mtype);CHKERRQ(ierr);
ierr = MatCreate(comm, &tGmat);CHKERRQ(ierr);
ierr = MatSetSizes(tGmat,nloc,nloc,MM,MM);CHKERRQ(ierr);
ierr = MatSetBlockSizes(tGmat, 1, 1);CHKERRQ(ierr);
ierr = MatSetType(tGmat, mtype);CHKERRQ(ierr);
ierr = MatSeqAIJSetPreallocation(tGmat,0,d_nnz);CHKERRQ(ierr);
ierr = MatMPIAIJSetPreallocation(tGmat,0,d_nnz,0,o_nnz);CHKERRQ(ierr);
ierr = PetscFree2(d_nnz,o_nnz);CHKERRQ(ierr);
if (symm) {
ierr = MatDestroy(&matTrans);CHKERRQ(ierr);
} else {
/* all entries are generated locally so MatAssembly will be slightly faster for large process counts */
ierr = MatSetOption(tGmat,MAT_NO_OFF_PROC_ENTRIES,PETSC_TRUE);CHKERRQ(ierr);
}
for (Ii = Istart, nnz0 = nnz1 = 0; Ii < Iend; Ii++) {
ierr = MatGetRow(Gmat,Ii,&ncols,&idx,&vals);CHKERRQ(ierr);
for (jj=0; jj<ncols; jj++,nnz0++) {
PetscScalar sv = PetscAbs(PetscRealPart(vals[jj]));
if (PetscRealPart(sv) > vfilter) {
nnz1++;
if (symm) {
sv *= 0.5;
ierr = MatSetValues(tGmat,1,&Ii,1,&idx[jj],&sv,ADD_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(tGmat,1,&idx[jj],1,&Ii,&sv,ADD_VALUES);CHKERRQ(ierr);
} else {
ierr = MatSetValues(tGmat,1,&Ii,1,&idx[jj],&sv,ADD_VALUES);CHKERRQ(ierr);
}
}
}
ierr = MatRestoreRow(Gmat,Ii,&ncols,&idx,&vals);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(tGmat,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(tGmat,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
#if defined PETSC_GAMG_USE_LOG
ierr = PetscLogEventEnd(petsc_gamg_setup_events[GRAPH],0,0,0,0);CHKERRQ(ierr);
#endif
#if defined(PETSC_USE_INFO)
{
double t1 = (!nnz0) ? 1. : 100.*(double)nnz1/(double)nnz0, t2 = (!nloc) ? 1. : (double)nnz0/(double)nloc;
ierr = PetscInfo4(*a_Gmat,"\t %g%% nnz after filtering, with threshold %g, %g nnz ave. (N=%D)\n",t1,vfilter,t2,MM);CHKERRQ(ierr);
}
#endif
ierr = MatDestroy(&Gmat);CHKERRQ(ierr);
*a_Gmat = tGmat;
PetscFunctionReturn(0);
}
int main(int argc,char **args)
{
Vec x,y,b,s1,s2;
Mat A; /* linear system matrix */
Mat sA; /* symmetric part of the matrices */
PetscInt n,mbs=16,bs=1,nz=3,prob=2,i,j,col[3],row,Ii,J,n1;
const PetscInt *ip_ptr;
PetscScalar neg_one = -1.0,value[3],alpha=0.1;
PetscMPIInt size;
PetscErrorCode ierr;
IS ip, isrow, iscol;
PetscRandom rdm;
PetscBool reorder=PETSC_FALSE;
MatInfo minfo1,minfo2;
PetscReal norm1,norm2,tol=1.e-10;
PetscInitialize(&argc,&args,(char *)0,help);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
if (size != 1) SETERRQ(PETSC_COMM_WORLD,1,"This is a uniprocessor example only!");
ierr = PetscOptionsGetInt(PETSC_NULL,"-bs",&bs,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(PETSC_NULL,"-mbs",&mbs,PETSC_NULL);CHKERRQ(ierr);
n = mbs*bs;
ierr=MatCreateSeqBAIJ(PETSC_COMM_WORLD,bs,n,n,nz,PETSC_NULL, &A);CHKERRQ(ierr);
ierr=MatCreateSeqSBAIJ(PETSC_COMM_WORLD,bs,n,n,nz,PETSC_NULL, &sA);CHKERRQ(ierr);
/* Test MatGetOwnershipRange() */
ierr = MatGetOwnershipRange(A,&Ii,&J);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(sA,&i,&j);CHKERRQ(ierr);
if (i-Ii || j-J){
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatGetOwnershipRange() in MatSBAIJ format\n");CHKERRQ(ierr);
}
/* Assemble matrix */
if (bs == 1){
ierr = PetscOptionsGetInt(PETSC_NULL,"-test_problem",&prob,PETSC_NULL);CHKERRQ(ierr);
if (prob == 1){ /* tridiagonal matrix */
value[0] = -1.0; value[1] = 2.0; value[2] = -1.0;
for (i=1; i<n-1; i++) {
col[0] = i-1; col[1] = i; col[2] = i+1;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
i = n - 1; col[0]=0; col[1] = n - 2; col[2] = n - 1;
value[0]= 0.1; value[1]=-1; value[2]=2;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
i = 0; col[0] = 0; col[1] = 1; col[2]=n-1;
value[0] = 2.0; value[1] = -1.0; value[2]=0.1;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
else if (prob ==2){ /* matrix for the five point stencil */
n1 = (int) (PetscSqrtReal((PetscReal)n) + 0.001);
if (n1*n1 - n) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"sqrt(n) must be a positive interger!");
for (i=0; i<n1; i++) {
for (j=0; j<n1; j++) {
Ii = j + n1*i;
if (i>0) {
J = Ii - n1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
if (i<n1-1) {
J = Ii + n1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
if (j>0) {
J = Ii - 1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
if (j<n1-1) {
J = Ii + 1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
/*
ierr = MatSetValues(A,1,&I,1,&I,&four,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&I,1,&I,&four,INSERT_VALUES);CHKERRQ(ierr);
*/
}
}
}
}
else { /* bs > 1 */
#ifdef DIAGB
for (block=0; block<n/bs; block++){
/* diagonal blocks */
value[0] = -1.0; value[1] = 4.0; value[2] = -1.0;
for (i=1+block*bs; i<bs-1+block*bs; i++) {
col[0] = i-1; col[1] = i; col[2] = i+1;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
i = bs - 1+block*bs; col[0] = bs - 2+block*bs; col[1] = bs - 1+block*bs;
value[0]=-1.0; value[1]=4.0;
ierr = MatSetValues(A,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
i = 0+block*bs; col[0] = 0+block*bs; col[1] = 1+block*bs;
value[0]=4.0; value[1] = -1.0;
ierr = MatSetValues(A,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
#endif
/* off-diagonal blocks */
value[0]=-1.0;
for (i=0; i<(n/bs-1)*bs; i++){
col[0]=i+bs;
ierr = MatSetValues(A,1,&i,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
col[0]=i; row=i+bs;
ierr = MatSetValues(A,1,&row,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&row,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
}
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* PetscPrintf(PETSC_COMM_SELF,"\n The Matrix: \n");
MatView(A, VIEWER_DRAW_WORLD);
MatView(A, VIEWER_STDOUT_WORLD); */
ierr = MatAssemblyBegin(sA,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(sA,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* PetscPrintf(PETSC_COMM_SELF,"\n Symmetric Part of Matrix: \n");
MatView(sA, VIEWER_DRAW_WORLD);
MatView(sA, VIEWER_STDOUT_WORLD);
*/
/* Test MatNorm() */
ierr = MatNorm(A,NORM_FROBENIUS,&norm1);CHKERRQ(ierr);
ierr = MatNorm(sA,NORM_FROBENIUS,&norm2);CHKERRQ(ierr);
norm1 -= norm2;
if (norm1<-tol || norm1>tol){
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm(), fnorm1-fnorm2=%16.14e\n",norm1);CHKERRQ(ierr);
}
ierr = MatNorm(A,NORM_INFINITY,&norm1);CHKERRQ(ierr);
ierr = MatNorm(sA,NORM_INFINITY,&norm2);CHKERRQ(ierr);
norm1 -= norm2;
if (norm1<-tol || norm1>tol){
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm(), inf_norm1-inf_norm2=%16.14e\n",norm1);CHKERRQ(ierr);
}
/* Test MatGetInfo(), MatGetSize(), MatGetBlockSize() */
ierr = MatGetInfo(A,MAT_LOCAL,&minfo1);CHKERRQ(ierr);
ierr = MatGetInfo(sA,MAT_LOCAL,&minfo2);CHKERRQ(ierr);
/*
printf("matrix nonzeros (BAIJ format) = %d, allocated nonzeros= %d\n", (int)minfo1.nz_used,(int)minfo1.nz_allocated);
printf("matrix nonzeros(SBAIJ format) = %d, allocated nonzeros= %d\n", (int)minfo2.nz_used,(int)minfo2.nz_allocated);
*/
i = (int) (minfo1.nz_used - minfo2.nz_used);
j = (int) (minfo1.nz_allocated - minfo2.nz_allocated);
if (i<0 || j<0) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatGetInfo()\n");CHKERRQ(ierr);
}
ierr = MatGetSize(A,&Ii,&J);CHKERRQ(ierr);
ierr = MatGetSize(sA,&i,&j);CHKERRQ(ierr);
if (i-Ii || j-J) {
PetscPrintf(PETSC_COMM_SELF,"Error: MatGetSize()\n");CHKERRQ(ierr);
}
ierr = MatGetBlockSize(A, &Ii);CHKERRQ(ierr);
ierr = MatGetBlockSize(sA, &i);CHKERRQ(ierr);
if (i-Ii){
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatGetBlockSize()\n");CHKERRQ(ierr);
}
/* Test MatDiagonalScale(), MatGetDiagonal(), MatScale() */
ierr = PetscRandomCreate(PETSC_COMM_SELF,&rdm);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(rdm);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,n,&x);CHKERRQ(ierr);
ierr = VecDuplicate(x,&s1);CHKERRQ(ierr);
ierr = VecDuplicate(x,&s2);CHKERRQ(ierr);
ierr = VecDuplicate(x,&y);CHKERRQ(ierr);
ierr = VecDuplicate(x,&b);CHKERRQ(ierr);
ierr = VecSetRandom(x,rdm);CHKERRQ(ierr);
ierr = MatDiagonalScale(A,x,x);CHKERRQ(ierr);
ierr = MatDiagonalScale(sA,x,x);CHKERRQ(ierr);
ierr = MatGetDiagonal(A,s1);CHKERRQ(ierr);
ierr = MatGetDiagonal(sA,s2);CHKERRQ(ierr);
ierr = VecNorm(s1,NORM_1,&norm1);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_1,&norm2);CHKERRQ(ierr);
norm1 -= norm2;
if (norm1<-tol || norm1>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error:MatGetDiagonal() \n");CHKERRQ(ierr);
}
ierr = MatScale(A,alpha);CHKERRQ(ierr);
ierr = MatScale(sA,alpha);CHKERRQ(ierr);
/* Test MatMult(), MatMultAdd() */
for (i=0; i<40; i++) {
ierr = VecSetRandom(x,rdm);CHKERRQ(ierr);
ierr = MatMult(A,x,s1);CHKERRQ(ierr);
ierr = MatMult(sA,x,s2);CHKERRQ(ierr);
ierr = VecNorm(s1,NORM_1,&norm1);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_1,&norm2);CHKERRQ(ierr);
norm1 -= norm2;
if (norm1<-tol || norm1>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatMult(), MatDiagonalScale() or MatScale()\n");CHKERRQ(ierr);
}
}
for (i=0; i<40; i++) {
ierr = VecSetRandom(x,rdm);CHKERRQ(ierr);
ierr = VecSetRandom(y,rdm);CHKERRQ(ierr);
ierr = MatMultAdd(A,x,y,s1);CHKERRQ(ierr);
ierr = MatMultAdd(sA,x,y,s2);CHKERRQ(ierr);
ierr = VecNorm(s1,NORM_1,&norm1);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_1,&norm2);CHKERRQ(ierr);
norm1 -= norm2;
if (norm1<-tol || norm1>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error:MatMultAdd(), MatDiagonalScale() or MatScale() \n");CHKERRQ(ierr);
}
}
/* Test MatReordering() */
ierr = MatGetOrdering(A,MATORDERINGNATURAL,&isrow,&iscol);CHKERRQ(ierr);
ip = isrow;
if (reorder){
IS nip;
PetscInt *nip_ptr;
ierr = PetscMalloc(mbs*sizeof(PetscInt),&nip_ptr);CHKERRQ(ierr);
ierr = ISGetIndices(ip,&ip_ptr);CHKERRQ(ierr);
ierr = PetscMemcpy(nip_ptr,ip_ptr,mbs*sizeof(PetscInt));CHKERRQ(ierr);
i = nip_ptr[1]; nip_ptr[1] = nip_ptr[mbs-2]; nip_ptr[mbs-2] = i;
i = nip_ptr[0]; nip_ptr[0] = nip_ptr[mbs-1]; nip_ptr[mbs-1] = i;
ierr = ISRestoreIndices(ip,&ip_ptr);CHKERRQ(ierr);
ierr = ISCreateGeneral(PETSC_COMM_SELF,mbs,nip_ptr,PETSC_COPY_VALUES,&nip);CHKERRQ(ierr);
ierr = PetscFree(nip_ptr);CHKERRQ(ierr);
ierr = MatReorderingSeqSBAIJ(sA, ip);CHKERRQ(ierr);
ierr = ISDestroy(&nip);CHKERRQ(ierr);
/* ierr = ISView(ip, VIEWER_STDOUT_SELF);CHKERRQ(ierr);
ierr = MatView(sA,VIEWER_DRAW_SELF);CHKERRQ(ierr); */
}
ierr = ISDestroy(&iscol);CHKERRQ(ierr);
/* ierr = ISDestroy(&isrow);CHKERRQ(ierr);*/
ierr = ISDestroy(&isrow);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = MatDestroy(&sA);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = VecDestroy(&s1);CHKERRQ(ierr);
ierr = VecDestroy(&s2);CHKERRQ(ierr);
ierr = VecDestroy(&b);CHKERRQ(ierr);
ierr = PetscRandomDestroy(&rdm);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
int main(int argc,char **args)
{
PetscMPIInt size;
PetscErrorCode ierr;
Vec x,y,b,s1,s2;
Mat A; /* linear system matrix */
Mat sA,sB,sC; /* symmetric part of the matrices */
PetscInt n,mbs=16,bs=1,nz=3,prob=1,i,j,k1,k2,col[3],lf,block, row,Ii,J,n1,inc;
PetscReal norm1,norm2,rnorm,tol=PETSC_SMALL;
PetscScalar neg_one = -1.0,four=4.0,value[3];
IS perm, iscol;
PetscRandom rdm;
PetscBool doIcc=PETSC_TRUE,equal;
MatInfo minfo1,minfo2;
MatFactorInfo factinfo;
MatType type;
PetscInitialize(&argc,&args,(char*)0,help);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
if (size != 1) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"This is a uniprocessor example only!");
ierr = PetscOptionsGetInt(NULL,"-bs",&bs,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-mbs",&mbs,NULL);CHKERRQ(ierr);
n = mbs*bs;
ierr = MatCreate(PETSC_COMM_SELF,&A);CHKERRQ(ierr);
ierr = MatSetSizes(A,n,n,PETSC_DETERMINE,PETSC_DETERMINE);CHKERRQ(ierr);
ierr = MatSetType(A,MATSEQBAIJ);CHKERRQ(ierr);
ierr = MatSetFromOptions(A);CHKERRQ(ierr);
ierr = MatSeqBAIJSetPreallocation(A,bs,nz,NULL);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_SELF,&sA);CHKERRQ(ierr);
ierr = MatSetSizes(sA,n,n,PETSC_DETERMINE,PETSC_DETERMINE);CHKERRQ(ierr);
ierr = MatSetType(sA,MATSEQSBAIJ);CHKERRQ(ierr);
ierr = MatSetFromOptions(sA);CHKERRQ(ierr);
ierr = MatGetType(sA,&type);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)sA,MATSEQSBAIJ,&doIcc);CHKERRQ(ierr);
ierr = MatSeqSBAIJSetPreallocation(sA,bs,nz,NULL);CHKERRQ(ierr);
ierr = MatSetOption(sA,MAT_IGNORE_LOWER_TRIANGULAR,PETSC_TRUE);CHKERRQ(ierr);
/* Test MatGetOwnershipRange() */
ierr = MatGetOwnershipRange(A,&Ii,&J);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(sA,&i,&j);CHKERRQ(ierr);
if (i-Ii || j-J) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatGetOwnershipRange() in MatSBAIJ format\n");CHKERRQ(ierr);
}
/* Assemble matrix */
if (bs == 1) {
ierr = PetscOptionsGetInt(NULL,"-test_problem",&prob,NULL);CHKERRQ(ierr);
if (prob == 1) { /* tridiagonal matrix */
value[0] = -1.0; value[1] = 2.0; value[2] = -1.0;
for (i=1; i<n-1; i++) {
col[0] = i-1; col[1] = i; col[2] = i+1;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
i = n - 1; col[0]=0; col[1] = n - 2; col[2] = n - 1;
value[0]= 0.1; value[1]=-1; value[2]=2;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
i = 0;
col[0] = n-1; col[1] = 1; col[2] = 0;
value[0] = 0.1; value[1] = -1.0; value[2] = 2;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
} else if (prob ==2) { /* matrix for the five point stencil */
n1 = (PetscInt) (PetscSqrtReal((PetscReal)n) + 0.001);
if (n1*n1 - n) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"sqrt(n) must be a positive interger!");
for (i=0; i<n1; i++) {
for (j=0; j<n1; j++) {
Ii = j + n1*i;
if (i>0) {
J = Ii - n1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
if (i<n1-1) {
J = Ii + n1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
if (j>0) {
J = Ii - 1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
if (j<n1-1) {
J = Ii + 1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatSetValues(A,1,&Ii,1,&Ii,&four,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&Ii,1,&Ii,&four,INSERT_VALUES);CHKERRQ(ierr);
}
}
}
} else { /* bs > 1 */
for (block=0; block<n/bs; block++) {
/* diagonal blocks */
value[0] = -1.0; value[1] = 4.0; value[2] = -1.0;
for (i=1+block*bs; i<bs-1+block*bs; i++) {
col[0] = i-1; col[1] = i; col[2] = i+1;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
i = bs - 1+block*bs; col[0] = bs - 2+block*bs; col[1] = bs - 1+block*bs;
value[0]=-1.0; value[1]=4.0;
ierr = MatSetValues(A,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
i = 0+block*bs; col[0] = 0+block*bs; col[1] = 1+block*bs;
value[0]=4.0; value[1] = -1.0;
ierr = MatSetValues(A,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
/* off-diagonal blocks */
value[0]=-1.0;
for (i=0; i<(n/bs-1)*bs; i++) {
col[0]=i+bs;
ierr = MatSetValues(A,1,&i,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
col[0]=i; row=i+bs;
ierr = MatSetValues(A,1,&row,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&row,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
}
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyBegin(sA,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(sA,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* Test MatGetInfo() of A and sA */
ierr = MatGetInfo(A,MAT_LOCAL,&minfo1);CHKERRQ(ierr);
ierr = MatGetInfo(sA,MAT_LOCAL,&minfo2);CHKERRQ(ierr);
/*
printf("A matrix nonzeros (BAIJ format) = %d, allocated nonzeros= %d\n", (int)minfo1.nz_used,(int)minfo1.nz_allocated);
printf("sA matrix nonzeros(SBAIJ format) = %d, allocated nonzeros= %d\n", (int)minfo2.nz_used,(int)minfo2.nz_allocated);
*/
i = (int) (minfo1.nz_used - minfo2.nz_used);
j = (int) (minfo1.nz_allocated - minfo2.nz_allocated);
k1 = (int) (minfo1.nz_allocated - minfo1.nz_used);
k2 = (int) (minfo2.nz_allocated - minfo2.nz_used);
if (i < 0 || j < 0 || k1 < 0 || k2 < 0) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error (compare A and sA): MatGetInfo()\n");CHKERRQ(ierr);
}
/* Test MatDuplicate() */
ierr = MatNorm(A,NORM_FROBENIUS,&norm1);CHKERRQ(ierr);
ierr = MatDuplicate(sA,MAT_COPY_VALUES,&sB);CHKERRQ(ierr);
ierr = MatEqual(sA,sB,&equal);CHKERRQ(ierr);
if (!equal) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NOTSAMETYPE,"Error in MatDuplicate()");
/* Test MatNorm() */
ierr = MatNorm(A,NORM_FROBENIUS,&norm1);CHKERRQ(ierr);
ierr = MatNorm(sB,NORM_FROBENIUS,&norm2);CHKERRQ(ierr);
rnorm = PetscAbsReal(norm1-norm2)/norm2;
if (rnorm > tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm_FROBENIUS, NormA=%16.14e NormsB=%16.14e\n",norm1,norm2);CHKERRQ(ierr);
}
ierr = MatNorm(A,NORM_INFINITY,&norm1);CHKERRQ(ierr);
ierr = MatNorm(sB,NORM_INFINITY,&norm2);CHKERRQ(ierr);
rnorm = PetscAbsReal(norm1-norm2)/norm2;
if (rnorm > tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm_INFINITY(), NormA=%16.14e NormsB=%16.14e\n",norm1,norm2);CHKERRQ(ierr);
}
ierr = MatNorm(A,NORM_1,&norm1);CHKERRQ(ierr);
ierr = MatNorm(sB,NORM_1,&norm2);CHKERRQ(ierr);
rnorm = PetscAbsReal(norm1-norm2)/norm2;
if (rnorm > tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm_INFINITY(), NormA=%16.14e NormsB=%16.14e\n",norm1,norm2);CHKERRQ(ierr);
}
/* Test MatGetInfo(), MatGetSize(), MatGetBlockSize() */
ierr = MatGetInfo(A,MAT_LOCAL,&minfo1);CHKERRQ(ierr);
ierr = MatGetInfo(sB,MAT_LOCAL,&minfo2);CHKERRQ(ierr);
/*
printf("matrix nonzeros (BAIJ format) = %d, allocated nonzeros= %d\n", (int)minfo1.nz_used,(int)minfo1.nz_allocated);
printf("matrix nonzeros(SBAIJ format) = %d, allocated nonzeros= %d\n", (int)minfo2.nz_used,(int)minfo2.nz_allocated);
*/
i = (int) (minfo1.nz_used - minfo2.nz_used);
j = (int) (minfo1.nz_allocated - minfo2.nz_allocated);
k1 = (int) (minfo1.nz_allocated - minfo1.nz_used);
k2 = (int) (minfo2.nz_allocated - minfo2.nz_used);
if (i < 0 || j < 0 || k1 < 0 || k2 < 0) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error(compare A and sB): MatGetInfo()\n");CHKERRQ(ierr);
}
ierr = MatGetSize(A,&Ii,&J);CHKERRQ(ierr);
ierr = MatGetSize(sB,&i,&j);CHKERRQ(ierr);
if (i-Ii || j-J) {
PetscPrintf(PETSC_COMM_SELF,"Error: MatGetSize()\n");CHKERRQ(ierr);
}
ierr = MatGetBlockSize(A, &Ii);CHKERRQ(ierr);
ierr = MatGetBlockSize(sB, &i);CHKERRQ(ierr);
if (i-Ii) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatGetBlockSize()\n");CHKERRQ(ierr);
}
ierr = PetscRandomCreate(PETSC_COMM_SELF,&rdm);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(rdm);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,n,&x);CHKERRQ(ierr);
ierr = VecDuplicate(x,&s1);CHKERRQ(ierr);
ierr = VecDuplicate(x,&s2);CHKERRQ(ierr);
ierr = VecDuplicate(x,&y);CHKERRQ(ierr);
ierr = VecDuplicate(x,&b);CHKERRQ(ierr);
ierr = VecSetRandom(x,rdm);CHKERRQ(ierr);
/* Test MatDiagonalScale(), MatGetDiagonal(), MatScale() */
#if !defined(PETSC_USE_COMPLEX)
/* Scaling matrix with complex numbers results non-spd matrix,
causing crash of MatForwardSolve() and MatBackwardSolve() */
ierr = MatDiagonalScale(A,x,x);CHKERRQ(ierr);
ierr = MatDiagonalScale(sB,x,x);CHKERRQ(ierr);
ierr = MatMultEqual(A,sB,10,&equal);CHKERRQ(ierr);
if (!equal) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NOTSAMETYPE,"Error in MatDiagonalScale");
ierr = MatGetDiagonal(A,s1);CHKERRQ(ierr);
ierr = MatGetDiagonal(sB,s2);CHKERRQ(ierr);
ierr = VecAXPY(s2,neg_one,s1);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_1,&norm1);CHKERRQ(ierr);
if (norm1>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error:MatGetDiagonal(), ||s1-s2||=%G\n",norm1);CHKERRQ(ierr);
}
{
PetscScalar alpha=0.1;
ierr = MatScale(A,alpha);CHKERRQ(ierr);
ierr = MatScale(sB,alpha);CHKERRQ(ierr);
}
#endif
/* Test MatGetRowMaxAbs() */
ierr = MatGetRowMaxAbs(A,s1,NULL);CHKERRQ(ierr);
ierr = MatGetRowMaxAbs(sB,s2,NULL);CHKERRQ(ierr);
ierr = VecNorm(s1,NORM_1,&norm1);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_1,&norm2);CHKERRQ(ierr);
norm1 -= norm2;
if (norm1<-tol || norm1>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error:MatGetRowMaxAbs() \n");CHKERRQ(ierr);
}
/* Test MatMult() */
for (i=0; i<40; i++) {
ierr = VecSetRandom(x,rdm);CHKERRQ(ierr);
ierr = MatMult(A,x,s1);CHKERRQ(ierr);
ierr = MatMult(sB,x,s2);CHKERRQ(ierr);
ierr = VecNorm(s1,NORM_1,&norm1);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_1,&norm2);CHKERRQ(ierr);
norm1 -= norm2;
if (norm1<-tol || norm1>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatMult(), norm1-norm2: %G\n",norm1);CHKERRQ(ierr);
}
}
/* MatMultAdd() */
for (i=0; i<40; i++) {
ierr = VecSetRandom(x,rdm);CHKERRQ(ierr);
ierr = VecSetRandom(y,rdm);CHKERRQ(ierr);
ierr = MatMultAdd(A,x,y,s1);CHKERRQ(ierr);
ierr = MatMultAdd(sB,x,y,s2);CHKERRQ(ierr);
ierr = VecNorm(s1,NORM_1,&norm1);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_1,&norm2);CHKERRQ(ierr);
norm1 -= norm2;
if (norm1<-tol || norm1>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error:MatMultAdd(), norm1-norm2: %G\n",norm1);CHKERRQ(ierr);
}
}
/* Test MatCholeskyFactor(), MatICCFactor() with natural ordering */
ierr = MatGetOrdering(A,MATORDERINGNATURAL,&perm,&iscol);CHKERRQ(ierr);
ierr = ISDestroy(&iscol);CHKERRQ(ierr);
norm1 = tol;
inc = bs;
/* initialize factinfo */
ierr = PetscMemzero(&factinfo,sizeof(MatFactorInfo));CHKERRQ(ierr);
for (lf=-1; lf<10; lf += inc) {
if (lf==-1) { /* Cholesky factor of sB (duplicate sA) */
factinfo.fill = 5.0;
ierr = MatGetFactor(sB,MATSOLVERPETSC,MAT_FACTOR_CHOLESKY,&sC);CHKERRQ(ierr);
ierr = MatCholeskyFactorSymbolic(sC,sB,perm,&factinfo);CHKERRQ(ierr);
} else if (!doIcc) break;
else { /* incomplete Cholesky factor */
factinfo.fill = 5.0;
factinfo.levels = lf;
ierr = MatGetFactor(sB,MATSOLVERPETSC,MAT_FACTOR_ICC,&sC);CHKERRQ(ierr);
ierr = MatICCFactorSymbolic(sC,sB,perm,&factinfo);CHKERRQ(ierr);
}
ierr = MatCholeskyFactorNumeric(sC,sB,&factinfo);CHKERRQ(ierr);
/* MatView(sC, PETSC_VIEWER_DRAW_WORLD); */
/* test MatGetDiagonal on numeric factor */
/*
if (lf == -1) {
ierr = MatGetDiagonal(sC,s1);CHKERRQ(ierr);
printf(" in ex74.c, diag: \n");
ierr = VecView(s1,PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
}
*/
ierr = MatMult(sB,x,b);CHKERRQ(ierr);
/* test MatForwardSolve() and MatBackwardSolve() */
if (lf == -1) {
ierr = MatForwardSolve(sC,b,s1);CHKERRQ(ierr);
ierr = MatBackwardSolve(sC,s1,s2);CHKERRQ(ierr);
ierr = VecAXPY(s2,neg_one,x);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_2,&norm2);CHKERRQ(ierr);
if (10*norm1 < norm2) {
ierr = PetscPrintf(PETSC_COMM_SELF,"MatForwardSolve and BackwardSolve: Norm of error=%G, bs=%d\n",norm2,bs);CHKERRQ(ierr);
}
}
/* test MatSolve() */
ierr = MatSolve(sC,b,y);CHKERRQ(ierr);
ierr = MatDestroy(&sC);CHKERRQ(ierr);
/* Check the error */
ierr = VecAXPY(y,neg_one,x);CHKERRQ(ierr);
ierr = VecNorm(y,NORM_2,&norm2);CHKERRQ(ierr);
/* printf("lf: %d, error: %G\n", lf,norm2); */
if (10*norm1 < norm2 && lf-inc != -1) {
ierr = PetscPrintf(PETSC_COMM_SELF,"lf=%D, %D, Norm of error=%G, %G\n",lf-inc,lf,norm1,norm2);CHKERRQ(ierr);
}
norm1 = norm2;
if (norm2 < tol && lf != -1) break;
}
ierr = ISDestroy(&perm);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = MatDestroy(&sB);CHKERRQ(ierr);
ierr = MatDestroy(&sA);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = VecDestroy(&s1);CHKERRQ(ierr);
ierr = VecDestroy(&s2);CHKERRQ(ierr);
ierr = VecDestroy(&b);CHKERRQ(ierr);
ierr = PetscRandomDestroy(&rdm);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
Matrix C is copied from ~petsc/src/ksp/ksp/examples/tutorials/ex5.c\n\n";
/*
Example: ./ex132 -mat_view_info
*/
#include <petscmat.h>
#undef __FUNCT__
#define __FUNCT__ "main"
int main(int argc,char **args)
{
Mat C,C1,C2; /* matrix */
PetscScalar v;
PetscInt Ii,J,Istart,Iend;
PetscErrorCode ierr;
PetscInt i,j,m = 3,n = 2;
PetscMPIInt size,rank;
PetscBool mat_nonsymmetric = PETSC_FALSE;
MatInfo info;
PetscInitialize(&argc,&args,(char *)0,help);
ierr = PetscOptionsGetInt(PETSC_NULL,"-m",&m,PETSC_NULL);CHKERRQ(ierr);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
n = 2*size;
/* Set flag if we are doing a nonsymmetric problem; the default is symmetric. */
ierr = PetscOptionsGetBool(PETSC_NULL,"-mat_nonsym",&mat_nonsymmetric,PETSC_NULL);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&C);CHKERRQ(ierr);
ierr = MatSetSizes(C,PETSC_DECIDE,PETSC_DECIDE,m*n,m*n);CHKERRQ(ierr);
ierr = MatSetFromOptions(C);CHKERRQ(ierr);
ierr = MatSeqAIJSetPreallocation(C,5,PETSC_NULL);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(C,&Istart,&Iend);CHKERRQ(ierr);
for (Ii=Istart; Ii<Iend; Ii++) {
v = -1.0; i = Ii/n; j = Ii - i*n;
if (i>0) {J = Ii - n; ierr = MatSetValues(C,1,&Ii,1,&J,&v,ADD_VALUES);CHKERRQ(ierr);}
if (i<m-1) {J = Ii + n; ierr = MatSetValues(C,1,&Ii,1,&J,&v,ADD_VALUES);CHKERRQ(ierr);}
if (j>0) {J = Ii - 1; ierr = MatSetValues(C,1,&Ii,1,&J,&v,ADD_VALUES);CHKERRQ(ierr);}
if (j<n-1) {J = Ii + 1; ierr = MatSetValues(C,1,&Ii,1,&J,&v,ADD_VALUES);CHKERRQ(ierr);}
v = 4.0; ierr = MatSetValues(C,1,&Ii,1,&Ii,&v,ADD_VALUES);
}
/* Make the matrix nonsymmetric if desired */
if (mat_nonsymmetric) {
for (Ii=Istart; Ii<Iend; Ii++) {
v = -1.5; i = Ii/n;
if (i>1) {J = Ii-n-1; ierr = MatSetValues(C,1,&Ii,1,&J,&v,ADD_VALUES);CHKERRQ(ierr);}
}
} else {
ierr = MatSetOption(C,MAT_SYMMETRIC,PETSC_TRUE);CHKERRQ(ierr);
ierr = MatSetOption(C,MAT_SYMMETRY_ETERNAL,PETSC_TRUE);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(C,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(C,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* First, create C1 = 2.0*C1 + C, C1 has less non-zeros than C */
ierr = PetscPrintf(PETSC_COMM_WORLD, "\ncreate C1 = 2.0*C1 + C, C1 has less non-zeros than C \n");
ierr = MatCreate(PETSC_COMM_WORLD,&C1);CHKERRQ(ierr);
ierr = MatSetSizes(C1,PETSC_DECIDE,PETSC_DECIDE,m*n,m*n);CHKERRQ(ierr);
ierr = MatSetFromOptions(C1);CHKERRQ(ierr);
ierr = MatSeqAIJSetPreallocation(C1,1,PETSC_NULL);CHKERRQ(ierr);
for (Ii=Istart; Ii<Iend; Ii++) {
ierr = MatSetValues(C1,1,&Ii,1,&Ii,&v,ADD_VALUES);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(C1,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(C1,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," MatAXPY(C1,2.0,C,DIFFERENT_NONZERO_PATTERN)...\n");
ierr = MatAXPY(C1,2.0,C,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = MatGetInfo(C1,MAT_GLOBAL_SUM,&info);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," C1: nz_allocated = %g; nz_used = %g; nz_unneeded = %g\n",info.nz_allocated,info.nz_used, info.nz_unneeded);
/* Secondly, create C2 = 2.0*C2 + C, C2 has non-zero pattern of C2 + C */
ierr = PetscPrintf(PETSC_COMM_WORLD, "\ncreate C2 = 2.0*C2 + C, C2 has non-zero pattern of C2 + C \n");
ierr = MatDuplicate(C,MAT_DO_NOT_COPY_VALUES,&C2);CHKERRQ(ierr);
/*
ierr = MatCreate(PETSC_COMM_WORLD,&C2);CHKERRQ(ierr);
ierr = MatSetSizes(C2,PETSC_DECIDE,PETSC_DECIDE,m*n,m*n);CHKERRQ(ierr);
ierr = MatSetFromOptions(C2);CHKERRQ(ierr);
ierr = MatSeqAIJSetPreallocation(C2,5,PETSC_NULL);CHKERRQ(ierr);
*/
for (Ii=Istart; Ii<Iend; Ii++) {
v = 1.0;
ierr = MatSetValues(C2,1,&Ii,1,&Ii,&v,ADD_VALUES);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(C2,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(C2,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
printf(" MatAXPY(C2,2.0,C,SUBSET_NONZERO_PATTERN)...\n");
ierr = MatAXPY(C2,2.0,C,SUBSET_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = MatGetInfo(C2,MAT_GLOBAL_SUM,&info);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," C2: nz_allocated = %g; nz_used = %g; nz_unneeded = %g\n",info.nz_allocated,info.nz_used, info.nz_unneeded);
ierr = MatDestroy(&C1);CHKERRQ(ierr);
ierr = MatDestroy(&C2);CHKERRQ(ierr);
ierr = MatDestroy(&C);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
