void MGinit( const MgSmootherType &mg_smoother_type, const unsigned &levelMax ){
KSPCreate(PETSC_COMM_WORLD,&_ksp);
KSPGetPC(_ksp,&_pc);
PCSetType(_pc,PCMG);
PCMGSetLevels(_pc,levelMax,NULL);
if( mg_smoother_type == FULL ){
PCMGSetType(_pc, PC_MG_FULL);
}
else if( mg_smoother_type == MULTIPLICATIVE ){
PCMGSetType(_pc, PC_MG_MULTIPLICATIVE);
}
else if( mg_smoother_type == ADDITIVE ){
PCMGSetType(_pc, PC_MG_ADDITIVE);
}
else if( mg_smoother_type == KASKADE ){
PCMGSetType(_pc, PC_MG_KASKADE);
}
else{
std::cout <<"Wrong mg_type for PETSCsolve()"<<std::endl;
abort();
}
};
PetscErrorCode PETSCSNES_DLLEXPORT DMMGSetUpLevel(DMMG *dmmg,KSP ksp,PetscInt nlevels)
{
PetscErrorCode ierr;
PetscInt i;
PC pc;
PetscTruth ismg,ismf,isshell,ismffd;
KSP lksp; /* solver internal to the multigrid preconditioner */
MPI_Comm *comms;
PetscFunctionBegin;
if (!dmmg) SETERRQ(PETSC_ERR_ARG_NULL,"Passing null as DMMG");
/* use fgmres on outer iteration by default */
ierr = KSPSetType(ksp,KSPFGMRES);CHKERRQ(ierr);
ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr);
ierr = PCSetType(pc,PCMG);CHKERRQ(ierr);
ierr = PetscMalloc(nlevels*sizeof(MPI_Comm),&comms);CHKERRQ(ierr);
for (i=0; i<nlevels; i++) {
comms[i] = dmmg[i]->comm;
}
ierr = PCMGSetLevels(pc,nlevels,comms);CHKERRQ(ierr);
ierr = PetscFree(comms);CHKERRQ(ierr);
ierr = PCMGSetType(pc,PC_MG_FULL);CHKERRQ(ierr);
ierr = PetscTypeCompare((PetscObject)pc,PCMG,&ismg);CHKERRQ(ierr);
if (ismg) {
/* set solvers for each level */
for (i=0; i<nlevels; i++) {
if (i < nlevels-1) { /* don't set for finest level, they are set in PCApply_MG()*/
ierr = PCMGSetX(pc,i,dmmg[i]->x);CHKERRQ(ierr);
ierr = PCMGSetRhs(pc,i,dmmg[i]->b);CHKERRQ(ierr);
}
if (i > 0) {
ierr = PCMGSetR(pc,i,dmmg[i]->r);CHKERRQ(ierr);
}
/* If using a matrix free multiply and did not provide an explicit matrix to build
the preconditioner then must use no preconditioner
*/
ierr = PetscTypeCompare((PetscObject)dmmg[i]->B,MATSHELL,&isshell);CHKERRQ(ierr);
ierr = PetscTypeCompare((PetscObject)dmmg[i]->B,MATDAAD,&ismf);CHKERRQ(ierr);
ierr = PetscTypeCompare((PetscObject)dmmg[i]->B,MATMFFD,&ismffd);CHKERRQ(ierr);
if (isshell || ismf || ismffd) {
PC lpc;
ierr = PCMGGetSmoother(pc,i,&lksp);CHKERRQ(ierr);
ierr = KSPGetPC(lksp,&lpc);CHKERRQ(ierr);
ierr = PCSetType(lpc,PCNONE);CHKERRQ(ierr);
}
}
/* Set interpolation/restriction between levels */
for (i=1; i<nlevels; i++) {
ierr = PCMGSetInterpolation(pc,i,dmmg[i]->R);CHKERRQ(ierr);
ierr = PCMGSetRestriction(pc,i,dmmg[i]->R);CHKERRQ(ierr);
}
}
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode PCCreate_Exotic(PC pc)
{
PetscErrorCode ierr;
PC_Exotic *ex;
PC_MG *mg;
PetscFunctionBegin;
/* if type was previously mg; must manually destroy it because call to PCSetType(pc,PCMG) will not destroy it */
if (pc->ops->destroy) {
ierr = (*pc->ops->destroy)(pc);
CHKERRQ(ierr);
pc->data = 0;
}
ierr = PetscFree(((PetscObject)pc)->type_name);
CHKERRQ(ierr);
((PetscObject)pc)->type_name = 0;
ierr = PCSetType(pc,PCMG);
CHKERRQ(ierr);
ierr = PCMGSetLevels(pc,2,NULL);
CHKERRQ(ierr);
ierr = PCMGSetGalerkin(pc,PETSC_TRUE);
CHKERRQ(ierr);
ierr = PetscNew(&ex);
CHKERRQ(ierr);
\
ex->type = PC_EXOTIC_FACE;
mg = (PC_MG*) pc->data;
mg->innerctx = ex;
pc->ops->setfromoptions = PCSetFromOptions_Exotic;
pc->ops->view = PCView_Exotic;
pc->ops->destroy = PCDestroy_Exotic;
pc->ops->setup = PCSetUp_Exotic;
ierr = PetscObjectComposeFunction((PetscObject)pc,"PCExoticSetType_C",PCExoticSetType_Exotic);
CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int main(int Argc,char **Args)
{
PetscInt x_mesh = 15,levels = 3,cycles = 1,use_jacobi = 0;
PetscInt i,smooths = 1,*N,its;
PetscErrorCode ierr;
PCMGType am = PC_MG_MULTIPLICATIVE;
Mat cmat,mat[20],fmat;
KSP cksp,ksp[20],kspmg;
PetscReal e[3]; /* l_2 error,max error, residual */
const char *shellname;
Vec x,solution,X[20],R[20],B[20];
PC pcmg,pc;
PetscBool flg;
PetscInitialize(&Argc,&Args,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-x",&x_mesh,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-l",&levels,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-c",&cycles,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-smooths",&smooths,NULL);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,"-a",&flg);CHKERRQ(ierr);
if (flg) am = PC_MG_ADDITIVE;
ierr = PetscOptionsHasName(NULL,"-f",&flg);CHKERRQ(ierr);
if (flg) am = PC_MG_FULL;
ierr = PetscOptionsHasName(NULL,"-j",&flg);CHKERRQ(ierr);
if (flg) use_jacobi = 1;
ierr = PetscMalloc1(levels,&N);CHKERRQ(ierr);
N[0] = x_mesh;
for (i=1; i<levels; i++) {
N[i] = N[i-1]/2;
if (N[i] < 1) SETERRQ(PETSC_COMM_WORLD,1,"Too many levels");
}
ierr = Create1dLaplacian(N[levels-1],&cmat);CHKERRQ(ierr);
ierr = KSPCreate(PETSC_COMM_WORLD,&kspmg);CHKERRQ(ierr);
ierr = KSPGetPC(kspmg,&pcmg);CHKERRQ(ierr);
ierr = KSPSetFromOptions(kspmg);CHKERRQ(ierr);
ierr = PCSetType(pcmg,PCMG);CHKERRQ(ierr);
ierr = PCMGSetLevels(pcmg,levels,NULL);CHKERRQ(ierr);
ierr = PCMGSetType(pcmg,am);CHKERRQ(ierr);
ierr = PCMGGetCoarseSolve(pcmg,&cksp);CHKERRQ(ierr);
ierr = KSPSetOperators(cksp,cmat,cmat);CHKERRQ(ierr);
ierr = KSPGetPC(cksp,&pc);CHKERRQ(ierr);
ierr = PCSetType(pc,PCLU);CHKERRQ(ierr);
ierr = KSPSetType(cksp,KSPPREONLY);CHKERRQ(ierr);
/* zero is finest level */
for (i=0; i<levels-1; i++) {
ierr = PCMGSetResidual(pcmg,levels - 1 - i,residual,(Mat)0);CHKERRQ(ierr);
ierr = MatCreateShell(PETSC_COMM_WORLD,N[i+1],N[i],N[i+1],N[i],(void*)0,&mat[i]);CHKERRQ(ierr);
ierr = MatShellSetOperation(mat[i],MATOP_MULT,(void (*)(void))restrct);CHKERRQ(ierr);
ierr = MatShellSetOperation(mat[i],MATOP_MULT_TRANSPOSE_ADD,(void (*)(void))interpolate);CHKERRQ(ierr);
ierr = PCMGSetInterpolation(pcmg,levels - 1 - i,mat[i]);CHKERRQ(ierr);
ierr = PCMGSetRestriction(pcmg,levels - 1 - i,mat[i]);CHKERRQ(ierr);
ierr = PCMGSetCyclesOnLevel(pcmg,levels - 1 - i,cycles);CHKERRQ(ierr);
/* set smoother */
ierr = PCMGGetSmoother(pcmg,levels - 1 - i,&ksp[i]);CHKERRQ(ierr);
ierr = KSPGetPC(ksp[i],&pc);CHKERRQ(ierr);
ierr = PCSetType(pc,PCSHELL);CHKERRQ(ierr);
ierr = PCShellSetName(pc,"user_precond");CHKERRQ(ierr);
ierr = PCShellGetName(pc,&shellname);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"level=%D, PCShell name is %s\n",i,shellname);CHKERRQ(ierr);
/* this is a dummy! since KSP requires a matrix passed in */
ierr = KSPSetOperators(ksp[i],mat[i],mat[i]);CHKERRQ(ierr);
/*
We override the matrix passed in by forcing it to use Richardson with
a user provided application. This is non-standard and this practice
should be avoided.
*/
ierr = PCShellSetApplyRichardson(pc,gauss_seidel);CHKERRQ(ierr);
if (use_jacobi) {
ierr = PCShellSetApplyRichardson(pc,jacobi);CHKERRQ(ierr);
}
ierr = KSPSetType(ksp[i],KSPRICHARDSON);CHKERRQ(ierr);
ierr = KSPSetInitialGuessNonzero(ksp[i],PETSC_TRUE);CHKERRQ(ierr);
ierr = KSPSetTolerances(ksp[i],PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT,smooths);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,N[i],&x);CHKERRQ(ierr);
X[levels - 1 - i] = x;
if (i > 0) {
ierr = PCMGSetX(pcmg,levels - 1 - i,x);CHKERRQ(ierr);
}
ierr = VecCreateSeq(PETSC_COMM_SELF,N[i],&x);CHKERRQ(ierr);
B[levels -1 - i] = x;
if (i > 0) {
ierr = PCMGSetRhs(pcmg,levels - 1 - i,x);CHKERRQ(ierr);
}
ierr = VecCreateSeq(PETSC_COMM_SELF,N[i],&x);CHKERRQ(ierr);
R[levels - 1 - i] = x;
ierr = PCMGSetR(pcmg,levels - 1 - i,x);CHKERRQ(ierr);
}
/* create coarse level vectors */
ierr = VecCreateSeq(PETSC_COMM_SELF,N[levels-1],&x);CHKERRQ(ierr);
ierr = PCMGSetX(pcmg,0,x);CHKERRQ(ierr); X[0] = x;
ierr = VecCreateSeq(PETSC_COMM_SELF,N[levels-1],&x);CHKERRQ(ierr);
ierr = PCMGSetRhs(pcmg,0,x);CHKERRQ(ierr); B[0] = x;
/* create matrix multiply for finest level */
ierr = MatCreateShell(PETSC_COMM_WORLD,N[0],N[0],N[0],N[0],(void*)0,&fmat);CHKERRQ(ierr);
ierr = MatShellSetOperation(fmat,MATOP_MULT,(void (*)(void))amult);CHKERRQ(ierr);
ierr = KSPSetOperators(kspmg,fmat,fmat);CHKERRQ(ierr);
ierr = CalculateSolution(N[0],&solution);CHKERRQ(ierr);
ierr = CalculateRhs(B[levels-1]);CHKERRQ(ierr);
ierr = VecSet(X[levels-1],0.0);CHKERRQ(ierr);
ierr = residual((Mat)0,B[levels-1],X[levels-1],R[levels-1]);CHKERRQ(ierr);
ierr = CalculateError(solution,X[levels-1],R[levels-1],e);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"l_2 error %g max error %g resi %g\n",(double)e[0],(double)e[1],(double)e[2]);CHKERRQ(ierr);
ierr = KSPSolve(kspmg,B[levels-1],X[levels-1]);CHKERRQ(ierr);
ierr = KSPGetIterationNumber(kspmg,&its);CHKERRQ(ierr);
ierr = residual((Mat)0,B[levels-1],X[levels-1],R[levels-1]);CHKERRQ(ierr);
ierr = CalculateError(solution,X[levels-1],R[levels-1],e);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"its %D l_2 error %g max error %g resi %g\n",its,(double)e[0],(double)e[1],(double)e[2]);CHKERRQ(ierr);
ierr = PetscFree(N);CHKERRQ(ierr);
ierr = VecDestroy(&solution);CHKERRQ(ierr);
/* note we have to keep a list of all vectors allocated, this is
not ideal, but putting it in MGDestroy is not so good either*/
for (i=0; i<levels; i++) {
ierr = VecDestroy(&X[i]);CHKERRQ(ierr);
ierr = VecDestroy(&B[i]);CHKERRQ(ierr);
if (i) {ierr = VecDestroy(&R[i]);CHKERRQ(ierr);}
}
for (i=0; i<levels-1; i++) {
ierr = MatDestroy(&mat[i]);CHKERRQ(ierr);
}
ierr = MatDestroy(&cmat);CHKERRQ(ierr);
ierr = MatDestroy(&fmat);CHKERRQ(ierr);
ierr = KSPDestroy(&kspmg);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
PetscErrorCode PCSetUp_MG(PC pc)
{
PC_MG *mg = (PC_MG*)pc->data;
PC_MG_Levels **mglevels = mg->levels;
PetscErrorCode ierr;
PetscInt i,n = mglevels[0]->levels;
PC cpc;
PetscBool dump = PETSC_FALSE,opsset,use_amat,missinginterpolate = PETSC_FALSE;
Mat dA,dB;
Vec tvec;
DM *dms;
PetscViewer viewer = 0;
PetscFunctionBegin;
/* FIX: Move this to PCSetFromOptions_MG? */
if (mg->usedmfornumberoflevels) {
PetscInt levels;
ierr = DMGetRefineLevel(pc->dm,&levels);CHKERRQ(ierr);
levels++;
if (levels > n) { /* the problem is now being solved on a finer grid */
ierr = PCMGSetLevels(pc,levels,NULL);CHKERRQ(ierr);
n = levels;
ierr = PCSetFromOptions(pc);CHKERRQ(ierr); /* it is bad to call this here, but otherwise will never be called for the new hierarchy */
mglevels = mg->levels;
}
}
ierr = KSPGetPC(mglevels[0]->smoothd,&cpc);CHKERRQ(ierr);
/* If user did not provide fine grid operators OR operator was not updated since last global KSPSetOperators() */
/* so use those from global PC */
/* Is this what we always want? What if user wants to keep old one? */
ierr = KSPGetOperatorsSet(mglevels[n-1]->smoothd,NULL,&opsset);CHKERRQ(ierr);
if (opsset) {
Mat mmat;
ierr = KSPGetOperators(mglevels[n-1]->smoothd,NULL,&mmat);CHKERRQ(ierr);
if (mmat == pc->pmat) opsset = PETSC_FALSE;
}
if (!opsset) {
ierr = PCGetUseAmat(pc,&use_amat);CHKERRQ(ierr);
if(use_amat){
ierr = PetscInfo(pc,"Using outer operators to define finest grid operator \n because PCMGGetSmoother(pc,nlevels-1,&ksp);KSPSetOperators(ksp,...); was not called.\n");CHKERRQ(ierr);
ierr = KSPSetOperators(mglevels[n-1]->smoothd,pc->mat,pc->pmat);CHKERRQ(ierr);
}
else {
ierr = PetscInfo(pc,"Using matrix (pmat) operators to define finest grid operator \n because PCMGGetSmoother(pc,nlevels-1,&ksp);KSPSetOperators(ksp,...); was not called.\n");CHKERRQ(ierr);
ierr = KSPSetOperators(mglevels[n-1]->smoothd,pc->pmat,pc->pmat);CHKERRQ(ierr);
}
}
for (i=n-1; i>0; i--) {
if (!(mglevels[i]->interpolate || mglevels[i]->restrct)) {
missinginterpolate = PETSC_TRUE;
continue;
}
}
/*
Skipping if user has provided all interpolation/restriction needed (since DM might not be able to produce them (when coming from SNES/TS)
Skipping for galerkin==2 (externally managed hierarchy such as ML and GAMG). Cleaner logic here would be great. Wrap ML/GAMG as DMs?
*/
if (missinginterpolate && pc->dm && mg->galerkin != 2 && !pc->setupcalled) {
/* construct the interpolation from the DMs */
Mat p;
Vec rscale;
ierr = PetscMalloc1(n,&dms);CHKERRQ(ierr);
dms[n-1] = pc->dm;
/* Separately create them so we do not get DMKSP interference between levels */
for (i=n-2; i>-1; i--) {ierr = DMCoarsen(dms[i+1],MPI_COMM_NULL,&dms[i]);CHKERRQ(ierr);}
for (i=n-2; i>-1; i--) {
DMKSP kdm;
PetscBool dmhasrestrict;
ierr = KSPSetDM(mglevels[i]->smoothd,dms[i]);CHKERRQ(ierr);
if (mg->galerkin) {ierr = KSPSetDMActive(mglevels[i]->smoothd,PETSC_FALSE);CHKERRQ(ierr);}
ierr = DMGetDMKSPWrite(dms[i],&kdm);CHKERRQ(ierr);
/* Ugly hack so that the next KSPSetUp() will use the RHS that we set. A better fix is to change dmActive to take
* a bitwise OR of computing the matrix, RHS, and initial iterate. */
kdm->ops->computerhs = NULL;
kdm->rhsctx = NULL;
if (!mglevels[i+1]->interpolate) {
ierr = DMCreateInterpolation(dms[i],dms[i+1],&p,&rscale);CHKERRQ(ierr);
ierr = PCMGSetInterpolation(pc,i+1,p);CHKERRQ(ierr);
if (rscale) {ierr = PCMGSetRScale(pc,i+1,rscale);CHKERRQ(ierr);}
ierr = VecDestroy(&rscale);CHKERRQ(ierr);
ierr = MatDestroy(&p);CHKERRQ(ierr);
}
ierr = DMHasCreateRestriction(dms[i],&dmhasrestrict);CHKERRQ(ierr);
if (dmhasrestrict && !mglevels[i+1]->restrct){
ierr = DMCreateRestriction(dms[i],dms[i+1],&p);CHKERRQ(ierr);
ierr = PCMGSetRestriction(pc,i+1,p);CHKERRQ(ierr);
ierr = MatDestroy(&p);CHKERRQ(ierr);
}
}
for (i=n-2; i>-1; i--) {ierr = DMDestroy(&dms[i]);CHKERRQ(ierr);}
ierr = PetscFree(dms);CHKERRQ(ierr);
}
if (pc->dm && !pc->setupcalled) {
/* finest smoother also gets DM but it is not active, independent of whether galerkin==2 */
ierr = KSPSetDM(mglevels[n-1]->smoothd,pc->dm);CHKERRQ(ierr);
ierr = KSPSetDMActive(mglevels[n-1]->smoothd,PETSC_FALSE);CHKERRQ(ierr);
}
if (mg->galerkin == 1) {
Mat B;
/* currently only handle case where mat and pmat are the same on coarser levels */
ierr = KSPGetOperators(mglevels[n-1]->smoothd,&dA,&dB);CHKERRQ(ierr);
if (!pc->setupcalled) {
for (i=n-2; i>-1; i--) {
if (!mglevels[i+1]->restrct && !mglevels[i+1]->interpolate) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"Must provide interpolation or restriction for each MG level except level 0");
if (!mglevels[i+1]->interpolate) {
ierr = PCMGSetInterpolation(pc,i+1,mglevels[i+1]->restrct);CHKERRQ(ierr);
}
if (!mglevels[i+1]->restrct) {
ierr = PCMGSetRestriction(pc,i+1,mglevels[i+1]->interpolate);CHKERRQ(ierr);
}
if (mglevels[i+1]->interpolate == mglevels[i+1]->restrct) {
ierr = MatPtAP(dB,mglevels[i+1]->interpolate,MAT_INITIAL_MATRIX,1.0,&B);CHKERRQ(ierr);
} else {
ierr = MatMatMatMult(mglevels[i+1]->restrct,dB,mglevels[i+1]->interpolate,MAT_INITIAL_MATRIX,1.0,&B);CHKERRQ(ierr);
}
ierr = KSPSetOperators(mglevels[i]->smoothd,B,B);CHKERRQ(ierr);
if (i != n-2) {ierr = PetscObjectDereference((PetscObject)dB);CHKERRQ(ierr);}
dB = B;
}
if (n > 1) {ierr = PetscObjectDereference((PetscObject)dB);CHKERRQ(ierr);}
} else {
for (i=n-2; i>-1; i--) {
if (!mglevels[i+1]->restrct && !mglevels[i+1]->interpolate) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"Must provide interpolation or restriction for each MG level except level 0");
if (!mglevels[i+1]->interpolate) {
ierr = PCMGSetInterpolation(pc,i+1,mglevels[i+1]->restrct);CHKERRQ(ierr);
}
if (!mglevels[i+1]->restrct) {
ierr = PCMGSetRestriction(pc,i+1,mglevels[i+1]->interpolate);CHKERRQ(ierr);
}
ierr = KSPGetOperators(mglevels[i]->smoothd,NULL,&B);CHKERRQ(ierr);
if (mglevels[i+1]->interpolate == mglevels[i+1]->restrct) {
ierr = MatPtAP(dB,mglevels[i+1]->interpolate,MAT_REUSE_MATRIX,1.0,&B);CHKERRQ(ierr);
} else {
ierr = MatMatMatMult(mglevels[i+1]->restrct,dB,mglevels[i+1]->interpolate,MAT_REUSE_MATRIX,1.0,&B);CHKERRQ(ierr);
}
ierr = KSPSetOperators(mglevels[i]->smoothd,B,B);CHKERRQ(ierr);
dB = B;
}
}
} else if (!mg->galerkin && pc->dm && pc->dm->x) {
/* need to restrict Jacobian location to coarser meshes for evaluation */
for (i=n-2; i>-1; i--) {
Mat R;
Vec rscale;
if (!mglevels[i]->smoothd->dm->x) {
Vec *vecs;
ierr = KSPCreateVecs(mglevels[i]->smoothd,1,&vecs,0,NULL);CHKERRQ(ierr);
mglevels[i]->smoothd->dm->x = vecs[0];
ierr = PetscFree(vecs);CHKERRQ(ierr);
}
ierr = PCMGGetRestriction(pc,i+1,&R);CHKERRQ(ierr);
ierr = PCMGGetRScale(pc,i+1,&rscale);CHKERRQ(ierr);
ierr = MatRestrict(R,mglevels[i+1]->smoothd->dm->x,mglevels[i]->smoothd->dm->x);CHKERRQ(ierr);
ierr = VecPointwiseMult(mglevels[i]->smoothd->dm->x,mglevels[i]->smoothd->dm->x,rscale);CHKERRQ(ierr);
}
}
if (!mg->galerkin && pc->dm) {
for (i=n-2; i>=0; i--) {
DM dmfine,dmcoarse;
Mat Restrict,Inject;
Vec rscale;
ierr = KSPGetDM(mglevels[i+1]->smoothd,&dmfine);CHKERRQ(ierr);
ierr = KSPGetDM(mglevels[i]->smoothd,&dmcoarse);CHKERRQ(ierr);
ierr = PCMGGetRestriction(pc,i+1,&Restrict);CHKERRQ(ierr);
ierr = PCMGGetRScale(pc,i+1,&rscale);CHKERRQ(ierr);
Inject = NULL; /* Callback should create it if it needs Injection */
ierr = DMRestrict(dmfine,Restrict,rscale,Inject,dmcoarse);CHKERRQ(ierr);
}
}
if (!pc->setupcalled) {
for (i=0; i<n; i++) {
ierr = KSPSetFromOptions(mglevels[i]->smoothd);CHKERRQ(ierr);
}
for (i=1; i<n; i++) {
if (mglevels[i]->smoothu && (mglevels[i]->smoothu != mglevels[i]->smoothd)) {
ierr = KSPSetFromOptions(mglevels[i]->smoothu);CHKERRQ(ierr);
}
}
/* insure that if either interpolation or restriction is set the other other one is set */
for (i=1; i<n; i++) {
ierr = PCMGGetInterpolation(pc,i,NULL);CHKERRQ(ierr);
ierr = PCMGGetRestriction(pc,i,NULL);CHKERRQ(ierr);
}
for (i=0; i<n-1; i++) {
if (!mglevels[i]->b) {
Vec *vec;
ierr = KSPCreateVecs(mglevels[i]->smoothd,1,&vec,0,NULL);CHKERRQ(ierr);
ierr = PCMGSetRhs(pc,i,*vec);CHKERRQ(ierr);
ierr = VecDestroy(vec);CHKERRQ(ierr);
ierr = PetscFree(vec);CHKERRQ(ierr);
}
if (!mglevels[i]->r && i) {
ierr = VecDuplicate(mglevels[i]->b,&tvec);CHKERRQ(ierr);
ierr = PCMGSetR(pc,i,tvec);CHKERRQ(ierr);
ierr = VecDestroy(&tvec);CHKERRQ(ierr);
}
if (!mglevels[i]->x) {
ierr = VecDuplicate(mglevels[i]->b,&tvec);CHKERRQ(ierr);
ierr = PCMGSetX(pc,i,tvec);CHKERRQ(ierr);
ierr = VecDestroy(&tvec);CHKERRQ(ierr);
}
}
if (n != 1 && !mglevels[n-1]->r) {
/* PCMGSetR() on the finest level if user did not supply it */
Vec *vec;
ierr = KSPCreateVecs(mglevels[n-1]->smoothd,1,&vec,0,NULL);CHKERRQ(ierr);
ierr = PCMGSetR(pc,n-1,*vec);CHKERRQ(ierr);
ierr = VecDestroy(vec);CHKERRQ(ierr);
ierr = PetscFree(vec);CHKERRQ(ierr);
}
}
if (pc->dm) {
/* need to tell all the coarser levels to rebuild the matrix using the DM for that level */
for (i=0; i<n-1; i++) {
if (mglevels[i]->smoothd->setupstage != KSP_SETUP_NEW) mglevels[i]->smoothd->setupstage = KSP_SETUP_NEWMATRIX;
}
}
for (i=1; i<n; i++) {
if (mglevels[i]->smoothu == mglevels[i]->smoothd || mg->am == PC_MG_FULL || mg->am == PC_MG_KASKADE || mg->cyclesperpcapply > 1){
/* if doing only down then initial guess is zero */
ierr = KSPSetInitialGuessNonzero(mglevels[i]->smoothd,PETSC_TRUE);CHKERRQ(ierr);
}
if (mglevels[i]->eventsmoothsetup) {ierr = PetscLogEventBegin(mglevels[i]->eventsmoothsetup,0,0,0,0);CHKERRQ(ierr);}
ierr = KSPSetUp(mglevels[i]->smoothd);CHKERRQ(ierr);
if (mglevels[i]->smoothd->reason == KSP_DIVERGED_PCSETUP_FAILED) {
pc->failedreason = PC_SUBPC_ERROR;
}
if (mglevels[i]->eventsmoothsetup) {ierr = PetscLogEventEnd(mglevels[i]->eventsmoothsetup,0,0,0,0);CHKERRQ(ierr);}
if (!mglevels[i]->residual) {
Mat mat;
ierr = KSPGetOperators(mglevels[i]->smoothd,NULL,&mat);CHKERRQ(ierr);
ierr = PCMGSetResidual(pc,i,PCMGResidualDefault,mat);CHKERRQ(ierr);
}
}
for (i=1; i<n; i++) {
if (mglevels[i]->smoothu && mglevels[i]->smoothu != mglevels[i]->smoothd) {
Mat downmat,downpmat;
/* check if operators have been set for up, if not use down operators to set them */
ierr = KSPGetOperatorsSet(mglevels[i]->smoothu,&opsset,NULL);CHKERRQ(ierr);
if (!opsset) {
ierr = KSPGetOperators(mglevels[i]->smoothd,&downmat,&downpmat);CHKERRQ(ierr);
ierr = KSPSetOperators(mglevels[i]->smoothu,downmat,downpmat);CHKERRQ(ierr);
}
ierr = KSPSetInitialGuessNonzero(mglevels[i]->smoothu,PETSC_TRUE);CHKERRQ(ierr);
if (mglevels[i]->eventsmoothsetup) {ierr = PetscLogEventBegin(mglevels[i]->eventsmoothsetup,0,0,0,0);CHKERRQ(ierr);}
ierr = KSPSetUp(mglevels[i]->smoothu);CHKERRQ(ierr);
if (mglevels[i]->smoothu->reason == KSP_DIVERGED_PCSETUP_FAILED) {
pc->failedreason = PC_SUBPC_ERROR;
}
if (mglevels[i]->eventsmoothsetup) {ierr = PetscLogEventEnd(mglevels[i]->eventsmoothsetup,0,0,0,0);CHKERRQ(ierr);}
}
}
if (mglevels[0]->eventsmoothsetup) {ierr = PetscLogEventBegin(mglevels[0]->eventsmoothsetup,0,0,0,0);CHKERRQ(ierr);}
ierr = KSPSetUp(mglevels[0]->smoothd);CHKERRQ(ierr);
if (mglevels[0]->smoothd->reason == KSP_DIVERGED_PCSETUP_FAILED) {
pc->failedreason = PC_SUBPC_ERROR;
}
if (mglevels[0]->eventsmoothsetup) {ierr = PetscLogEventEnd(mglevels[0]->eventsmoothsetup,0,0,0,0);CHKERRQ(ierr);}
/*
Dump the interpolation/restriction matrices plus the
Jacobian/stiffness on each level. This allows MATLAB users to
easily check if the Galerkin condition A_c = R A_f R^T is satisfied.
Only support one or the other at the same time.
*/
#if defined(PETSC_USE_SOCKET_VIEWER)
ierr = PetscOptionsGetBool(((PetscObject)pc)->options,((PetscObject)pc)->prefix,"-pc_mg_dump_matlab",&dump,NULL);CHKERRQ(ierr);
if (dump) viewer = PETSC_VIEWER_SOCKET_(PetscObjectComm((PetscObject)pc));
dump = PETSC_FALSE;
#endif
ierr = PetscOptionsGetBool(((PetscObject)pc)->options,((PetscObject)pc)->prefix,"-pc_mg_dump_binary",&dump,NULL);CHKERRQ(ierr);
if (dump) viewer = PETSC_VIEWER_BINARY_(PetscObjectComm((PetscObject)pc));
if (viewer) {
for (i=1; i<n; i++) {
ierr = MatView(mglevels[i]->restrct,viewer);CHKERRQ(ierr);
}
for (i=0; i<n; i++) {
ierr = KSPGetPC(mglevels[i]->smoothd,&pc);CHKERRQ(ierr);
ierr = MatView(pc->mat,viewer);CHKERRQ(ierr);
}
}
PetscFunctionReturn(0);
}
PetscErrorCode PCSetFromOptions_MG(PetscOptionItems *PetscOptionsObject,PC pc)
{
PetscErrorCode ierr;
PetscInt m,levels = 1,cycles;
PetscBool flg,set;
PC_MG *mg = (PC_MG*)pc->data;
PC_MG_Levels **mglevels;
PCMGType mgtype;
PCMGCycleType mgctype;
PetscFunctionBegin;
ierr = PetscOptionsHead(PetscOptionsObject,"Multigrid options");CHKERRQ(ierr);
if (!mg->levels) {
ierr = PetscOptionsInt("-pc_mg_levels","Number of Levels","PCMGSetLevels",levels,&levels,&flg);CHKERRQ(ierr);
if (!flg && pc->dm) {
ierr = DMGetRefineLevel(pc->dm,&levels);CHKERRQ(ierr);
levels++;
mg->usedmfornumberoflevels = PETSC_TRUE;
}
ierr = PCMGSetLevels(pc,levels,NULL);CHKERRQ(ierr);
}
mglevels = mg->levels;
mgctype = (PCMGCycleType) mglevels[0]->cycles;
ierr = PetscOptionsEnum("-pc_mg_cycle_type","V cycle or for W-cycle","PCMGSetCycleType",PCMGCycleTypes,(PetscEnum)mgctype,(PetscEnum*)&mgctype,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCMGSetCycleType(pc,mgctype);CHKERRQ(ierr);
}
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-pc_mg_galerkin","Use Galerkin process to compute coarser operators","PCMGSetGalerkin",flg,&flg,&set);CHKERRQ(ierr);
if (set) {
ierr = PCMGSetGalerkin(pc,flg);CHKERRQ(ierr);
}
ierr = PetscOptionsInt("-pc_mg_smoothup","Number of post-smoothing steps","PCMGSetNumberSmoothUp",mg->default_smoothu,&m,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCMGSetNumberSmoothUp(pc,m);CHKERRQ(ierr);
}
ierr = PetscOptionsInt("-pc_mg_smoothdown","Number of pre-smoothing steps","PCMGSetNumberSmoothDown",mg->default_smoothd,&m,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCMGSetNumberSmoothDown(pc,m);CHKERRQ(ierr);
}
mgtype = mg->am;
ierr = PetscOptionsEnum("-pc_mg_type","Multigrid type","PCMGSetType",PCMGTypes,(PetscEnum)mgtype,(PetscEnum*)&mgtype,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCMGSetType(pc,mgtype);CHKERRQ(ierr);
}
if (mg->am == PC_MG_MULTIPLICATIVE) {
ierr = PetscOptionsInt("-pc_mg_multiplicative_cycles","Number of cycles for each preconditioner step","PCMGMultiplicativeSetCycles",mg->cyclesperpcapply,&cycles,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCMGMultiplicativeSetCycles(pc,cycles);CHKERRQ(ierr);
}
}
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-pc_mg_log","Log times for each multigrid level","None",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
PetscInt i;
char eventname[128];
if (!mglevels) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"Must set MG levels before calling");
levels = mglevels[0]->levels;
for (i=0; i<levels; i++) {
sprintf(eventname,"MGSetup Level %d",(int)i);
ierr = PetscLogEventRegister(eventname,((PetscObject)pc)->classid,&mglevels[i]->eventsmoothsetup);CHKERRQ(ierr);
sprintf(eventname,"MGSmooth Level %d",(int)i);
ierr = PetscLogEventRegister(eventname,((PetscObject)pc)->classid,&mglevels[i]->eventsmoothsolve);CHKERRQ(ierr);
if (i) {
sprintf(eventname,"MGResid Level %d",(int)i);
ierr = PetscLogEventRegister(eventname,((PetscObject)pc)->classid,&mglevels[i]->eventresidual);CHKERRQ(ierr);
sprintf(eventname,"MGInterp Level %d",(int)i);
ierr = PetscLogEventRegister(eventname,((PetscObject)pc)->classid,&mglevels[i]->eventinterprestrict);CHKERRQ(ierr);
}
}
#if defined(PETSC_USE_LOG)
{
const char *sname = "MG Apply";
PetscStageLog stageLog;
PetscInt st;
PetscFunctionBegin;
ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr);
for (st = 0; st < stageLog->numStages; ++st) {
PetscBool same;
ierr = PetscStrcmp(stageLog->stageInfo[st].name, sname, &same);CHKERRQ(ierr);
if (same) mg->stageApply = st;
}
if (!mg->stageApply) {
ierr = PetscLogStageRegister(sname, &mg->stageApply);CHKERRQ(ierr);
}
}
#endif
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode PCSetUp_ML(PC pc)
{
PetscErrorCode ierr;
PetscMPIInt size;
FineGridCtx *PetscMLdata;
ML *ml_object;
ML_Aggregate *agg_object;
ML_Operator *mlmat;
PetscInt nlocal_allcols,Nlevels,mllevel,level,level1,m,fine_level,bs;
Mat A,Aloc;
GridCtx *gridctx;
PC_MG *mg = (PC_MG*)pc->data;
PC_ML *pc_ml = (PC_ML*)mg->innerctx;
PetscBool isSeq, isMPI;
KSP smoother;
PC subpc;
PetscInt mesh_level, old_mesh_level;
PetscFunctionBegin;
A = pc->pmat;
ierr = MPI_Comm_size(((PetscObject)A)->comm,&size);CHKERRQ(ierr);
if (pc->setupcalled) {
if (pc->flag == SAME_NONZERO_PATTERN && pc_ml->reuse_interpolation) {
/*
Reuse interpolaton instead of recomputing aggregates and updating the whole hierarchy. This is less expensive for
multiple solves in which the matrix is not changing too quickly.
*/
ml_object = pc_ml->ml_object;
gridctx = pc_ml->gridctx;
Nlevels = pc_ml->Nlevels;
fine_level = Nlevels - 1;
gridctx[fine_level].A = A;
ierr = PetscObjectTypeCompare((PetscObject) A, MATSEQAIJ, &isSeq);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject) A, MATMPIAIJ, &isMPI);CHKERRQ(ierr);
if (isMPI){
ierr = MatConvert_MPIAIJ_ML(A,PETSC_NULL,MAT_INITIAL_MATRIX,&Aloc);CHKERRQ(ierr);
} else if (isSeq) {
Aloc = A;
ierr = PetscObjectReference((PetscObject)Aloc);CHKERRQ(ierr);
} else SETERRQ1(((PetscObject)pc)->comm,PETSC_ERR_ARG_WRONG, "Matrix type '%s' cannot be used with ML. ML can only handle AIJ matrices.",((PetscObject)A)->type_name);
ierr = MatGetSize(Aloc,&m,&nlocal_allcols);CHKERRQ(ierr);
PetscMLdata = pc_ml->PetscMLdata;
ierr = MatDestroy(&PetscMLdata->Aloc);CHKERRQ(ierr);
PetscMLdata->A = A;
PetscMLdata->Aloc = Aloc;
ML_Init_Amatrix(ml_object,0,m,m,PetscMLdata);
ML_Set_Amatrix_Matvec(ml_object,0,PetscML_matvec);
mesh_level = ml_object->ML_finest_level;
while (ml_object->SingleLevel[mesh_level].Rmat->to) {
old_mesh_level = mesh_level;
mesh_level = ml_object->SingleLevel[mesh_level].Rmat->to->levelnum;
/* clean and regenerate A */
mlmat = &(ml_object->Amat[mesh_level]);
ML_Operator_Clean(mlmat);
ML_Operator_Init(mlmat,ml_object->comm);
ML_Gen_AmatrixRAP(ml_object, old_mesh_level, mesh_level);
}
level = fine_level - 1;
if (size == 1) { /* convert ML P, R and A into seqaij format */
for (mllevel=1; mllevel<Nlevels; mllevel++){
mlmat = &(ml_object->Amat[mllevel]);
ierr = MatWrapML_SeqAIJ(mlmat,MAT_REUSE_MATRIX,&gridctx[level].A);CHKERRQ(ierr);
level--;
}
} else { /* convert ML P and R into shell format, ML A into mpiaij format */
for (mllevel=1; mllevel<Nlevels; mllevel++){
mlmat = &(ml_object->Amat[mllevel]);
ierr = MatWrapML_MPIAIJ(mlmat,MAT_REUSE_MATRIX,&gridctx[level].A);CHKERRQ(ierr);
level--;
}
}
for (level=0; level<fine_level; level++) {
if (level > 0){
ierr = PCMGSetResidual(pc,level,PCMGDefaultResidual,gridctx[level].A);CHKERRQ(ierr);
}
ierr = KSPSetOperators(gridctx[level].ksp,gridctx[level].A,gridctx[level].A,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
}
ierr = PCMGSetResidual(pc,fine_level,PCMGDefaultResidual,gridctx[fine_level].A);CHKERRQ(ierr);
ierr = KSPSetOperators(gridctx[fine_level].ksp,gridctx[level].A,gridctx[fine_level].A,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = PCSetUp_MG(pc);CHKERRQ(ierr);
PetscFunctionReturn(0);
} else {
/* since ML can change the size of vectors/matrices at any level we must destroy everything */
ierr = PCReset_ML(pc);CHKERRQ(ierr);
ierr = PCReset_MG(pc);CHKERRQ(ierr);
}
}
/* setup special features of PCML */
/*--------------------------------*/
/* covert A to Aloc to be used by ML at fine grid */
pc_ml->size = size;
ierr = PetscObjectTypeCompare((PetscObject) A, MATSEQAIJ, &isSeq);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject) A, MATMPIAIJ, &isMPI);CHKERRQ(ierr);
if (isMPI){
ierr = MatConvert_MPIAIJ_ML(A,PETSC_NULL,MAT_INITIAL_MATRIX,&Aloc);CHKERRQ(ierr);
} else if (isSeq) {
Aloc = A;
ierr = PetscObjectReference((PetscObject)Aloc);CHKERRQ(ierr);
} else SETERRQ1(((PetscObject)pc)->comm,PETSC_ERR_ARG_WRONG, "Matrix type '%s' cannot be used with ML. ML can only handle AIJ matrices.",((PetscObject)A)->type_name);
/* create and initialize struct 'PetscMLdata' */
ierr = PetscNewLog(pc,FineGridCtx,&PetscMLdata);CHKERRQ(ierr);
pc_ml->PetscMLdata = PetscMLdata;
ierr = PetscMalloc((Aloc->cmap->n+1)*sizeof(PetscScalar),&PetscMLdata->pwork);CHKERRQ(ierr);
ierr = VecCreate(PETSC_COMM_SELF,&PetscMLdata->x);CHKERRQ(ierr);
ierr = VecSetSizes(PetscMLdata->x,Aloc->cmap->n,Aloc->cmap->n);CHKERRQ(ierr);
ierr = VecSetType(PetscMLdata->x,VECSEQ);CHKERRQ(ierr);
ierr = VecCreate(PETSC_COMM_SELF,&PetscMLdata->y);CHKERRQ(ierr);
ierr = VecSetSizes(PetscMLdata->y,A->rmap->n,PETSC_DECIDE);CHKERRQ(ierr);
ierr = VecSetType(PetscMLdata->y,VECSEQ);CHKERRQ(ierr);
PetscMLdata->A = A;
PetscMLdata->Aloc = Aloc;
/* create ML discretization matrix at fine grid */
/* ML requires input of fine-grid matrix. It determines nlevels. */
ierr = MatGetSize(Aloc,&m,&nlocal_allcols);CHKERRQ(ierr);
ierr = MatGetBlockSize(A,&bs);CHKERRQ(ierr);
ML_Create(&ml_object,pc_ml->MaxNlevels);
ML_Comm_Set_UsrComm(ml_object->comm,((PetscObject)A)->comm);
pc_ml->ml_object = ml_object;
ML_Init_Amatrix(ml_object,0,m,m,PetscMLdata);
ML_Set_Amatrix_Getrow(ml_object,0,PetscML_getrow,PetscML_comm,nlocal_allcols);
ML_Set_Amatrix_Matvec(ml_object,0,PetscML_matvec);
ML_Set_Symmetrize(ml_object,pc_ml->Symmetrize ? ML_YES : ML_NO);
/* aggregation */
ML_Aggregate_Create(&agg_object);
pc_ml->agg_object = agg_object;
{
MatNullSpace mnull;
ierr = MatGetNearNullSpace(A,&mnull);CHKERRQ(ierr);
if (pc_ml->nulltype == PCML_NULLSPACE_AUTO) {
if (mnull) pc_ml->nulltype = PCML_NULLSPACE_USER;
else if (bs > 1) pc_ml->nulltype = PCML_NULLSPACE_BLOCK;
else pc_ml->nulltype = PCML_NULLSPACE_SCALAR;
}
switch (pc_ml->nulltype) {
case PCML_NULLSPACE_USER: {
PetscScalar *nullvec;
const PetscScalar *v;
PetscBool has_const;
PetscInt i,j,mlocal,nvec,M;
const Vec *vecs;
if (!mnull) SETERRQ(((PetscObject)pc)->comm,PETSC_ERR_USER,"Must provide explicit null space using MatSetNearNullSpace() to use user-specified null space");
ierr = MatGetSize(A,&M,PETSC_NULL);CHKERRQ(ierr);
ierr = MatGetLocalSize(Aloc,&mlocal,PETSC_NULL);CHKERRQ(ierr);
ierr = MatNullSpaceGetVecs(mnull,&has_const,&nvec,&vecs);CHKERRQ(ierr);
ierr = PetscMalloc((nvec+!!has_const)*mlocal*sizeof *nullvec,&nullvec);CHKERRQ(ierr);
if (has_const) for (i=0; i<mlocal; i++) nullvec[i] = 1.0/M;
for (i=0; i<nvec; i++) {
ierr = VecGetArrayRead(vecs[i],&v);CHKERRQ(ierr);
for (j=0; j<mlocal; j++) nullvec[(i+!!has_const)*mlocal + j] = v[j];
ierr = VecRestoreArrayRead(vecs[i],&v);CHKERRQ(ierr);
}
ierr = ML_Aggregate_Set_NullSpace(agg_object,bs,nvec+!!has_const,nullvec,mlocal);CHKERRQ(ierr);
ierr = PetscFree(nullvec);CHKERRQ(ierr);
} break;
case PCML_NULLSPACE_BLOCK:
ierr = ML_Aggregate_Set_NullSpace(agg_object,bs,bs,0,0);CHKERRQ(ierr);
break;
case PCML_NULLSPACE_SCALAR:
break;
default: SETERRQ(((PetscObject)pc)->comm,PETSC_ERR_SUP,"Unknown null space type");
}
}
ML_Aggregate_Set_MaxCoarseSize(agg_object,pc_ml->MaxCoarseSize);
/* set options */
switch (pc_ml->CoarsenScheme) {
case 1:
ML_Aggregate_Set_CoarsenScheme_Coupled(agg_object);break;
case 2:
ML_Aggregate_Set_CoarsenScheme_MIS(agg_object);break;
case 3:
ML_Aggregate_Set_CoarsenScheme_METIS(agg_object);break;
}
ML_Aggregate_Set_Threshold(agg_object,pc_ml->Threshold);
ML_Aggregate_Set_DampingFactor(agg_object,pc_ml->DampingFactor);
if (pc_ml->SpectralNormScheme_Anorm){
ML_Set_SpectralNormScheme_Anorm(ml_object);
}
agg_object->keep_agg_information = (int)pc_ml->KeepAggInfo;
agg_object->keep_P_tentative = (int)pc_ml->Reusable;
agg_object->block_scaled_SA = (int)pc_ml->BlockScaling;
agg_object->minimizing_energy = (int)pc_ml->EnergyMinimization;
agg_object->minimizing_energy_droptol = (double)pc_ml->EnergyMinimizationDropTol;
agg_object->cheap_minimizing_energy = (int)pc_ml->EnergyMinimizationCheap;
if (pc_ml->OldHierarchy) {
Nlevels = ML_Gen_MGHierarchy_UsingAggregation(ml_object,0,ML_INCREASING,agg_object);
} else {
Nlevels = ML_Gen_MultiLevelHierarchy_UsingAggregation(ml_object,0,ML_INCREASING,agg_object);
}
if (Nlevels<=0) SETERRQ1(((PetscObject)pc)->comm,PETSC_ERR_ARG_OUTOFRANGE,"Nlevels %d must > 0",Nlevels);
pc_ml->Nlevels = Nlevels;
fine_level = Nlevels - 1;
ierr = PCMGSetLevels(pc,Nlevels,PETSC_NULL);CHKERRQ(ierr);
/* set default smoothers */
for (level=1; level<=fine_level; level++){
if (size == 1){
ierr = PCMGGetSmoother(pc,level,&smoother);CHKERRQ(ierr);
ierr = KSPSetType(smoother,KSPRICHARDSON);CHKERRQ(ierr);
ierr = KSPGetPC(smoother,&subpc);CHKERRQ(ierr);
ierr = PCSetType(subpc,PCSOR);CHKERRQ(ierr);
} else {
ierr = PCMGGetSmoother(pc,level,&smoother);CHKERRQ(ierr);
ierr = KSPSetType(smoother,KSPRICHARDSON);CHKERRQ(ierr);
ierr = KSPGetPC(smoother,&subpc);CHKERRQ(ierr);
ierr = PCSetType(subpc,PCSOR);CHKERRQ(ierr);
}
}
ierr = PetscObjectOptionsBegin((PetscObject)pc);CHKERRQ(ierr);
ierr = PCSetFromOptions_MG(pc);CHKERRQ(ierr); /* should be called in PCSetFromOptions_ML(), but cannot be called prior to PCMGSetLevels() */
ierr = PetscOptionsEnd();CHKERRQ(ierr);
ierr = PetscMalloc(Nlevels*sizeof(GridCtx),&gridctx);CHKERRQ(ierr);
pc_ml->gridctx = gridctx;
/* wrap ML matrices by PETSc shell matrices at coarsened grids.
Level 0 is the finest grid for ML, but coarsest for PETSc! */
gridctx[fine_level].A = A;
level = fine_level - 1;
if (size == 1){ /* convert ML P, R and A into seqaij format */
for (mllevel=1; mllevel<Nlevels; mllevel++){
mlmat = &(ml_object->Pmat[mllevel]);
ierr = MatWrapML_SeqAIJ(mlmat,MAT_INITIAL_MATRIX,&gridctx[level].P);CHKERRQ(ierr);
mlmat = &(ml_object->Rmat[mllevel-1]);
ierr = MatWrapML_SeqAIJ(mlmat,MAT_INITIAL_MATRIX,&gridctx[level].R);CHKERRQ(ierr);
mlmat = &(ml_object->Amat[mllevel]);
ierr = MatWrapML_SeqAIJ(mlmat,MAT_INITIAL_MATRIX,&gridctx[level].A);CHKERRQ(ierr);
level--;
}
} else { /* convert ML P and R into shell format, ML A into mpiaij format */
for (mllevel=1; mllevel<Nlevels; mllevel++){
mlmat = &(ml_object->Pmat[mllevel]);
ierr = MatWrapML_SHELL(mlmat,MAT_INITIAL_MATRIX,&gridctx[level].P);CHKERRQ(ierr);
mlmat = &(ml_object->Rmat[mllevel-1]);
ierr = MatWrapML_SHELL(mlmat,MAT_INITIAL_MATRIX,&gridctx[level].R);CHKERRQ(ierr);
mlmat = &(ml_object->Amat[mllevel]);
ierr = MatWrapML_MPIAIJ(mlmat,MAT_INITIAL_MATRIX,&gridctx[level].A);CHKERRQ(ierr);
level--;
}
}
/* create vectors and ksp at all levels */
for (level=0; level<fine_level; level++){
level1 = level + 1;
ierr = VecCreate(((PetscObject)gridctx[level].A)->comm,&gridctx[level].x);CHKERRQ(ierr);
ierr = VecSetSizes(gridctx[level].x,gridctx[level].A->cmap->n,PETSC_DECIDE);CHKERRQ(ierr);
ierr = VecSetType(gridctx[level].x,VECMPI);CHKERRQ(ierr);
ierr = PCMGSetX(pc,level,gridctx[level].x);CHKERRQ(ierr);
ierr = VecCreate(((PetscObject)gridctx[level].A)->comm,&gridctx[level].b);CHKERRQ(ierr);
ierr = VecSetSizes(gridctx[level].b,gridctx[level].A->rmap->n,PETSC_DECIDE);CHKERRQ(ierr);
ierr = VecSetType(gridctx[level].b,VECMPI);CHKERRQ(ierr);
ierr = PCMGSetRhs(pc,level,gridctx[level].b);CHKERRQ(ierr);
ierr = VecCreate(((PetscObject)gridctx[level1].A)->comm,&gridctx[level1].r);CHKERRQ(ierr);
ierr = VecSetSizes(gridctx[level1].r,gridctx[level1].A->rmap->n,PETSC_DECIDE);CHKERRQ(ierr);
ierr = VecSetType(gridctx[level1].r,VECMPI);CHKERRQ(ierr);
ierr = PCMGSetR(pc,level1,gridctx[level1].r);CHKERRQ(ierr);
if (level == 0){
ierr = PCMGGetCoarseSolve(pc,&gridctx[level].ksp);CHKERRQ(ierr);
} else {
ierr = PCMGGetSmoother(pc,level,&gridctx[level].ksp);CHKERRQ(ierr);
}
}
ierr = PCMGGetSmoother(pc,fine_level,&gridctx[fine_level].ksp);CHKERRQ(ierr);
/* create coarse level and the interpolation between the levels */
for (level=0; level<fine_level; level++){
level1 = level + 1;
ierr = PCMGSetInterpolation(pc,level1,gridctx[level].P);CHKERRQ(ierr);
ierr = PCMGSetRestriction(pc,level1,gridctx[level].R);CHKERRQ(ierr);
if (level > 0){
ierr = PCMGSetResidual(pc,level,PCMGDefaultResidual,gridctx[level].A);CHKERRQ(ierr);
}
ierr = KSPSetOperators(gridctx[level].ksp,gridctx[level].A,gridctx[level].A,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
}
ierr = PCMGSetResidual(pc,fine_level,PCMGDefaultResidual,gridctx[fine_level].A);CHKERRQ(ierr);
ierr = KSPSetOperators(gridctx[fine_level].ksp,gridctx[level].A,gridctx[fine_level].A,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
/* setupcalled is set to 0 so that MG is setup from scratch */
pc->setupcalled = 0;
ierr = PCSetUp_MG(pc);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
void PETScMGSolver_UpdateSolvers( PETScMGSolver* self ) {
PETScMGSolver_Level* level;
PC pc;
KSP levelKSP;
PC levelPC;
PetscErrorCode ec;
unsigned l_i;
PetscTruth smoothers_differ, flag;
PetscMPIInt size;
MPI_Comm comm;
assert( self && Stg_CheckType( self, PETScMGSolver ) );
ec = KSPGetPC( self->mgData->ksp, &pc );
CheckPETScError( ec );
ec = PCMGSetLevels( pc, self->nLevels, PETSC_NULL );
CheckPETScError( ec );
ec = PCMGSetType( pc, PC_MG_MULTIPLICATIVE );
CheckPETScError( ec );
ec=PetscOptionsGetTruth( PETSC_NULL, "-pc_mg_different_smoothers", &smoothers_differ, &flag ); CheckPETScError(ec);
ec=PetscObjectGetComm( (PetscObject)pc, &comm ); CheckPETScError(ec);
MPI_Comm_size( comm, &size );
for( l_i = 1; l_i < self->nLevels; l_i++ ) {
level = self->levels + l_i;
printf("Configuring MG level %d \n", l_i );
ec = PCMGGetSmootherDown( pc, l_i, &levelKSP );
CheckPETScError( ec );
if(smoothers_differ==PETSC_TRUE) { ec=KSPAppendOptionsPrefix( levelKSP, "down_" ); CheckPETScError(ec); }
ec = KSPSetType( levelKSP, KSPRICHARDSON ); CheckPETScError( ec );
ec = KSPGetPC( levelKSP, &levelPC ); CheckPETScError( ec );
if(size==1) {
ec = PCSetType( levelPC, PCSOR ); CheckPETScError( ec );
}
/* This does not work - bug with the order the operators are created I guess */
/* For parallel jobs you best bet is to use the command line args and let petsc work it out */
/*
else {
KSP *sub_ksp;
PetscInt k, n_local, first_local;
PC sub_pc;
PCSetType( levelPC, PCBJACOBI );
KSPSetUp( levelKSP );
PCBJacobiGetSubKSP( levelPC, &n_local,&first_local,&sub_ksp);
for(k=0;k<n_local;k++ ) {
KSPSetType( sub_ksp[k], KSPFGMRES );
KSPGetPC( sub_ksp[k], &sub_pc );
PCSetType( sub_pc, PCSOR );
}
}
*/
ec = KSPSetTolerances( levelKSP, PETSC_DEFAULT, PETSC_DEFAULT, PETSC_DEFAULT, level->nDownIts ); CheckPETScError( ec );
if( l_i == self->nLevels - 1 ) {
ec = KSPSetInitialGuessNonzero( levelKSP, PETSC_TRUE ); CheckPETScError( ec );
}
else { ec = KSPSetInitialGuessNonzero( levelKSP, PETSC_FALSE ); CheckPETScError( ec ); }
ec = PCMGGetSmootherUp( pc, l_i, &levelKSP ); CheckPETScError( ec );
if(smoothers_differ==PETSC_TRUE) { ec=KSPAppendOptionsPrefix( levelKSP, "up_" ); CheckPETScError(ec); }
ec = KSPSetType( levelKSP, KSPRICHARDSON ); CheckPETScError( ec );
ec = KSPGetPC( levelKSP, &levelPC ); CheckPETScError( ec );
if(size==1) {
ec = PCSetType( levelPC, PCSOR ); CheckPETScError( ec );
}
ec = KSPSetTolerances( levelKSP, PETSC_DEFAULT, PETSC_DEFAULT, PETSC_DEFAULT, level->nUpIts ); CheckPETScError( ec );
ec = KSPSetInitialGuessNonzero( levelKSP, PETSC_TRUE ); CheckPETScError( ec );
ec = PCMGSetCyclesOnLevel( pc, l_i, level->nCycles ); CheckPETScError( ec );
}
}
/*@
PetscConvEstGetConvRate - Returns an estimate of the convergence rate for the discretization
Not collective
Input Parameter:
. ce - The PetscConvEst object
Output Parameter:
. alpha - The convergence rate for each field
Note: The convergence rate alpha is defined by
$ || u_h - u_exact || < C h^alpha
where u_h is the discrete solution, and h is a measure of the discretization size.
We solve a series of problems on refined meshes, calculate an error based upon the exact solution in the DS,
and then fit the result to our model above using linear regression.
Options database keys:
. -snes_convergence_estimate : Execute convergence estimation and print out the rate
Level: intermediate
.keywords: PetscConvEst, convergence
.seealso: PetscConvEstSetSolver(), PetscConvEstCreate(), PetscConvEstGetConvRate()
@*/
PetscErrorCode PetscConvEstGetConvRate(PetscConvEst ce, PetscReal alpha[])
{
DM *dm;
PetscObject disc;
MPI_Comm comm;
const char *uname, *dmname;
void *ctx;
Vec u;
PetscReal t = 0.0, *x, *y, slope, intercept;
PetscInt *dof, dim, Nr = ce->Nr, r, f, oldlevel, oldnlev;
PetscLogEvent event;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscObjectGetComm((PetscObject) ce, &comm);CHKERRQ(ierr);
ierr = DMGetDimension(ce->idm, &dim);CHKERRQ(ierr);
ierr = DMGetApplicationContext(ce->idm, &ctx);CHKERRQ(ierr);
ierr = DMPlexSetRefinementUniform(ce->idm, PETSC_TRUE);CHKERRQ(ierr);
ierr = DMGetRefineLevel(ce->idm, &oldlevel);CHKERRQ(ierr);
ierr = PetscMalloc2((Nr+1), &dm, (Nr+1)*ce->Nf, &dof);CHKERRQ(ierr);
dm[0] = ce->idm;
for (f = 0; f < ce->Nf; ++f) alpha[f] = 0.0;
/* Loop over meshes */
ierr = PetscLogEventRegister("ConvEst Error", PETSC_OBJECT_CLASSID, &event);CHKERRQ(ierr);
for (r = 0; r <= Nr; ++r) {
PetscLogStage stage;
char stageName[PETSC_MAX_PATH_LEN];
ierr = PetscSNPrintf(stageName, PETSC_MAX_PATH_LEN-1, "ConvEst Refinement Level %D", r);CHKERRQ(ierr);
ierr = PetscLogStageRegister(stageName, &stage);CHKERRQ(ierr);
ierr = PetscLogStagePush(stage);CHKERRQ(ierr);
if (r > 0) {
ierr = DMRefine(dm[r-1], MPI_COMM_NULL, &dm[r]);CHKERRQ(ierr);
ierr = DMSetCoarseDM(dm[r], dm[r-1]);CHKERRQ(ierr);
ierr = DMCopyDisc(ce->idm, dm[r]);CHKERRQ(ierr);
ierr = DMCopyTransform(ce->idm, dm[r]);CHKERRQ(ierr);
ierr = PetscObjectGetName((PetscObject) dm[r-1], &dmname);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) dm[r], dmname);CHKERRQ(ierr);
for (f = 0; f <= ce->Nf; ++f) {
PetscErrorCode (*nspconstr)(DM, PetscInt, MatNullSpace *);
ierr = DMGetNullSpaceConstructor(dm[r-1], f, &nspconstr);CHKERRQ(ierr);
ierr = DMSetNullSpaceConstructor(dm[r], f, nspconstr);CHKERRQ(ierr);
}
}
ierr = DMViewFromOptions(dm[r], NULL, "-conv_dm_view");CHKERRQ(ierr);
/* Create solution */
ierr = DMCreateGlobalVector(dm[r], &u);CHKERRQ(ierr);
ierr = DMGetField(dm[r], 0, NULL, &disc);CHKERRQ(ierr);
ierr = PetscObjectGetName(disc, &uname);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) u, uname);CHKERRQ(ierr);
/* Setup solver */
ierr = SNESReset(ce->snes);CHKERRQ(ierr);
ierr = SNESSetDM(ce->snes, dm[r]);CHKERRQ(ierr);
ierr = DMPlexSetSNESLocalFEM(dm[r], ctx, ctx, ctx);CHKERRQ(ierr);
ierr = SNESSetFromOptions(ce->snes);CHKERRQ(ierr);
/* Create initial guess */
ierr = DMProjectFunction(dm[r], t, ce->initGuess, ce->ctxs, INSERT_VALUES, u);CHKERRQ(ierr);
ierr = SNESSolve(ce->snes, NULL, u);CHKERRQ(ierr);
ierr = PetscLogEventBegin(event, ce, 0, 0, 0);CHKERRQ(ierr);
ierr = DMComputeL2FieldDiff(dm[r], t, ce->exactSol, ce->ctxs, u, &ce->errors[r*ce->Nf]);CHKERRQ(ierr);
ierr = PetscLogEventEnd(event, ce, 0, 0, 0);CHKERRQ(ierr);
for (f = 0; f < ce->Nf; ++f) {
PetscSection s, fs;
PetscInt lsize;
/* Could use DMGetOutputDM() to add in Dirichlet dofs */
ierr = DMGetSection(dm[r], &s);CHKERRQ(ierr);
ierr = PetscSectionGetField(s, f, &fs);CHKERRQ(ierr);
ierr = PetscSectionGetConstrainedStorageSize(fs, &lsize);CHKERRQ(ierr);
ierr = MPI_Allreduce(&lsize, &dof[r*ce->Nf+f], 1, MPIU_INT, MPI_SUM, PetscObjectComm((PetscObject) ce->snes));CHKERRQ(ierr);
ierr = PetscLogEventSetDof(event, f, dof[r*ce->Nf+f]);CHKERRQ(ierr);
ierr = PetscLogEventSetError(event, f, ce->errors[r*ce->Nf+f]);CHKERRQ(ierr);
}
/* Monitor */
if (ce->monitor) {
PetscReal *errors = &ce->errors[r*ce->Nf];
ierr = PetscPrintf(comm, "L_2 Error: ");CHKERRQ(ierr);
if (ce->Nf > 1) {ierr = PetscPrintf(comm, "[");CHKERRQ(ierr);}
for (f = 0; f < ce->Nf; ++f) {
if (f > 0) {ierr = PetscPrintf(comm, ", ");CHKERRQ(ierr);}
if (errors[f] < 1.0e-11) {ierr = PetscPrintf(comm, "< 1e-11");CHKERRQ(ierr);}
else {ierr = PetscPrintf(comm, "%g", (double)errors[f]);CHKERRQ(ierr);}
}
if (ce->Nf > 1) {ierr = PetscPrintf(comm, "]");CHKERRQ(ierr);}
ierr = PetscPrintf(comm, "\n");CHKERRQ(ierr);
}
if (!r) {
/* PCReset() does not wipe out the level structure */
KSP ksp;
PC pc;
ierr = SNESGetKSP(ce->snes, &ksp);CHKERRQ(ierr);
ierr = KSPGetPC(ksp, &pc);CHKERRQ(ierr);
ierr = PCMGGetLevels(pc, &oldnlev);CHKERRQ(ierr);
}
/* Cleanup */
ierr = VecDestroy(&u);CHKERRQ(ierr);
ierr = PetscLogStagePop();CHKERRQ(ierr);
}
for (r = 1; r <= Nr; ++r) {
ierr = DMDestroy(&dm[r]);CHKERRQ(ierr);
}
/* Fit convergence rate */
ierr = PetscMalloc2(Nr+1, &x, Nr+1, &y);CHKERRQ(ierr);
for (f = 0; f < ce->Nf; ++f) {
for (r = 0; r <= Nr; ++r) {
x[r] = PetscLog10Real(dof[r*ce->Nf+f]);
y[r] = PetscLog10Real(ce->errors[r*ce->Nf+f]);
}
ierr = PetscLinearRegression(Nr+1, x, y, &slope, &intercept);CHKERRQ(ierr);
/* Since h^{-dim} = N, lg err = s lg N + b = -s dim lg h + b */
alpha[f] = -slope * dim;
}
ierr = PetscFree2(x, y);CHKERRQ(ierr);
ierr = PetscFree2(dm, dof);CHKERRQ(ierr);
/* Restore solver */
ierr = SNESReset(ce->snes);CHKERRQ(ierr);
{
/* PCReset() does not wipe out the level structure */
KSP ksp;
PC pc;
ierr = SNESGetKSP(ce->snes, &ksp);CHKERRQ(ierr);
ierr = KSPGetPC(ksp, &pc);CHKERRQ(ierr);
ierr = PCMGSetLevels(pc, oldnlev, NULL);CHKERRQ(ierr);
ierr = DMSetRefineLevel(ce->idm, oldlevel);CHKERRQ(ierr); /* The damn DMCoarsen() calls in PCMG can reset this */
}
ierr = SNESSetDM(ce->snes, ce->idm);CHKERRQ(ierr);
ierr = DMPlexSetSNESLocalFEM(ce->idm, ctx, ctx, ctx);CHKERRQ(ierr);
ierr = SNESSetFromOptions(ce->snes);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int
main(int argc, char** argv) {
int levels = 4;
int mg_levels = 3;
PetscInitialize(&argc, &argv, PETSC_NULL, PETSC_NULL);
construct_operator(&problem, levels);
KSP ksp;
PC pc;
KSPCreate(PETSC_COMM_WORLD, &ksp);
KSPSetOperators(ksp, problem.A, problem.A, SAME_PRECONDITIONER);
KSPSetType(ksp, KSPRICHARDSON);
if (1) {
KSPGetPC(ksp, &pc);
PCSetType(pc, PCMG);
PCMGSetLevels(pc, mg_levels, NULL);
PCMGSetGalerkin(pc);
PCMGSetType(pc, PC_MG_MULTIPLICATIVE);
PCMGSetCycleType(pc, PC_MG_CYCLE_V);
int ii;
for (ii=0; ii<mg_levels; ii++) {
if (ii == 0) {
KSP smooth_ksp;
PCMGGetSmoother(pc, ii, &smooth_ksp);
KSPSetType(smooth_ksp, KSPPREONLY);
PC smooth_pc;
KSPGetPC(smooth_ksp, &smooth_pc);
PCSetType(smooth_pc, PCLU);
} else {
// set up the smoother.
KSP smooth_ksp;
PC smooth_pc;
PCMGGetSmoother(pc, ii, &smooth_ksp);
KSPSetType(smooth_ksp, KSPRICHARDSON);
KSPRichardsonSetScale(smooth_ksp, 2./3.);
KSPGetPC(smooth_ksp, &smooth_pc);
PCSetType(smooth_pc, PCJACOBI);
KSPSetTolerances(smooth_ksp, PETSC_DEFAULT, PETSC_DEFAULT, PETSC_DEFAULT, 2);
//set up the interpolation operator
Mat prolongation;
construct_prolongation_operator(ii+1+levels-mg_levels, &prolongation);
PCMGSetInterpolation(pc, ii, prolongation);
MatScale(prolongation, 1./2.);
Mat restriction;
MatTranspose(prolongation, &restriction);
PCMGSetRestriction(pc, ii, prolongation);
MatDestroy(prolongation);
MatDestroy(restriction);
}
}
} else {
KSPGetPC(ksp, &pc);
PCSetType(pc, PCJACOBI);
}
//*/
/*
if (0) {
KSPSetType(ksp, KSPRICHARDSON);
KSPRichardsonSetScale(ksp, 2./3.);
KSPGetPC(ksp, &pc);
PCSetType(pc, PCJACOBI);
} else {
PetscOptionsInsertString("-ksp_type richardson");
PetscOptionsInsertString("-ksp_richardson_scale 0.666666666666666666");
PetscOptionsInsertString("-pc_type jacobi");
}
//*/
KSPSetInitialGuessNonzero(ksp, PETSC_TRUE);
KSPSetFromOptions(ksp);
KSPSetUp(ksp);
//VecView(problem.x, PETSC_VIEWER_STDOUT_WORLD);
{
//CHKERR(PCApply(pc, problem.b, problem.x));
CHKERR(KSPSolve(ksp, problem.b, problem.x));
KSPConvergedReason reason;
CHKERR(KSPGetConvergedReason(ksp, &reason));
printf("KSPConvergedReason: %d\n", reason);
PetscInt its;
CHKERR(KSPGetIterationNumber(ksp, &its));
printf("Num iterations: %d\n", its);
}
//compute_residual_norm(&problem);
VecView(problem.x, PETSC_VIEWER_STDOUT_WORLD);
PetscFinalize();
return 0;
}
void StgFEM_GMG_SolverSetup( void* _solver, void* _stokesSLE ) {
StgFEM_GMG* self = StgFEM_GMG_selfPointer;
Stokes_SLE_UzawaSolver* solver = (Stokes_SLE_UzawaSolver*)_solver;
Stokes_SLE* sle = (Stokes_SLE*)_stokesSLE;
KSP ksp = solver->velSolver;
PC pc;
int ii;
Journal_DPrintf( solver->debug, "In %s:\n", __func__ );
Stream_IndentBranch( StgFEM_Debug );
KSPSetType( ksp, KSPFGMRES );
KSPGetPC( ksp, &pc );
PCSetType( pc, PCMG );
PCMGSetLevels( pc, self->numLevels, PETSC_NULL );
PCMGSetType( pc, PC_MG_MULTIPLICATIVE );
#if ((PETSC_VERSION_MAJOR==3) && (PETSC_VERSION_MINOR>=2) )
PCMGSetGalerkin( pc, PETSC_TRUE );
#else
PCMGSetGalerkin( pc );
#endif
/* Set the operators for each level. */
{
Mat *pOps, *rOps;
MGOpGenerator_SetNumLevels( self->opGen, self->numLevels );
MGOpGenerator_Generate( self->opGen, &pOps, &rOps );
for( ii = 1; ii < self->numLevels; ii++ )
PCMGSetInterpolation( pc, ii, pOps[ii] );
Memory_Free( pOps );
Memory_Free( rOps );
}
/* Set the solvers on each level. */
for( ii = 1; ii < self->numLevels; ii++ ) {
KSP smoother;
PC smPc;
PCMGGetSmoother( pc, ii, &smoother );
KSPSetType( smoother, KSPRICHARDSON );
KSPGetPC( smoother, &smPc );
PCSetType( smPc, PCSOR );
KSPSetTolerances( smoother, PETSC_DEFAULT, PETSC_DEFAULT,
PETSC_DEFAULT, 2 );
}
Stg_KSPSetOperators( ksp, sle->kStiffMat->matrix, sle->kStiffMat->matrix,
DIFFERENT_NONZERO_PATTERN );
KSPSetFromOptions( ksp );
/* Because we stole the setup routine we need to do this too. */
if( solver->pcSolver ) {
Journal_DPrintfL( solver->debug, 1,
"Setting up MatrixSolver for the "
"Preconditioner.\n" );
Stg_KSPSetOperators( solver->pcSolver, solver->preconditioner->matrix,
solver->preconditioner->matrix,
DIFFERENT_NONZERO_PATTERN );
KSPSetFromOptions( solver->pcSolver );
}
Stream_UnIndentBranch( StgFEM_Debug );
}
