PetscErrorCode NavierStokesSolver::solveIntermediateVelocity() { PetscErrorCode ierr; ierr = KSPSolve(ksp1, rhs1, qStar); CHKERRQ(ierr); ierr = KSPView(ksp1, PETSC_VIEWER_STDOUT_WORLD); return 0; }
static PetscErrorCode PCView_Redundant(PC pc,PetscViewer viewer) { PC_Redundant *red = (PC_Redundant*)pc->data; PetscErrorCode ierr; PetscMPIInt rank; PetscTruth iascii,isstring; PetscViewer subviewer; PetscFunctionBegin; ierr = MPI_Comm_rank(((PetscObject)pc)->comm,&rank);CHKERRQ(ierr); ierr = PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_ASCII,&iascii);CHKERRQ(ierr); ierr = PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_STRING,&isstring);CHKERRQ(ierr); if (iascii) { if (!red->psubcomm) { ierr = PetscViewerASCIIPrintf(viewer," Redundant preconditioner: Not yet setup\n");CHKERRQ(ierr); } else { ierr = PetscViewerASCIIPrintf(viewer," Redundant preconditioner: First (color=0) of %D PCs follows\n",red->nsubcomm);CHKERRQ(ierr); ierr = PetscViewerGetSubcomm(viewer,((PetscObject)red->pc)->comm,&subviewer);CHKERRQ(ierr); if (red->psubcomm->color) { /* only view first redundant pc */ ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = KSPView(red->ksp,subviewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); } ierr = PetscViewerRestoreSubcomm(viewer,((PetscObject)red->pc)->comm,&subviewer);CHKERRQ(ierr); } } else if (isstring) { ierr = PetscViewerStringSPrintf(viewer," Redundant solver preconditioner");CHKERRQ(ierr); } else { SETERRQ1(PETSC_ERR_SUP,"Viewer type %s not supported for PC redundant",((PetscObject)viewer)->type_name); } PetscFunctionReturn(0); }
static PetscErrorCode PCView_Redundant(PC pc,PetscViewer viewer) { PC_Redundant *red = (PC_Redundant*)pc->data; PetscErrorCode ierr; PetscBool iascii,isstring; PetscViewer subviewer; PetscFunctionBegin; ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr); ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSTRING,&isstring);CHKERRQ(ierr); if (iascii) { if (!red->psubcomm) { ierr = PetscViewerASCIIPrintf(viewer," Redundant preconditioner: Not yet setup\n");CHKERRQ(ierr); } else { ierr = PetscViewerASCIIPrintf(viewer," Redundant preconditioner: First (color=0) of %D PCs follows\n",red->nsubcomm);CHKERRQ(ierr); ierr = PetscViewerGetSubViewer(viewer,((PetscObject)red->pc)->comm,&subviewer);CHKERRQ(ierr); if (!red->psubcomm->color) { /* only view first redundant pc */ ierr = PetscViewerASCIIPushTab(subviewer);CHKERRQ(ierr); ierr = KSPView(red->ksp,subviewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(subviewer);CHKERRQ(ierr); } ierr = PetscViewerRestoreSubViewer(viewer,((PetscObject)red->pc)->comm,&subviewer);CHKERRQ(ierr); } } else if (isstring) { ierr = PetscViewerStringSPrintf(viewer," Redundant solver preconditioner");CHKERRQ(ierr); } PetscFunctionReturn(0); }
static PetscErrorCode PCView_KSP(PC pc,PetscViewer viewer) { PC_KSP *jac = (PC_KSP*)pc->data; PetscErrorCode ierr; PetscTruth iascii; PetscFunctionBegin; if (!jac->ksp) {ierr = PCKSPCreateKSP_KSP(pc);CHKERRQ(ierr);} ierr = PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_ASCII,&iascii);CHKERRQ(ierr); if (iascii) { if (jac->use_true_matrix) { ierr = PetscViewerASCIIPrintf(viewer,"Using true matrix (not preconditioner matrix) on inner solve\n");CHKERRQ(ierr); } ierr = PetscViewerASCIIPrintf(viewer,"KSP and PC on KSP preconditioner follow\n");CHKERRQ(ierr); ierr = PetscViewerASCIIPrintf(viewer,"---------------------------------\n");CHKERRQ(ierr); } else { SETERRQ1(PETSC_ERR_SUP,"Viewer type %s not supported for this object",((PetscObject)viewer)->type_name); } ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = KSPView(jac->ksp,viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); if (iascii) { ierr = PetscViewerASCIIPrintf(viewer,"---------------------------------\n");CHKERRQ(ierr); } PetscFunctionReturn(0); }
PetscErrorCode KSPView_Chebyshev(KSP ksp,PetscViewer viewer) { KSP_Chebyshev *cheb = (KSP_Chebyshev*)ksp->data; PetscErrorCode ierr; PetscBool iascii; PetscFunctionBegin; ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr); if (iascii) { ierr = PetscViewerASCIIPrintf(viewer," Chebyshev: eigenvalue estimates: min = %g, max = %g\n",(double)cheb->emin,(double)cheb->emax);CHKERRQ(ierr); if (cheb->kspest) { ierr = PetscViewerASCIIPrintf(viewer," Chebyshev: estimated using: [%g %g; %g %g]\n",(double)cheb->tform[0],(double)cheb->tform[1],(double)cheb->tform[2],(double)cheb->tform[3]);CHKERRQ(ierr); if (cheb->random) { ierr = PetscViewerASCIIPrintf(viewer," Chebyshev: estimating eigenvalues using random right hand side\n");CHKERRQ(ierr); ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = PetscRandomView(cheb->random,viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); } ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = KSPView(cheb->kspest,viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); } } PetscFunctionReturn(0); }
PetscErrorCode MatView_SchurComplement(Mat N,PetscViewer viewer) { Mat_SchurComplement *Na = (Mat_SchurComplement*)N->data; PetscErrorCode ierr; PetscFunctionBegin; ierr = PetscViewerASCIIPrintf(viewer,"Schur complement A11 - A10 inv(A00) A01\n");CHKERRQ(ierr); if (Na->D) { ierr = PetscViewerASCIIPrintf(viewer,"A11\n");CHKERRQ(ierr); ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = MatView(Na->D,viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); } else { ierr = PetscViewerASCIIPrintf(viewer,"A11 = 0\n");CHKERRQ(ierr); } ierr = PetscViewerASCIIPrintf(viewer,"A10\n");CHKERRQ(ierr); ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = MatView(Na->C,viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPrintf(viewer,"KSP of A00\n");CHKERRQ(ierr); ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = KSPView(Na->ksp,viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPrintf(viewer,"A01\n");CHKERRQ(ierr); ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = MatView(Na->B,viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); PetscFunctionReturn(0); }
PetscErrorCode NavierStokesSolver::solvePoissonSystem() { PetscErrorCode ierr; ierr = KSPSolve(ksp2, rhs2, lambda); CHKERRQ(ierr); ierr = KSPView(ksp2,PETSC_VIEWER_STDOUT_WORLD); return 0; }
/*@C DMMGView - prints information on a DA based multi-level preconditioner Collective on DMMG and PetscViewer Input Parameter: + dmmg - the context - viewer - the viewer Level: advanced .seealso DMMGCreate(), DMMGDestroy(), DMMGSetMatType() @*/ PetscErrorCode PETSCSNES_DLLEXPORT DMMGView(DMMG *dmmg,PetscViewer viewer) { PetscErrorCode ierr; PetscInt i,nlevels = dmmg[0]->nlevels; PetscMPIInt flag; MPI_Comm comm; PetscTruth iascii,isbinary; PetscFunctionBegin; PetscValidPointer(dmmg,1); PetscValidHeaderSpecific(viewer,PETSC_VIEWER_COOKIE,2); ierr = PetscObjectGetComm((PetscObject)viewer,&comm);CHKERRQ(ierr); ierr = MPI_Comm_compare(comm,dmmg[0]->comm,&flag);CHKERRQ(ierr); if (flag != MPI_CONGRUENT && flag != MPI_IDENT) { SETERRQ(PETSC_ERR_ARG_NOTSAMECOMM,"Different communicators in the DMMG and the PetscViewer"); } ierr = PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_ASCII,&iascii);CHKERRQ(ierr); ierr = PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_BINARY,&isbinary);CHKERRQ(ierr); if (isbinary) { for (i=0; i<nlevels; i++) { ierr = MatView(dmmg[i]->J,viewer);CHKERRQ(ierr); } for (i=1; i<nlevels; i++) { ierr = MatView(dmmg[i]->R,viewer);CHKERRQ(ierr); } } else { if (iascii) { ierr = PetscViewerASCIIPrintf(viewer,"DMMG Object with %D levels\n",nlevels);CHKERRQ(ierr); if (dmmg[0]->isctype == IS_COLORING_GLOBAL) { ierr = PetscViewerASCIIPrintf(viewer,"Using global (nonghosted) Jacobian coloring computation\n");CHKERRQ(ierr); } else { ierr = PetscViewerASCIIPrintf(viewer,"Using ghosted Jacobian coloring computation\n");CHKERRQ(ierr); } } for (i=0; i<nlevels; i++) { ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = DMView(dmmg[i]->dm,viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); } if (iascii) { ierr = PetscViewerASCIIPrintf(viewer,"Using matrix type %s\n",dmmg[nlevels-1]->mtype);CHKERRQ(ierr); } if (DMMGGetKSP(dmmg)) { ierr = KSPView(DMMGGetKSP(dmmg),viewer);CHKERRQ(ierr); } else if (DMMGGetSNES(dmmg)) { ierr = SNESView(DMMGGetSNES(dmmg),viewer);CHKERRQ(ierr); } else if (iascii) { ierr = PetscViewerASCIIPrintf(viewer,"DMMG does not have a SNES or KSP set\n");CHKERRQ(ierr); } } PetscFunctionReturn(0); }
static PetscErrorCode PCView_Redistribute(PC pc,PetscViewer viewer) { PC_Redistribute *red = (PC_Redistribute*)pc->data; PetscErrorCode ierr; PetscBool iascii,isstring; PetscInt ncnt,N; PetscFunctionBegin; ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr); ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSTRING,&isstring);CHKERRQ(ierr); if (iascii) { ierr = MPI_Allreduce(&red->dcnt,&ncnt,1,MPIU_INT,MPI_SUM,((PetscObject)pc)->comm);CHKERRQ(ierr); ierr = MatGetSize(pc->pmat,&N,PETSC_NULL);CHKERRQ(ierr); ierr = PetscViewerASCIIPrintf(viewer," Number rows eliminated %D Percentage rows eliminated %g\n",ncnt,100.0*((PetscReal)ncnt)/((PetscReal)N));CHKERRQ(ierr); ierr = PetscViewerASCIIPrintf(viewer," Redistribute preconditioner: \n");CHKERRQ(ierr); ierr = KSPView(red->ksp,viewer);CHKERRQ(ierr); } else if (isstring) { ierr = PetscViewerStringSPrintf(viewer," Redistribute preconditioner");CHKERRQ(ierr); ierr = KSPView(red->ksp,viewer);CHKERRQ(ierr); } else SETERRQ1(((PetscObject)pc)->comm,PETSC_ERR_SUP,"Viewer type %s not supported for PC redistribute",((PetscObject)viewer)->type_name); PetscFunctionReturn(0); }
static PetscErrorCode PCView_LSC(PC pc,PetscViewer viewer) { PC_LSC *jac = (PC_LSC*)pc->data; PetscErrorCode ierr; PetscBool iascii; PetscFunctionBegin; ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr); if (iascii) { ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = KSPView(jac->kspL,viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); } PetscFunctionReturn(0); }
static PetscErrorCode KSPView_SpecEst(KSP ksp,PetscViewer viewer) { KSP_SpecEst *spec = (KSP_SpecEst*)ksp->data; PetscErrorCode ierr; PetscBool iascii; PetscFunctionBegin; ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr); if (iascii) { ierr = PetscViewerASCIIPrintf(viewer," SpecEst: last singular value estimate min=%G max=%G rad=%G\n",spec->min,spec->max,spec->radius);CHKERRQ(ierr); ierr = PetscViewerASCIIPrintf(viewer," Using scaling factors min=%G max=%G rich=%G\n",spec->minfactor,spec->maxfactor,spec->richfactor);CHKERRQ(ierr); ierr = PetscViewerASCIIPrintf(viewer," Sub KSP used for estimating spectrum:\n");CHKERRQ(ierr); ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = KSPView(spec->kspest,viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPrintf(viewer," Sub KSP used for subsequent smoothing steps:\n");CHKERRQ(ierr); ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = KSPView(spec->kspcheap,viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); } else { SETERRQ1(((PetscObject)ksp)->comm,PETSC_ERR_SUP,"Viewer type %s not supported for KSP cg",((PetscObject)viewer)->type_name); } PetscFunctionReturn(0); }
PetscErrorCode PCView_Exotic(PC pc,PetscViewer viewer) { PC_MG *mg = (PC_MG*)pc->data; PetscErrorCode ierr; PetscBool iascii; PC_Exotic *ctx = (PC_Exotic*) mg->innerctx; PetscFunctionBegin; ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii); CHKERRQ(ierr); if (iascii) { ierr = PetscViewerASCIIPrintf(viewer," Exotic type = %s\n",PCExoticTypes[ctx->type]); CHKERRQ(ierr); if (ctx->directSolve) { ierr = PetscViewerASCIIPrintf(viewer," Using direct solver to construct interpolation\n"); CHKERRQ(ierr); } else { PetscViewer sviewer; PetscMPIInt rank; ierr = PetscViewerASCIIPrintf(viewer," Using iterative solver to construct interpolation\n"); CHKERRQ(ierr); ierr = PetscViewerASCIIPushTab(viewer); CHKERRQ(ierr); ierr = PetscViewerASCIIPushTab(viewer); CHKERRQ(ierr); /* should not need to push this twice? */ ierr = PetscViewerGetSubViewer(viewer,PETSC_COMM_SELF,&sviewer); CHKERRQ(ierr); ierr = MPI_Comm_rank(PetscObjectComm((PetscObject)pc),&rank); CHKERRQ(ierr); if (!rank) { ierr = KSPView(ctx->ksp,sviewer); CHKERRQ(ierr); } ierr = PetscViewerRestoreSubViewer(viewer,PETSC_COMM_SELF,&sviewer); CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer); CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer); CHKERRQ(ierr); } } ierr = PCView_MG(pc,viewer); CHKERRQ(ierr); PetscFunctionReturn(0); }
PetscErrorCode BSSCR_PCView_ScGtKG( PC pc, PetscViewer viewer ) { PC_SC_GtKG ctx = (PC_SC_GtKG)pc->data; PetscViewerASCIIPushTab(viewer); //1 PetscViewerASCIIPrintf( viewer, "gtkg-ksp \n" ); PetscViewerASCIIPrintf(viewer,"---------------------------------\n"); PetscViewerASCIIPushTab(viewer); KSPView( ctx->ksp_BBt, viewer ); PetscViewerASCIIPopTab(viewer); PetscViewerASCIIPrintf(viewer,"---------------------------------\n"); PetscViewerASCIIPopTab(viewer); //1 PetscFunctionReturn(0); }
PetscErrorCode BSSCR_PCView_GtKG( PC pc, PetscViewer viewer ) { PC_GtKG ctx = (PC_GtKG)pc->data; PetscViewerASCIIPushTab(viewer); //1 if( ctx->M == PETSC_NULL ) { PetscViewerASCIIPrintf( viewer, "gtkg: Standard \n" ); }else { PetscViewerASCIIPrintf( viewer, "gtkg: Least Squares Commutator \n" ); } PetscViewerASCIIPrintf( viewer, "gtkg-ksp \n" ); PetscViewerASCIIPrintf(viewer,"---------------------------------\n"); PetscViewerASCIIPushTab(viewer); KSPView( ctx->ksp, viewer ); PetscViewerASCIIPopTab(viewer); PetscViewerASCIIPrintf(viewer,"---------------------------------\n"); PetscViewerASCIIPopTab(viewer); //1 PetscFunctionReturn(0); }
static PetscErrorCode PCView_KSP(PC pc,PetscViewer viewer) { PC_KSP *jac = (PC_KSP*)pc->data; PetscErrorCode ierr; PetscBool iascii; PetscFunctionBegin; if (!jac->ksp) {ierr = PCKSPCreateKSP_KSP(pc);CHKERRQ(ierr);} ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr); if (iascii) { if (pc->useAmat) { ierr = PetscViewerASCIIPrintf(viewer," Using Amat (not Pmat) as operator on inner solve\n");CHKERRQ(ierr); } ierr = PetscViewerASCIIPrintf(viewer," KSP and PC on KSP preconditioner follow\n");CHKERRQ(ierr); ierr = PetscViewerASCIIPrintf(viewer," ---------------------------------\n");CHKERRQ(ierr); } ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = KSPView(jac->ksp,viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); if (iascii) { ierr = PetscViewerASCIIPrintf(viewer," ---------------------------------\n");CHKERRQ(ierr); } PetscFunctionReturn(0); }
PetscErrorCode PCView_MG(PC pc,PetscViewer viewer) { PC_MG *mg = (PC_MG*)pc->data; PC_MG_Levels **mglevels = mg->levels; PetscErrorCode ierr; PetscInt levels = mglevels ? mglevels[0]->levels : 0,i; PetscBool iascii,isbinary,isdraw; PetscFunctionBegin; ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);CHKERRQ(ierr); ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERBINARY,&isbinary);CHKERRQ(ierr); ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERDRAW,&isdraw);CHKERRQ(ierr); if (iascii) { const char *cyclename = levels ? (mglevels[0]->cycles == PC_MG_CYCLE_V ? "v" : "w") : "unknown"; ierr = PetscViewerASCIIPrintf(viewer," MG: type is %s, levels=%D cycles=%s\n", PCMGTypes[mg->am],levels,cyclename);CHKERRQ(ierr); if (mg->am == PC_MG_MULTIPLICATIVE) { ierr = PetscViewerASCIIPrintf(viewer," Cycles per PCApply=%d\n",mg->cyclesperpcapply);CHKERRQ(ierr); } if (mg->galerkin) { ierr = PetscViewerASCIIPrintf(viewer," Using Galerkin computed coarse grid matrices\n");CHKERRQ(ierr); } else { ierr = PetscViewerASCIIPrintf(viewer," Not using Galerkin computed coarse grid matrices\n");CHKERRQ(ierr); } if (mg->view){ ierr = (*mg->view)(pc,viewer);CHKERRQ(ierr); } for (i=0; i<levels; i++) { if (!i) { ierr = PetscViewerASCIIPrintf(viewer,"Coarse grid solver -- level -------------------------------\n",i);CHKERRQ(ierr); } else { ierr = PetscViewerASCIIPrintf(viewer,"Down solver (pre-smoother) on level %D -------------------------------\n",i);CHKERRQ(ierr); } ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = KSPView(mglevels[i]->smoothd,viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); if (i && mglevels[i]->smoothd == mglevels[i]->smoothu) { ierr = PetscViewerASCIIPrintf(viewer,"Up solver (post-smoother) same as down solver (pre-smoother)\n");CHKERRQ(ierr); } else if (i) { ierr = PetscViewerASCIIPrintf(viewer,"Up solver (post-smoother) on level %D -------------------------------\n",i);CHKERRQ(ierr); ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr); ierr = KSPView(mglevels[i]->smoothu,viewer);CHKERRQ(ierr); ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr); } } } else if (isbinary) { for (i=levels-1; i>=0; i--) { ierr = KSPView(mglevels[i]->smoothd,viewer);CHKERRQ(ierr); if (i && mglevels[i]->smoothd != mglevels[i]->smoothu) { ierr = KSPView(mglevels[i]->smoothu,viewer);CHKERRQ(ierr); } } } else if (isdraw) { PetscDraw draw; PetscReal x,w,y,bottom,th; ierr = PetscViewerDrawGetDraw(viewer,0,&draw);CHKERRQ(ierr); ierr = PetscDrawGetCurrentPoint(draw,&x,&y);CHKERRQ(ierr); ierr = PetscDrawStringGetSize(draw,NULL,&th);CHKERRQ(ierr); bottom = y - th; for (i=levels-1; i>=0; i--) { if (!mglevels[i]->smoothu || (mglevels[i]->smoothu == mglevels[i]->smoothd)) { ierr = PetscDrawPushCurrentPoint(draw,x,bottom);CHKERRQ(ierr); ierr = KSPView(mglevels[i]->smoothd,viewer);CHKERRQ(ierr); ierr = PetscDrawPopCurrentPoint(draw);CHKERRQ(ierr); } else { w = 0.5*PetscMin(1.0-x,x); ierr = PetscDrawPushCurrentPoint(draw,x+w,bottom);CHKERRQ(ierr); ierr = KSPView(mglevels[i]->smoothd,viewer);CHKERRQ(ierr); ierr = PetscDrawPopCurrentPoint(draw);CHKERRQ(ierr); ierr = PetscDrawPushCurrentPoint(draw,x-w,bottom);CHKERRQ(ierr); ierr = KSPView(mglevels[i]->smoothu,viewer);CHKERRQ(ierr); ierr = PetscDrawPopCurrentPoint(draw);CHKERRQ(ierr); } ierr = PetscDrawGetBoundingBox(draw,NULL,&bottom,NULL,NULL);CHKERRQ(ierr); bottom -= th; } } PetscFunctionReturn(0); }
int main(int argc,char **args) { Vec x,b,u; /* approx solution, RHS, exact solution */ Mat A; /* linear system matrix */ KSP ksp; /* KSP context */ PetscErrorCode ierr; PetscInt n = 10,its, dim,p = 1,use_random; PetscScalar none = -1.0,pfive = 0.5; PetscReal norm; PetscRandom rctx; TestType type; PetscBool flg; PetscInitialize(&argc,&args,(char *)0,help); ierr = PetscOptionsGetInt(PETSC_NULL,"-n",&n,PETSC_NULL);CHKERRQ(ierr); ierr = PetscOptionsGetInt(PETSC_NULL,"-p",&p,PETSC_NULL);CHKERRQ(ierr); switch (p) { case 1: type = TEST_1; dim = n; break; case 2: type = TEST_2; dim = n; break; case 3: type = TEST_3; dim = n; break; case 4: type = HELMHOLTZ_1; dim = n*n; break; case 5: type = HELMHOLTZ_2; dim = n*n; break; default: type = TEST_1; dim = n; } /* Create vectors */ ierr = VecCreate(PETSC_COMM_WORLD,&x);CHKERRQ(ierr); ierr = VecSetSizes(x,PETSC_DECIDE,dim);CHKERRQ(ierr); ierr = VecSetFromOptions(x);CHKERRQ(ierr); ierr = VecDuplicate(x,&b);CHKERRQ(ierr); ierr = VecDuplicate(x,&u);CHKERRQ(ierr); use_random = 1; flg = PETSC_FALSE; ierr = PetscOptionsGetBool(PETSC_NULL,"-norandom",&flg,PETSC_NULL);CHKERRQ(ierr); if (flg) { use_random = 0; ierr = VecSet(u,pfive);CHKERRQ(ierr); } else { ierr = PetscRandomCreate(PETSC_COMM_WORLD,&rctx);CHKERRQ(ierr); ierr = PetscRandomSetFromOptions(rctx);CHKERRQ(ierr); ierr = VecSetRandom(u,rctx);CHKERRQ(ierr); } /* Create and assemble matrix */ ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr); ierr = MatSetSizes(A,PETSC_DECIDE,PETSC_DECIDE,dim,dim);CHKERRQ(ierr); ierr = MatSetFromOptions(A);CHKERRQ(ierr); ierr = MatSetUp(A);CHKERRQ(ierr); ierr = FormTestMatrix(A,n,type);CHKERRQ(ierr); ierr = MatMult(A,u,b);CHKERRQ(ierr); flg = PETSC_FALSE; ierr = PetscOptionsGetBool(PETSC_NULL,"-printout",&flg,PETSC_NULL);CHKERRQ(ierr); if (flg) { ierr = MatView(A,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr); ierr = VecView(u,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr); ierr = VecView(b,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr); } /* Create KSP context; set operators and options; solve linear system */ ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);CHKERRQ(ierr); ierr = KSPSetOperators(ksp,A,A,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr); ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr); ierr = KSPSolve(ksp,b,x);CHKERRQ(ierr); ierr = KSPView(ksp,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr); /* Check error */ ierr = VecAXPY(x,none,u);CHKERRQ(ierr); ierr = VecNorm(x,NORM_2,&norm);CHKERRQ(ierr); ierr = KSPGetIterationNumber(ksp,&its);CHKERRQ(ierr); ierr = PetscPrintf(PETSC_COMM_WORLD,"Norm of error %G,Iterations %D\n",norm,its);CHKERRQ(ierr); /* Free work space */ ierr = VecDestroy(&x);CHKERRQ(ierr); ierr = VecDestroy(&u);CHKERRQ(ierr); ierr = VecDestroy(&b);CHKERRQ(ierr); ierr = MatDestroy(&A);CHKERRQ(ierr); if (use_random) {ierr = PetscRandomDestroy(&rctx);CHKERRQ(ierr);} ierr = KSPDestroy(&ksp);CHKERRQ(ierr); ierr = PetscFinalize(); return 0; }
int TaoLinearSolverPetsc::View(){ int info; PetscFunctionBegin; info=KSPView(this->ksp,this->pkspviewer);CHKERRQ(info); PetscFunctionReturn(0); }
static int TaoSolve_BNLS(TAO_SOLVER tao, void*solver){ TAO_BNLS *bnls = (TAO_BNLS *)solver; int info; TaoInt lsflag,iter=0; TaoTerminateReason reason=TAO_CONTINUE_ITERATING; double f,f_full,gnorm,gdx,stepsize=1.0; TaoTruth success; TaoVec *XU, *XL; TaoVec *X, *G=bnls->G, *PG=bnls->PG; TaoVec *R=bnls->R, *DXFree=bnls->DXFree; TaoVec *DX=bnls->DX, *Work=bnls->Work; TaoMat *H, *Hsub=bnls->Hsub; TaoIndexSet *FreeVariables = bnls->FreeVariables; TaoFunctionBegin; /* Check if upper bound greater than lower bound. */ info = TaoGetSolution(tao,&X);CHKERRQ(info); bnls->X=X; info = TaoGetVariableBounds(tao,&XL,&XU);CHKERRQ(info); info = TaoEvaluateVariableBounds(tao,XL,XU); CHKERRQ(info); info = TaoGetHessian(tao,&H);CHKERRQ(info); bnls->H=H; /* Project the current point onto the feasible set */ info = X->Median(XL,X,XU); CHKERRQ(info); TaoLinearSolver *tls; // Modify the linear solver to a conjugate gradient method info = TaoGetLinearSolver(tao, &tls); CHKERRQ(info); TaoLinearSolverPetsc *pls; pls = dynamic_cast <TaoLinearSolverPetsc *> (tls); // set trust radius to zero // PETSc ignores this case and should return the negative curvature direction // at its current default length pls->SetTrustRadius(0.0); if(!bnls->M) bnls->M = new TaoLMVMMat(X); TaoLMVMMat *M = bnls->M; KSP pksp = pls->GetKSP(); // we will want to provide an initial guess in case neg curvature on the first iteration info = KSPSetInitialGuessNonzero(pksp,PETSC_TRUE); CHKERRQ(info); PC ppc; // Modify the preconditioner to use the bfgs approximation info = KSPGetPC(pksp, &ppc); CHKERRQ(info); PetscTruth BFGSPreconditioner=PETSC_FALSE;// debug flag info = PetscOptionsGetTruth(PETSC_NULL,"-bnls_pc_bfgs", &BFGSPreconditioner,PETSC_NULL); CHKERRQ(info); if( BFGSPreconditioner) { info=PetscInfo(tao,"TaoSolve_BNLS: using bfgs preconditioner\n"); info = KSPSetNormType(pksp, KSP_NORM_PRECONDITIONED); CHKERRQ(info); info = PCSetType(ppc, PCSHELL); CHKERRQ(info); info = PCShellSetName(ppc, "bfgs"); CHKERRQ(info); info = PCShellSetContext(ppc, M); CHKERRQ(info); info = PCShellSetApply(ppc, bfgs_apply); CHKERRQ(info); } else {// default to none info=PetscInfo(tao,"TaoSolve_BNLS: using no preconditioner\n"); info = PCSetType(ppc, PCNONE); CHKERRQ(info); } info = TaoComputeMeritFunctionGradient(tao,X,&f,G);CHKERRQ(info); info = PG->BoundGradientProjection(G,XL,X,XU);CHKERRQ(info); info = PG->Norm2(&gnorm); CHKERRQ(info); // Set initial scaling for the function if (f != 0.0) { info = M->SetDelta(2.0 * TaoAbsDouble(f) / (gnorm*gnorm)); CHKERRQ(info); } else { info = M->SetDelta(2.0 / (gnorm*gnorm)); CHKERRQ(info); } while (reason==TAO_CONTINUE_ITERATING){ /* Project the gradient and calculate the norm */ info = PG->BoundGradientProjection(G,XL,X,XU);CHKERRQ(info); info = PG->Norm2(&gnorm); CHKERRQ(info); info = M->Update(X, PG); CHKERRQ(info); PetscScalar ewAtol = PetscMin(0.5,gnorm)*gnorm; info = KSPSetTolerances(pksp,PETSC_DEFAULT,ewAtol, PETSC_DEFAULT, PETSC_DEFAULT); CHKERRQ(info); info=PetscInfo1(tao,"TaoSolve_BNLS: gnorm =%g\n",gnorm); pksp->printreason = PETSC_TRUE; info = KSPView(pksp,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(info); M->View(); info = TaoMonitor(tao,iter++,f,gnorm,0.0,stepsize,&reason); CHKERRQ(info); if (reason!=TAO_CONTINUE_ITERATING) break; info = FreeVariables->WhichEqual(PG,G); CHKERRQ(info); info = TaoComputeHessian(tao,X,H);CHKERRQ(info); /* Create a reduced linear system */ info = R->SetReducedVec(G,FreeVariables);CHKERRQ(info); info = R->Negate();CHKERRQ(info); /* Use gradient as initial guess */ PetscTruth UseGradientIG=PETSC_FALSE;// debug flag info = PetscOptionsGetTruth(PETSC_NULL,"-bnls_use_gradient_ig", &UseGradientIG,PETSC_NULL); CHKERRQ(info); if(UseGradientIG) info = DX->CopyFrom(G); else { info=PetscInfo(tao,"TaoSolve_BNLS: use bfgs init guess \n"); info = M->Solve(G, DX, &success); } CHKERRQ(info); info = DXFree->SetReducedVec(DX,FreeVariables);CHKERRQ(info); info = DXFree->Negate(); CHKERRQ(info); info = Hsub->SetReducedMatrix(H,FreeVariables,FreeVariables);CHKERRQ(info); bnls->gamma_factor /= 2; success = TAO_FALSE; while (success==TAO_FALSE) { /* Approximately solve the reduced linear system */ info = TaoPreLinearSolve(tao,Hsub);CHKERRQ(info); info = TaoLinearSolve(tao,Hsub,R,DXFree,&success);CHKERRQ(info); info = DX->SetToZero(); CHKERRQ(info); info = DX->ReducedXPY(DXFree,FreeVariables);CHKERRQ(info); info = DX->Dot(G,&gdx); CHKERRQ(info); if (gdx>=0 || success==TAO_FALSE) { /* use bfgs direction */ info = M->Solve(G, DX, &success); CHKERRQ(info); info = DX->BoundGradientProjection(DX,XL,X,XU); CHKERRQ(info); info = DX->Negate(); CHKERRQ(info); // Check for success (descent direction) info = DX->Dot(G,&gdx); CHKERRQ(info); if (gdx >= 0) { // Step is not descent or solve was not successful // Use steepest descent direction (scaled) if (f != 0.0) { info = M->SetDelta(2.0 * TaoAbsDouble(f) / (gnorm*gnorm)); CHKERRQ(info); } else { info = M->SetDelta(2.0 / (gnorm*gnorm)); CHKERRQ(info); } info = M->Reset(); CHKERRQ(info); info = M->Update(X, G); CHKERRQ(info); info = DX->CopyFrom(G); info = DX->Negate(); CHKERRQ(info); info = DX->Dot(G,&gdx); CHKERRQ(info); info=PetscInfo1(tao,"LMVM Solve Fail use steepest descent, gdx %22.12e \n",gdx); } else { info=PetscInfo1(tao,"Newton Solve Fail use BFGS direction, gdx %22.12e \n",gdx); } success = TAO_TRUE; // bnls->gamma_factor *= 2; // bnls->gamma = bnls->gamma_factor*(gnorm); //#if !defined(PETSC_USE_COMPLEX) // info=PetscInfo2(tao,"TaoSolve_NLS: modify diagonal (assume same nonzero structure), gamma_factor=%g, gamma=%g\n",bnls->gamma_factor,bnls->gamma); // CHKERRQ(info); //#else // info=PetscInfo3(tao,"TaoSolve_NLS: modify diagonal (asuume same nonzero structure), gamma_factor=%g, gamma=%g, gdx %22.12e \n", // bnls->gamma_factor,PetscReal(bnls->gamma),gdx);CHKERRQ(info); //#endif // info = Hsub->ShiftDiagonal(bnls->gamma);CHKERRQ(info); // if (f != 0.0) { // info = M->SetDelta(2.0 * TaoAbsDouble(f) / (gnorm*gnorm)); CHKERRQ(info); // } // else { // info = M->SetDelta(2.0 / (gnorm*gnorm)); CHKERRQ(info); // } // info = M->Reset(); CHKERRQ(info); // info = M->Update(X, G); CHKERRQ(info); // success = TAO_FALSE; } else { info=PetscInfo1(tao,"Newton Solve is descent direction, gdx %22.12e \n",gdx); success = TAO_TRUE; } } stepsize=1.0; info = TaoLineSearchApply(tao,X,G,DX,Work, &f,&f_full,&stepsize,&lsflag); CHKERRQ(info); } /* END MAIN LOOP */ TaoFunctionReturn(0); }
int main(int argc,char **args) { Vec x, b, u; /* approx solution, RHS, exact solution */ Mat A; /* linear system matrix */ KSP ksp; /* linear solver context */ PC pc; /* preconditioner context */ PetscReal norm; /* norm of solution error */ PetscErrorCode ierr; PetscInt i,n = 10,col[3],its; PetscMPIInt size; PetscScalar one = 1.0,value[3]; PetscBool nonzeroguess = PETSC_FALSE; ierr = PetscInitialize(&argc,&args,(char*)0,help);if (ierr) return ierr; 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(NULL,NULL,"-n",&n,NULL);CHKERRQ(ierr); ierr = PetscOptionsGetBool(NULL,NULL,"-nonzero_guess",&nonzeroguess,NULL);CHKERRQ(ierr); /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Compute the matrix and right-hand-side vector that define the linear system, Ax = b. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* Create vectors. Note that we form 1 vector from scratch and then duplicate as needed. */ ierr = VecCreate(PETSC_COMM_WORLD,&x);CHKERRQ(ierr); ierr = PetscObjectSetName((PetscObject) x, "Solution");CHKERRQ(ierr); ierr = VecSetSizes(x,PETSC_DECIDE,n);CHKERRQ(ierr); ierr = VecSetFromOptions(x);CHKERRQ(ierr); ierr = VecDuplicate(x,&b);CHKERRQ(ierr); ierr = VecDuplicate(x,&u);CHKERRQ(ierr); /* Create matrix. When using MatCreate(), the matrix format can be specified at runtime. Performance tuning note: For problems of substantial size, preallocation of matrix memory is crucial for attaining good performance. See the matrix chapter of the users manual for details. */ ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr); ierr = MatSetSizes(A,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr); ierr = MatSetFromOptions(A);CHKERRQ(ierr); ierr = MatSetUp(A);CHKERRQ(ierr); /* Assemble 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); } i = n - 1; col[0] = n - 2; col[1] = n - 1; ierr = MatSetValues(A,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr); i = 0; col[0] = 0; col[1] = 1; value[0] = 2.0; value[1] = -1.0; ierr = MatSetValues(A,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr); ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); /* Set exact solution; then compute right-hand-side vector. */ ierr = VecSet(u,one);CHKERRQ(ierr); ierr = MatMult(A,u,b);CHKERRQ(ierr); /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Create the linear solver and set various options - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* Create linear solver context */ ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);CHKERRQ(ierr); /* Set operators. Here the matrix that defines the linear system also serves as the preconditioning matrix. */ ierr = KSPSetOperators(ksp,A,A);CHKERRQ(ierr); /* Set linear solver defaults for this problem (optional). - By extracting the KSP and PC contexts from the KSP context, we can then directly call any KSP and PC routines to set various options. - The following four statements are optional; all of these parameters could alternatively be specified at runtime via KSPSetFromOptions(); */ ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr); ierr = PCSetType(pc,PCJACOBI);CHKERRQ(ierr); ierr = KSPSetTolerances(ksp,1.e-5,PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT);CHKERRQ(ierr); /* Set runtime options, e.g., -ksp_type <type> -pc_type <type> -ksp_monitor -ksp_rtol <rtol> These options will override those specified above as long as KSPSetFromOptions() is called _after_ any other customization routines. */ ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr); if (nonzeroguess) { PetscScalar p = .5; ierr = VecSet(x,p);CHKERRQ(ierr); ierr = KSPSetInitialGuessNonzero(ksp,PETSC_TRUE);CHKERRQ(ierr); } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Solve the linear system - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* Solve linear system */ ierr = KSPSolve(ksp,b,x);CHKERRQ(ierr); /* View solver info; we could instead use the option -ksp_view to print this info to the screen at the conclusion of KSPSolve(). */ ierr = KSPView(ksp,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr); /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Check solution and clean up - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* Check the error */ ierr = VecAXPY(x,-1.0,u);CHKERRQ(ierr); ierr = VecNorm(x,NORM_2,&norm);CHKERRQ(ierr); ierr = KSPGetIterationNumber(ksp,&its);CHKERRQ(ierr); ierr = PetscPrintf(PETSC_COMM_WORLD,"Norm of error %g, Iterations %D\n",(double)norm,its);CHKERRQ(ierr); /* Free work space. All PETSc objects should be destroyed when they are no longer needed. */ ierr = VecDestroy(&x);CHKERRQ(ierr); ierr = VecDestroy(&u);CHKERRQ(ierr); ierr = VecDestroy(&b);CHKERRQ(ierr); ierr = MatDestroy(&A);CHKERRQ(ierr); ierr = KSPDestroy(&ksp);CHKERRQ(ierr); /* Always call PetscFinalize() before exiting a program. This routine - finalizes the PETSc libraries as well as MPI - provides summary and diagnostic information if certain runtime options are chosen (e.g., -log_view). */ ierr = PetscFinalize(); return ierr; }
int main(int argc,char **args) { Mat A; /* linear system matrix */ PetscErrorCode ierr; PetscMPIInt rank=0; PetscBool flg; PetscViewer fd; /* viewer */ PetscViewer log; char file[PETSC_MAX_PATH_LEN]; char logfile[PETSC_MAX_PATH_LEN]; char lockfile[PETSC_MAX_PATH_LEN], tmpstr[PETSC_MAX_PATH_LEN], dirname[PETSC_MAX_PATH_LEN], matrix[PETSC_MAX_PATH_LEN]; char hash[20]; PetscLogDouble solveTime,endTime,startTime; PetscInt its; PetscReal norm; KSP ksp; // Linear solver context Vec b,x,u; // RHS, solution, vector for norm calculation PetscScalar one = 1.0; PetscInt m, n, i; FILE *lock; /* if (rank == 0) { printf("Command line arguments:\n"); for (i=0; i < argc; i++) printf("%d: %s\n", i, args[i]); } // Save args int argcount = argc; char **argv = (char**) malloc (argc*sizeof(char*)); for (i=0; i < argc; i++) { argv[i] = (char*) malloc(strlen(args[i]) + 1); strcpy(argv[i],args[i]); } MPI_Comm_rank(MPI_COMM_WORLD,&rank); */ PetscInitialize(&argc,&args,(char *)0,help); ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr); ierr = PetscOptionsGetString(PETSC_NULL,"-hash",hash,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr); if (!flg) { strcpy(hash,"nohash"); } ierr = PetscOptionsGetString(PETSC_NULL,"-f",file,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr); if (!flg) { PetscPrintf(PETSC_COMM_WORLD,"Must indicate matrix file with the -f option"); } /* Create lock file */ if (rank == 0) { for (i = strlen(file); i> 0; i--) if (file[i] == '.') break; strncpy(tmpstr, file, i-1); for (i = strlen(tmpstr); i> 0; i--) if (file[i] == '/') break; strncpy(dirname, tmpstr, i); dirname[i] = '\0'; sprintf(lockfile,"%s/../timing/.%s.%s", dirname, basename(tmpstr), hash); sprintf(logfile,"%s/../timing/%s.%s.log", dirname, basename(tmpstr), hash); lock = fopen(lockfile, "w"); fprintf(lock, "%s\n", file); fclose(lock); } /* Read file */ ierr = PetscViewerBinaryOpen(PETSC_COMM_WORLD,file,FILE_MODE_READ,&fd);CHKERRQ(ierr); // Create matrix ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr); ierr = MatSetType(A,MATMPIAIJ); CHKERRQ(ierr); ierr = MatSetFromOptions(A);CHKERRQ(ierr); // Load matrix from file ierr = MatLoad(A,fd);CHKERRQ(ierr); ierr = PetscViewerDestroy(&fd);CHKERRQ(ierr); ierr = MatGetSize(A, &m, &n); CHKERRQ(ierr); // Assemble matrix //ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); //ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); // Create RHS vector ierr = VecCreate(PETSC_COMM_WORLD,&b);CHKERRQ(ierr); ierr = VecSetSizes(b,PETSC_DECIDE,n); CHKERRQ(ierr); ierr = VecSetFromOptions(b);CHKERRQ(ierr); ierr = VecSet(b,one); CHKERRQ(ierr); //ierr = VecLoad(b,fd);CHKERRQ(ierr); // Create vectors x and u ierr = VecDuplicate(b,&x);CHKERRQ(ierr); ierr = VecDuplicate(b,&u);CHKERRQ(ierr); // Create KSP ierr = KSPCreate(PETSC_COMM_WORLD,&ksp); CHKERRQ(ierr); ierr = KSPSetInitialGuessNonzero(ksp,PETSC_FALSE);CHKERRQ(ierr); ierr = KSPSetOperators(ksp,A,A);CHKERRQ(ierr); ierr = KSPSetFromOptions(ksp); CHKERRQ(ierr); // Setup KSP ierr = KSPSetUp(ksp);CHKERRQ(ierr); ierr = KSPSetUpOnBlocks(ksp);CHKERRQ(ierr); // Get start time ierr = PetscTime(&startTime);CHKERRQ(ierr); // Get KSP and PC type KSPType kt; ierr = KSPGetType(ksp,&kt); PC pc; ierr = KSPGetPC(ksp,&pc); PCType pt; ierr = PCGetType(pc,&pt); // Print method info ierr = PetscViewerASCIIOpen(PETSC_COMM_WORLD, logfile, &log); CHKERRQ(ierr); ierr = PetscViewerASCIIPrintf(log, "Hash: %s\n", hash); ierr = PetscViewerASCIIPrintf(log, "%s | %s",kt,pt);CHKERRQ(ierr); // Make sure the program doesn't crash // while trying to solve the system PetscPushErrorHandler(PetscIgnoreErrorHandler,NULL); ierr = KSPSolve(ksp,b,x); PetscPopErrorHandler(); // Check if anything went wrong if(ierr == 0 || ierr == -1){ // If no error occurred or stopped by MyKSPMonitor, // compute normal and stuff ierr = KSPGetIterationNumber(ksp,&its);CHKERRQ(ierr); ierr = MatMult(A,x,u);CHKERRQ(ierr); ierr = VecAXPY(u,-1.0,b);CHKERRQ(ierr); ierr = VecNorm(u,NORM_2,&norm);CHKERRQ(ierr); ierr = PetscTime(&endTime);CHKERRQ(ierr); // Compute solve time solveTime = endTime - startTime; // Check if KSP converged KSPConvergedReason reason; KSPGetConvergedReason(ksp,&reason); // Print convergence code, solve time, preconditioned norm, iterations ierr = PetscViewerASCIIPrintf(log, " | %D | %e | %g | %D\n",reason,solveTime,norm,its);CHKERRQ(ierr); ierr = KSPView(ksp,log); ierr = PCView(pc,log); ierr = PetscLogView(log); } else{ // Disaster happened, bail out if (rank == 0) remove(lockfile); PetscFinalize(); return 0; } // Again, destroy KSP and vector ierr = KSPDestroy(&ksp);CHKERRQ(ierr); ierr = VecDestroy(&x);CHKERRQ(ierr); ierr = VecDestroy(&b);CHKERRQ(ierr); ierr = VecDestroy(&u);CHKERRQ(ierr); if (rank == 0) remove(lockfile); PetscFinalize(); return 0; }
int main(int argc,char **args){ PetscErrorCode ierr; PetscInitialize(&argc,&args,0,help); MPI_Comm comm=MPI_COMM_WORLD; PetscMPIInt rank,size; ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr); ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr); // ------------------------------------------------------------------- PetscOptionsGetInt (NULL, "-vtk_order",&VTK_ORDER ,NULL); PetscOptionsGetInt (NULL, "-dof",&INPUT_DOF ,NULL); PetscOptionsGetReal(NULL, "-scal",& SCAL_EXP ,NULL); PetscOptionsGetBool(NULL, "-periodic",& PERIODIC ,NULL); PetscOptionsGetBool(NULL, "-tree",& TREE_ONLY ,NULL); PetscOptionsGetInt (NULL, "-max_depth" ,&MAXDEPTH ,NULL); PetscOptionsGetInt (NULL, "-min_depth" ,&MINDEPTH ,NULL); PetscOptionsGetReal(NULL, "-ref_tol" ,& TOL ,NULL); PetscOptionsGetReal(NULL, "-gmres_tol" ,&GMRES_TOL ,NULL); PetscOptionsGetInt (NULL, "-fmm_q" ,& CHEB_DEG ,NULL); PetscOptionsGetInt (NULL, "-fmm_m" ,&MUL_ORDER ,NULL); PetscOptionsGetInt (NULL, "-gmres_iter",& MAX_ITER ,NULL); PetscOptionsGetReal(NULL, "-eta" ,& eta_ ,NULL); // ------------------------------------------------------------------- { /* ------------------------------------------------------------------- Compute the matrix and right-hand-side vector that define the linear system, Ax = b. ------------------------------------------------------------------- */ // Initialize FMM FMMData fmm_data; FMM_Init(comm, &fmm_data); std::cout << "Can you HERE me now" << std::endl; if(TREE_ONLY){ pvfmm::Profile::print(&comm); ierr = PetscFinalize(); return 0; } eval_function_at_nodes(&fmm_data, eta, fmm_data.eta); PetscInt m,n, M,N,l,L; m=fmm_data.m; // local rows n=fmm_data.n; // local columns M=fmm_data.M; // global rows N=fmm_data.N; // global columns l=fmm_data.l; // local values at cheb nodes in cubes (the above are coeff numbers) L=fmm_data.L; // global values at cheb nodes in cubes Vec pt_sources,eta_comp,phi_0,phi_0_val,eta_val,phi; { // Create vectors VecCreateMPI(comm,n,PETSC_DETERMINE,&pt_sources); VecCreateMPI(comm,l,PETSC_DETERMINE,&phi_0_val); // vec of values at each cube VecCreateMPI(comm,l,PETSC_DETERMINE,&eta_val); // vec of values at each cube VecCreateMPI(comm,m,PETSC_DETERMINE,&phi_0); // b=G[f] // vec of the cheb coeffs VecCreateMPI(comm,n,PETSC_DETERMINE,&eta_comp); // Ax=b VecCreateMPI(comm,m,PETSC_DETERMINE,&phi); } std::vector<PetscInt> idxs; std::vector<PetscScalar> eta_std_vec((int)L); idxs.reserve((int)L); //std::iota(idxs.begin(), idxs.end(), 0); for(int i=0;i<(int)L;i++){ idxs.push_back(i); eta_std_vec[i] = (PetscScalar)fmm_data.eta[i]; } ierr = VecSetValues(eta_val,L,idxs.data(),eta_std_vec.data(),INSERT_VALUES); CHKERRQ(ierr); // Seeing if the copy constructor works?? //FMM_Tree_t* eta_tree = fmm_data.tree; //std::cout << "here" << std::endl; //fmm_data.eta_tree->Write2File("results/eta_other",0); //PtWiseTreeMult(fmm_data,*fmm_data.eta_tree); //fmm_data.tree->Write2File("results/etatimespt_srces",0); VecAssemblyBegin(eta_val); VecAssemblyEnd(eta_val); //VecView(eta_val, PETSC_VIEWER_STDOUT_WORLD); fmm_data.eta_val = eta_val; pvfmm::Profile::Tic("Input_Vector_pt_sources",&comm,true); { // Create Input Vector. f tree2vec(fmm_data,pt_sources); fmm_data.tree->Write2File("results/pt_source",0); } pvfmm::Profile::Toc(); pvfmm::Profile::Tic("Input_Vector_phi_0",&comm,true); { // Compute phi_0(x) = \int G(x,y)fn_input(y)dy fmm_data.tree->SetupFMM(fmm_data.fmm_mat); fmm_data.tree->RunFMM(); fmm_data.tree->Copy_FMMOutput(); fmm_data.tree->Write2File("results/phi_0",0); tree2vec(fmm_data,phi_0); fmm_data.phi_0 = phi_0; eval_cheb_at_nodes(&fmm_data,phi_0_val); fmm_data.phi_0_vec = phi_0_val; } pvfmm::Profile::Toc(); pvfmm::Profile::Tic("FMMCreateShell",&comm,true); Mat A; { // Create Matrix. A FMMCreateShell(&fmm_data, &A); MatShellSetOperation(A,MATOP_MULT,(void(*)(void))mult); } pvfmm::Profile::Toc(); pvfmm::Profile::Tic("Phi",&comm,true); { // Compute phi(x) = phi_0(x) -\int G(x,y)eta(y)phi_0(y)dy CompPhiUsingBorn(phi, fmm_data); fmm_data.tree->Write2File("results/phi",0); // tree2vec(fmm_data,b); } pvfmm::Profile::Toc(); pvfmm::Profile::Tic("Right_hand_side",&comm,true); { // Compute phi_0(x) - phi(x) // After this block phi becomes the RHS ierr = VecAXPY(phi,-1,phi_0); CHKERRQ(ierr); vec2tree(phi,fmm_data); //fmm_data.tree->RunFMM(); //fmm_data.tree->Copy_FMMOutput(); fmm_data.tree->Write2File("results/rhs",0); // tree2vec(fmm_data,b); } pvfmm::Profile::Toc(); // Create solution vector pvfmm::Profile::Tic("Initial_Vector_eta_comp",&comm,true); ierr = VecDuplicate(pt_sources,&eta_comp);CHKERRQ(ierr); pvfmm::Profile::Toc(); // Create linear solver context pvfmm::Profile::Tic("KSPCreate",&comm,true); KSP ksp ; ierr = KSPCreate(PETSC_COMM_WORLD,&ksp );CHKERRQ(ierr); pvfmm::Profile::Toc(); // Set operators. Here the matrix that defines the linear system // also serves as the preconditioning matrix. pvfmm::Profile::Tic("KSPSetOperators",&comm,true); ierr = KSPSetOperators(ksp ,A ,A ,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr); pvfmm::Profile::Toc(); // Set runtime options KSPSetType(ksp ,KSPGMRES); KSPSetNormType(ksp , KSP_NORM_UNPRECONDITIONED); KSPSetTolerances(ksp ,GMRES_TOL ,PETSC_DEFAULT,PETSC_DEFAULT,MAX_ITER ); //KSPGMRESSetRestart(ksp , MAX_ITER ); KSPGMRESSetRestart(ksp , 100 ); ierr = KSPSetFromOptions(ksp );CHKERRQ(ierr); // ------------------------------------------------------------------- // Solve the linear system // ------------------------------------------------------------------- pvfmm::Profile::Tic("KSPSolve",&comm,true); time_ksp=-omp_get_wtime(); ierr = KSPSolve(ksp,phi,eta_comp);CHKERRQ(ierr); MPI_Barrier(comm); time_ksp+=omp_get_wtime(); pvfmm::Profile::Toc(); // View info about the solver KSPView(ksp,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr); // ------------------------------------------------------------------- // Check solution and clean up // ------------------------------------------------------------------- // Iterations PetscInt its; ierr = KSPGetIterationNumber(ksp,&its);CHKERRQ(ierr); ierr = PetscPrintf(PETSC_COMM_WORLD,"Iterations %D\n",its);CHKERRQ(ierr); iter_ksp=its; { // Write output vec2tree(eta_comp, fmm_data); fmm_data.tree->Write2File("results/eta_comp",VTK_ORDER); } // Free work space. All PETSc objects should be destroyed when they // are no longer needed. ierr = KSPDestroy(&ksp);CHKERRQ(ierr); ierr = VecDestroy(&eta_comp);CHKERRQ(ierr); ierr = VecDestroy(&phi_0);CHKERRQ(ierr); ierr = MatDestroy(&A);CHKERRQ(ierr); // Delete fmm data FMMDestroy(&fmm_data); pvfmm::Profile::print(&comm); } ierr = PetscFinalize(); return 0; }
typename SolverLinearPetsc<T>::solve_return_type SolverLinearPetsc<T>::solve ( MatrixSparse<T> const& matrix_in, MatrixSparse<T> const& precond_in, Vector<T> & solution_in, Vector<T> const& rhs_in, const double tol, const unsigned int m_its, bool transpose ) { this->setWorldComm( matrix_in.comm() ); this->init (); MatrixPetsc<T> * matrix = const_cast<MatrixPetsc<T> *>( dynamic_cast<MatrixPetsc<T> const*>( &matrix_in ) ); MatrixPetsc<T> * precond = const_cast<MatrixPetsc<T> *>( dynamic_cast<MatrixPetsc<T> const*>( &precond_in ) ); VectorPetsc<T> * solution = dynamic_cast<VectorPetsc<T>*>( &solution_in ); VectorPetsc<T> * rhs = const_cast<VectorPetsc<T> *>( dynamic_cast<VectorPetsc<T> const*>( &rhs_in ) ); // We cast to pointers so we can be sure that they succeeded // by comparing the result against NULL. FEELPP_ASSERT( matrix != NULL ).error( "non petsc matrix structure" ); FEELPP_ASSERT( precond != NULL ).error( "non petsc matrix structure" ); FEELPP_ASSERT( solution != NULL ).error( "non petsc vector structure" ); FEELPP_ASSERT( rhs != NULL ).error( "non petsc vector structure" ); int ierr=0; int its=0; PetscReal final_resid=0.; // Close the matrices and vectors in case this wasn't already done. matrix->close (); precond->close (); solution->close (); rhs->close (); if ( !this->M_preconditioner && this->preconditionerType() == FIELDSPLIT_PRECOND ) matrix->updatePCFieldSplit( M_pc ); // // If matrix != precond, then this means we have specified a // // special preconditioner, so reset preconditioner type to PCMAT. // if (matrix != precond) // { // this->_preconditioner_type = USER_PRECOND; // this->set_petsc_preconditioner_type (); // } // 2.1.x & earlier style #if (PETSC_VERSION_MAJOR == 2) && (PETSC_VERSION_MINOR <= 1) // Set operators. The input matrix works as the preconditioning matrix ierr = SLESSetOperators( M_sles, matrix->mat(), precond->mat(), SAME_NONZERO_PATTERN ); CHKERRABORT( this->worldComm().globalComm(),ierr ); // Set the tolerances for the iterative solver. Use the user-supplied // tolerance for the relative residual & leave the others at default values. ierr = KSPSetTolerances ( M_ksp, this->rTolerance(), this->aTolerance(), this->dTolerance(), this->maxIterations() ); CHKERRABORT( this->worldComm().globalComm(),ierr ); // makes the default convergence test use || B*(b - A*(initial guess))|| // instead of || B*b ||. In the case of right preconditioner or if // KSPSetNormType(ksp,KSP_NORM_UNPRECONDIITONED) is used there is no B in // the above formula. UIRNorm is short for Use Initial Residual Norm. #if PETSC_VERSION_GREATER_OR_EQUAL_THAN(3,4,4) KSPConvergedDefaultSetUIRNorm( M_ksp ); #else KSPDefaultConvergedSetUIRNorm( M_ksp ); #endif // Solve the linear system ierr = SLESSolve ( M_sles, rhs->vec(), solution->vec(), &its ); CHKERRABORT( this->worldComm().globalComm(),ierr ); // Get the norm of the final residual to return to the user. ierr = KSPGetResidualNorm ( M_ksp, &final_resid ); CHKERRABORT( this->worldComm().globalComm(),ierr ); // 2.2.0 #elif (PETSC_VERSION_MAJOR == 2) && (PETSC_VERSION_MINOR == 2) && (PETSC_VERSION_SUBMINOR == 0) // Set operators. The input matrix works as the preconditioning matrix ierr = KSPSetOperators( M_ksp, matrix->mat(), precond->mat(), MatStructure::SAME_NONZERO_PATTERN ); CHKERRABORT( this->worldComm().globalComm(),ierr ); // Set the tolerances for the iterative solver. Use the user-supplied // tolerance for the relative residual & leave the others at default values. // Convergence is detected at iteration k if // ||r_k||_2 < max(rtol*||b||_2 , abstol) // where r_k is the residual vector and b is the right-hand side. Note that // it is the *maximum* of the two values, the larger of which will almost // always be rtol*||b||_2. ierr = KSPSetTolerances ( M_ksp, this->rTolerance(), this->aTolerance(), this->dTolerance(), this->maxIterations() ); CHKERRABORT( this->worldComm().globalComm(),ierr ); // Set the solution vector to use ierr = KSPSetSolution ( M_ksp, solution->vec() ); CHKERRABORT( this->worldComm().globalComm(),ierr ); // Set the RHS vector to use ierr = KSPSetRhs ( M_ksp, rhs->vec() ); CHKERRABORT( this->worldComm().globalComm(),ierr ); // makes the default convergence test use || B*(b - A*(initial guess))|| // instead of || B*b ||. In the case of right preconditioner or if // KSPSetNormType(ksp,KSP_NORM_UNPRECONDIITONED) is used there is no B in // the above formula. UIRNorm is short for Use Initial Residual Norm. #if PETSC_VERSION_GREATER_OR_EQUAL_THAN(3,4,4) KSPConvergedDefaultSetUIRNorm( M_ksp ); #else KSPDefaultConvergedSetUIRNorm( M_ksp ); #endif // Solve the linear system if ( transpose ) ierr = KSPSolveTranspose ( M_ksp ); else ierr = KSPSolve ( M_ksp ); CHKERRABORT( this->worldComm().globalComm(),ierr ); // Get the number of iterations required for convergence ierr = KSPGetIterationNumber ( M_ksp, &its ); CHKERRABORT( this->worldComm().globalComm(),ierr ); // Get the norm of the final residual to return to the user. ierr = KSPGetResidualNorm ( M_ksp, &final_resid ); CHKERRABORT( this->worldComm().globalComm(),ierr ); // 2.2.1 & newer style #else //std::cout << "sles: " << this->precMatrixStructure() << "\n"; // Set operators. The input matrix works as the preconditioning matrix #if PETSC_VERSION_LESS_THAN(3,5,0) ierr = KSPSetOperators( M_ksp, matrix->mat(), precond->mat(), PetscGetMatStructureEnum(this->precMatrixStructure()) ); #else ierr = KSPSetReusePreconditioner( M_ksp, (this->precMatrixStructure() == Feel::SAME_PRECONDITIONER)? PETSC_TRUE : PETSC_FALSE ); CHKERRABORT( this->worldComm().globalComm(),ierr ); ierr = KSPSetOperators( M_ksp, matrix->mat(), precond->mat() ); #endif CHKERRABORT( this->worldComm().globalComm(),ierr ); // Set the tolerances for the iterative solver. Use the user-supplied // tolerance for the relative residual & leave the others at default values. ierr = KSPSetTolerances ( M_ksp, this->rTolerance(), //1e-15, this->aTolerance(), this->dTolerance(), this->maxIterations() ); CHKERRABORT( this->worldComm().globalComm(),ierr ); //PreconditionerPetsc<T>::setPetscPreconditionerType( this->preconditionerType(),this->matSolverPackageType(),M_pc, this->worldComm() ); // makes the default convergence test use || B*(b - A*(initial guess))|| // instead of || B*b ||. In the case of right preconditioner or if // KSPSetNormType(ksp,KSP_NORM_UNPRECONDIITONED) is used there is no B in // the above formula. UIRNorm is short for Use Initial Residual Norm. #if PETSC_VERSION_LESS_THAN(3,5,0) KSPDefaultConvergedSetUIRNorm( M_ksp ); #else KSPConvergedDefaultSetUIRNorm( M_ksp ); #endif // Solve the linear system if ( transpose ) ierr = KSPSolveTranspose ( M_ksp, rhs->vec(), solution->vec() ); else ierr = KSPSolve ( M_ksp, rhs->vec(), solution->vec() ); CHKERRABORT( this->worldComm().globalComm(),ierr ); // Get the number of iterations required for convergence ierr = KSPGetIterationNumber ( M_ksp, &its ); CHKERRABORT( this->worldComm().globalComm(),ierr ); // Get the norm of the final residual to return to the user. ierr = KSPGetResidualNorm ( M_ksp, &final_resid ); //std::cout << "final residual = " << final_resid << "\n"; CHKERRABORT( this->worldComm().globalComm(),ierr ); KSPConvergedReason reason; KSPGetConvergedReason( M_ksp,&reason ); if ( option( _prefix=this->prefix(), _name="ksp-view" ).template as<bool>() ) check( KSPView( M_ksp, PETSC_VIEWER_STDOUT_WORLD ) ); if ( reason==KSP_DIVERGED_INDEFINITE_PC ) { LOG(INFO) << "[solverlinearpetsc] Divergence because of indefinite preconditioner;\n"; LOG(INFO) << "[solverlinearpetsc] Run the executable again but with '-pc_factor_shift_type POSITIVE_DEFINITE' option.\n"; } else if ( reason<0 ) { LOG(INFO) <<"[solverlinearpetsc] Other kind of divergence: this should not happen.\n"; } bool hasConverged; if ( reason> 0 ) { hasConverged=true; if (this->showKSPConvergedReason() && this->worldComm().globalRank() == this->worldComm().masterRank() ) std::cout<< "Linear solve converged due to " << PetscConvertKSPReasonToString(reason) << " iterations " << its << std::endl; } else { hasConverged=false; if (this->showKSPConvergedReason() && this->worldComm().globalRank() == this->worldComm().masterRank() ) std::cout<< "Linear solve did not converge due to " << PetscConvertKSPReasonToString(reason) << " iterations " << its << std::endl; } #endif // return the # of its. and the final residual norm. //return std::make_pair(its, final_resid); return solve_return_type( boost::make_tuple( hasConverged, its, final_resid ) ); }
int main(int argc,char **args) { Vec x,b,u; /* approx solution, RHS, exact solution */ Mat A; /* linear system matrix */ KSP ksp; /* KSP context */ KSP *subksp; /* array of local KSP contexts on this processor */ PC pc; /* PC context */ PC subpc; /* PC context for subdomain */ PetscReal norm; /* norm of solution error */ PetscErrorCode ierr; PetscInt i,j,Ii,J,*blks,m = 8,n; PetscMPIInt rank,size; PetscInt its,nlocal,first,Istart,Iend; PetscScalar v,one = 1.0,none = -1.0; PetscBool isbjacobi,flg = PETSC_FALSE; PetscInitialize(&argc,&args,(char*)0,help); ierr = PetscOptionsGetInt(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 = m+2; /* ------------------------------------------------------------------- Compute the matrix and right-hand-side vector that define the linear system, Ax = b. ------------------------------------------------------------------- */ /* Create and assemble parallel matrix */ ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr); ierr = MatSetSizes(A,PETSC_DECIDE,PETSC_DECIDE,m*n,m*n);CHKERRQ(ierr); ierr = MatSetFromOptions(A);CHKERRQ(ierr); ierr = MatMPIAIJSetPreallocation(A,5,NULL,5,NULL);CHKERRQ(ierr); ierr = MatSeqAIJSetPreallocation(A,5,NULL);CHKERRQ(ierr); ierr = MatGetOwnershipRange(A,&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(A,1,&Ii,1,&J,&v,ADD_VALUES);CHKERRQ(ierr);} if (i<m-1) {J = Ii + n; ierr = MatSetValues(A,1,&Ii,1,&J,&v,ADD_VALUES);CHKERRQ(ierr);} if (j>0) {J = Ii - 1; ierr = MatSetValues(A,1,&Ii,1,&J,&v,ADD_VALUES);CHKERRQ(ierr);} if (j<n-1) {J = Ii + 1; ierr = MatSetValues(A,1,&Ii,1,&J,&v,ADD_VALUES);CHKERRQ(ierr);} v = 4.0; ierr = MatSetValues(A,1,&Ii,1,&Ii,&v,ADD_VALUES);CHKERRQ(ierr); } ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); /* Create parallel vectors */ ierr = VecCreate(PETSC_COMM_WORLD,&u);CHKERRQ(ierr); ierr = VecSetSizes(u,PETSC_DECIDE,m*n);CHKERRQ(ierr); ierr = VecSetFromOptions(u);CHKERRQ(ierr); ierr = VecDuplicate(u,&b);CHKERRQ(ierr); ierr = VecDuplicate(b,&x);CHKERRQ(ierr); /* Set exact solution; then compute right-hand-side vector. */ ierr = VecSet(u,one);CHKERRQ(ierr); ierr = MatMult(A,u,b);CHKERRQ(ierr); /* Create linear solver context */ ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);CHKERRQ(ierr); /* Set operators. Here the matrix that defines the linear system also serves as the preconditioning matrix. */ ierr = KSPSetOperators(ksp,A,A,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr); /* Set default preconditioner for this program to be block Jacobi. This choice can be overridden at runtime with the option -pc_type <type> */ ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr); ierr = PCSetType(pc,PCBJACOBI);CHKERRQ(ierr); /* ------------------------------------------------------------------- Define the problem decomposition ------------------------------------------------------------------- */ /* Call PCBJacobiSetTotalBlocks() to set individually the size of each block in the preconditioner. This could also be done with the runtime option -pc_bjacobi_blocks <blocks> Also, see the command PCBJacobiSetLocalBlocks() to set the local blocks. Note: The default decomposition is 1 block per processor. */ ierr = PetscMalloc(m*sizeof(PetscInt),&blks);CHKERRQ(ierr); for (i=0; i<m; i++) blks[i] = n; ierr = PCBJacobiSetTotalBlocks(pc,m,blks);CHKERRQ(ierr); ierr = PetscFree(blks);CHKERRQ(ierr); /* ------------------------------------------------------------------- Set the linear solvers for the subblocks ------------------------------------------------------------------- */ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Basic method, should be sufficient for the needs of most users. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - By default, the block Jacobi method uses the same solver on each block of the problem. To set the same solver options on all blocks, use the prefix -sub before the usual PC and KSP options, e.g., -sub_pc_type <pc> -sub_ksp_type <ksp> -sub_ksp_rtol 1.e-4 */ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Advanced method, setting different solvers for various blocks. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Note that each block's KSP context is completely independent of the others, and the full range of uniprocessor KSP options is available for each block. The following section of code is intended to be a simple illustration of setting different linear solvers for the individual blocks. These choices are obviously not recommended for solving this particular problem. */ ierr = PetscObjectTypeCompare((PetscObject)pc,PCBJACOBI,&isbjacobi);CHKERRQ(ierr); if (isbjacobi) { /* Call KSPSetUp() to set the block Jacobi data structures (including creation of an internal KSP context for each block). Note: KSPSetUp() MUST be called before PCBJacobiGetSubKSP(). */ ierr = KSPSetUp(ksp);CHKERRQ(ierr); /* Extract the array of KSP contexts for the local blocks */ ierr = PCBJacobiGetSubKSP(pc,&nlocal,&first,&subksp);CHKERRQ(ierr); /* Loop over the local blocks, setting various KSP options for each block. */ for (i=0; i<nlocal; i++) { ierr = KSPGetPC(subksp[i],&subpc);CHKERRQ(ierr); if (!rank) { if (i%2) { ierr = PCSetType(subpc,PCILU);CHKERRQ(ierr); } else { ierr = PCSetType(subpc,PCNONE);CHKERRQ(ierr); ierr = KSPSetType(subksp[i],KSPBCGS);CHKERRQ(ierr); ierr = KSPSetTolerances(subksp[i],1.e-6,PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT);CHKERRQ(ierr); } } else { ierr = PCSetType(subpc,PCJACOBI);CHKERRQ(ierr); ierr = KSPSetType(subksp[i],KSPGMRES);CHKERRQ(ierr); ierr = KSPSetTolerances(subksp[i],1.e-7,PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT);CHKERRQ(ierr); } } } /* ------------------------------------------------------------------- Solve the linear system ------------------------------------------------------------------- */ /* Set runtime options */ ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr); /* Solve the linear system */ ierr = KSPSolve(ksp,b,x);CHKERRQ(ierr); /* View info about the solver */ ierr = PetscOptionsGetBool(NULL,"-nokspview",&flg,NULL);CHKERRQ(ierr); if (!flg) { ierr = KSPView(ksp,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr); } /* ------------------------------------------------------------------- Check solution and clean up ------------------------------------------------------------------- */ /* Check the error */ ierr = VecAXPY(x,none,u);CHKERRQ(ierr); ierr = VecNorm(x,NORM_2,&norm);CHKERRQ(ierr); ierr = KSPGetIterationNumber(ksp,&its);CHKERRQ(ierr); ierr = PetscPrintf(PETSC_COMM_WORLD,"Norm of error %G iterations %D\n",norm,its);CHKERRQ(ierr); /* Free work space. All PETSc objects should be destroyed when they are no longer needed. */ ierr = KSPDestroy(&ksp);CHKERRQ(ierr); ierr = VecDestroy(&u);CHKERRQ(ierr); ierr = VecDestroy(&x);CHKERRQ(ierr); ierr = VecDestroy(&b);CHKERRQ(ierr); ierr = MatDestroy(&A);CHKERRQ(ierr); ierr = PetscFinalize(); return 0; }
/* This function returns the suitable solver for pressure. linear system */ KSP Solver_get_pressure_solver(Mat lhs, Parameters *params) { KSP solver; PC pc; double rtol; int ierr; PetscLogDouble T1, T2; rtol = params->resmax; ierr = KSPCreate(PETSC_COMM_WORLD, &solver); PETScErrAct(ierr); short int hasnullspace = NO; if (hasnullspace) { MatNullSpace nullsp; MatNullSpaceCreate(PETSC_COMM_WORLD, PETSC_TRUE, 0, PETSC_NULL, &nullsp); KSPSetNullSpace(solver, nullsp); //MatNullSpaceDestroy(nullsp); } ierr = KSPSetOperators(solver, lhs, lhs, SAME_PRECONDITIONER); PETScErrAct(ierr); ierr = KSPSetType(solver, KSPGMRES); PETScErrAct(ierr); ierr = KSPGMRESSetRestart(solver, 20); PETScErrAct(ierr); ierr = KSPSetTolerances(solver, rtol, PETSC_DEFAULT, PETSC_DEFAULT, 300); PETScErrAct(ierr); ierr = KSPGetPC(solver, &pc); PETScErrAct(ierr); //PCSetType(pc, PCNONE); //PCSetType(pc, PCASM); PCSetType(pc, PCHYPRE); PCHYPRESetType(pc,"boomeramg"); ierr = PetscOptionsSetValue("-pc_hypre_boomeramg_max_levels", "25"); PETScErrAct(ierr); ierr = PetscOptionsSetValue("-pc_hypre_boomeramg_strong_threshold", "0.0"); PETScErrAct(ierr); ierr = PetscOptionsSetValue("-pc_hypre_boomeramg_relax_type_all", "SOR/Jacobi"); PETScErrAct(ierr); //ierr = PetscOptionsSetValue("-pc_hypre_boomeramg_cycle_type", ""); PETScErrAct(ierr); //ierr = PetscOptionsSetValue("-pc_hypre_boomeramg_cycle_type", "V"); PETScErrAct(ierr); //ierr = PetscOptionsSetValue("-pc_hypre_boomeramg_coarsen_type", "PMIS"); PETScErrAct(ierr); //ierr = PetscOptionsSetValue("-pc_hypre_boomeramg_truncfactor", "0.9"); PETScErrAct(ierr); /*******************************************************************************************************/ /*******************************************************************************************************/ /*******************************************************************************************************/ /* Hypre-Petsc Interface. The most important parameters to be set are 1- Strong Threshold 2- Truncation Factor 3- Coarsennig Type */ /* Between 0 to 1 */ /* "0 "gives better convergence rate (in 3D). */ /* Suggested values (By Hypre manual): 0.25 for 2D, 0.5 for 3D ierr = PetscOptionsSetValue("-pc_hypre_boomeramg_strong_threshold", "0.0"); PETScErrAct(ierr); */ /*******************************************************************************************************/ /* Available Options: "CLJP","Ruge-Stueben","modifiedRuge-Stueben","Falgout", "PMIS", "HMIS" Falgout is usually the best. ierr = PetscOptionsSetValue("-pc_hypre_boomeramg_coarsen_type", "Falgout"); PETScErrAct(ierr); */ /*******************************************************************************************************/ /* Availble options: "local", "global" ierr = PetscOptionsSetValue("-pc_hypre_boomeramg_measure_type", "local"); PETScErrAct(ierr); */ /*******************************************************************************************************/ /* Availble options: Jacobi,sequential-Gauss-Seidel, SOR/Jacobi,backward-SOR/Jacobi,symmetric-SOR/Jacobi,Gaussian-elimination Important: If you are using a symmetric KSP solver (like CG), you should use a symmetric smoother here. ierr = PetscOptionsSetValue("-pc_hypre_boomeramg_relax_type_all", "symmetric-SOR/Jacobi"); PETScErrAct(ierr); */ /*******************************************************************************************************/ /* Available options: "V", "W" ierr = PetscOptionsSetValue("-pc_hypre_boomeramg_cycle_type", "V"); PETScErrAct(ierr); */ /*******************************************************************************************************/ /* Availble options: "classical", "", "", "direct", "multipass", "multipass-wts", "ext+i", "ext+i-cc", "standard", "standard-wts", "", "", "FF", "FF1" ierr = PetscOptionsSetValue("-pc_hypre_boomeramg_interp_type", ""); PETScErrAct(ierr); */ /*******************************************************************************************************/ /* Available options: Greater than zero. Use zero for the best convergence. However, if you have memory problems, use greate than zero to save some memory. ierr = PetscOptionsSetValue("-pc_hypre_boomeramg_truncfactor", "0.0"); PETScErrAct(ierr); */ /* Preconditioner Generation Options PCSetType(pc,PCHYPRE) or -pc_type hypre -pc_hypre_boomeramg_max_levels nmax -pc_hypre_boomeramg_truncfactor -pc_hypre_boomeramg_strong_threshold -pc_hypre_boomeramg_max_row_sum -pc_hypre_boomeramg_no_CF -pc_hypre_boomeramg_coarsen_type CLJP,Ruge-Stueben,modifiedRuge-Stueben, -pc_hypre_boomeramg_measure_type local,global Preconditioner Iteration Options -pc_hypre_boomeramg_relax_type_all Jacobi,sequential-Gauss-Seidel, SOR/Jacobi,backward-SOR/Jacobi,symmetric-SOR/Jacobi,Gaussian-eliminat -pc_hypre_boomeramg_relax_type_fine -pc_hypre_boomeramg_relax_type_down -pc_hypre_boomeramg_relax_type_up -pc_hypre_boomeramg_relax_weight_all r -pc_hypre_boomeramg_outer_relax_weight_all r -pc_hypre_boomeramg_grid_sweeps_down n -pc_hypre_boomeramg_grid_sweeps_up n -pc_hypre_boomeramg_grid_sweeps_coarse n -pc_hypre_boomeramg_tol tol -pc_hypre_boomeramg_max_iter it */ /* //ierr = PCSetType(pc, PCASM); PETScErrAct(ierr); ierr = PCSetType(pc, PCNONE); PETScErrAct(ierr); //ierr = PCSetType(pc, PCILU); PETScErrAct(ierr); //ierr = PCSetType(pc, PCBJACOBI); PETScErrAct(ierr); //ierr = PCSetType(pc, PCLU); PETScErrAct(ierr); //ierr = PCSetType(pc, PCEISENSTAT); PETScErrAct(ierr); //ierr = PCSetType(pc, PCSOR); PETScErrAct(ierr); //ierr = PCSetType(pc, PCJACOBI); PETScErrAct(ierr); //ierr = PCSetType(pc, PCNONE); PETScErrAct(ierr); */ /* ierr = KSPGetPC(solver, &pc); PETScErrAct(ierr); ierr = PCSetType(pc, PCILU); PETScErrAct(ierr); ierr = PCFactorSetLevels(pc, 3); PETScErrAct(ierr); //ierr = PCFactorSetUseDropTolerance(pc, 1e-3, .1, 50); PETScErrAct(ierr); //ierr = PCFactorSetFill(pc, 30.7648); PETScErrAct(ierr); ierr = PCFactorSetReuseOrdering(pc, PETSC_TRUE); PETScErrAct(ierr); ierr = PCFactorSetReuseFill(pc, PETSC_TRUE); PETScErrAct(ierr); ierr = PCFactorSetAllowDiagonalFill(pc); PETScErrAct(ierr); //ierr = PCFactorSetUseInPlace(pc); PETScErrAct(ierr); */ ierr = KSPSetInitialGuessNonzero(solver, PETSC_TRUE); PETScErrAct(ierr); ierr = PetscGetTime(&T1);PETScErrAct(ierr); ierr = KSPSetFromOptions(solver); PETScErrAct(ierr); ierr = PetscGetTime(&T2);PETScErrAct(ierr); PetscPrintf(PCW, "Setup time for the Pressure solver was:%f\n", (T2 - T1)); ierr = KSPView(solver, PETSC_VIEWER_STDOUT_WORLD); PETScErrAct(ierr); return solver; }