MGSolver_Status _GetSolveStatus( MGSolver_PETScData* mgData ) {
PC pc;
const KSPType kspType;
const PCType pcType;
KSPConvergedReason reason;
PetscErrorCode ec;
ec = KSPGetType( mgData->ksp, &kspType );
CheckPETScError( ec );
ec = KSPGetPC( mgData->ksp, &pc );
CheckPETScError( ec );
ec = PCGetType( pc, &pcType );
CheckPETScError( ec );
if( !strcmp( kspType, KSPRICHARDSON ) && !strcmp( pcType, PCSOR ) ) {
double rnorm;
PetscInt curIt;
//rnorm = PETScMatrixSolver_GetResidualNorm( self );
//curIt = PETScMatrixSolver_GetIterations( self );
rnorm = _GetResidualNorm( mgData );
KSPGetIterationNumber( mgData->ksp, &curIt );
//PETScMatrixSolver_SetNormType( self, MultigridSolver_NormType_Preconditioned );
KSPSetNormType( mgData->ksp, MultigridSolver_NormType_Preconditioned );
ec = KSPDefaultConverged( mgData->ksp, curIt, (PetscScalar)rnorm, &reason, PETSC_NULL );
CheckPETScError( ec );
}
else {
ec = KSPGetConvergedReason( mgData->ksp, &reason );
CheckPETScError( ec );
}
return reason;
}
MGSolver_PETScData* MultigridSolver_CreateOuterSolver( MultigridSolver* self, Mat matrix ) {
//MatrixSolver* outerSolver;
MGSolver_PETScData* outerSolver = malloc( sizeof(MGSolver_PETScData) );
PC pc;
/*
outerSolver = (MatrixSolver*)PETScMatrixSolver_New( "" );
PETScMatrixSolver_SetKSPType( outerSolver, PETScMatrixSolver_KSPType_Richardson );
PETScMatrixSolver_SetPCType( outerSolver, PETScMatrixSolver_PCType_SOR );
PETScMatrixSolver_SetMatrix( outerSolver, matrix );
PETScMatrixSolver_SetMaxIterations( outerSolver, 3 );
PETScMatrixSolver_SetUseInitialSolution( outerSolver, True );
PETScMatrixSolver_SetNormType( outerSolver, PETScMatrixSolver_NormType_Preconditioned );
*/
KSPCreate( MPI_COMM_WORLD, &outerSolver->ksp );
KSPSetType( outerSolver->ksp, KSPRICHARDSON );
KSPGetPC( outerSolver->ksp, &pc );
PCSetType( pc, PCSOR );
if( outerSolver->matrix != PETSC_NULL )
Stg_MatDestroy(&outerSolver->matrix );
outerSolver->matrix = matrix;
Stg_KSPSetOperators( outerSolver->ksp, matrix, matrix, DIFFERENT_NONZERO_PATTERN );
KSPSetTolerances( outerSolver->ksp, PETSC_DEFAULT, PETSC_DEFAULT, PETSC_DEFAULT, (PetscInt)3 );
KSPSetInitialGuessNonzero( outerSolver->ksp, (PetscTruth)True );
KSPSetNormType( outerSolver->ksp, MultigridSolver_NormType_Preconditioned );
return outerSolver;
}
/*@
PCMGGetSmootherUp - Gets the KSP context to be used as smoother after
coarse grid correction (post-smoother).
Not Collective, KSP returned is parallel if PC is
Input Parameters:
+ pc - the multigrid context
- l - the level (0 is coarsest) to supply
Ouput Parameters:
. ksp - the smoother
Level: advanced
Notes: calling this will result in a different pre and post smoother so you may need to
set options on the pre smoother also
.keywords: MG, multigrid, get, smoother, up, post-smoother, level
.seealso: PCMGGetSmootherUp(), PCMGGetSmootherDown()
@*/
PetscErrorCode PCMGGetSmootherUp(PC pc,PetscInt l,KSP *ksp)
{
PC_MG *mg = (PC_MG*)pc->data;
PC_MG_Levels **mglevels = mg->levels;
PetscErrorCode ierr;
const char *prefix;
MPI_Comm comm;
PetscFunctionBegin;
PetscValidHeaderSpecific(pc,PC_CLASSID,1);
/*
This is called only if user wants a different pre-smoother from post.
Thus we check if a different one has already been allocated,
if not we allocate it.
*/
if (!l) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_OUTOFRANGE,"There is no such thing as a up smoother on the coarse grid");
if (mglevels[l]->smoothu == mglevels[l]->smoothd) {
KSPType ksptype;
PCType pctype;
PC ipc;
PetscReal rtol,abstol,dtol;
PetscInt maxits;
KSPNormType normtype;
ierr = PetscObjectGetComm((PetscObject)mglevels[l]->smoothd,&comm);CHKERRQ(ierr);
ierr = KSPGetOptionsPrefix(mglevels[l]->smoothd,&prefix);CHKERRQ(ierr);
ierr = KSPGetTolerances(mglevels[l]->smoothd,&rtol,&abstol,&dtol,&maxits);CHKERRQ(ierr);
ierr = KSPGetType(mglevels[l]->smoothd,&ksptype);CHKERRQ(ierr);
ierr = KSPGetNormType(mglevels[l]->smoothd,&normtype);CHKERRQ(ierr);
ierr = KSPGetPC(mglevels[l]->smoothd,&ipc);CHKERRQ(ierr);
ierr = PCGetType(ipc,&pctype);CHKERRQ(ierr);
ierr = KSPCreate(comm,&mglevels[l]->smoothu);CHKERRQ(ierr);
ierr = KSPSetErrorIfNotConverged(mglevels[l]->smoothu,pc->erroriffailure);CHKERRQ(ierr);
ierr = PetscObjectIncrementTabLevel((PetscObject)mglevels[l]->smoothu,(PetscObject)pc,mglevels[0]->levels-l);CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix(mglevels[l]->smoothu,prefix);CHKERRQ(ierr);
ierr = KSPSetTolerances(mglevels[l]->smoothu,rtol,abstol,dtol,maxits);CHKERRQ(ierr);
ierr = KSPSetType(mglevels[l]->smoothu,ksptype);CHKERRQ(ierr);
ierr = KSPSetNormType(mglevels[l]->smoothu,normtype);CHKERRQ(ierr);
ierr = KSPSetConvergenceTest(mglevels[l]->smoothu,KSPConvergedSkip,NULL,NULL);CHKERRQ(ierr);
ierr = KSPGetPC(mglevels[l]->smoothu,&ipc);CHKERRQ(ierr);
ierr = PCSetType(ipc,pctype);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)mglevels[l]->smoothu);CHKERRQ(ierr);
ierr = PetscObjectComposedDataSetInt((PetscObject) mglevels[l]->smoothu, PetscMGLevelId, mglevels[l]->level);CHKERRQ(ierr);
}
if (ksp) *ksp = mglevels[l]->smoothu;
PetscFunctionReturn(0);
}
static PetscErrorCode KSPChebyshevSetEstimateEigenvalues_Chebyshev(KSP ksp,PetscReal a,PetscReal b,PetscReal c,PetscReal d)
{
KSP_Chebyshev *cheb = (KSP_Chebyshev*)ksp->data;
PetscErrorCode ierr;
PetscFunctionBegin;
if (a != 0.0 || b != 0.0 || c != 0.0 || d != 0.0) {
if (!cheb->kspest) { /* should this block of code be moved to KSPSetUp_Chebyshev()? */
PetscBool nonzero;
ierr = KSPCreate(PetscObjectComm((PetscObject)ksp),&cheb->kspest);CHKERRQ(ierr);
ierr = PetscObjectIncrementTabLevel((PetscObject)cheb->kspest,(PetscObject)ksp,1);CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix(cheb->kspest,((PetscObject)ksp)->prefix);CHKERRQ(ierr);
ierr = KSPAppendOptionsPrefix(cheb->kspest,"est_");CHKERRQ(ierr);
ierr = KSPGetPC(cheb->kspest,&cheb->pcnone);CHKERRQ(ierr);
ierr = PetscObjectReference((PetscObject)cheb->pcnone);CHKERRQ(ierr);
ierr = PCSetType(cheb->pcnone,PCNONE);CHKERRQ(ierr);
ierr = KSPSetPC(cheb->kspest,ksp->pc);CHKERRQ(ierr);
ierr = KSPGetInitialGuessNonzero(ksp,&nonzero);CHKERRQ(ierr);
ierr = KSPSetInitialGuessNonzero(cheb->kspest,nonzero);CHKERRQ(ierr);
ierr = KSPSetComputeEigenvalues(cheb->kspest,PETSC_TRUE);CHKERRQ(ierr);
/* Estimate with a fixed number of iterations */
ierr = KSPSetConvergenceTest(cheb->kspest,KSPConvergedSkip,0,0);CHKERRQ(ierr);
ierr = KSPSetNormType(cheb->kspest,KSP_NORM_NONE);CHKERRQ(ierr);
ierr = KSPSetTolerances(cheb->kspest,PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT,cheb->eststeps);CHKERRQ(ierr);
}
if (a >= 0) cheb->tform[0] = a;
if (b >= 0) cheb->tform[1] = b;
if (c >= 0) cheb->tform[2] = c;
if (d >= 0) cheb->tform[3] = d;
cheb->estimate_current = PETSC_FALSE;
} else {
ierr = KSPDestroy(&cheb->kspest);CHKERRQ(ierr);
ierr = PCDestroy(&cheb->pcnone);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/*@C
PCMGSetLevels - Sets the number of levels to use with MG.
Must be called before any other MG routine.
Logically Collective on PC
Input Parameters:
+ pc - the preconditioner context
. levels - the number of levels
- comms - optional communicators for each level; this is to allow solving the coarser problems
on smaller sets of processors. Use NULL_OBJECT for default in Fortran
Level: intermediate
Notes:
If the number of levels is one then the multigrid uses the -mg_levels prefix
for setting the level options rather than the -mg_coarse prefix.
.keywords: MG, set, levels, multigrid
.seealso: PCMGSetType(), PCMGGetLevels()
@*/
PetscErrorCode PCMGSetLevels(PC pc,PetscInt levels,MPI_Comm *comms)
{
PetscErrorCode ierr;
PC_MG *mg = (PC_MG*)pc->data;
MPI_Comm comm;
PC_MG_Levels **mglevels = mg->levels;
PCMGType mgtype = mg->am;
PetscInt mgctype = (PetscInt) PC_MG_CYCLE_V;
PetscInt i;
PetscMPIInt size;
const char *prefix;
PC ipc;
PetscInt n;
PetscFunctionBegin;
PetscValidHeaderSpecific(pc,PC_CLASSID,1);
PetscValidLogicalCollectiveInt(pc,levels,2);
ierr = PetscObjectGetComm((PetscObject)pc,&comm);CHKERRQ(ierr);
if (mg->nlevels == levels) PetscFunctionReturn(0);
if (mglevels) {
mgctype = mglevels[0]->cycles;
/* changing the number of levels so free up the previous stuff */
ierr = PCReset_MG(pc);CHKERRQ(ierr);
n = mglevels[0]->levels;
for (i=0; i<n; i++) {
if (mglevels[i]->smoothd != mglevels[i]->smoothu) {
ierr = KSPDestroy(&mglevels[i]->smoothd);CHKERRQ(ierr);
}
ierr = KSPDestroy(&mglevels[i]->smoothu);CHKERRQ(ierr);
ierr = PetscFree(mglevels[i]);CHKERRQ(ierr);
}
ierr = PetscFree(mg->levels);CHKERRQ(ierr);
}
mg->nlevels = levels;
ierr = PetscMalloc1(levels,&mglevels);CHKERRQ(ierr);
ierr = PetscLogObjectMemory((PetscObject)pc,levels*(sizeof(PC_MG*)));CHKERRQ(ierr);
ierr = PCGetOptionsPrefix(pc,&prefix);CHKERRQ(ierr);
mg->stageApply = 0;
for (i=0; i<levels; i++) {
ierr = PetscNewLog(pc,&mglevels[i]);CHKERRQ(ierr);
mglevels[i]->level = i;
mglevels[i]->levels = levels;
mglevels[i]->cycles = mgctype;
mg->default_smoothu = 2;
mg->default_smoothd = 2;
mglevels[i]->eventsmoothsetup = 0;
mglevels[i]->eventsmoothsolve = 0;
mglevels[i]->eventresidual = 0;
mglevels[i]->eventinterprestrict = 0;
if (comms) comm = comms[i];
ierr = KSPCreate(comm,&mglevels[i]->smoothd);CHKERRQ(ierr);
ierr = KSPSetErrorIfNotConverged(mglevels[i]->smoothd,pc->erroriffailure);CHKERRQ(ierr);
ierr = PetscObjectIncrementTabLevel((PetscObject)mglevels[i]->smoothd,(PetscObject)pc,levels-i);CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix(mglevels[i]->smoothd,prefix);CHKERRQ(ierr);
ierr = PetscObjectComposedDataSetInt((PetscObject) mglevels[i]->smoothd, PetscMGLevelId, mglevels[i]->level);CHKERRQ(ierr);
if (i || levels == 1) {
char tprefix[128];
ierr = KSPSetType(mglevels[i]->smoothd,KSPCHEBYSHEV);CHKERRQ(ierr);
ierr = KSPSetConvergenceTest(mglevels[i]->smoothd,KSPConvergedSkip,NULL,NULL);CHKERRQ(ierr);
ierr = KSPSetNormType(mglevels[i]->smoothd,KSP_NORM_NONE);CHKERRQ(ierr);
ierr = KSPGetPC(mglevels[i]->smoothd,&ipc);CHKERRQ(ierr);
ierr = PCSetType(ipc,PCSOR);CHKERRQ(ierr);
ierr = KSPSetTolerances(mglevels[i]->smoothd,PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT, mg->default_smoothd);CHKERRQ(ierr);
sprintf(tprefix,"mg_levels_%d_",(int)i);
ierr = KSPAppendOptionsPrefix(mglevels[i]->smoothd,tprefix);CHKERRQ(ierr);
} else {
ierr = KSPAppendOptionsPrefix(mglevels[0]->smoothd,"mg_coarse_");CHKERRQ(ierr);
/* coarse solve is (redundant) LU by default; set shifttype NONZERO to avoid annoying zero-pivot in LU preconditioner */
ierr = KSPSetType(mglevels[0]->smoothd,KSPPREONLY);CHKERRQ(ierr);
ierr = KSPGetPC(mglevels[0]->smoothd,&ipc);CHKERRQ(ierr);
ierr = MPI_Comm_size(comm,&size);CHKERRQ(ierr);
if (size > 1) {
ierr = PCSetType(ipc,PCREDUNDANT);CHKERRQ(ierr);
} else {
ierr = PCSetType(ipc,PCLU);CHKERRQ(ierr);
}
ierr = PCFactorSetShiftType(ipc,MAT_SHIFT_INBLOCKS);CHKERRQ(ierr);
}
ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)mglevels[i]->smoothd);CHKERRQ(ierr);
mglevels[i]->smoothu = mglevels[i]->smoothd;
mg->rtol = 0.0;
mg->abstol = 0.0;
mg->dtol = 0.0;
mg->ttol = 0.0;
mg->cyclesperpcapply = 1;
}
mg->levels = mglevels;
ierr = PCMGSetType(pc,mgtype);CHKERRQ(ierr);
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)
{
Mat A,B,Y; /*input : the three imput matrix */
Mat P; /* P=QR factorization*/
PetscViewer fd1,fd2;
char file[4][PETSC_MAX_PATH_LEN];
//Mat C; /*C=B*Y*/
PetscInt m,n; /*size of matrix C;*/
Mat E,X; /*lhs and rhs of the linear equations;*/
Vec b,x; /*column vector of rhs;*/
KSP ksp; /* linear solver context */
PetscErrorCode ierr;
PetscInt i,its; /*iteration numbers of KSP*/
PetscBool flg;
m=10;
n=4;
PetscInitialize(&argc,&args,(char*)0,help);
ierr = PetscOptionsGetString(NULL,"-fa",file[0],PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if(!flg){SETERRQ(PETSC_COMM_WORLD,1,"Please provide matrix A!\n");}
ierr = PetscOptionsGetString(NULL,"-fb",file[1],PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if(!flg){SETERRQ(PETSC_COMM_WORLD,1,"Please provide matrix B!\n");}
ierr = PetscOptionsGetString(NULL,"-fy",file[2],PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if(!flg){SETERRQ(PETSC_COMM_WORLD,1,"Please provide matrix Y!\n");}
ierr = PetscOptionsGetString(NULL,"-fp",file[3],PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if(!flg){SETERRQ(PETSC_COMM_WORLD,1,"Please provide matrix P!\n");}
/*Load the matrices*/
ierr = PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[0],FILE_MODE_READ,&fd1);
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatSetFromOptions(A);CHKERRQ(ierr);
ierr = PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[1],FILE_MODE_READ,&fd2);
ierr = MatCreate(PETSC_COMM_WORLD,&B);CHKERRQ(ierr);
ierr = MatSetFromOptions(B);CHKERRQ(ierr);
ierr = MatLoad(A,fd1);CHKERRQ(ierr);
ierr = MatLoad(B,fd2);CHKERRQ(ierr);
readmm(file[2], &Y);
readmm(file[3], &P);
ierr = PetscPrintf(PETSC_COMM_SELF,"Read file completes.\n");CHKERRQ(ierr);
#if(cxDEBUG==1)
ierr = MatView(A,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = MatView(B,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
#endif
Mat Q1;
ierr = MatCreate(PETSC_COMM_WORLD, &Q1); CHKERRQ(ierr);
ierr = MatSetFromOptions(Q1); CHKERRQ(ierr);
ierr = MatMatMult(B,Y,MAT_INITIAL_MATRIX,PETSC_DEFAULT, &Q1);CHKERRQ(ierr);
#if(cxDEBUG==1)
ierr = PetscPrintf(PETSC_COMM_SELF,"Cao this is BY.\n");CHKERRQ(ierr);
ierr = MatView(Q1,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
#endif
getQ1(&Q1);
#if(cxDEBUG==1)
ierr = PetscPrintf(PETSC_COMM_SELF,"\nTHIS IS Q1.\n");CHKERRQ(ierr);
ierr = MatView(Q1,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
#endif
Mat SBP;
ierr = MatMatTransposeMult(Q1,Q1,MAT_INITIAL_MATRIX, PETSC_DEFAULT ,&SBP);
ierr = MatAssemblyBegin(SBP,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(SBP,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatShift(SBP,-1);
ierr = MatScale(SBP,-1);
#if(cxDEBUG==1)
ierr = PetscPrintf(PETSC_COMM_SELF,"\nTHIS IS SBP = Q1*Q1'.\n");CHKERRQ(ierr);
ierr = MatView(SBP,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"\nBelows is act_P.\n");CHKERRQ(ierr);
ierr = MatView(P ,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
#endif
ierr = MatMatMult(A,Y,MAT_INITIAL_MATRIX,PETSC_DEFAULT,&E);CHKERRQ(ierr);
ierr = MatMatMult(SBP,E,MAT_INITIAL_MATRIX,PETSC_DEFAULT,&E);CHKERRQ(ierr);
#if(cxDEBUG==1)
ierr = PetscPrintf(PETSC_COMM_SELF,"\nBelows is PAY.\n");CHKERRQ(ierr);
ierr = MatView(E,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
#endif
ierr = MatAssemblyBegin(E,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(E,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
//ierr = MatGetSize(E,&m,&n);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&X);CHKERRQ(ierr);
ierr = MatSetSizes(X,PETSC_DECIDE,PETSC_DECIDE,m,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(X);CHKERRQ(ierr);
ierr = MatSetUp(X); CHKERRQ(ierr);
ierr = MatZeroEntries(X);CHKERRQ(ierr);
ierr = MatAssemblyBegin(X,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(X,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
// PetscInt ix[m];
// for(i=0;i<m;i++){
// ix[i] = i;
// }
VecCreate(PETSC_COMM_WORLD,&b);
VecSetSizes(b,PETSC_DECIDE,m);
VecSetFromOptions(b);
VecCreate(PETSC_COMM_WORLD,&x);
VecSetSizes(x,PETSC_DECIDE,m);
VecSetFromOptions(x);
//#if(cxDEBUG==1)
ierr = PetscPrintf(PETSC_COMM_SELF,"\nBEFORE CG Check A\n");CHKERRQ(ierr);
ierr = MatView(A,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"\nBEFORE CG Check SBP\n");CHKERRQ(ierr);
ierr = MatView(SBP,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"\nBEFORE CG Check E\n");CHKERRQ(ierr);
ierr = MatView(E,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
//#endif
for(i=0;i<n;i++){
MatGetColumnVector(E,b,i);
PetscPrintf(PETSC_COMM_WORLD,"the rhs\n");
VecView(b,PETSC_VIEWER_STDOUT_WORLD);
KSPCreate(PETSC_COMM_WORLD,&ksp);
KSPSetOperators(ksp,A,SBP);
KSPSetNormType(ksp,KSP_NORM_UNPRECONDITIONED);
KSPSetCheckNormIteration(ksp,-1);
KSPSetTolerances(ksp,1.0e-06,PETSC_DEFAULT,PETSC_DEFAULT,400);
KSPSetInitialGuessNonzero(ksp,PETSC_FALSE);
KSPSetFromOptions(ksp);
KSPSolve(ksp,b,x);
KSPGetIterationNumber(ksp,&its);
PetscPrintf(PETSC_COMM_WORLD,"%d-th equation,iteration=%D\n",i,its);
VecView(x,PETSC_VIEWER_STDOUT_WORLD);
}
return 0;
}
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "KSPCreate_SpecEst"
/*MC
KSPSPECEST - Estimate the spectrum on the first KSPSolve, then use cheaper smoother for subsequent solves.
Options Database Keys:
+ -ksp_specest_minfactor <0.9> - Multiplier on the minimum eigen/singular value
. -ksp_specest_maxfactor <1.1> - Multiplier on the maximum eigen/singular value
. -ksp_specest_richfactor <1> - Multiplier on the richimum eigen/singular value
. -specest_ksp_type <type> - KSP used to estimate the spectrum (usually CG or GMRES)
. -speccheap_ksp_type <type> - KSP used as a cheap smoother once the spectrum has been estimated (usually Chebyshev or Richardson)
- see KSPSolve() for more
Notes:
This KSP estimates the extremal singular values on the first pass, then uses them to configure a smoother that
uses fewer dot products. It is intended for use on the levels of multigrid, especially at high process counts,
where dot products are very expensive.
The same PC is used for both the estimator and the cheap smoother, it is only set up once. There are no options
keys for -specest_pc_ or speccheap_pc_ since it is the same object as -pc_.
Level: intermediate
.seealso: KSPCreate(), KSPSetType(), KSPType (for list of available types), KSP, KSPGMRES, KSPCG, KSPCHEBYSHEV, KSPRICHARDSON
M*/
PetscErrorCode KSPCreate_SpecEst(KSP ksp)
{
KSP_SpecEst *spec;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,2);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_RIGHT,1);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_LEFT,1);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_RIGHT,1);CHKERRQ(ierr);
ierr = PetscNewLog(ksp,KSP_SpecEst,&spec);CHKERRQ(ierr);
ksp->data = (void*)spec;
ksp->ops->setup = KSPSetUp_SpecEst;
ksp->ops->solve = KSPSolve_SpecEst;
ksp->ops->destroy = KSPDestroy_SpecEst;
ksp->ops->buildsolution = KSPDefaultBuildSolution;
ksp->ops->buildresidual = KSPDefaultBuildResidual;
ksp->ops->setfromoptions = KSPSetFromOptions_SpecEst;
ksp->ops->view = KSPView_SpecEst;
spec->minfactor = 0.9;
spec->maxfactor = 1.1;
spec->richfactor = 1.0;
ierr = KSPCreate(((PetscObject)ksp)->comm,&spec->kspest);CHKERRQ(ierr);
ierr = KSPCreate(((PetscObject)ksp)->comm,&spec->kspcheap);CHKERRQ(ierr);
/* Hold an empty PC */
ierr = KSPGetPC(spec->kspest,&spec->pcnone);CHKERRQ(ierr);
ierr = PetscObjectReference((PetscObject)spec->pcnone);CHKERRQ(ierr);
ierr = PCSetType(spec->pcnone,PCNONE);CHKERRQ(ierr);
ierr = KSPSetPC(spec->kspcheap,spec->pcnone);CHKERRQ(ierr);
ierr = KSPSetTolerances(spec->kspest,PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT,5);CHKERRQ(ierr);
/* Make the "cheap" preconditioner cheap by default */
ierr = KSPSetConvergenceTest(spec->kspcheap,KSPSkipConverged,0,0);CHKERRQ(ierr);
ierr = KSPSetNormType(spec->kspcheap,KSP_NORM_NONE);CHKERRQ(ierr);
ierr = KSPSetTolerances(spec->kspcheap,PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT,5);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
KSPSetFromOptions - Sets KSP options from the options database.
This routine must be called before KSPSetUp() if the user is to be
allowed to set the Krylov type.
Collective on KSP
Input Parameters:
. ksp - the Krylov space context
Options Database Keys:
+ -ksp_max_it - maximum number of linear iterations
. -ksp_rtol rtol - relative tolerance used in default determination of convergence, i.e.
if residual norm decreases by this factor than convergence is declared
. -ksp_atol abstol - absolute tolerance used in default convergence test, i.e. if residual
norm is less than this then convergence is declared
. -ksp_divtol tol - if residual norm increases by this factor than divergence is declared
. -ksp_converged_use_initial_residual_norm - see KSPConvergedDefaultSetUIRNorm()
. -ksp_converged_use_min_initial_residual_norm - see KSPConvergedDefaultSetUMIRNorm()
. -ksp_norm_type - none - skip norms used in convergence tests (useful only when not using
convergence test (say you always want to run with 5 iterations) to
save on communication overhead
preconditioned - default for left preconditioning
unpreconditioned - see KSPSetNormType()
natural - see KSPSetNormType()
. -ksp_check_norm_iteration it - do not compute residual norm until iteration number it (does compute at 0th iteration)
works only for PCBCGS, PCIBCGS and and PCCG
. -ksp_lag_norm - compute the norm of the residual for the ith iteration on the i+1 iteration; this means that one can use
the norm of the residual for convergence test WITHOUT an extra MPI_Allreduce() limiting global synchronizations.
This will require 1 more iteration of the solver than usual.
. -ksp_fischer_guess <model,size> - uses the Fischer initial guess generator for repeated linear solves
. -ksp_constant_null_space - assume the operator (matrix) has the constant vector in its null space
. -ksp_test_null_space - tests the null space set with KSPSetNullSpace() to see if it truly is a null space
. -ksp_knoll - compute initial guess by applying the preconditioner to the right hand side
. -ksp_monitor_cancel - cancel all previous convergene monitor routines set
. -ksp_monitor <optional filename> - print residual norm at each iteration
. -ksp_monitor_lg_residualnorm - plot residual norm at each iteration
. -ksp_monitor_solution - plot solution at each iteration
- -ksp_monitor_singular_value - monitor extremem singular values at each iteration
Notes:
To see all options, run your program with the -help option
or consult Users-Manual: ch_ksp
Level: beginner
.keywords: KSP, set, from, options, database
.seealso: KSPSetUseFischerGuess()
@*/
PetscErrorCode KSPSetFromOptions(KSP ksp)
{
PetscErrorCode ierr;
PetscInt indx;
const char *convtests[] = {"default","skip"};
char type[256], monfilename[PETSC_MAX_PATH_LEN];
PetscViewer monviewer;
PetscBool flg,flag,reuse;
PetscInt model[2]={0,0},nmax;
KSPNormType normtype;
PCSide pcside;
void *ctx;
PetscFunctionBegin;
PetscValidHeaderSpecific(ksp,KSP_CLASSID,1);
if (!ksp->pc) {ierr = KSPGetPC(ksp,&ksp->pc);CHKERRQ(ierr);}
ierr = PCSetFromOptions(ksp->pc);CHKERRQ(ierr);
if (!KSPRegisterAllCalled) {ierr = KSPRegisterAll();CHKERRQ(ierr);}
ierr = PetscObjectOptionsBegin((PetscObject)ksp);CHKERRQ(ierr);
ierr = PetscOptionsFList("-ksp_type","Krylov method","KSPSetType",KSPList,(char*)(((PetscObject)ksp)->type_name ? ((PetscObject)ksp)->type_name : KSPGMRES),type,256,&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPSetType(ksp,type);CHKERRQ(ierr);
}
/*
Set the type if it was never set.
*/
if (!((PetscObject)ksp)->type_name) {
ierr = KSPSetType(ksp,KSPGMRES);CHKERRQ(ierr);
}
ierr = PetscOptionsInt("-ksp_max_it","Maximum number of iterations","KSPSetTolerances",ksp->max_it,&ksp->max_it,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-ksp_rtol","Relative decrease in residual norm","KSPSetTolerances",ksp->rtol,&ksp->rtol,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-ksp_atol","Absolute value of residual norm","KSPSetTolerances",ksp->abstol,&ksp->abstol,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-ksp_divtol","Residual norm increase cause divergence","KSPSetTolerances",ksp->divtol,&ksp->divtol,NULL);CHKERRQ(ierr);
flag = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_converged_use_initial_residual_norm","Use initial residual residual norm for computing relative convergence","KSPConvergedDefaultSetUIRNorm",flag,&flag,NULL);CHKERRQ(ierr);
if (flag) {ierr = KSPConvergedDefaultSetUIRNorm(ksp);CHKERRQ(ierr);}
flag = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_converged_use_min_initial_residual_norm","Use minimum of initial residual norm and b for computing relative convergence","KSPConvergedDefaultSetUMIRNorm",flag,&flag,NULL);CHKERRQ(ierr);
if (flag) {ierr = KSPConvergedDefaultSetUMIRNorm(ksp);CHKERRQ(ierr);}
ierr = KSPGetInitialGuessNonzero(ksp,&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_initial_guess_nonzero","Use the contents of the solution vector for initial guess","KSPSetInitialNonzero",flag,&flag,&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPSetInitialGuessNonzero(ksp,flag);CHKERRQ(ierr);
}
ierr = PCGetReusePreconditioner(ksp->pc,&reuse);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_reuse_preconditioner","Use initial preconditioner and don't ever compute a new one ","KSPReusePreconditioner",reuse,&reuse,NULL);CHKERRQ(ierr);
ierr = KSPSetReusePreconditioner(ksp,reuse);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_knoll","Use preconditioner applied to b for initial guess","KSPSetInitialGuessKnoll",ksp->guess_knoll,&ksp->guess_knoll,NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_error_if_not_converged","Generate error if solver does not converge","KSPSetErrorIfNotConverged",ksp->errorifnotconverged,&ksp->errorifnotconverged,NULL);CHKERRQ(ierr);
nmax = 2;
ierr = PetscOptionsIntArray("-ksp_fischer_guess","Use Paul Fischer's algorithm for initial guess","KSPSetUseFischerGuess",model,&nmax,&flag);CHKERRQ(ierr);
if (flag) {
if (nmax != 2) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_ARG_OUTOFRANGE,"Must pass in model,size as arguments");
ierr = KSPSetUseFischerGuess(ksp,model[0],model[1]);CHKERRQ(ierr);
}
ierr = PetscOptionsEList("-ksp_convergence_test","Convergence test","KSPSetConvergenceTest",convtests,2,"default",&indx,&flg);CHKERRQ(ierr);
if (flg) {
switch (indx) {
case 0:
ierr = KSPConvergedDefaultCreate(&ctx);CHKERRQ(ierr);
ierr = KSPSetConvergenceTest(ksp,KSPConvergedDefault,ctx,KSPConvergedDefaultDestroy);CHKERRQ(ierr);
break;
case 1: ierr = KSPSetConvergenceTest(ksp,KSPConvergedSkip,NULL,NULL);CHKERRQ(ierr); break;
}
}
ierr = KSPSetUpNorms_Private(ksp,&normtype,&pcside);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-ksp_norm_type","KSP Norm type","KSPSetNormType",KSPNormTypes,(PetscEnum)normtype,(PetscEnum*)&normtype,&flg);CHKERRQ(ierr);
if (flg) { ierr = KSPSetNormType(ksp,normtype);CHKERRQ(ierr); }
ierr = PetscOptionsInt("-ksp_check_norm_iteration","First iteration to compute residual norm","KSPSetCheckNormIteration",ksp->chknorm,&ksp->chknorm,NULL);CHKERRQ(ierr);
flag = ksp->lagnorm;
ierr = PetscOptionsBool("-ksp_lag_norm","Lag the calculation of the residual norm","KSPSetLagNorm",flag,&flag,&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPSetLagNorm(ksp,flag);CHKERRQ(ierr);
}
ierr = KSPGetDiagonalScale(ksp,&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_diagonal_scale","Diagonal scale matrix before building preconditioner","KSPSetDiagonalScale",flag,&flag,&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPSetDiagonalScale(ksp,flag);CHKERRQ(ierr);
}
ierr = KSPGetDiagonalScaleFix(ksp,&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_diagonal_scale_fix","Fix diagonally scaled matrix after solve","KSPSetDiagonalScaleFix",flag,&flag,&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPSetDiagonalScaleFix(ksp,flag);CHKERRQ(ierr);
}
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_constant_null_space","Add constant null space to Krylov solver","KSPSetNullSpace",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
MatNullSpace nsp;
ierr = MatNullSpaceCreate(PetscObjectComm((PetscObject)ksp),PETSC_TRUE,0,0,&nsp);CHKERRQ(ierr);
ierr = KSPSetNullSpace(ksp,nsp);CHKERRQ(ierr);
ierr = MatNullSpaceDestroy(&nsp);CHKERRQ(ierr);
}
/* option is actually checked in KSPSetUp(), just here so goes into help message */
if (ksp->nullsp) {
ierr = PetscOptionsName("-ksp_test_null_space","Is provided null space correct","None",&flg);CHKERRQ(ierr);
}
/*
Prints reason for convergence or divergence of each linear solve
*/
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_converged_reason","Print reason for converged or diverged","KSPSolve",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) ksp->printreason = PETSC_TRUE;
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_monitor_cancel","Remove any hardwired monitor routines","KSPMonitorCancel",flg,&flg,NULL);CHKERRQ(ierr);
/* -----------------------------------------------------------------------*/
/*
Cancels all monitors hardwired into code before call to KSPSetFromOptions()
*/
if (flg) {
ierr = KSPMonitorCancel(ksp);CHKERRQ(ierr);
}
/*
Prints preconditioned residual norm at each iteration
*/
ierr = PetscOptionsString("-ksp_monitor","Monitor preconditioned residual norm","KSPMonitorSet","stdout",monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscViewerASCIIOpen(PetscObjectComm((PetscObject)ksp),monfilename,&monviewer);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorDefault,monviewer,(PetscErrorCode (*)(void**))PetscViewerDestroy);CHKERRQ(ierr);
}
/*
Prints preconditioned residual norm at each iteration
*/
ierr = PetscOptionsString("-ksp_monitor_range","Monitor percent of residual entries more than 10 percent of max","KSPMonitorRange","stdout",monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscViewerASCIIOpen(PetscObjectComm((PetscObject)ksp),monfilename,&monviewer);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorRange,monviewer,(PetscErrorCode (*)(void**))PetscViewerDestroy);CHKERRQ(ierr);
}
ierr = PetscObjectTypeCompare((PetscObject)ksp->pc,PCKSP,&flg);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)ksp->pc,PCBJACOBI,&flag);CHKERRQ(ierr);
if (flg || flag) {
/* A hack for using dynamic tolerance in preconditioner */
ierr = PetscOptionsString("-sub_ksp_dynamic_tolerance","Use dynamic tolerance for PC if PC is a KSP","KSPMonitorDynamicTolerance","stdout",monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {
KSPDynTolCtx *scale = NULL;
PetscReal defaultv = 1.0;
ierr = PetscMalloc1(1,&scale);CHKERRQ(ierr);
scale->bnrm = -1.0;
scale->coef = defaultv;
ierr = PetscOptionsReal("-sub_ksp_dynamic_tolerance_param","Parameter of dynamic tolerance for inner PCKSP","KSPMonitorDynamicToleranceParam",defaultv,&(scale->coef),&flg);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorDynamicTolerance,scale,KSPMonitorDynamicToleranceDestroy);CHKERRQ(ierr);
}
}
/*
Plots the vector solution
*/
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_monitor_solution","Monitor solution graphically","KSPMonitorSet",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
ierr = KSPMonitorSet(ksp,KSPMonitorSolution,NULL,NULL);CHKERRQ(ierr);
}
/*
Prints preconditioned and true residual norm at each iteration
*/
ierr = PetscOptionsString("-ksp_monitor_true_residual","Monitor true residual norm","KSPMonitorSet","stdout",monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscViewerASCIIOpen(PetscObjectComm((PetscObject)ksp),monfilename,&monviewer);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorTrueResidualNorm,monviewer,(PetscErrorCode (*)(void**))PetscViewerDestroy);CHKERRQ(ierr);
}
/*
Prints with max norm at each iteration
*/
ierr = PetscOptionsString("-ksp_monitor_max","Monitor true residual max norm","KSPMonitorSet","stdout",monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscViewerASCIIOpen(PetscObjectComm((PetscObject)ksp),monfilename,&monviewer);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorTrueResidualMaxNorm,monviewer,(PetscErrorCode (*)(void**))PetscViewerDestroy);CHKERRQ(ierr);
}
/*
Prints extreme eigenvalue estimates at each iteration
*/
ierr = PetscOptionsString("-ksp_monitor_singular_value","Monitor singular values","KSPMonitorSet","stdout",monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPSetComputeSingularValues(ksp,PETSC_TRUE);CHKERRQ(ierr);
ierr = PetscViewerASCIIOpen(PetscObjectComm((PetscObject)ksp),monfilename,&monviewer);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorSingularValue,monviewer,(PetscErrorCode (*)(void**))PetscViewerDestroy);CHKERRQ(ierr);
}
/*
Prints preconditioned residual norm with fewer digits
*/
ierr = PetscOptionsString("-ksp_monitor_short","Monitor preconditioned residual norm with fewer digits","KSPMonitorSet","stdout",monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscViewerASCIIOpen(PetscObjectComm((PetscObject)ksp),monfilename,&monviewer);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorDefaultShort,monviewer,(PetscErrorCode (*)(void**))PetscViewerDestroy);CHKERRQ(ierr);
}
/*
Calls Python function
*/
ierr = PetscOptionsString("-ksp_monitor_python","Use Python function","KSPMonitorSet",0,monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {ierr = PetscPythonMonitorSet((PetscObject)ksp,monfilename);CHKERRQ(ierr);}
/*
Graphically plots preconditioned residual norm
*/
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_monitor_lg_residualnorm","Monitor graphically preconditioned residual norm","KSPMonitorSet",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
PetscDrawLG ctx;
ierr = KSPMonitorLGResidualNormCreate(0,0,PETSC_DECIDE,PETSC_DECIDE,300,300,&ctx);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorLGResidualNorm,ctx,(PetscErrorCode (*)(void**))KSPMonitorLGResidualNormDestroy);CHKERRQ(ierr);
}
/*
Graphically plots preconditioned and true residual norm
*/
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_monitor_lg_true_residualnorm","Monitor graphically true residual norm","KSPMonitorSet",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
PetscDrawLG ctx;
ierr = KSPMonitorLGTrueResidualNormCreate(PetscObjectComm((PetscObject)ksp),0,0,PETSC_DECIDE,PETSC_DECIDE,300,300,&ctx);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorLGTrueResidualNorm,ctx,(PetscErrorCode (*)(void**))KSPMonitorLGTrueResidualNormDestroy);CHKERRQ(ierr);
}
/*
Graphically plots preconditioned residual norm and range of residual element values
*/
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_monitor_lg_range","Monitor graphically range of preconditioned residual norm","KSPMonitorSet",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
PetscViewer ctx;
ierr = PetscViewerDrawOpen(PetscObjectComm((PetscObject)ksp),0,0,PETSC_DECIDE,PETSC_DECIDE,300,300,&ctx);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorLGRange,ctx,(PetscErrorCode (*)(void**))PetscViewerDestroy);CHKERRQ(ierr);
}
#if defined(PETSC_HAVE_SAWS)
/*
Publish convergence information using AMS
*/
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_monitor_saws","Publish KSP progress using SAWs","KSPMonitorSet",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
void *ctx;
ierr = KSPMonitorSAWsCreate(ksp,&ctx);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorSAWs,ctx,KSPMonitorSAWsDestroy);CHKERRQ(ierr);
ierr = KSPSetComputeSingularValues(ksp,PETSC_TRUE);CHKERRQ(ierr);
}
#endif
/* -----------------------------------------------------------------------*/
ierr = KSPSetUpNorms_Private(ksp,&normtype,&pcside);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-ksp_pc_side","KSP preconditioner side","KSPSetPCSide",PCSides,(PetscEnum)pcside,(PetscEnum*)&pcside,&flg);CHKERRQ(ierr);
if (flg) {ierr = KSPSetPCSide(ksp,pcside);CHKERRQ(ierr);}
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_compute_singularvalues","Compute singular values of preconditioned operator","KSPSetComputeSingularValues",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) { ierr = KSPSetComputeSingularValues(ksp,PETSC_TRUE);CHKERRQ(ierr); }
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_compute_eigenvalues","Compute eigenvalues of preconditioned operator","KSPSetComputeSingularValues",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) { ierr = KSPSetComputeSingularValues(ksp,PETSC_TRUE);CHKERRQ(ierr); }
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_plot_eigenvalues","Scatter plot extreme eigenvalues","KSPSetComputeSingularValues",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) { ierr = KSPSetComputeSingularValues(ksp,PETSC_TRUE);CHKERRQ(ierr); }
#if defined(PETSC_HAVE_SAWS)
{
PetscBool set;
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_saws_block","Block for SAWs at end of KSPSolve","PetscObjectSAWsBlock",((PetscObject)ksp)->amspublishblock,&flg,&set);CHKERRQ(ierr);
if (set) {
ierr = PetscObjectSAWsSetBlock((PetscObject)ksp,flg);CHKERRQ(ierr);
}
}
#endif
if (ksp->ops->setfromoptions) {
ierr = (*ksp->ops->setfromoptions)(ksp);CHKERRQ(ierr);
}
/* process any options handlers added with PetscObjectAddOptionsHandler() */
ierr = PetscObjectProcessOptionsHandlers((PetscObject)ksp);CHKERRQ(ierr);
ierr = PetscOptionsEnd();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PETSC_EXTERN void PETSC_STDCALL kspsetnormtype_(KSP ksp,KSPNormType *normtype, int *__ierr ){
*__ierr = KSPSetNormType(
(KSP)PetscToPointer((ksp) ),*normtype);
}
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;
}
/*@
KSPSetFromOptions - Sets KSP options from the options database.
This routine must be called before KSPSetUp() if the user is to be
allowed to set the Krylov type.
Collective on KSP
Input Parameters:
. ksp - the Krylov space context
Options Database Keys:
+ -ksp_max_it - maximum number of linear iterations
. -ksp_rtol rtol - relative tolerance used in default determination of convergence, i.e.
if residual norm decreases by this factor than convergence is declared
. -ksp_atol abstol - absolute tolerance used in default convergence test, i.e. if residual
norm is less than this then convergence is declared
. -ksp_divtol tol - if residual norm increases by this factor than divergence is declared
. -ksp_converged_use_initial_residual_norm - see KSPConvergedDefaultSetUIRNorm()
. -ksp_converged_use_min_initial_residual_norm - see KSPConvergedDefaultSetUMIRNorm()
. -ksp_norm_type - none - skip norms used in convergence tests (useful only when not using
convergence test (say you always want to run with 5 iterations) to
save on communication overhead
preconditioned - default for left preconditioning
unpreconditioned - see KSPSetNormType()
natural - see KSPSetNormType()
. -ksp_check_norm_iteration it - do not compute residual norm until iteration number it (does compute at 0th iteration)
works only for PCBCGS, PCIBCGS and and PCCG
. -ksp_lag_norm - compute the norm of the residual for the ith iteration on the i+1 iteration; this means that one can use
the norm of the residual for convergence test WITHOUT an extra MPI_Allreduce() limiting global synchronizations.
This will require 1 more iteration of the solver than usual.
. -ksp_guess_type - Type of initial guess generator for repeated linear solves
. -ksp_fischer_guess <model,size> - uses the Fischer initial guess generator for repeated linear solves
. -ksp_constant_null_space - assume the operator (matrix) has the constant vector in its null space
. -ksp_test_null_space - tests the null space set with MatSetNullSpace() to see if it truly is a null space
. -ksp_knoll - compute initial guess by applying the preconditioner to the right hand side
. -ksp_monitor_cancel - cancel all previous convergene monitor routines set
. -ksp_monitor <optional filename> - print residual norm at each iteration
. -ksp_monitor_lg_residualnorm - plot residual norm at each iteration
. -ksp_monitor_solution [ascii binary or draw][:filename][:format option] - plot solution at each iteration
- -ksp_monitor_singular_value - monitor extreme singular values at each iteration
Notes:
To see all options, run your program with the -help option
or consult Users-Manual: ch_ksp
Level: beginner
.keywords: KSP, set, from, options, database
.seealso: KSPSetOptionsPrefix(), KSPResetFromOptions(), KSPSetUseFischerGuess()
@*/
PetscErrorCode KSPSetFromOptions(KSP ksp)
{
PetscInt indx;
const char *convtests[] = {"default","skip","lsqr"};
char type[256], guesstype[256], monfilename[PETSC_MAX_PATH_LEN];
PetscBool flg,flag,reuse,set;
PetscInt model[2]={0,0},nmax;
KSPNormType normtype;
PCSide pcside;
void *ctx;
MPI_Comm comm;
const char *prefix;
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(ksp,KSP_CLASSID,1);
ierr = PetscObjectGetComm((PetscObject) ksp, &comm);CHKERRQ(ierr);
ierr = PetscObjectGetOptionsPrefix((PetscObject) ksp, &prefix);CHKERRQ(ierr);
if (!ksp->skippcsetfromoptions) {
if (!ksp->pc) {ierr = KSPGetPC(ksp,&ksp->pc);CHKERRQ(ierr);}
ierr = PCSetFromOptions(ksp->pc);CHKERRQ(ierr);
}
ierr = KSPRegisterAll();CHKERRQ(ierr);
ierr = PetscObjectOptionsBegin((PetscObject)ksp);CHKERRQ(ierr);
ierr = PetscOptionsFList("-ksp_type","Krylov method","KSPSetType",KSPList,(char*)(((PetscObject)ksp)->type_name ? ((PetscObject)ksp)->type_name : KSPGMRES),type,256,&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPSetType(ksp,type);CHKERRQ(ierr);
}
/*
Set the type if it was never set.
*/
if (!((PetscObject)ksp)->type_name) {
ierr = KSPSetType(ksp,KSPGMRES);CHKERRQ(ierr);
}
ierr = KSPResetViewers(ksp);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)ksp,KSPPREONLY,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCGetReusePreconditioner(ksp->pc,&reuse);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_error_if_not_converged","Generate error if solver does not converge","KSPSetErrorIfNotConverged",ksp->errorifnotconverged,&ksp->errorifnotconverged,NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_reuse_preconditioner","Use initial preconditioner and don't ever compute a new one ","KSPReusePreconditioner",reuse,&reuse,NULL);CHKERRQ(ierr);
ierr = KSPSetReusePreconditioner(ksp,reuse);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view", &ksp->viewer, &ksp->format, &ksp->view);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_converged_reason", &ksp->viewerReason, &ksp->formatReason, &ksp->viewReason);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_mat", &ksp->viewerMat, &ksp->formatMat, &ksp->viewMat);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_pmat", &ksp->viewerPMat, &ksp->formatPMat, &ksp->viewPMat);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_rhs", &ksp->viewerRhs, &ksp->formatRhs, &ksp->viewRhs);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_solution", &ksp->viewerSol, &ksp->formatSol, &ksp->viewSol);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_mat_explicit", &ksp->viewerMatExp, &ksp->formatMatExp, &ksp->viewMatExp);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_final_residual", &ksp->viewerFinalRes,&ksp->formatFinalRes,&ksp->viewFinalRes);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_preconditioned_operator_explicit",&ksp->viewerPOpExp, &ksp->formatPOpExp, &ksp->viewPOpExp);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_diagonal_scale", &ksp->viewerDScale, &ksp->formatDScale, &ksp->viewDScale);CHKERRQ(ierr);
ierr = KSPGetDiagonalScale(ksp,&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_diagonal_scale","Diagonal scale matrix before building preconditioner","KSPSetDiagonalScale",flag,&flag,&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPSetDiagonalScale(ksp,flag);CHKERRQ(ierr);
}
ierr = KSPGetDiagonalScaleFix(ksp,&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_diagonal_scale_fix","Fix diagonally scaled matrix after solve","KSPSetDiagonalScaleFix",flag,&flag,&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPSetDiagonalScaleFix(ksp,flag);CHKERRQ(ierr);
}
goto skipoptions;
}
ierr = PetscOptionsInt("-ksp_max_it","Maximum number of iterations","KSPSetTolerances",ksp->max_it,&ksp->max_it,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-ksp_rtol","Relative decrease in residual norm","KSPSetTolerances",ksp->rtol,&ksp->rtol,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-ksp_atol","Absolute value of residual norm","KSPSetTolerances",ksp->abstol,&ksp->abstol,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-ksp_divtol","Residual norm increase cause divergence","KSPSetTolerances",ksp->divtol,&ksp->divtol,NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_converged_use_initial_residual_norm","Use initial residual norm for computing relative convergence","KSPConvergedDefaultSetUIRNorm",PETSC_FALSE,&flag,&set);CHKERRQ(ierr);
if (set && flag) {ierr = KSPConvergedDefaultSetUIRNorm(ksp);CHKERRQ(ierr);}
ierr = PetscOptionsBool("-ksp_converged_use_min_initial_residual_norm","Use minimum of initial residual norm and b for computing relative convergence","KSPConvergedDefaultSetUMIRNorm",PETSC_FALSE,&flag,&set);CHKERRQ(ierr);
if (set && flag) {ierr = KSPConvergedDefaultSetUMIRNorm(ksp);CHKERRQ(ierr);}
ierr = PetscOptionsBool("-ksp_initial_guess_nonzero","Use the contents of the solution vector for initial guess","KSPSetInitialNonzero",ksp->guess_zero ? PETSC_FALSE : PETSC_TRUE,&flag,&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPSetInitialGuessNonzero(ksp,flag);CHKERRQ(ierr);
}
ierr = PCGetReusePreconditioner(ksp->pc,&reuse);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_reuse_preconditioner","Use initial preconditioner and don't ever compute a new one ","KSPReusePreconditioner",reuse,&reuse,NULL);CHKERRQ(ierr);
ierr = KSPSetReusePreconditioner(ksp,reuse);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_knoll","Use preconditioner applied to b for initial guess","KSPSetInitialGuessKnoll",ksp->guess_knoll,&ksp->guess_knoll,NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_error_if_not_converged","Generate error if solver does not converge","KSPSetErrorIfNotConverged",ksp->errorifnotconverged,&ksp->errorifnotconverged,NULL);CHKERRQ(ierr);
ierr = PetscOptionsFList("-ksp_guess_type","Initial guess in Krylov method",NULL,KSPGuessList,NULL,guesstype,256,&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPGetGuess(ksp,&ksp->guess);CHKERRQ(ierr);
ierr = KSPGuessSetType(ksp->guess,guesstype);CHKERRQ(ierr);
ierr = KSPGuessSetFromOptions(ksp->guess);CHKERRQ(ierr);
} else { /* old option for KSP */
nmax = 2;
ierr = PetscOptionsIntArray("-ksp_fischer_guess","Use Paul Fischer's algorithm for initial guess","KSPSetUseFischerGuess",model,&nmax,&flag);CHKERRQ(ierr);
if (flag) {
if (nmax != 2) SETERRQ(comm,PETSC_ERR_ARG_OUTOFRANGE,"Must pass in model,size as arguments");
ierr = KSPSetUseFischerGuess(ksp,model[0],model[1]);CHKERRQ(ierr);
}
}
ierr = PetscOptionsEList("-ksp_convergence_test","Convergence test","KSPSetConvergenceTest",convtests,3,"default",&indx,&flg);CHKERRQ(ierr);
if (flg) {
switch (indx) {
case 0:
ierr = KSPConvergedDefaultCreate(&ctx);CHKERRQ(ierr);
ierr = KSPSetConvergenceTest(ksp,KSPConvergedDefault,ctx,KSPConvergedDefaultDestroy);CHKERRQ(ierr);
break;
case 1: ierr = KSPSetConvergenceTest(ksp,KSPConvergedSkip,NULL,NULL);CHKERRQ(ierr); break;
case 2:
ierr = KSPConvergedDefaultCreate(&ctx);CHKERRQ(ierr);
ierr = KSPSetConvergenceTest(ksp,KSPLSQRConvergedDefault,ctx,KSPConvergedDefaultDestroy);CHKERRQ(ierr);
break;
}
}
ierr = KSPSetUpNorms_Private(ksp,PETSC_FALSE,&normtype,NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-ksp_norm_type","KSP Norm type","KSPSetNormType",KSPNormTypes,(PetscEnum)normtype,(PetscEnum*)&normtype,&flg);CHKERRQ(ierr);
if (flg) { ierr = KSPSetNormType(ksp,normtype);CHKERRQ(ierr); }
ierr = PetscOptionsInt("-ksp_check_norm_iteration","First iteration to compute residual norm","KSPSetCheckNormIteration",ksp->chknorm,&ksp->chknorm,NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_lag_norm","Lag the calculation of the residual norm","KSPSetLagNorm",ksp->lagnorm,&flag,&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPSetLagNorm(ksp,flag);CHKERRQ(ierr);
}
ierr = KSPGetDiagonalScale(ksp,&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_diagonal_scale","Diagonal scale matrix before building preconditioner","KSPSetDiagonalScale",flag,&flag,&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPSetDiagonalScale(ksp,flag);CHKERRQ(ierr);
}
ierr = KSPGetDiagonalScaleFix(ksp,&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ksp_diagonal_scale_fix","Fix diagonally scaled matrix after solve","KSPSetDiagonalScaleFix",flag,&flag,&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPSetDiagonalScaleFix(ksp,flag);CHKERRQ(ierr);
}
ierr = PetscOptionsBool("-ksp_constant_null_space","Add constant null space to Krylov solver matrix","MatSetNullSpace",PETSC_FALSE,&flg,&set);CHKERRQ(ierr);
if (set && flg) {
MatNullSpace nsp;
Mat Amat;
ierr = MatNullSpaceCreate(comm,PETSC_TRUE,0,NULL,&nsp);CHKERRQ(ierr);
ierr = PCGetOperators(ksp->pc,&Amat,NULL);CHKERRQ(ierr);
if (Amat) {
ierr = MatSetNullSpace(Amat,nsp);CHKERRQ(ierr);
ierr = MatNullSpaceDestroy(&nsp);CHKERRQ(ierr);
} else SETERRQ(comm,PETSC_ERR_ARG_WRONGSTATE,"Cannot set nullspace, matrix has not yet been provided");
}
ierr = PetscOptionsBool("-ksp_monitor_cancel","Remove any hardwired monitor routines","KSPMonitorCancel",PETSC_FALSE,&flg,&set);CHKERRQ(ierr);
/* -----------------------------------------------------------------------*/
/*
Cancels all monitors hardwired into code before call to KSPSetFromOptions()
*/
if (set && flg) {
ierr = KSPMonitorCancel(ksp);CHKERRQ(ierr);
}
ierr = KSPMonitorSetFromOptions(ksp,"-ksp_monitor","Monitor the (preconditioned) residual norm","KSPMonitorDefault",KSPMonitorDefault);CHKERRQ(ierr);
ierr = KSPMonitorSetFromOptions(ksp,"-ksp_monitor_range","Monitor the percentage of large entries in the residual","KSPMonitorRange",KSPMonitorRange);CHKERRQ(ierr);
ierr = KSPMonitorSetFromOptions(ksp,"-ksp_monitor_true_residual","Monitor the unprecondiitoned residual norm","KSPMOnitorTrueResidual",KSPMonitorTrueResidualNorm);CHKERRQ(ierr);
ierr = KSPMonitorSetFromOptions(ksp,"-ksp_monitor_max","Monitor the maximum norm of the residual","KSPMonitorTrueResidualMaxNorm",KSPMonitorTrueResidualMaxNorm);CHKERRQ(ierr);
ierr = KSPMonitorSetFromOptions(ksp,"-ksp_monitor_short","Monitor preconditioned residual norm with fewer digits","KSPMonitorDefaultShort",KSPMonitorDefaultShort);CHKERRQ(ierr);
ierr = KSPMonitorSetFromOptions(ksp,"-ksp_monitor_solution","Monitor the solution","KSPMonitorSolution",KSPMonitorSolution);CHKERRQ(ierr);
ierr = KSPMonitorSetFromOptions(ksp,"-ksp_monitor_singular_value","Monitor singular values","KSPMonitorSingularValue",KSPMonitorSingularValue);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,((PetscObject)ksp)->prefix,"-ksp_monitor_singular_value",&flg);CHKERRQ(ierr);
if (flg) {
ierr = KSPSetComputeSingularValues(ksp,PETSC_TRUE);CHKERRQ(ierr);
}
ierr = PetscObjectTypeCompare((PetscObject)ksp->pc,PCKSP,&flg);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)ksp->pc,PCBJACOBI,&flag);CHKERRQ(ierr);
if (flg || flag) {
/* A hack for using dynamic tolerance in preconditioner */
ierr = PetscOptionsString("-sub_ksp_dynamic_tolerance","Use dynamic tolerance for PC if PC is a KSP","KSPMonitorDynamicTolerance","stdout",monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {
KSPDynTolCtx *scale;
ierr = PetscMalloc1(1,&scale);CHKERRQ(ierr);
scale->bnrm = -1.0;
scale->coef = 1.0;
ierr = PetscOptionsReal("-sub_ksp_dynamic_tolerance_param","Parameter of dynamic tolerance for inner PCKSP","KSPMonitorDynamicToleranceParam",scale->coef,&scale->coef,&flg);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorDynamicTolerance,scale,KSPMonitorDynamicToleranceDestroy);CHKERRQ(ierr);
}
}
/*
Calls Python function
*/
ierr = PetscOptionsString("-ksp_monitor_python","Use Python function","KSPMonitorSet",0,monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {ierr = PetscPythonMonitorSet((PetscObject)ksp,monfilename);CHKERRQ(ierr);}
/*
Graphically plots preconditioned residual norm
*/
ierr = PetscOptionsBool("-ksp_monitor_lg_residualnorm","Monitor graphically preconditioned residual norm","KSPMonitorSet",PETSC_FALSE,&flg,&set);CHKERRQ(ierr);
if (set && flg) {
PetscDrawLG ctx;
ierr = KSPMonitorLGResidualNormCreate(comm,NULL,NULL,PETSC_DECIDE,PETSC_DECIDE,400,300,&ctx);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorLGResidualNorm,ctx,(PetscErrorCode (*)(void**))PetscDrawLGDestroy);CHKERRQ(ierr);
}
/*
Graphically plots preconditioned and true residual norm
*/
ierr = PetscOptionsBool("-ksp_monitor_lg_true_residualnorm","Monitor graphically true residual norm","KSPMonitorSet",PETSC_FALSE,&flg,&set);CHKERRQ(ierr);
if (set && flg) {
PetscDrawLG ctx;
ierr = KSPMonitorLGTrueResidualNormCreate(comm,NULL,NULL,PETSC_DECIDE,PETSC_DECIDE,400,300,&ctx);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorLGTrueResidualNorm,ctx,(PetscErrorCode (*)(void**))PetscDrawLGDestroy);CHKERRQ(ierr);
}
/*
Graphically plots preconditioned residual norm and range of residual element values
*/
ierr = PetscOptionsBool("-ksp_monitor_lg_range","Monitor graphically range of preconditioned residual norm","KSPMonitorSet",PETSC_FALSE,&flg,&set);CHKERRQ(ierr);
if (set && flg) {
PetscViewer ctx;
ierr = PetscViewerDrawOpen(comm,NULL,NULL,PETSC_DECIDE,PETSC_DECIDE,400,300,&ctx);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorLGRange,ctx,(PetscErrorCode (*)(void**))PetscViewerDestroy);CHKERRQ(ierr);
}
/* TODO Do these show up in help? */
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view", &ksp->viewer, &ksp->format, &ksp->view);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_pre", &ksp->viewerPre, &ksp->formatPre, &ksp->viewPre);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_converged_reason", &ksp->viewerReason, &ksp->formatReason, &ksp->viewReason);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_mat", &ksp->viewerMat, &ksp->formatMat, &ksp->viewMat);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_pmat", &ksp->viewerPMat, &ksp->formatPMat, &ksp->viewPMat);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_rhs", &ksp->viewerRhs, &ksp->formatRhs, &ksp->viewRhs);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_solution", &ksp->viewerSol, &ksp->formatSol, &ksp->viewSol);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_mat_explicit", &ksp->viewerMatExp, &ksp->formatMatExp, &ksp->viewMatExp);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_eigenvalues", &ksp->viewerEV, &ksp->formatEV, &ksp->viewEV);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_singularvalues", &ksp->viewerSV, &ksp->formatSV, &ksp->viewSV);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_eigenvalues_explicit", &ksp->viewerEVExp, &ksp->formatEVExp, &ksp->viewEVExp);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_final_residual", &ksp->viewerFinalRes,&ksp->formatFinalRes,&ksp->viewFinalRes);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_preconditioned_operator_explicit",&ksp->viewerPOpExp, &ksp->formatPOpExp, &ksp->viewPOpExp);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(comm,((PetscObject) ksp)->options,prefix,"-ksp_view_diagonal_scale", &ksp->viewerDScale, &ksp->formatDScale, &ksp->viewDScale);CHKERRQ(ierr);
/* Deprecated options */
if (!ksp->viewEV) {ierr = PetscOptionsGetViewer(comm, ((PetscObject) ksp)->options,prefix, "-ksp_compute_eigenvalues", &ksp->viewerEV, &ksp->formatEV, &ksp->viewEV);CHKERRQ(ierr);}
if (!ksp->viewEV) {
ierr = PetscOptionsName("-ksp_plot_eigenvalues", "[deprecated since PETSc 3.9; use -ksp_view_eigenvalues draw]", "KSPView", &ksp->viewEV);CHKERRQ(ierr);
if (ksp->viewEV) {
ksp->formatEV = PETSC_VIEWER_DEFAULT;
ksp->viewerEV = PETSC_VIEWER_DRAW_(comm);
ierr = PetscObjectReference((PetscObject) ksp->viewerEV);CHKERRQ(ierr);
}
}
if (!ksp->viewEV) {
ierr = PetscOptionsName("-ksp_plot_eigencontours", "[deprecated since PETSc 3.9; use -ksp_view_eigenvalues draw::draw_contour]", "KSPView", &ksp->viewEV);CHKERRQ(ierr);
if (ksp->viewEV) {
ksp->formatEV = PETSC_VIEWER_DRAW_CONTOUR;
ksp->viewerEV = PETSC_VIEWER_DRAW_(comm);
ierr = PetscObjectReference((PetscObject) ksp->viewerEV);CHKERRQ(ierr);
}
}
if (!ksp->viewEVExp) {ierr = PetscOptionsGetViewer(comm, ((PetscObject) ksp)->options,prefix, "-ksp_compute_eigenvalues_explicitly", &ksp->viewerEVExp, &ksp->formatEVExp, &ksp->viewEVExp);CHKERRQ(ierr);}
if (!ksp->viewEVExp) {
ierr = PetscOptionsName("-ksp_plot_eigenvalues_explicitly", "[deprecated since PETSc 3.9; use -ksp_view_eigenvalues_explicit draw]", "KSPView", &ksp->viewEVExp);CHKERRQ(ierr);
if (ksp->viewEVExp) {
ksp->formatEVExp = PETSC_VIEWER_DEFAULT;
ksp->viewerEVExp = PETSC_VIEWER_DRAW_(comm);
ierr = PetscObjectReference((PetscObject) ksp->viewerEVExp);CHKERRQ(ierr);
}
}
if (!ksp->viewSV) {ierr = PetscOptionsGetViewer(comm, ((PetscObject) ksp)->options,prefix, "-ksp_compute_singularvalues", &ksp->viewerSV, &ksp->formatSV, &ksp->viewSV);CHKERRQ(ierr);}
if (!ksp->viewFinalRes) {ierr = PetscOptionsGetViewer(comm, ((PetscObject) ksp)->options,prefix, "-ksp_final_residual", &ksp->viewerFinalRes, &ksp->formatFinalRes, &ksp->viewFinalRes);CHKERRQ(ierr);}
#if defined(PETSC_HAVE_SAWS)
/*
Publish convergence information using AMS
*/
ierr = PetscOptionsBool("-ksp_monitor_saws","Publish KSP progress using SAWs","KSPMonitorSet",PETSC_FALSE,&flg,&set);CHKERRQ(ierr);
if (set && flg) {
void *ctx;
ierr = KSPMonitorSAWsCreate(ksp,&ctx);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPMonitorSAWs,ctx,KSPMonitorSAWsDestroy);CHKERRQ(ierr);
ierr = KSPSetComputeSingularValues(ksp,PETSC_TRUE);CHKERRQ(ierr);
}
#endif
/* -----------------------------------------------------------------------*/
ierr = KSPSetUpNorms_Private(ksp,PETSC_FALSE,NULL,&pcside);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-ksp_pc_side","KSP preconditioner side","KSPSetPCSide",PCSides,(PetscEnum)pcside,(PetscEnum*)&pcside,&flg);CHKERRQ(ierr);
if (flg) {ierr = KSPSetPCSide(ksp,pcside);CHKERRQ(ierr);}
ierr = PetscOptionsBool("-ksp_compute_singularvalues","Compute singular values of preconditioned operator","KSPSetComputeSingularValues",ksp->calc_sings,&flg,&set);CHKERRQ(ierr);
if (set) { ierr = KSPSetComputeSingularValues(ksp,flg);CHKERRQ(ierr); }
ierr = PetscOptionsBool("-ksp_compute_eigenvalues","Compute eigenvalues of preconditioned operator","KSPSetComputeSingularValues",ksp->calc_sings,&flg,&set);CHKERRQ(ierr);
if (set) { ierr = KSPSetComputeSingularValues(ksp,flg);CHKERRQ(ierr); }
ierr = PetscOptionsBool("-ksp_plot_eigenvalues","Scatter plot extreme eigenvalues","KSPSetComputeSingularValues",PETSC_FALSE,&flg,&set);CHKERRQ(ierr);
if (set) { ierr = KSPSetComputeSingularValues(ksp,flg);CHKERRQ(ierr); }
#if defined(PETSC_HAVE_SAWS)
{
PetscBool set;
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_saws_block","Block for SAWs at end of KSPSolve","PetscObjectSAWsBlock",((PetscObject)ksp)->amspublishblock,&flg,&set);CHKERRQ(ierr);
if (set) {
ierr = PetscObjectSAWsSetBlock((PetscObject)ksp,flg);CHKERRQ(ierr);
}
}
#endif
if (ksp->ops->setfromoptions) {
ierr = (*ksp->ops->setfromoptions)(PetscOptionsObject,ksp);CHKERRQ(ierr);
}
skipoptions:
/* process any options handlers added with PetscObjectAddOptionsHandler() */
ierr = PetscObjectProcessOptionsHandlers(PetscOptionsObject,(PetscObject)ksp);CHKERRQ(ierr);
ierr = PetscOptionsEnd();CHKERRQ(ierr);
ksp->setfromoptionscalled++;
PetscFunctionReturn(0);
}