PETSC_EXTERN PetscErrorCode KSPCreate_MINRES(KSP ksp)
{
KSP_MINRES *minres;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,3);CHKERRQ(ierr);
ierr = PetscNewLog(ksp,&minres);CHKERRQ(ierr);
/* this parameter is arbitrary; but e-50 didn't work for __float128 in one example */
#if defined(PETSC_USE_REAL___FLOAT128)
minres->haptol = 1.e-100;
#else
minres->haptol = 1.e-50;
#endif
ksp->data = (void*)minres;
/*
Sets the functions that are associated with this data structure
(in C++ this is the same as defining virtual functions)
*/
ksp->ops->setup = KSPSetUp_MINRES;
ksp->ops->solve = KSPSolve_MINRES;
ksp->ops->destroy = KSPDestroyDefault;
ksp->ops->setfromoptions = 0;
ksp->ops->buildsolution = KSPBuildSolutionDefault;
ksp->ops->buildresidual = KSPBuildResidualDefault;
PetscFunctionReturn(0);
}
/*MC
KSPGCR - Implements the preconditioned Generalized Conjugate Residual method.
Options Database Keys:
+ -ksp_gcr_restart <restart> - the number of stored vectors to orthogonalize against
Level: beginner
Notes: The GCR Krylov method supports non-symmetric matrices and permits the use of a preconditioner
which may vary from one iteration to the next. Users can can define a method to vary the
preconditioner between iterates via KSPGCRSetModifyPC().
Restarts are solves with x0 not equal to zero. When a restart occurs, the initial starting
solution is given by the current estimate for x which was obtained by the last restart
iterations of the GCR algorithm.
Unlike GMRES and FGMRES, when using GCR, the solution and residual vector can be directly accessed at any iterate,
with zero computational cost, via a call to KSPBuildSolution() and KSPBuildResidual() respectively.
This implementation of GCR will only apply the stopping condition test whenever ksp->its > ksp->chknorm,
where ksp->chknorm is specified via the command line argument -ksp_check_norm_iteration or via
the function KSPSetCheckNormIteration().
The method implemented requires the storage of 2 x restart + 1 vectors, twice as much as GMRES.
Support only for right preconditioning.
Contributed by Dave May
References:
S. C. Eisenstat, H. C. Elman, and H. C. Schultz. Variational iterative methods for
non-symmetric systems of linear equations. SIAM J. Numer. Anal., 20, 345-357, 1983
.seealso: KSPCreate(), KSPSetType(), KSPType (for list of available types), KSP,
KSPGCRSetRestart(), KSPGCRSetModifyPC(), KSPGMRES, KSPFGMRES
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "KSPCreate_GCR"
PetscErrorCode KSPCreate_GCR(KSP ksp)
{
PetscErrorCode ierr;
KSP_GCR *ctx;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,KSP_GCR,&ctx);CHKERRQ(ierr);
ctx->restart = 30;
ctx->n_restarts = 0;
ksp->data = (void*)ctx;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_RIGHT,2);CHKERRQ(ierr);
ksp->ops->setup = KSPSetUp_GCR;
ksp->ops->solve = KSPSolve_GCR;
ksp->ops->reset = KSPReset_GCR;
ksp->ops->destroy = KSPDestroy_GCR;
ksp->ops->view = KSPView_GCR;
ksp->ops->setfromoptions = KSPSetFromOptions_GCR;
ksp->ops->buildsolution = KSPBuildSolution_GCR;
ksp->ops->buildresidual = KSPBuildResidual_GCR;
ierr = PetscObjectComposeFunctionDynamic( (PetscObject)ksp, "KSPGCRSetRestart_C",
"KSPGCRSetRestart_GCR",KSPGCRSetRestart_GCR );CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGCRSetModifyPC_C",
"KSPGCRSetModifyPC_GCR",KSPGCRSetModifyPC_GCR);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "KSPCreate_TEST"
PetscErrorCode PETSCKSP_DLLEXPORT KSPCreate_TEST(KSP ksp)
{
PetscErrorCode ierr;
PetscFunctionBegin;
#if ( (PETSC_VERSION_MAJOR >= 3) && (PETSC_VERSION_MINOR >= 2 ) )
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_NONE,PC_LEFT,1);CHKERRQ(ierr);
#endif
/*
Sets the functions that are associated with this data structure
(in C++ this is the same as defining virtual functions)
*/
ksp->ops->setup = KSPSetUp_TEST;
ksp->ops->solve = KSPSolve_TEST;
ksp->ops->destroy = KSPDestroy_TEST;
ksp->ops->view = KSPView_TEST;
ksp->ops->setfromoptions = KSPSetFromOptions_TEST;
ksp->ops->buildsolution = KSPDefaultBuildSolution;
ksp->ops->buildresidual = KSPDefaultBuildResidual;
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode KSPCreate_QCG(KSP ksp)
{
PetscErrorCode ierr;
KSP_QCG *cgP;
PetscFunctionBegin;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_SYMMETRIC,3);CHKERRQ(ierr);
ierr = PetscNewLog(ksp,&cgP);CHKERRQ(ierr);
ksp->data = (void*)cgP;
ksp->ops->setup = KSPSetUp_QCG;
ksp->ops->setfromoptions = KSPSetFromOptions_QCG;
ksp->ops->solve = KSPSolve_QCG;
ksp->ops->destroy = KSPDestroy_QCG;
ksp->ops->buildsolution = KSPBuildSolutionDefault;
ksp->ops->buildresidual = KSPBuildResidualDefault;
ksp->ops->setfromoptions = 0;
ksp->ops->view = 0;
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPQCGGetQuadratic_C",KSPQCGGetQuadratic_QCG);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPQCGGetTrialStepNorm_C",KSPQCGGetTrialStepNorm_QCG);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPQCGSetTrustRegionRadius_C",KSPQCGSetTrustRegionRadius_QCG);CHKERRQ(ierr);
cgP->delta = PETSC_MAX_REAL; /* default trust region radius is infinite */
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode KSPCreate_LCD(KSP ksp)
{
PetscErrorCode ierr;
KSP_LCD *lcd;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,&lcd);
CHKERRQ(ierr);
ksp->data = (void*)lcd;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,3);
CHKERRQ(ierr);
lcd->restart = 30;
lcd->haptol = 1.0e-30;
/*
Sets the functions that are associated with this data structure
(in C++ this is the same as defining virtual functions)
*/
ksp->ops->setup = KSPSetUp_LCD;
ksp->ops->solve = KSPSolve_LCD;
ksp->ops->reset = KSPReset_LCD;
ksp->ops->destroy = KSPDestroy_LCD;
ksp->ops->view = KSPView_LCD;
ksp->ops->setfromoptions = KSPSetFromOptions_LCD;
ksp->ops->buildsolution = KSPBuildSolutionDefault;
ksp->ops->buildresidual = KSPBuildResidualDefault;
PetscFunctionReturn(0);
}
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "KSPCreate_STCG"
PetscErrorCode KSPCreate_STCG(KSP ksp)
{
PetscErrorCode ierr;
KSP_STCG *cg;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,KSP_STCG, &cg);CHKERRQ(ierr);
cg->radius = 0.0;
cg->dtype = STCG_UNPRECONDITIONED_DIRECTION;
ksp->data = (void *) cg;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_LEFT,2);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,1);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_NATURAL,PC_LEFT,1);CHKERRQ(ierr);
/***************************************************************************/
/* Sets the functions that are associated with this data structure */
/* (in C++ this is the same as defining virtual functions). */
/***************************************************************************/
ksp->ops->setup = KSPSetUp_STCG;
ksp->ops->solve = KSPSolve_STCG;
ksp->ops->destroy = KSPDestroy_STCG;
ksp->ops->setfromoptions = KSPSetFromOptions_STCG;
ksp->ops->buildsolution = KSPDefaultBuildSolution;
ksp->ops->buildresidual = KSPDefaultBuildResidual;
ksp->ops->view = 0;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,
"KSPSTCGSetRadius_C",
"KSPSTCGSetRadius_STCG",
KSPSTCGSetRadius_STCG);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,
"KSPSTCGGetNormD_C",
"KSPSTCGGetNormD_STCG",
KSPSTCGGetNormD_STCG);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,
"KSPSTCGGetObjFcn_C",
"KSPSTCGGetObjFcn_STCG",
KSPSTCGGetObjFcn_STCG);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode KSPCreate_FGMRES(KSP ksp)
{
KSP_FGMRES *fgmres;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,&fgmres);CHKERRQ(ierr);
ksp->data = (void*)fgmres;
ksp->ops->buildsolution = KSPBuildSolution_FGMRES;
ksp->ops->setup = KSPSetUp_FGMRES;
ksp->ops->solve = KSPSolve_FGMRES;
ksp->ops->reset = KSPReset_FGMRES;
ksp->ops->destroy = KSPDestroy_FGMRES;
ksp->ops->view = KSPView_GMRES;
ksp->ops->setfromoptions = KSPSetFromOptions_FGMRES;
ksp->ops->computeextremesingularvalues = KSPComputeExtremeSingularValues_GMRES;
ksp->ops->computeeigenvalues = KSPComputeEigenvalues_GMRES;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_RIGHT,2);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_NONE,PC_LEFT,0);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPGMRESSetPreAllocateVectors_C",KSPGMRESSetPreAllocateVectors_GMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPGMRESSetOrthogonalization_C",KSPGMRESSetOrthogonalization_GMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPGMRESGetOrthogonalization_C",KSPGMRESGetOrthogonalization_GMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPGMRESSetRestart_C",KSPGMRESSetRestart_FGMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPGMRESGetRestart_C",KSPGMRESGetRestart_FGMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPFGMRESSetModifyPC_C",KSPFGMRESSetModifyPC_FGMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPGMRESSetCGSRefinementType_C",KSPGMRESSetCGSRefinementType_GMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPGMRESGetCGSRefinementType_C",KSPGMRESGetCGSRefinementType_GMRES);CHKERRQ(ierr);
fgmres->haptol = 1.0e-30;
fgmres->q_preallocate = 0;
fgmres->delta_allocate = FGMRES_DELTA_DIRECTIONS;
fgmres->orthog = KSPGMRESClassicalGramSchmidtOrthogonalization;
fgmres->nrs = 0;
fgmres->sol_temp = 0;
fgmres->max_k = FGMRES_DEFAULT_MAXK;
fgmres->Rsvd = 0;
fgmres->orthogwork = 0;
fgmres->modifypc = KSPFGMRESModifyPCNoChange;
fgmres->modifyctx = NULL;
fgmres->modifydestroy = NULL;
fgmres->cgstype = KSP_GMRES_CGS_REFINE_NEVER;
PetscFunctionReturn(0);
}
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "KSPCreate_BSSCR"
PetscErrorCode PETSCKSP_DLLEXPORT KSPCreate_BSSCR(KSP ksp)
{
KSP_BSSCR *bsscr;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = Stg_PetscNew(KSP_BSSCR,&bsscr);CHKERRQ(ierr);
ierr = PetscLogObjectMemory((PetscObject)ksp,sizeof(KSP_BSSCR));CHKERRQ(ierr);
//ierr = PetscNewLog(ksp,KSP_BSSCR,&bsscr);CHKERRQ(ierr);
ksp->data = (void*)bsscr;
#if ( (PETSC_VERSION_MAJOR >= 3) && (PETSC_VERSION_MINOR >= 2 ) )
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,0);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_LEFT,1);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_NATURAL,PC_LEFT,0);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_NONE,PC_LEFT,1);CHKERRQ(ierr);
#endif
/*
Sets the functions that are associated with this data structure
(in C++ this is the same as defining virtual functions)
*/
ksp->ops->setup = KSPSetUp_BSSCR;
ksp->ops->solve = KSPSolve_BSSCR;
ksp->ops->destroy = KSPDestroy_BSSCR;
ksp->ops->view = KSPView_BSSCR;
ksp->ops->setfromoptions = KSPSetFromOptions_BSSCR;
ksp->ops->buildsolution = KSPDefaultBuildSolution;
ksp->ops->buildresidual = KSPDefaultBuildResidual;
// bsscr->k2type=K2_GMG;
bsscr->k2type = 0;
bsscr->do_scaling = PETSC_FALSE;
bsscr->scaled = PETSC_FALSE;
bsscr->K2built = PETSC_FALSE;
bsscr->check_cb_pressureNS = PETSC_FALSE;/* checker board nullspace */
bsscr->check_const_pressureNS = PETSC_FALSE;/* constant nullspace */
bsscr->check_pressureNS = PETSC_FALSE;/* is true if either of above two are true */
bsscr->t = NULL;/* null space vectors for pressure */
bsscr->v = NULL;
bsscr->nstol = 1e-7;/* null space detection tolerance */
bsscr->uStar = NULL;
bsscr->been_here = 0;
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode KSPCreate_PIPECR(KSP ksp)
{
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,2);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_NONE,PC_LEFT,2);CHKERRQ(ierr);
ksp->ops->setup = KSPSetUp_PIPECR;
ksp->ops->solve = KSPSolve_PIPECR;
ksp->ops->destroy = KSPDestroyDefault;
ksp->ops->view = 0;
ksp->ops->setfromoptions = 0;
ksp->ops->buildsolution = KSPBuildSolutionDefault;
ksp->ops->buildresidual = KSPBuildResidualDefault;
PetscFunctionReturn(0);
}
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "KSPCreate_TCQMR"
PetscErrorCode KSPCreate_TCQMR(KSP ksp)
{
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,2);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_RIGHT,1);CHKERRQ(ierr);
ksp->data = (void*)0;
ksp->ops->buildsolution = KSPDefaultBuildSolution;
ksp->ops->buildresidual = KSPDefaultBuildResidual;
ksp->ops->setup = KSPSetUp_TCQMR;
ksp->ops->solve = KSPSolve_TCQMR;
ksp->ops->destroy = KSPDefaultDestroy;
ksp->ops->setfromoptions = 0;
ksp->ops->view = 0;
PetscFunctionReturn(0);
}
PETSC_EXTERN_C PetscErrorCode KSPCreate_GROPPCG(KSP ksp)
{
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_LEFT,1);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,1);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_NATURAL,PC_LEFT,1);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_NONE,PC_LEFT,1);CHKERRQ(ierr);
ksp->ops->setup = KSPSetUp_GROPPCG;
ksp->ops->solve = KSPSolve_GROPPCG;
ksp->ops->destroy = KSPDefaultDestroy;
ksp->ops->view = 0;
ksp->ops->setfromoptions = 0;
ksp->ops->buildsolution = KSPDefaultBuildSolution;
ksp->ops->buildresidual = KSPDefaultBuildResidual;
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode KSPCreate_NASH(KSP ksp)
{
PetscErrorCode ierr;
KSP_NASH *cg;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,&cg);
CHKERRQ(ierr);
cg->radius = 0.0;
cg->dtype = NASH_UNPRECONDITIONED_DIRECTION;
ksp->data = (void*) cg;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_LEFT,2);
CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,1);
CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_NATURAL,PC_LEFT,1);
CHKERRQ(ierr);
/***************************************************************************/
/* Sets the functions that are associated with this data structure */
/* (in C++ this is the same as defining virtual functions). */
/***************************************************************************/
ksp->ops->setup = KSPSetUp_NASH;
ksp->ops->solve = KSPSolve_NASH;
ksp->ops->destroy = KSPDestroy_NASH;
ksp->ops->setfromoptions = KSPSetFromOptions_NASH;
ksp->ops->buildsolution = KSPBuildSolutionDefault;
ksp->ops->buildresidual = KSPBuildResidualDefault;
ksp->ops->view = 0;
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPNASHSetRadius_C",KSPNASHSetRadius_NASH);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPNASHGetNormD_C",KSPNASHGetNormD_NASH);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPNASHGetObjFcn_C",KSPNASHGetObjFcn_NASH);
CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode KSPCreate_CG(KSP ksp)
{
PetscErrorCode ierr;
KSP_CG *cg;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,&cg);CHKERRQ(ierr);
#if !defined(PETSC_USE_COMPLEX)
cg->type = KSP_CG_SYMMETRIC;
#else
cg->type = KSP_CG_HERMITIAN;
#endif
ksp->data = (void*)cg;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,3);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_LEFT,2);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_NATURAL,PC_LEFT,2);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_NONE,PC_LEFT,2);CHKERRQ(ierr);
/*
Sets the functions that are associated with this data structure
(in C++ this is the same as defining virtual functions)
*/
ksp->ops->setup = KSPSetUp_CG;
ksp->ops->solve = KSPSolve_CG;
ksp->ops->destroy = KSPDestroy_CG;
ksp->ops->view = KSPView_CG;
ksp->ops->setfromoptions = KSPSetFromOptions_CG;
ksp->ops->buildsolution = KSPBuildSolutionDefault;
ksp->ops->buildresidual = KSPBuildResidualDefault;
/*
Attach the function KSPCGSetType_CG() to this object. The routine
KSPCGSetType() checks for this attached function and calls it if it finds
it. (Sort of like a dynamic member function that can be added at run time
*/
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPCGSetType_C",KSPCGSetType_CG);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPCGUseSingleReduction_C",KSPCGUseSingleReduction_CG);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*MC
KSPFBCGSR - Implements a mathematically equivalent variant of FBiCGSTab.
Options Database Keys:
. see KSPSolve()
Level: beginner
Notes:
Only allow right preconditioning
.seealso: KSPCreate(), KSPSetType(), KSPType (for list of available types), KSP, KSPBICG, KSPFBCGSL, KSPSetPCSide()
M*/
PETSC_EXTERN PetscErrorCode KSPCreate_FBCGSR(KSP ksp)
{
PetscErrorCode ierr;
KSP_BCGS *bcgs;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,&bcgs);CHKERRQ(ierr);
ksp->data = bcgs;
ksp->ops->setup = KSPSetUp_FBCGSR;
ksp->ops->solve = KSPSolve_FBCGSR;
ksp->ops->destroy = KSPDestroy_BCGS;
ksp->ops->reset = KSPReset_BCGS;
ksp->ops->buildsolution = KSPBuildSolution_BCGS;
ksp->ops->buildresidual = KSPBuildResidualDefault;
ksp->ops->setfromoptions = KSPSetFromOptions_BCGS;
ksp->pc_side = PC_RIGHT; /* set default PC side */
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,3);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_RIGHT,2);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode KSPCreate_IBCGS(KSP ksp)
{
PetscErrorCode ierr;
PetscFunctionBegin;
ksp->data = (void*)0;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,3);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_RIGHT,2);CHKERRQ(ierr);
ksp->ops->setup = KSPSetUp_IBCGS;
ksp->ops->solve = KSPSolve_IBCGS;
ksp->ops->destroy = KSPDestroyDefault;
ksp->ops->buildsolution = KSPBuildSolutionDefault;
ksp->ops->buildresidual = KSPBuildResidualDefault;
ksp->ops->setfromoptions = 0;
ksp->ops->view = 0;
#if defined(PETSC_USE_COMPLEX)
SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"This is not supported for complex numbers");
#endif
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode KSPCreate_Chebyshev(KSP ksp)
{
PetscErrorCode ierr;
KSP_Chebyshev *chebyshevP;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,&chebyshevP);CHKERRQ(ierr);
ksp->data = (void*)chebyshevP;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,3);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_LEFT,2);CHKERRQ(ierr);
chebyshevP->emin = 0.;
chebyshevP->emax = 0.;
chebyshevP->tform[0] = 0.0;
chebyshevP->tform[1] = 0.1;
chebyshevP->tform[2] = 0;
chebyshevP->tform[3] = 1.1;
chebyshevP->eststeps = 10;
chebyshevP->userandom = PETSC_FALSE;
ksp->ops->setup = KSPSetUp_Chebyshev;
ksp->ops->solve = KSPSolve_Chebyshev;
ksp->ops->destroy = KSPDestroy_Chebyshev;
ksp->ops->buildsolution = KSPBuildSolutionDefault;
ksp->ops->buildresidual = KSPBuildResidualDefault;
ksp->ops->setfromoptions = KSPSetFromOptions_Chebyshev;
ksp->ops->view = KSPView_Chebyshev;
ksp->ops->reset = KSPReset_Chebyshev;
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPChebyshevSetEigenvalues_C",KSPChebyshevSetEigenvalues_Chebyshev);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPChebyshevEstEigSet_C",KSPChebyshevEstEigSet_Chebyshev);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPChebyshevEstEigSetRandom_C",KSPChebyshevEstEigSetRandom_Chebyshev);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPChebyshevEstEigSetUseRandom_C",KSPChebyshevEstEigSetUseRandom_Chebyshev);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPChebyshevEstEigGetKSP_C",KSPChebyshevEstEigGetKSP_Chebyshev);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode KSPCreate_PIPEFGMRES(KSP ksp)
{
KSP_PIPEFGMRES *pipefgmres;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,&pipefgmres);CHKERRQ(ierr);
ksp->data = (void*)pipefgmres;
ksp->ops->buildsolution = KSPBuildSolution_PIPEFGMRES;
ksp->ops->setup = KSPSetUp_PIPEFGMRES;
ksp->ops->solve = KSPSolve_PIPEFGMRES;
ksp->ops->reset = KSPReset_PIPEFGMRES;
ksp->ops->destroy = KSPDestroy_PIPEFGMRES;
ksp->ops->view = KSPView_PIPEFGMRES;
ksp->ops->setfromoptions = KSPSetFromOptions_PIPEFGMRES;
ksp->ops->computeextremesingularvalues = KSPComputeExtremeSingularValues_GMRES;
ksp->ops->computeeigenvalues = KSPComputeEigenvalues_GMRES;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_RIGHT,3);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPGMRESSetPreAllocateVectors_C",KSPGMRESSetPreAllocateVectors_GMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPGMRESSetRestart_C",KSPGMRESSetRestart_GMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)ksp,"KSPGMRESGetRestart_C",KSPGMRESGetRestart_GMRES);CHKERRQ(ierr);
pipefgmres->nextra_vecs = 1;
pipefgmres->haptol = 1.0e-30;
pipefgmres->q_preallocate = 0;
pipefgmres->delta_allocate = PIPEFGMRES_DELTA_DIRECTIONS;
pipefgmres->orthog = 0;
pipefgmres->nrs = 0;
pipefgmres->sol_temp = 0;
pipefgmres->max_k = PIPEFGMRES_DEFAULT_MAXK;
pipefgmres->Rsvd = 0;
pipefgmres->orthogwork = 0;
pipefgmres->cgstype = KSP_GMRES_CGS_REFINE_NEVER;
pipefgmres->shift = 1.0;
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode KSPCreate_MINRES(KSP ksp)
{
KSP_MINRES *minres;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,2);CHKERRQ(ierr);
ierr = PetscNewLog(ksp,KSP_MINRES,&minres);CHKERRQ(ierr);
minres->haptol = 1.e-18;
ksp->data = (void*)minres;
/*
Sets the functions that are associated with this data structure
(in C++ this is the same as defining virtual functions)
*/
ksp->ops->setup = KSPSetUp_MINRES;
ksp->ops->solve = KSPSolve_MINRES;
ksp->ops->destroy = KSPDestroyDefault;
ksp->ops->setfromoptions = 0;
ksp->ops->buildsolution = KSPBuildSolutionDefault;
ksp->ops->buildresidual = KSPBuildResidualDefault;
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode KSPCreate_LSQR(KSP ksp)
{
KSP_LSQR *lsqr;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,KSP_LSQR,&lsqr);CHKERRQ(ierr);
lsqr->se = NULL;
lsqr->se_flg = PETSC_FALSE;
lsqr->arnorm = 0.0;
ksp->data = (void*)lsqr;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_LEFT,2);CHKERRQ(ierr);
ksp->ops->setup = KSPSetUp_LSQR;
ksp->ops->solve = KSPSolve_LSQR;
ksp->ops->destroy = KSPDestroy_LSQR;
ksp->ops->buildsolution = KSPBuildSolutionDefault;
ksp->ops->buildresidual = KSPBuildResidualDefault;
ksp->ops->setfromoptions = KSPSetFromOptions_LSQR;
ksp->ops->view = KSPView_LSQR;
ksp->converged = KSPLSQRDefaultConverged;
PetscFunctionReturn(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);
}
EXTERN_C_END
/*MC
KSPFGMRES - Implements the Flexible Generalized Minimal Residual method.
developed by Saad with restart
Options Database Keys:
+ -ksp_gmres_restart <restart> - the number of Krylov directions to orthogonalize against
. -ksp_gmres_haptol <tol> - sets the tolerance for "happy ending" (exact convergence)
. -ksp_gmres_preallocate - preallocate all the Krylov search directions initially (otherwise groups of
vectors are allocated as needed)
. -ksp_gmres_classicalgramschmidt - use classical (unmodified) Gram-Schmidt to orthogonalize against the Krylov space (fast) (the default)
. -ksp_gmres_modifiedgramschmidt - use modified Gram-Schmidt in the orthogonalization (more stable, but slower)
. -ksp_gmres_cgs_refinement_type <never,ifneeded,always> - determine if iterative refinement is used to increase the
stability of the classical Gram-Schmidt orthogonalization.
. -ksp_gmres_krylov_monitor - plot the Krylov space generated
. -ksp_fgmres_modifypcnochange - do not change the preconditioner between iterations
- -ksp_fgmres_modifypcksp - modify the preconditioner using KSPFGMRESModifyPCKSP()
Level: beginner
Notes: See KSPFGMRESSetModifyPC() for how to vary the preconditioner between iterations
Only right preconditioning is supported.
Notes: The following options -ksp_type fgmres -pc_type ksp -ksp_ksp_type bcgs -ksp_view -ksp_pc_type jacobi make the preconditioner (or inner solver)
be bi-CG-stab with a preconditioner of Jacobi.
Developer Notes: This object is subclassed off of KSPGMRES
.seealso: KSPCreate(), KSPSetType(), KSPType (for list of available types), KSP, KSPGMRES, KSPLGMRES,
KSPGMRESSetRestart(), KSPGMRESSetHapTol(), KSPGMRESSetPreAllocateVectors(), KSPGMRESSetOrthogonalization(), KSPGMRESGetOrthogonalization(),
KSPGMRESClassicalGramSchmidtOrthogonalization(), KSPGMRESModifiedGramSchmidtOrthogonalization(),
KSPGMRESCGSRefinementType, KSPGMRESSetCGSRefinementType(), KSPGMRESGetCGSRefinementType(), KSPGMRESMonitorKrylov(), KSPFGMRESSetModifyPC(),
KSPFGMRESModifyPCKSP()
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "KSPCreate_FGMRES"
PetscErrorCode KSPCreate_FGMRES(KSP ksp)
{
KSP_FGMRES *fgmres;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,KSP_FGMRES,&fgmres);CHKERRQ(ierr);
ksp->data = (void*)fgmres;
ksp->ops->buildsolution = KSPBuildSolution_FGMRES;
ksp->ops->setup = KSPSetUp_FGMRES;
ksp->ops->solve = KSPSolve_FGMRES;
ksp->ops->reset = KSPReset_FGMRES;
ksp->ops->destroy = KSPDestroy_FGMRES;
ksp->ops->view = KSPView_GMRES;
ksp->ops->setfromoptions = KSPSetFromOptions_FGMRES;
ksp->ops->computeextremesingularvalues = KSPComputeExtremeSingularValues_GMRES;
ksp->ops->computeeigenvalues = KSPComputeEigenvalues_GMRES;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_RIGHT,2);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_NONE,PC_LEFT,0);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESSetPreAllocateVectors_C",
"KSPGMRESSetPreAllocateVectors_GMRES",
KSPGMRESSetPreAllocateVectors_GMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESSetOrthogonalization_C",
"KSPGMRESSetOrthogonalization_GMRES",
KSPGMRESSetOrthogonalization_GMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESGetOrthogonalization_C",
"KSPGMRESGetOrthogonalization_GMRES",
KSPGMRESGetOrthogonalization_GMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESSetRestart_C",
"KSPGMRESSetRestart_FGMRES",
KSPGMRESSetRestart_FGMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESGetRestart_C",
"KSPGMRESGetRestart_FGMRES",
KSPGMRESGetRestart_FGMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPFGMRESSetModifyPC_C",
"KSPFGMRESSetModifyPC_FGMRES",
KSPFGMRESSetModifyPC_FGMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESSetCGSRefinementType_C",
"KSPGMRESSetCGSRefinementType_GMRES",
KSPGMRESSetCGSRefinementType_GMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESGetCGSRefinementType_C",
"KSPGMRESGetCGSRefinementType_GMRES",
KSPGMRESGetCGSRefinementType_GMRES);CHKERRQ(ierr);
fgmres->haptol = 1.0e-30;
fgmres->q_preallocate = 0;
fgmres->delta_allocate = FGMRES_DELTA_DIRECTIONS;
fgmres->orthog = KSPGMRESClassicalGramSchmidtOrthogonalization;
fgmres->nrs = 0;
fgmres->sol_temp = 0;
fgmres->max_k = FGMRES_DEFAULT_MAXK;
fgmres->Rsvd = 0;
fgmres->orthogwork = 0;
fgmres->modifypc = KSPFGMRESModifyPCNoChange;
fgmres->modifyctx = PETSC_NULL;
fgmres->modifydestroy = PETSC_NULL;
fgmres->cgstype = KSP_GMRES_CGS_REFINE_NEVER;
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode KSPCreate_AGMRES(KSP ksp)
{
KSP_AGMRES *agmres;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,&agmres);CHKERRQ(ierr);
ksp->data = (void*)agmres;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,3);
CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_RIGHT,2);
CHKERRQ(ierr);
ksp->ops->buildsolution = KSPBuildSolution_AGMRES;
ksp->ops->setup = KSPSetUp_AGMRES;
ksp->ops->solve = KSPSolve_AGMRES;
ksp->ops->destroy = KSPDestroy_AGMRES;
ksp->ops->view = KSPView_AGMRES;
ksp->ops->setfromoptions = KSPSetFromOptions_AGMRES;
ksp->guess_zero = PETSC_TRUE;
ksp->ops->computeextremesingularvalues = KSPComputeExtremeSingularValues_GMRES;
ksp->ops->computeeigenvalues = KSPComputeEigenvalues_GMRES;
ierr = PetscObjectComposeFunction((PetscObject) ksp,"KSPGMRESSetPreAllocateVectors_C",KSPGMRESSetPreAllocateVectors_GMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject) ksp,"KSPGMRESSetOrthogonalization_C",KSPGMRESSetOrthogonalization_GMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject) ksp,"KSPGMRESSetRestart_C",KSPGMRESSetRestart_GMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject) ksp,"KSPGMRESSetHapTol_C",KSPGMRESSetHapTol_GMRES);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject) ksp,"KSPGMRESSetCGSRefinementType_C",KSPGMRESSetCGSRefinementType_GMRES);CHKERRQ(ierr);
/* -- New functions defined in DGMRES -- */
ierr=PetscObjectComposeFunction((PetscObject) ksp, "KSPDGMRESSetEigen_C",KSPDGMRESSetEigen_DGMRES);CHKERRQ(ierr);
ierr=PetscObjectComposeFunction((PetscObject) ksp, "KSPDGMRESComputeSchurForm_C",KSPDGMRESComputeSchurForm_DGMRES);CHKERRQ(ierr);
ierr=PetscObjectComposeFunction((PetscObject) ksp, "KSPDGMRESComputeDeflationData_C",KSPDGMRESComputeDeflationData_DGMRES);CHKERRQ(ierr);
ierr=PetscObjectComposeFunction((PetscObject) ksp, "KSPDGMRESApplyDeflation_C",KSPDGMRESApplyDeflation_DGMRES);CHKERRQ(ierr);
PetscInt KSP_CLASSID = 1;
ierr = PetscLogEventRegister("AGMRESComputeDefl", KSP_CLASSID, &KSP_AGMRESComputeDeflationData);CHKERRQ(ierr);
ierr = PetscLogEventRegister("AGMRESBuildBasis", KSP_CLASSID, &KSP_AGMRESBuildBasis);CHKERRQ(ierr);
ierr = PetscLogEventRegister("AGMRESCompShifts", KSP_CLASSID, &KSP_AGMRESComputeShifts);CHKERRQ(ierr);
ierr = PetscLogEventRegister("AGMRESOrthog", KSP_CLASSID, &KSP_AGMRESRoddec);CHKERRQ(ierr);
agmres->haptol = 1.0e-30;
agmres->q_preallocate = 0;
agmres->delta_allocate = AGMRES_DELTA_DIRECTIONS;
agmres->orthog = KSPGMRESClassicalGramSchmidtOrthogonalization;
agmres->nrs = 0;
agmres->sol_temp = 0;
agmres->max_k = AGMRES_DEFAULT_MAXK;
agmres->Rsvd = 0;
agmres->cgstype = KSP_GMRES_CGS_REFINE_NEVER;
agmres->orthogwork = 0;
/* Default values for the deflation */
agmres->r = 0;
agmres->neig = 0;
agmres->max_neig = 0;
agmres->lambdaN = 0.0;
agmres->smv = SMV;
agmres->bgv = 1;
agmres->force = 0;
agmres->matvecs = 0;
agmres->improve = 0;
agmres->HasShifts = PETSC_FALSE;
agmres->r = 0;
agmres->HasSchur = PETSC_FALSE;
agmres->DeflPrecond = PETSC_FALSE;
PetscFunctionReturn(0);
}
EXTERN_C_END
/* end new lgmres functions */
/*MC
KSPLGMRES - Augments the standard GMRES approximation space with approximations to
the error from previous restart cycles.
Options Database Keys:
+ -ksp_gmres_restart <restart> - total approximation space size (Krylov directions + error approximations)
. -ksp_gmres_haptol <tol> - sets the tolerance for "happy ending" (exact convergence)
. -ksp_gmres_preallocate - preallocate all the Krylov search directions initially (otherwise groups of
vectors are allocated as needed)
. -ksp_gmres_classicalgramschmidt - use classical (unmodified) Gram-Schmidt to orthogonalize against the Krylov space (fast) (the default)
. -ksp_gmres_modifiedgramschmidt - use modified Gram-Schmidt in the orthogonalization (more stable, but slower)
. -ksp_gmres_cgs_refinement_type <never,ifneeded,always> - determine if iterative refinement is used to increase the
stability of the classical Gram-Schmidt orthogonalization.
. -ksp_gmres_krylov_monitor - plot the Krylov space generated
. -ksp_lgmres_augment <k> - number of error approximations to augment the Krylov space with
- -ksp_lgmres_constant - use a constant approx. space size (only affects restart cycles < num. error approx.(k), i.e. the first k restarts)
To run LGMRES(m, k) as described in the above paper, use:
-ksp_gmres_restart <m+k>
-ksp_lgmres_augment <k>
Level: beginner
Notes: Supports both left and right preconditioning, but not symmetric.
References:
A. H. Baker, E.R. Jessup, and T.A. Manteuffel. A technique for
accelerating the convergence of restarted GMRES. SIAM
Journal on Matrix Analysis and Applications, 26 (2005), pp. 962-984.
Developer Notes: This object is subclassed off of KSPGMRES
Contributed by: Allison Baker
.seealso: KSPCreate(), KSPSetType(), KSPType (for list of available types), KSP, KSPFGMRES, KSPGMRES,
KSPGMRESSetRestart(), KSPGMRESSetHapTol(), KSPGMRESSetPreAllocateVectors(), KSPGMRESSetOrthogonalization(), KSPGMRESGetOrthogonalization(),
KSPGMRESClassicalGramSchmidtOrthogonalization(), KSPGMRESModifiedGramSchmidtOrthogonalization(),
KSPGMRESCGSRefinementType, KSPGMRESSetCGSRefinementType(), KSPGMRESGetCGSRefinementType(), KSPGMRESMonitorKrylov(), KSPLGMRESSetAugDim(),
KSPGMRESSetConstant()
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "KSPCreate_LGMRES"
PetscErrorCode KSPCreate_LGMRES(KSP ksp)
{
KSP_LGMRES *lgmres;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,KSP_LGMRES,&lgmres);
CHKERRQ(ierr);
ksp->data = (void*)lgmres;
ksp->ops->buildsolution = KSPBuildSolution_LGMRES;
ksp->ops->setup = KSPSetUp_LGMRES;
ksp->ops->solve = KSPSolve_LGMRES;
ksp->ops->destroy = KSPDestroy_LGMRES;
ksp->ops->view = KSPView_LGMRES;
ksp->ops->setfromoptions = KSPSetFromOptions_LGMRES;
ksp->ops->computeextremesingularvalues = KSPComputeExtremeSingularValues_GMRES;
ksp->ops->computeeigenvalues = KSPComputeEigenvalues_GMRES;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,2);
CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_RIGHT,1);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESSetPreAllocateVectors_C",
"KSPGMRESSetPreAllocateVectors_GMRES",
KSPGMRESSetPreAllocateVectors_GMRES);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESSetOrthogonalization_C",
"KSPGMRESSetOrthogonalization_GMRES",
KSPGMRESSetOrthogonalization_GMRES);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESGetOrthogonalization_C",
"KSPGMRESGetOrthogonalization_GMRES",
KSPGMRESGetOrthogonalization_GMRES);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESSetRestart_C",
"KSPGMRESSetRestart_GMRES",
KSPGMRESSetRestart_GMRES);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESGetRestart_C",
"KSPGMRESGetRestart_GMRES",
KSPGMRESGetRestart_GMRES);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESSetHapTol_C",
"KSPGMRESSetHapTol_GMRES",
KSPGMRESSetHapTol_GMRES);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESSetCGSRefinementType_C",
"KSPGMRESSetCGSRefinementType_GMRES",
KSPGMRESSetCGSRefinementType_GMRES);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPGMRESGetCGSRefinementType_C",
"KSPGMRESGetCGSRefinementType_GMRES",
KSPGMRESGetCGSRefinementType_GMRES);
CHKERRQ(ierr);
/*LGMRES_MOD add extra functions here - like the one to set num of aug vectors */
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPLGMRESSetConstant_C",
"KSPLGMRESSetConstant_LGMRES",
KSPLGMRESSetConstant_LGMRES);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPLGMRESSetAugDim_C",
"KSPLGMRESSetAugDim_LGMRES",
KSPLGMRESSetAugDim_LGMRES);
CHKERRQ(ierr);
/*defaults */
lgmres->haptol = 1.0e-30;
lgmres->q_preallocate = 0;
lgmres->delta_allocate = LGMRES_DELTA_DIRECTIONS;
lgmres->orthog = KSPGMRESClassicalGramSchmidtOrthogonalization;
lgmres->nrs = 0;
lgmres->sol_temp = 0;
lgmres->max_k = LGMRES_DEFAULT_MAXK;
lgmres->Rsvd = 0;
lgmres->cgstype = KSP_GMRES_CGS_REFINE_NEVER;
lgmres->orthogwork = 0;
/*LGMRES_MOD - new defaults */
lgmres->aug_dim = LGMRES_DEFAULT_AUGDIM;
lgmres->aug_ct = 0; /* start with no aug vectors */
lgmres->approx_constant = 0;
lgmres->matvecs = 0;
PetscFunctionReturn(0);
}
PETSC_EXTERN void PETSC_STDCALL kspsetsupportednorm_(KSP ksp,KSPNormType *normtype,PCSide *pcside,PetscInt *priority, int *__ierr ){
*__ierr = KSPSetSupportedNorm(
(KSP)PetscToPointer((ksp) ),*normtype,*pcside,*priority);
}
EXTERN_C_END
/*
KSPCreate_CG - Creates the data structure for the Krylov method CG and sets the
function pointers for all the routines it needs to call (KSPSolve_CG() etc)
It must be wrapped in EXTERN_C_BEGIN to be dynamically linkable in C++
*/
/*MC
KSPCG - The preconditioned conjugate gradient (PCG) iterative method
Options Database Keys:
+ -ksp_cg_type Hermitian - (for complex matrices only) indicates the matrix is Hermitian, see KSPCGSetType()
. -ksp_cg_type symmetric - (for complex matrices only) indicates the matrix is symmetric
- -ksp_cg_single_reduction - performs both inner products needed in the algorithm with a single MPI_Allreduce() call, see KSPCGUseSingleReduction()
Level: beginner
Notes: The PCG method requires both the matrix and preconditioner to be symmetric positive (or negative) (semi) definite
Only left preconditioning is supported.
For complex numbers there are two different CG methods. One for Hermitian symmetric matrices and one for non-Hermitian symmetric matrices. Use
KSPCGSetType() to indicate which type you are using.
Developer Notes: KSPSolve_CG() should actually query the matrix to determine if it is Hermitian symmetric or not and NOT require the user to
indicate it to the KSP object.
References:
Methods of Conjugate Gradients for Solving Linear Systems, Magnus R. Hestenes and Eduard Stiefel,
Journal of Research of the National Bureau of Standards Vol. 49, No. 6, December 1952 Research Paper 2379
pp. 409--436.
.seealso: KSPCreate(), KSPSetType(), KSPType (for list of available types), KSP,
KSPCGSetType(), KSPCGUseSingleReduction()
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "KSPCreate_CG"
PetscErrorCode KSPCreate_CG(KSP ksp)
{
PetscErrorCode ierr;
KSP_CG *cg;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,KSP_CG,&cg);CHKERRQ(ierr);
#if !defined(PETSC_USE_COMPLEX)
cg->type = KSP_CG_SYMMETRIC;
#else
cg->type = KSP_CG_HERMITIAN;
#endif
ksp->data = (void*)cg;
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_PRECONDITIONED,PC_LEFT,2);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_UNPRECONDITIONED,PC_LEFT,1);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_NATURAL,PC_LEFT,1);CHKERRQ(ierr);
ierr = KSPSetSupportedNorm(ksp,KSP_NORM_NONE,PC_LEFT,1);CHKERRQ(ierr);
/*
Sets the functions that are associated with this data structure
(in C++ this is the same as defining virtual functions)
*/
ksp->ops->setup = KSPSetUp_CG;
ksp->ops->solve = KSPSolve_CG;
ksp->ops->destroy = KSPDestroy_CG;
ksp->ops->view = KSPView_CG;
ksp->ops->setfromoptions = KSPSetFromOptions_CG;
ksp->ops->buildsolution = KSPDefaultBuildSolution;
ksp->ops->buildresidual = KSPDefaultBuildResidual;
/*
Attach the function KSPCGSetType_CG() to this object. The routine
KSPCGSetType() checks for this attached function and calls it if it finds
it. (Sort of like a dynamic member function that can be added at run time
*/
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPCGSetType_C","KSPCGSetType_CG", KSPCGSetType_CG);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPCGUseSingleReduction_C","KSPCGUseSingleReduction_CG", KSPCGUseSingleReduction_CG);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
