/*@
DMDASetBoundaryType - Sets the type of ghost nodes on domain boundaries.
Not collective
Input Parameter:
+ da - The DMDA
- bx,by,bz - One of DMDA_BOUNDARY_NONE, DMDA_BOUNDARY_GHOSTED, DMDA_BOUNDARY_PERIODIC
Level: intermediate
.keywords: distributed array, periodicity
.seealso: DMDACreate(), DMDestroy(), DMDA, DMDABoundaryType
@*/
PetscErrorCode DMDASetBoundaryType(DM da,DMDABoundaryType bx,DMDABoundaryType by,DMDABoundaryType bz)
{
DM_DA *dd = (DM_DA*)da->data;
PetscFunctionBegin;
PetscValidHeaderSpecific(da,DM_CLASSID,1);
PetscValidLogicalCollectiveEnum(da,bx,2);
PetscValidLogicalCollectiveEnum(da,by,3);
PetscValidLogicalCollectiveEnum(da,bz,4);
if (da->setupcalled) SETERRQ(((PetscObject)da)->comm,PETSC_ERR_ARG_WRONGSTATE,"This function must be called before DMSetUp()");
dd->bx = bx;
dd->by = by;
dd->bz = bz;
PetscFunctionReturn(0);
}
/*@
NEPSetWhichEigenpairs - Specifies which portion of the spectrum is
to be sought.
Logically Collective on NEP
Input Parameters:
+ nep - eigensolver context obtained from NEPCreate()
- which - the portion of the spectrum to be sought
Possible values:
The parameter 'which' can have one of these values
+ NEP_LARGEST_MAGNITUDE - largest eigenvalues in magnitude (default)
. NEP_SMALLEST_MAGNITUDE - smallest eigenvalues in magnitude
. NEP_LARGEST_REAL - largest real parts
. NEP_SMALLEST_REAL - smallest real parts
. NEP_LARGEST_IMAGINARY - largest imaginary parts
. NEP_SMALLEST_IMAGINARY - smallest imaginary parts
. NEP_TARGET_MAGNITUDE - eigenvalues closest to the target (in magnitude)
. NEP_TARGET_REAL - eigenvalues with real part closest to target
- NEP_TARGET_IMAGINARY - eigenvalues with imaginary part closest to target
Options Database Keys:
+ -nep_largest_magnitude - Sets largest eigenvalues in magnitude
. -nep_smallest_magnitude - Sets smallest eigenvalues in magnitude
. -nep_largest_real - Sets largest real parts
. -nep_smallest_real - Sets smallest real parts
. -nep_largest_imaginary - Sets largest imaginary parts
. -nep_smallest_imaginary - Sets smallest imaginary parts
. -nep_target_magnitude - Sets eigenvalues closest to target
. -nep_target_real - Sets real parts closest to target
- -nep_target_imaginary - Sets imaginary parts closest to target
Notes:
Not all eigensolvers implemented in NEP account for all the possible values
stated above. If SLEPc is compiled for real numbers NEP_LARGEST_IMAGINARY
and NEP_SMALLEST_IMAGINARY use the absolute value of the imaginary part
for eigenvalue selection.
Level: intermediate
.seealso: NEPGetWhichEigenpairs(), NEPWhich
@*/
PetscErrorCode NEPSetWhichEigenpairs(NEP nep,NEPWhich which)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(nep,NEP_CLASSID,1);
PetscValidLogicalCollectiveEnum(nep,which,2);
switch (which) {
case NEP_LARGEST_MAGNITUDE:
case NEP_SMALLEST_MAGNITUDE:
case NEP_LARGEST_REAL:
case NEP_SMALLEST_REAL:
case NEP_LARGEST_IMAGINARY:
case NEP_SMALLEST_IMAGINARY:
case NEP_TARGET_MAGNITUDE:
case NEP_TARGET_REAL:
#if defined(PETSC_USE_COMPLEX)
case NEP_TARGET_IMAGINARY:
#endif
if (nep->which != which) {
nep->state = NEP_STATE_INITIAL;
nep->which = which;
}
break;
default:
SETERRQ(PetscObjectComm((PetscObject)nep),PETSC_ERR_ARG_OUTOFRANGE,"Invalid 'which' value");
}
PetscFunctionReturn(0);
}
/*@
NEPSetRefine - Specifies the refinement type (and options) to be used
after the solve.
Logically Collective on NEP
Input Parameters:
+ nep - the nonlinear eigensolver context
. refine - refinement type
. tol - the convergence tolerance
- its - maximum number of refinement iterations
Options Database Keys:
+ -nep_refine <type> - refinement type, one of <none,simple,multiple>
. -nep_refine_tol <tol> - the tolerance
- -nep_refine_its <its> - number of iterations
Notes:
By default, iterative refinement is disabled, since it may be very
costly. There are two possible refinement strategies: simple and multiple.
The simple approach performs iterative refinement on each of the
converged eigenpairs individually, whereas the multiple strategy works
with the invariant pair as a whole, refining all eigenpairs simultaneously.
The latter may be required for the case of multiple eigenvalues.
The tol and its parameters specify the stopping criterion. In the simple
method, refinement continues until the residual of each eigenpair is
below the tolerance (tol defaults to the NEP tol, but may be set to a
different value). In contrast, the multiple method simply performs its
refinement iterations (just one by default).
Level: intermediate
.seealso: NEPGetRefine()
@*/
PetscErrorCode NEPSetRefine(NEP nep,NEPRefine refine,PetscReal tol,PetscInt its)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(nep,NEP_CLASSID,1);
PetscValidLogicalCollectiveEnum(nep,refine,2);
PetscValidLogicalCollectiveReal(nep,tol,3);
PetscValidLogicalCollectiveInt(nep,its,4);
nep->refine = refine;
if (refine) { /* process parameters only if not REFINE_NONE */
if (tol == PETSC_DEFAULT || tol == PETSC_DECIDE) {
nep->reftol = nep->rtol;
} else {
if (tol<=0.0) SETERRQ(PetscObjectComm((PetscObject)nep),PETSC_ERR_ARG_OUTOFRANGE,"Illegal value of tol. Must be > 0");
nep->reftol = tol;
}
if (its==PETSC_DECIDE || its==PETSC_DEFAULT) {
nep->rits = PETSC_DEFAULT;
} else {
if (its<=0) SETERRQ(PetscObjectComm((PetscObject)nep),PETSC_ERR_ARG_OUTOFRANGE,"Illegal value of its. Must be > 0");
nep->rits = its;
}
}
nep->state = NEP_STATE_INITIAL;
PetscFunctionReturn(0);
}
/*@
EPSSetBalance - Specifies the balancing technique to be employed by the
eigensolver, and some parameters associated to it.
Logically Collective on EPS
Input Parameters:
+ eps - the eigensolver context
. bal - the balancing method, one of EPS_BALANCE_NONE, EPS_BALANCE_ONESIDE,
EPS_BALANCE_TWOSIDE, or EPS_BALANCE_USER
. its - number of iterations of the balancing algorithm
- cutoff - cutoff value
Options Database Keys:
+ -eps_balance <method> - the balancing method, where <method> is one of
'none', 'oneside', 'twoside', or 'user'
. -eps_balance_its <its> - number of iterations
- -eps_balance_cutoff <cutoff> - cutoff value
Notes:
When balancing is enabled, the solver works implicitly with matrix DAD^-1,
where D is an appropriate diagonal matrix. This improves the accuracy of
the computed results in some cases. See the SLEPc Users Manual for details.
Balancing makes sense only for non-Hermitian problems when the required
precision is high (i.e. a small tolerance such as 1e-15).
By default, balancing is disabled. The two-sided method is much more
effective than the one-sided counterpart, but it requires the system
matrices to have the MatMultTranspose operation defined.
The parameter 'its' is the number of iterations performed by the method. The
cutoff value is used only in the two-side variant. Use PETSC_DEFAULT to assign
a reasonably good value.
User-defined balancing is allowed provided that the corresponding matrix
is set via STSetBalanceMatrix.
Level: intermediate
.seealso: EPSGetBalance(), EPSBalance, STSetBalanceMatrix()
@*/
PetscErrorCode EPSSetBalance(EPS eps,EPSBalance bal,PetscInt its,PetscReal cutoff)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidLogicalCollectiveEnum(eps,bal,2);
PetscValidLogicalCollectiveInt(eps,its,3);
PetscValidLogicalCollectiveReal(eps,cutoff,4);
switch (bal) {
case EPS_BALANCE_NONE:
case EPS_BALANCE_ONESIDE:
case EPS_BALANCE_TWOSIDE:
case EPS_BALANCE_USER:
eps->balance = bal;
break;
default:
SETERRQ(PetscObjectComm((PetscObject)eps),PETSC_ERR_ARG_OUTOFRANGE,"Invalid value of argument 'bal'");
}
if (its==PETSC_DECIDE || its==PETSC_DEFAULT) eps->balance_its = 5;
else {
if (its <= 0) SETERRQ(PetscObjectComm((PetscObject)eps),PETSC_ERR_ARG_OUTOFRANGE,"Illegal value of its. Must be > 0");
eps->balance_its = its;
}
if (cutoff==PETSC_DECIDE || cutoff==PETSC_DEFAULT) eps->balance_cutoff = 1e-8;
else {
if (cutoff <= 0.0) SETERRQ(PetscObjectComm((PetscObject)eps),PETSC_ERR_ARG_OUTOFRANGE,"Illegal value of cutoff. Must be > 0");
eps->balance_cutoff = cutoff;
}
PetscFunctionReturn(0);
}
/*@
EPSSetWhichEigenpairs - Specifies which portion of the spectrum is
to be sought.
Logically Collective on EPS
Input Parameters:
+ eps - eigensolver context obtained from EPSCreate()
- which - the portion of the spectrum to be sought
Possible values:
The parameter 'which' can have one of these values
+ EPS_LARGEST_MAGNITUDE - largest eigenvalues in magnitude (default)
. EPS_SMALLEST_MAGNITUDE - smallest eigenvalues in magnitude
. EPS_LARGEST_REAL - largest real parts
. EPS_SMALLEST_REAL - smallest real parts
. EPS_LARGEST_IMAGINARY - largest imaginary parts
. EPS_SMALLEST_IMAGINARY - smallest imaginary parts
. EPS_TARGET_MAGNITUDE - eigenvalues closest to the target (in magnitude)
. EPS_TARGET_REAL - eigenvalues with real part closest to target
. EPS_TARGET_IMAGINARY - eigenvalues with imaginary part closest to target
. EPS_ALL - all eigenvalues contained in a given interval
- EPS_WHICH_USER - user defined ordering set with EPSSetEigenvalueComparison()
Options Database Keys:
+ -eps_largest_magnitude - Sets largest eigenvalues in magnitude
. -eps_smallest_magnitude - Sets smallest eigenvalues in magnitude
. -eps_largest_real - Sets largest real parts
. -eps_smallest_real - Sets smallest real parts
. -eps_largest_imaginary - Sets largest imaginary parts
. -eps_smallest_imaginary - Sets smallest imaginary parts
. -eps_target_magnitude - Sets eigenvalues closest to target
. -eps_target_real - Sets real parts closest to target
. -eps_target_imaginary - Sets imaginary parts closest to target
- -eps_all - Sets all eigenvalues in an interval
Notes:
Not all eigensolvers implemented in EPS account for all the possible values
stated above. Also, some values make sense only for certain types of
problems. If SLEPc is compiled for real numbers EPS_LARGEST_IMAGINARY
and EPS_SMALLEST_IMAGINARY use the absolute value of the imaginary part
for eigenvalue selection.
The target is a scalar value provided with EPSSetTarget().
The criterion EPS_TARGET_IMAGINARY is available only in case PETSc and
SLEPc have been built with complex scalars.
EPS_ALL is intended for use in combination with an interval (see
EPSSetInterval()), when all eigenvalues within the interval are requested.
In that case, the number of eigenvalues is unknown, so the nev parameter
has a different sense, see EPSSetDimensions().
Level: intermediate
.seealso: EPSGetWhichEigenpairs(), EPSSetTarget(), EPSSetInterval(),
EPSSetDimensions(), EPSSetEigenvalueComparison(), EPSWhich
@*/
PetscErrorCode EPSSetWhichEigenpairs(EPS eps,EPSWhich which)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidLogicalCollectiveEnum(eps,which,2);
switch (which) {
case EPS_LARGEST_MAGNITUDE:
case EPS_SMALLEST_MAGNITUDE:
case EPS_LARGEST_REAL:
case EPS_SMALLEST_REAL:
case EPS_LARGEST_IMAGINARY:
case EPS_SMALLEST_IMAGINARY:
case EPS_TARGET_MAGNITUDE:
case EPS_TARGET_REAL:
#if defined(PETSC_USE_COMPLEX)
case EPS_TARGET_IMAGINARY:
#endif
case EPS_ALL:
case EPS_WHICH_USER:
if (eps->which != which) {
eps->state = EPS_STATE_INITIAL;
eps->which = which;
}
break;
default:
SETERRQ(PetscObjectComm((PetscObject)eps),PETSC_ERR_ARG_OUTOFRANGE,"Invalid 'which' value");
}
PetscFunctionReturn(0);
}
/*@
EPSSetExtraction - Specifies the type of extraction technique to be employed
by the eigensolver.
Logically Collective on EPS
Input Parameters:
+ eps - the eigensolver context
- extr - a known type of extraction
Options Database Keys:
+ -eps_ritz - Rayleigh-Ritz extraction
. -eps_harmonic - harmonic Ritz extraction
. -eps_harmonic_relative - harmonic Ritz extraction relative to the eigenvalue
. -eps_harmonic_right - harmonic Ritz extraction for rightmost eigenvalues
. -eps_harmonic_largest - harmonic Ritz extraction for largest magnitude
(without target)
. -eps_refined - refined Ritz extraction
- -eps_refined_harmonic - refined harmonic Ritz extraction
Notes:
Not all eigensolvers support all types of extraction. See the SLEPc
Users Manual for details.
By default, a standard Rayleigh-Ritz extraction is used. Other extractions
may be useful when computing interior eigenvalues.
Harmonic-type extractions are used in combination with a 'target'.
Level: beginner
.seealso: EPSSetTarget(), EPSGetExtraction(), EPSExtraction
@*/
PetscErrorCode EPSSetExtraction(EPS eps,EPSExtraction extr)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidLogicalCollectiveEnum(eps,extr,2);
eps->extraction = extr;
PetscFunctionReturn(0);
}
/*@
KSPSetNormType - Sets the norm that is used for convergence testing.
Logically Collective on KSP
Input Parameter:
+ ksp - Krylov solver context
- normtype - one of
$ KSP_NORM_NONE - skips computing the norm, this should only be used if you are using
$ the Krylov method as a smoother with a fixed small number of iterations.
$ Implicitly sets KSPConvergedSkip as KSP convergence test.
$ KSP_NORM_PRECONDITIONED - the default for left preconditioned solves, uses the l2 norm
$ of the preconditioned residual P^{-1}(b - A x)
$ KSP_NORM_UNPRECONDITIONED - uses the l2 norm of the true b - Ax residual.
$ KSP_NORM_NATURAL - supported by KSPCG, KSPCR, KSPCGNE, KSPCGS
Options Database Key:
. -ksp_norm_type <none,preconditioned,unpreconditioned,natural>
Notes:
Not all combinations of preconditioner side (see KSPSetPCSide()) and norm type are supported by all Krylov methods.
If only one is set, PETSc tries to automatically change the other to find a compatible pair. If no such combination
is supported, PETSc will generate an error.
Developer Notes:
Supported combinations of norm and preconditioner side are set using KSPSetSupportedNorm().
Level: advanced
.keywords: KSP, create, context, norms
.seealso: KSPSetUp(), KSPSolve(), KSPDestroy(), KSPConvergedSkip(), KSPSetCheckNormIteration(), KSPSetPCSide(), KSPGetPCSide(), KSPNormType
@*/
PetscErrorCode KSPSetNormType(KSP ksp,KSPNormType normtype)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(ksp,KSP_CLASSID,1);
PetscValidLogicalCollectiveEnum(ksp,normtype,2);
ksp->normtype = ksp->normtype_set = normtype;
PetscFunctionReturn(0);
}
/*@C
PetscViewerSetFormat - Sets the format for PetscViewers.
Logically Collective on PetscViewer
Input Parameters:
+ viewer - the PetscViewer
- format - the format
Level: intermediate
Notes:
Available formats include
+ PETSC_VIEWER_DEFAULT - default format
. PETSC_VIEWER_ASCII_MATLAB - MATLAB format
. PETSC_VIEWER_ASCII_DENSE - print matrix as dense
. PETSC_VIEWER_ASCII_IMPL - implementation-specific format
(which is in many cases the same as the default)
. PETSC_VIEWER_ASCII_INFO - basic information about object
. PETSC_VIEWER_ASCII_INFO_DETAIL - more detailed info
about object
. PETSC_VIEWER_ASCII_COMMON - identical output format for
all objects of a particular type
. PETSC_VIEWER_ASCII_INDEX - (for vectors) prints the vector
element number next to each vector entry
. PETSC_VIEWER_ASCII_SYMMODU - print parallel vectors without
indicating the processor ranges
. PETSC_VIEWER_ASCII_VTK - outputs the object to a VTK file
. PETSC_VIEWER_NATIVE - store the object to the binary
file in its native format (for example, dense
matrices are stored as dense), DMDA vectors are dumped directly to the
file instead of being first put in the natural ordering
. PETSC_VIEWER_DRAW_BASIC - views the vector with a simple 1d plot
. PETSC_VIEWER_DRAW_LG - views the vector with a line graph
- PETSC_VIEWER_DRAW_CONTOUR - views the vector with a contour plot
These formats are most often used for viewing matrices and vectors.
If a format (for example PETSC_VIEWER_DRAW_CONTOUR) was applied to a viewer
where it didn't apply (PETSC_VIEWER_STDOUT_WORLD) it cause the default behavior
for that viewer to be used.
Note: This supports passing in a NULL for the viewer for use in the debugger, but it should never be called in the code with a NULL viewer
Concepts: PetscViewer^setting format
.seealso: PetscViewerASCIIOpen(), PetscViewerBinaryOpen(), MatView(), VecView(), PetscViewerType,
PetscViewerPushFormat(), PetscViewerPopFormat(), PetscViewerDrawOpen(),PetscViewerSocketOpen()
@*/
PetscErrorCode PetscViewerSetFormat(PetscViewer viewer,PetscViewerFormat format)
{
PetscFunctionBegin;
if (!viewer) viewer = PETSC_VIEWER_STDOUT_SELF;
PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,1);
PetscValidLogicalCollectiveEnum(viewer,format,2);
viewer->format = format;
PetscFunctionReturn(0);
}
/*@
PCPARMSSetLocal - Sets the local preconditioner to be used in PARMS.
Collective on PC
Input Parameters:
+ pc - the preconditioner context
- type - the local preconditioner type, one of
.vb
PC_PARMS_LOCAL_ILU0 - ILU0 preconditioner
PC_PARMS_LOCAL_ILUK - ILU(k) preconditioner
PC_PARMS_LOCAL_ILUT - ILUT preconditioner
PC_PARMS_LOCAL_ARMS - ARMS preconditioner
.ve
Options Database Keys:
-pc_parms_local [ilu0,iluk,ilut,arms] - Sets local preconditioner
Level: intermediate
Notes:
For the ARMS preconditioner, one can use either the symmetric ARMS or the non-symmetric
variant (ARMS-ddPQ) by setting the permutation type with PCPARMSSetNonsymPerm().
See the pARMS function parms_PCILUSetType for more information.
.seealso: PCPARMS, PCPARMSSetGlobal(), PCPARMSSetNonsymPerm()
@*/
PetscErrorCode PCPARMSSetLocal(PC pc,PCPARMSLocalType type)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(pc,PC_CLASSID,1);
PetscValidLogicalCollectiveEnum(pc,type,2);
ierr = PetscTryMethod(pc,"PCPARMSSetLocal_C",(PC,PCPARMSLocalType),(pc,type));CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
PetscSFWindowSetSyncType - set synchrozitaion type for PetscSF communication
Logically Collective
Input Arguments:
+ sf - star forest for communication
- sync - synchronization type
Options Database Key:
. -sf_window_sync <sync> - sets the synchronization type FENCE, LOCK, or ACTIVE (see PetscSFWindowSyncType)
Level: advanced
.seealso: PetscSFSetFromOptions(), PetscSFWindowGetSyncType()
@*/
PetscErrorCode PetscSFWindowSetSyncType(PetscSF sf,PetscSFWindowSyncType sync)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(sf,PETSCSF_CLASSID,1);
PetscValidLogicalCollectiveEnum(sf,sync,2);
ierr = PetscUseMethod(sf,"PetscSFWindowSetSyncType_C",(PetscSF,PetscSFWindowSyncType),(sf,sync));CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
MatPartitioningChacoSetEigenSolver - Set eigensolver method for Chaco partitioner.
Collective on MatPartitioning
Input Parameters:
+ part - the partitioning context
- method - one of MP_CHACO_LANCZOS or MP_CHACO_RQI
Options Database:
. -mat_partitioning_chaco_eigen_solver <method> - the eigensolver
Level: advanced
Notes:
The default is to use a Lanczos method. See Chaco documentation for details.
.seealso: MatPartitioningChacoSetEigenTol(),MatPartitioningChacoSetEigenNumber(),
MatPartitioningChacoGetEigenSolver()
@*/
PetscErrorCode MatPartitioningChacoSetEigenSolver(MatPartitioning part,MPChacoEigenType method)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(part,MAT_PARTITIONING_CLASSID,1);
PetscValidLogicalCollectiveEnum(part,method,2);
ierr = PetscTryMethod(part,"MatPartitioningChacoSetEigenSolver_C",(MatPartitioning,MPChacoEigenType),(part,method));CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
PetscViewerFileSetMode - Sets the type of file to be open
Logically Collective on PetscViewer
Input Parameters:
+ viewer - the PetscViewer; must be a binary, Matlab, hdf, or netcdf PetscViewer
- type - type of file
$ FILE_MODE_WRITE - create new file for binary output
$ FILE_MODE_READ - open existing file for binary input
$ FILE_MODE_APPEND - open existing file for binary output
Level: advanced
.seealso: PetscViewerFileSetMode(), PetscViewerCreate(), PetscViewerSetType(), PetscViewerBinaryOpen()
@*/
PetscErrorCode PetscViewerFileSetMode(PetscViewer viewer,PetscFileMode type)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,1);
PetscValidLogicalCollectiveEnum(viewer,type,2);
ierr = PetscTryMethod(viewer,"PetscViewerFileSetMode_C",(PetscViewer,PetscFileMode),(viewer,type));CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
PCFactorSetShiftType - adds a particular type of quantity to the diagonal of the matrix during
numerical factorization, thus the matrix has nonzero pivots
Logically Collective on PC
Input Parameters:
+ pc - the preconditioner context
- shifttype - type of shift; one of MAT_SHIFT_NONE, MAT_SHIFT_NONZERO, MAT_SHIFT_POSITIVE_DEFINITE, MAT_SHIFT_INBLOCKS
Options Database Key:
. -pc_factor_shift_type <shifttype> - Sets shift type or PETSC_DECIDE for the default; use '-help' for a list of available types
Level: intermediate
.keywords: PC, set, factorization,
.seealso: PCFactorSetZeroPivot(), PCFactorSetShiftAmount()
@*/
PetscErrorCode PCFactorSetShiftType(PC pc,MatFactorShiftType shifttype)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(pc,PC_CLASSID,1);
PetscValidLogicalCollectiveEnum(pc,shifttype,2);
ierr = PetscTryMethod(pc,"PCFactorSetShiftType_C",(PC,MatFactorShiftType),(pc,shifttype));CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
KSPPIPEFCGSetTruncationType - specify how many of its stored previous directions PIPEFCG uses during orthoganalization
Logically Collective on KSP
KSP_FCD_TRUNC_TYPE_STANDARD uses all (up to mmax) stored directions
KSP_FCD_TRUNC_TYPE_NOTAY uses max(1,mod(i,mmax)) stored directions at iteration i=0,1,..
Input Parameters:
+ ksp - the Krylov space context
- truncstrat - the choice of strategy
Level: intermediate
Options Database:
. -ksp_pipefcg_truncation_type <standard,notay> - which stored search directions to orthogonalize against
.seealso: KSPPIPEFCG, KSPPIPEFCGGetTruncationType, KSPFCDTruncationType
@*/
PetscErrorCode KSPPIPEFCGSetTruncationType(KSP ksp,KSPFCDTruncationType truncstrat)
{
KSP_PIPEFCG *pipefcg=(KSP_PIPEFCG*)ksp->data;;
PetscFunctionBegin;
PetscValidHeaderSpecific(ksp,KSP_CLASSID,1);
PetscValidLogicalCollectiveEnum(ksp,truncstrat,2);
pipefcg->truncstrat=truncstrat;
PetscFunctionReturn(0);
}
/*@
KSPGMRESSetCGSRefinementType - Sets the type of iterative refinement to use
in the classical Gram Schmidt orthogonalization.
Logically Collective on KSP
Input Parameters:
+ ksp - the Krylov space context
- type - the type of refinement
Options Database:
. -ksp_gmres_cgs_refinement_type <never,ifneeded,always>
Level: intermediate
.keywords: KSP, GMRES, iterative refinement
.seealso: KSPGMRESSetOrthogonalization(), KSPGMRESCGSRefinementType, KSPGMRESClassicalGramSchmidtOrthogonalization(), KSPGMRESGetCGSRefinementType(),
KSPGMRESGetOrthogonalization()
@*/
PetscErrorCode KSPGMRESSetCGSRefinementType(KSP ksp,KSPGMRESCGSRefinementType type)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(ksp,KSP_CLASSID,1);
PetscValidLogicalCollectiveEnum(ksp,type,2);
ierr = PetscTryMethod(ksp,"KSPGMRESSetCGSRefinementType_C",(KSP,KSPGMRESCGSRefinementType),(ksp,type));CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
KSPPIPEFCGSetMmax - set the maximum number of previous directions PIPEFCG will store for orthogonalization
Note: mmax + 1 directions are stored (mmax previous ones along with the current one)
and whether all are used in each iteration also depends on the truncation strategy
(see KSPPIPEFCGSetTruncationType)
Logically Collective on KSP
Input Parameters:
+ ksp - the Krylov space context
- mmax - the maximum number of previous directions to orthogonalize against
Level: intermediate
Options Database:
. -ksp_pipefcg_mmax <N>
.seealso: KSPPIPEFCG, KSPPIPEFCGSetTruncationType(), KSPPIPEFCGSetNprealloc()
@*/
PetscErrorCode KSPPIPEFCGSetMmax(KSP ksp,PetscInt mmax)
{
KSP_PIPEFCG *pipefcg=(KSP_PIPEFCG*)ksp->data;;
PetscFunctionBegin;
PetscValidHeaderSpecific(ksp,KSP_CLASSID,1);
PetscValidLogicalCollectiveEnum(ksp,mmax,2);
pipefcg->mmax=mmax;
PetscFunctionReturn(0);
}
/*@
KSPPIPEFCGSetNprealloc - set the number of directions to preallocate with PIPEFCG
Logically Collective on KSP
Input Parameters:
+ ksp - the Krylov space context
- nprealloc - the number of vectors to preallocate
Level: advanced
Options Database:
. -ksp_pipefcg_nprealloc <N>
.seealso: KSPPIPEFCG, KSPPIPEFCGSetTruncationType(), KSPPIPEFCGGetNprealloc()
@*/
PetscErrorCode KSPPIPEFCGSetNprealloc(KSP ksp,PetscInt nprealloc)
{
KSP_PIPEFCG *pipefcg=(KSP_PIPEFCG*)ksp->data;;
PetscFunctionBegin;
PetscValidHeaderSpecific(ksp,KSP_CLASSID,1);
PetscValidLogicalCollectiveEnum(ksp,nprealloc,2);
pipefcg->nprealloc = nprealloc;
PetscFunctionReturn(0);
}
/*@C
SNESCompositeSetType - Sets the type of composite preconditioner.
Logically Collective on SNES
Input Parameter:
+ snes - the preconditioner context
- type - SNES_COMPOSITE_ADDITIVE (default), SNES_COMPOSITE_MULTIPLICATIVE
Options Database Key:
. -snes_composite_type <type: one of multiplicative, additive, special> - Sets composite preconditioner type
Level: Developer
.keywords: SNES, set, type, composite preconditioner, additive, multiplicative
@*/
PetscErrorCode SNESCompositeSetType(SNES snes,SNESCompositeType type)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(snes,SNES_CLASSID,1);
PetscValidLogicalCollectiveEnum(snes,type,2);
ierr = PetscTryMethod(snes,"SNESCompositeSetType_C",(SNES,SNESCompositeType),(snes,type));CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
EPSLanczosSetReorthog - Sets the type of reorthogonalization used during the Lanczos
iteration.
Logically Collective on EPS
Input Parameters:
+ eps - the eigenproblem solver context
- reorthog - the type of reorthogonalization
Options Database Key:
. -eps_lanczos_reorthog - Sets the reorthogonalization type (either 'local', 'selective',
'periodic', 'partial', 'full' or 'delayed')
Level: advanced
.seealso: EPSLanczosGetReorthog(), EPSLanczosReorthogType
@*/
PetscErrorCode EPSLanczosSetReorthog(EPS eps,EPSLanczosReorthogType reorthog)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidLogicalCollectiveEnum(eps,reorthog,2);
ierr = PetscTryMethod(eps,"EPSLanczosSetReorthog_C",(EPS,EPSLanczosReorthogType),(eps,reorthog));CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
MatPartitioningPTScotchSetStrategy - Sets the strategy to be used in PTScotch.
Collective on MatPartitioning
Input Parameters:
+ part - the partitioning context
- strategy - the strategy, one of
.vb
MP_PTSCOTCH_DEFAULT - Default behavior
MP_PTSCOTCH_QUALITY - Prioritize quality over speed
MP_PTSCOTCH_SPEED - Prioritize speed over quality
MP_PTSCOTCH_BALANCE - Enforce load balance
MP_PTSCOTCH_SAFETY - Avoid methods that may fail
MP_PTSCOTCH_SCALABILITY - Favor scalability as much as possible
.ve
Options Database:
. -mat_partitioning_ptscotch_strategy [quality,speed,balance,safety,scalability] - strategy
Level: advanced
Notes:
The default is MP_SCOTCH_QUALITY. See the PTScotch documentation for more information.
.seealso: MatPartitioningPTScotchSetImbalance(), MatPartitioningPTScotchGetStrategy()
@*/
PetscErrorCode MatPartitioningPTScotchSetStrategy(MatPartitioning part,MPPTScotchStrategyType strategy)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(part,MAT_PARTITIONING_CLASSID,1);
PetscValidLogicalCollectiveEnum(part,strategy,2);
ierr = PetscTryMethod(part,"MatPartitioningPTScotchSetStrategy_C",(MatPartitioning,MPPTScotchStrategyType),(part,strategy));CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
DMDASetInterpolationType - Sets the type of interpolation that will be
returned by DMCreateInterpolation()
Logically Collective on DMDA
Input Parameter:
+ da - initial distributed array
. ctype - DMDA_Q1 and DMDA_Q0 are currently the only supported forms
Level: intermediate
Notes: you should call this on the coarser of the two DMDAs you pass to DMCreateInterpolation()
.keywords: distributed array, interpolation
.seealso: DMDACreate1d(), DMDACreate2d(), DMDACreate3d(), DMDestroy(), DMDA, DMDAInterpolationType
@*/
PetscErrorCode DMDASetInterpolationType(DM da,DMDAInterpolationType ctype)
{
DM_DA *dd = (DM_DA*)da->data;
PetscFunctionBegin;
PetscValidHeaderSpecific(da,DM_CLASSID,1);
PetscValidLogicalCollectiveEnum(da,ctype,2);
dd->interptype = ctype;
PetscFunctionReturn(0);
}
/*@
KSPFCGSetNprealloc - set the number of directions to preallocate with FCG
Logically Collective on KSP
Input Parameters:
+ ksp - the Krylov space context
- nprealloc - the number of vectors to preallocate
Level: advanced
Options Database:
. -ksp_fcg_nprealloc <N>
.seealso: KSPFCG, KSPFCGGetTruncationType(), KSPFCGGetNprealloc()
@*/
PetscErrorCode KSPFCGSetNprealloc(KSP ksp,PetscInt nprealloc)
{
KSP_FCG *fcg=(KSP_FCG*)ksp->data;
PetscFunctionBegin;
PetscValidHeaderSpecific(ksp,KSP_CLASSID,1);
PetscValidLogicalCollectiveEnum(ksp,nprealloc,2);
if(nprealloc > fcg->mmax+1) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Cannot preallocate more than m_max+1 vectors");
fcg->nprealloc = nprealloc;
PetscFunctionReturn(0);
}
/*@
DMDASetStencilType - Sets the type of the communication stencil
Logically Collective on DMDA
Input Parameter:
+ da - The DMDA
- stype - The stencil type, use either DMDA_STENCIL_BOX or DMDA_STENCIL_STAR.
Level: intermediate
.keywords: distributed array, stencil
.seealso: DMDACreate(), DMDestroy(), DMDA
@*/
PetscErrorCode DMDASetStencilType(DM da, DMDAStencilType stype)
{
DM_DA *dd = (DM_DA*)da->data;
PetscFunctionBegin;
PetscValidHeaderSpecific(da,DM_CLASSID,1);
PetscValidLogicalCollectiveEnum(da,stype,2);
if (da->setupcalled) SETERRQ(((PetscObject)da)->comm,PETSC_ERR_ARG_WRONGSTATE,"This function must be called before DMSetUp()");
dd->stencil_type = stype;
PetscFunctionReturn(0);
}
/*@C
PetscViewerPushFormat - Sets the format for file PetscViewers.
Logically Collective on PetscViewer
Input Parameters:
+ viewer - the PetscViewer
- format - the format
Level: intermediate
Notes:
Available formats include
+ PETSC_VIEWER_DEFAULT - default format
. PETSC_VIEWER_ASCII_MATLAB - MATLAB format
. PETSC_VIEWER_ASCII_IMPL - implementation-specific format
(which is in many cases the same as the default)
. PETSC_VIEWER_ASCII_INFO - basic information about object
. PETSC_VIEWER_ASCII_INFO_DETAIL - more detailed info
about object
. PETSC_VIEWER_ASCII_COMMON - identical output format for
all objects of a particular type
. PETSC_VIEWER_ASCII_INDEX - (for vectors) prints the vector
element number next to each vector entry
. PETSC_VIEWER_NATIVE - store the object to the binary
file in its native format (for example, dense
matrices are stored as dense), for DMDA vectors displays vectors in DMDA ordering, not natural
. PETSC_VIEWER_DRAW_BASIC - views the vector with a simple 1d plot
. PETSC_VIEWER_DRAW_LG - views the vector with a line graph
- PETSC_VIEWER_DRAW_CONTOUR - views the vector with a contour plot
These formats are most often used for viewing matrices and vectors.
Currently, the object name is used only in the MATLAB format.
Concepts: PetscViewer^setting format
.seealso: PetscViewerASCIIOpen(), PetscViewerBinaryOpen(), MatView(), VecView(),
PetscViewerSetFormat(), PetscViewerPopFormat()
@*/
PetscErrorCode PetscViewerPushFormat(PetscViewer viewer,PetscViewerFormat format)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,1);
PetscValidLogicalCollectiveEnum(viewer,format,2);
if (viewer->iformat > 9) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Too many pushes");
viewer->formats[viewer->iformat++] = viewer->format;
viewer->format = format;
PetscFunctionReturn(0);
}
/*@
PCMGSetType - Determines the form of multigrid to use:
multiplicative, additive, full, or the Kaskade algorithm.
Logically Collective on PC
Input Parameters:
+ pc - the preconditioner context
- form - multigrid form, one of PC_MG_MULTIPLICATIVE, PC_MG_ADDITIVE,
PC_MG_FULL, PC_MG_KASKADE
Options Database Key:
. -pc_mg_type <form> - Sets <form>, one of multiplicative,
additive, full, kaskade
Level: advanced
.keywords: MG, set, method, multiplicative, additive, full, Kaskade, multigrid
.seealso: PCMGSetLevels()
@*/
PetscErrorCode PCMGSetType(PC pc,PCMGType form)
{
PC_MG *mg = (PC_MG*)pc->data;
PetscFunctionBegin;
PetscValidHeaderSpecific(pc,PC_CLASSID,1);
PetscValidLogicalCollectiveEnum(pc,form,2);
mg->am = form;
if (form == PC_MG_MULTIPLICATIVE) pc->ops->applyrichardson = PCApplyRichardson_MG;
else pc->ops->applyrichardson = NULL;
PetscFunctionReturn(0);
}
/*@
KSPSetNormType - Sets the norm that is used for convergence testing.
Logically Collective on KSP
Input Parameter:
+ ksp - Krylov solver context
- normtype - one of
$ KSP_NORM_NONE - skips computing the norm, this should only be used if you are using
$ the Krylov method as a smoother with a fixed small number of iterations.
$ Implicitly sets KSPSkipConverged as KSP convergence test.
$ Supported only by CG, Richardson, Bi-CG-stab, CR, and CGS methods.
$ KSP_NORM_PRECONDITIONED - the default for left preconditioned solves, uses the l2 norm
$ of the preconditioned residual
$ KSP_NORM_UNPRECONDITIONED - uses the l2 norm of the true b - Ax residual, supported only by
$ CG, CHEBYSHEV, and RICHARDSON, automatically true for right (see KSPSetPCSide())
$ preconditioning..
$ KSP_NORM_NATURAL - supported by KSPCG, KSPCR, KSPCGNE, KSPCGS
Options Database Key:
. -ksp_norm_type <none,preconditioned,unpreconditioned,natural>
Notes:
Currently only works with the CG, Richardson, Bi-CG-stab, CR, and CGS methods.
Level: advanced
.keywords: KSP, create, context, norms
.seealso: KSPSetUp(), KSPSolve(), KSPDestroy(), KSPSkipConverged(), KSPSetCheckNormIteration()
@*/
PetscErrorCode KSPSetNormType(KSP ksp,KSPNormType normtype)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(ksp,KSP_CLASSID,1);
PetscValidLogicalCollectiveEnum(ksp,normtype,2);
ksp->normtype = normtype;
if (normtype == KSP_NORM_NONE) {
ierr = KSPSetConvergenceTest(ksp,KSPSkipConverged,0,0);CHKERRQ(ierr);
ierr = PetscInfo(ksp,"Warning: setting KSPNormType to skip computing the norm\n\
KSP convergence test is implicitly set to KSPSkipConverged\n");CHKERRQ(ierr);
}
/*@
PCMGSetCycleTypeOnLevel - Sets the type of cycle (aka cycle index) to run on the specified level.
Logically Collective on PC
Input Parameters:
+ pc - the multigrid context
. l - the level (0 is coarsest)
- c - either PC_MG_CYCLE_V or PC_MG_CYCLE_W
Level: advanced
.keywords: MG, multigrid, set, cycles, V-cycle, W-cycle, level
.seealso: PCMGSetCycleType()
@*/
PetscErrorCode PCMGSetCycleTypeOnLevel(PC pc,PetscInt l,PCMGCycleType c)
{
PC_MG *mg = (PC_MG*)pc->data;
PC_MG_Levels **mglevels = mg->levels;
PetscFunctionBegin;
PetscValidHeaderSpecific(pc,PC_CLASSID,1);
if (!mglevels) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"Must set MG levels before calling");
PetscValidLogicalCollectiveInt(pc,l,2);
PetscValidLogicalCollectiveEnum(pc,c,3);
mglevels[l]->cycles = c;
PetscFunctionReturn(0);
}
/*@
MFNSetFunction - Specifies the function to be computed.
Logically Collective on MFN
Input Parameters:
+ mfn - the matrix function context
- fun - a known function
Options Database Keys:
. -mfn_exp - matrix exponential
Level: beginner
.seealso: MFNSetOperator(), MFNSetType(), MFNGetFunction(), SlepcFunction
@*/
PetscErrorCode MFNSetFunction(MFN mfn,SlepcFunction fun)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(mfn,MFN_CLASSID,1);
PetscValidLogicalCollectiveEnum(mfn,fun,2);
switch (fun) {
case SLEPC_FUNCTION_EXP:
break;
default:
SETERRQ(PetscObjectComm((PetscObject)mfn),PETSC_ERR_ARG_WRONG,"Unknown function");
}
mfn->function = fun;
PetscFunctionReturn(0);
}
/*@
SNESFASSetType - Sets the update and correction type used for FAS.
Logically Collective
Input Parameters:
+ snes - FAS context
- fastype - SNES_FAS_ADDITIVE, SNES_FAS_MULTIPLICATIVE, SNES_FAS_FULL, or SNES_FAS_KASKADE
Level: intermediate
.seealso: PCMGSetType()
@*/
PetscErrorCode SNESFASSetType(SNES snes,SNESFASType fastype)
{
SNES_FAS *fas = (SNES_FAS*)snes->data;
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(snes,SNES_CLASSID,1);
PetscValidLogicalCollectiveEnum(snes,fastype,2);
fas->fastype = fastype;
if (fas->next) {
ierr = SNESFASSetType(fas->next, fastype);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/*@
PCMGSetCycleType - Sets the type cycles to use. Use PCMGSetCycleTypeOnLevel() for more
complicated cycling.
Logically Collective on PC
Input Parameters:
+ pc - the multigrid context
- PC_MG_CYCLE_V or PC_MG_CYCLE_W
Options Database Key:
. -pc_mg_cycle_type <v,w>
Level: advanced
.keywords: MG, set, cycles, V-cycle, W-cycle, multigrid
.seealso: PCMGSetCycleTypeOnLevel()
@*/
PetscErrorCode PCMGSetCycleType(PC pc,PCMGCycleType n)
{
PC_MG *mg = (PC_MG*)pc->data;
PC_MG_Levels **mglevels = mg->levels;
PetscInt i,levels;
PetscFunctionBegin;
PetscValidHeaderSpecific(pc,PC_CLASSID,1);
if (!mglevels) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"Must set MG levels before calling");
PetscValidLogicalCollectiveEnum(pc,n,2);
levels = mglevels[0]->levels;
for (i=0; i<levels; i++) mglevels[i]->cycles = n;
PetscFunctionReturn(0);
}