/*@C
MatCoarsenSetType - Sets the type of aggregator to use
Collective on MatCoarsen
Input Parameter:
. coarser - the coarsen context.
. type - a known method
Options Database Command:
$ -mat_coarsen_type <type>
$ Use -help for a list of available methods
$ (for instance, mis)
Level: intermediate
.keywords: coarsen, set, method, type
.seealso: MatCoarsenCreate(), MatCoarsenApply(), MatCoarsenType
@*/
PetscErrorCode MatCoarsenSetType(MatCoarsen coarser, MatCoarsenType type)
{
PetscErrorCode ierr,(*r)(MatCoarsen);
PetscBool match;
PetscFunctionBegin;
PetscValidHeaderSpecific(coarser,MAT_COARSEN_CLASSID,1);
PetscValidCharPointer(type,2);
ierr = PetscObjectTypeCompare((PetscObject)coarser,type,&match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
if (coarser->setupcalled) {
ierr = (*coarser->ops->destroy)(coarser);CHKERRQ(ierr);
coarser->ops->destroy = NULL;
coarser->subctx = 0;
coarser->setupcalled = 0;
}
ierr = PetscFunctionListFind(MatCoarsenList,type,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PetscObjectComm((PetscObject)coarser),PETSC_ERR_ARG_UNKNOWN_TYPE,"Unknown coarsen type %s",type);
coarser->ops->destroy = (PetscErrorCode (*)(MatCoarsen)) 0;
coarser->ops->view = (PetscErrorCode (*)(MatCoarsen,PetscViewer)) 0;
ierr = (*r)(coarser);CHKERRQ(ierr);
ierr = PetscFree(((PetscObject)coarser)->type_name);CHKERRQ(ierr);
ierr = PetscStrallocpy(type,&((PetscObject)coarser)->type_name);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
MatPartitioningSetType - Sets the type of partitioner to use
Collective on MatPartitioning
Input Parameter:
. part - the partitioning context.
. type - a known method
Options Database Command:
$ -mat_partitioning_type <type>
$ Use -help for a list of available methods
$ (for instance, parmetis)
Level: intermediate
.keywords: partitioning, set, method, type
.seealso: MatPartitioningCreate(), MatPartitioningApply(), MatPartitioningType
@*/
PetscErrorCode MatPartitioningSetType(MatPartitioning part,MatPartitioningType type)
{
PetscErrorCode ierr,(*r)(MatPartitioning);
PetscBool match;
PetscFunctionBegin;
PetscValidHeaderSpecific(part,MAT_PARTITIONING_CLASSID,1);
PetscValidCharPointer(type,2);
ierr = PetscObjectTypeCompare((PetscObject)part,type,&match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
if (part->setupcalled) {
ierr = (*part->ops->destroy)(part);CHKERRQ(ierr);
part->ops->destroy = NULL;
part->data = 0;
part->setupcalled = 0;
}
ierr = PetscFunctionListFind(MatPartitioningList,type,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PetscObjectComm((PetscObject)part),PETSC_ERR_ARG_UNKNOWN_TYPE,"Unknown partitioning type %s",type);
part->ops->destroy = (PetscErrorCode (*)(MatPartitioning)) 0;
part->ops->view = (PetscErrorCode (*)(MatPartitioning,PetscViewer)) 0;
ierr = (*r)(part);CHKERRQ(ierr);
ierr = PetscFree(((PetscObject)part)->type_name);CHKERRQ(ierr);
ierr = PetscStrallocpy(type,&((PetscObject)part)->type_name);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
KSPSetType - Builds KSP for a particular solver.
Logically Collective on KSP
Input Parameters:
+ ksp - the Krylov space context
- type - a known method
Options Database Key:
. -ksp_type <method> - Sets the method; use -help for a list
of available methods (for instance, cg or gmres)
Notes:
See "petsc/include/petscksp.h" for available methods (for instance,
KSPCG or KSPGMRES).
Normally, it is best to use the KSPSetFromOptions() command and
then set the KSP type from the options database rather than by using
this routine. Using the options database provides the user with
maximum flexibility in evaluating the many different Krylov methods.
The KSPSetType() routine is provided for those situations where it
is necessary to set the iterative solver independently of the command
line or options database. This might be the case, for example, when
the choice of iterative solver changes during the execution of the
program, and the user's application is taking responsibility for
choosing the appropriate method. In other words, this routine is
not for beginners.
Level: intermediate
Developer Note: KSPRegister() is used to add Krylov types to KSPList from which they
are accessed by KSPSetType().
.keywords: KSP, set, method
.seealso: PCSetType(), KSPType, KSPRegister(), KSPCreate()
@*/
PetscErrorCode KSPSetType(KSP ksp, KSPType type)
{
PetscErrorCode ierr,(*r)(KSP);
PetscBool match;
PetscFunctionBegin;
PetscValidHeaderSpecific(ksp,KSP_CLASSID,1);
PetscValidCharPointer(type,2);
ierr = PetscObjectTypeCompare((PetscObject)ksp,type,&match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
ierr = PetscFunctionListFind(KSPList,type,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_ARG_UNKNOWN_TYPE,"Unable to find requested KSP type %s",type);
/* Destroy the previous private KSP context */
if (ksp->ops->destroy) {
ierr = (*ksp->ops->destroy)(ksp);CHKERRQ(ierr);
ksp->ops->destroy = NULL;
}
/* Reinitialize function pointers in KSPOps structure */
ierr = PetscMemzero(ksp->ops,sizeof(struct _KSPOps));CHKERRQ(ierr);
ksp->ops->buildsolution = KSPBuildSolutionDefault;
ksp->ops->buildresidual = KSPBuildResidualDefault;
ierr = KSPNormSupportTableReset_Private(ksp);CHKERRQ(ierr);
/* Call the KSPCreate_XXX routine for this particular Krylov solver */
ksp->setupstage = KSP_SETUP_NEW;
ierr = PetscObjectChangeTypeName((PetscObject)ksp,type);CHKERRQ(ierr);
ierr = (*r)(ksp);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
PetscViewerSetType - Builds PetscViewer for a particular implementation.
Collective on PetscViewer
Input Parameter:
+ viewer - the PetscViewer context
- type - for example, PETSCVIEWERASCII
Options Database Command:
. -draw_type <type> - Sets the type; use -help for a list
of available methods (for instance, ascii)
Level: advanced
Notes:
See "include/petscviewer.h" for available methods (for instance,
PETSCVIEWERSOCKET)
.seealso: PetscViewerCreate(), PetscViewerGetType(), PetscViewerType, PetscViewerSetFormat()
@*/
PetscErrorCode PetscViewerSetType(PetscViewer viewer,PetscViewerType type)
{
PetscErrorCode ierr,(*r)(PetscViewer);
PetscBool match;
PetscFunctionBegin;
PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,1);
PetscValidCharPointer(type,2);
ierr = PetscObjectTypeCompare((PetscObject)viewer,type,&match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
/* cleanup any old type that may be there */
if (viewer->data) {
ierr = (*viewer->ops->destroy)(viewer);CHKERRQ(ierr);
viewer->ops->destroy = NULL;
viewer->data = 0;
}
ierr = PetscMemzero(viewer->ops,sizeof(struct _PetscViewerOps));CHKERRQ(ierr);
ierr = PetscFunctionListFind(PetscViewerList,type,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE,"Unknown PetscViewer type given: %s",type);
ierr = PetscObjectChangeTypeName((PetscObject)viewer,type);CHKERRQ(ierr);
ierr = (*r)(viewer);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode PetscRandomSetType(PetscRandom rnd, PetscRandomType type)
{
PetscErrorCode (*r)(PetscRandom);
PetscBool match;
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(rnd, PETSC_RANDOM_CLASSID,1);
ierr = PetscObjectTypeCompare((PetscObject)rnd, type, &match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
ierr = PetscFunctionListFind(PetscRandomList,type,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE, "Unknown random type: %s", type);
if (rnd->ops->destroy) {
ierr = (*rnd->ops->destroy)(rnd);CHKERRQ(ierr);
rnd->ops->destroy = NULL;
}
ierr = (*r)(rnd);CHKERRQ(ierr);
ierr = PetscRandomSeed(rnd);CHKERRQ(ierr);
ierr = PetscObjectChangeTypeName((PetscObject)rnd, type);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
MatColoringSetType - Sets the type of coloring algorithm used
Collective on MatColoring
Input Parameter:
+ mc - the MatColoring context
- type - the type of coloring
Level: beginner
Notes: Possible types include the sequential types MATCOLORINGLF,
MATCOLORINGSL, and MATCOLORINGID from the MINPACK package as well
as a parallel MATCOLORINGMIS algorithm.
.keywords: Coloring, type
.seealso: MatColoringCreate(), MatColoringApply()
@*/
PetscErrorCode MatColoringSetType(MatColoring mc,MatColoringType type)
{
PetscBool match;
PetscErrorCode ierr,(*r)(MatColoring);
PetscFunctionBegin;
PetscValidHeaderSpecific(mc,MAT_COLORING_CLASSID,1);
PetscValidCharPointer(type,2);
ierr = PetscObjectTypeCompare((PetscObject)mc,type,&match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
ierr = PetscFunctionListFind(MatColoringList,type,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE,"Unable to find requested MatColoring type %s",type);
if (mc->ops->destroy) {
ierr = (*(mc)->ops->destroy)(mc);CHKERRQ(ierr);
mc->ops->destroy = NULL;
}
mc->ops->apply = 0;
mc->ops->view = 0;
mc->ops->setfromoptions = 0;
mc->ops->destroy = 0;
ierr = PetscObjectChangeTypeName((PetscObject)mc,type);CHKERRQ(ierr);
ierr = (*r)(mc);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
MatMFFDSetType - Sets the method that is used to compute the
differencing parameter for finite differene matrix-free formulations.
Input Parameters:
+ mat - the "matrix-free" matrix created via MatCreateSNESMF(), or MatCreateMFFD()
or MatSetType(mat,MATMFFD);
- ftype - the type requested, either MATMFFD_WP or MATMFFD_DS
Level: advanced
Notes:
For example, such routines can compute h for use in
Jacobian-vector products of the form
F(x+ha) - F(x)
F'(u)a ~= ----------------
h
.seealso: MatCreateSNESMF(), MatMFFDRegister(), MatMFFDSetFunction(), MatCreateMFFD()
@*/
PetscErrorCode MatMFFDSetType(Mat mat,MatMFFDType ftype)
{
PetscErrorCode ierr,(*r)(MatMFFD);
MatMFFD ctx = (MatMFFD)mat->data;
PetscBool match;
PetscFunctionBegin;
PetscValidHeaderSpecific(mat,MAT_CLASSID,1);
PetscValidCharPointer(ftype,2);
ierr = PetscObjectTypeCompare((PetscObject)mat,MATMFFD,&match);CHKERRQ(ierr);
if (!match) PetscFunctionReturn(0);
/* already set, so just return */
ierr = PetscObjectTypeCompare((PetscObject)ctx,ftype,&match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
/* destroy the old one if it exists */
if (ctx->ops->destroy) {
ierr = (*ctx->ops->destroy)(ctx);CHKERRQ(ierr);
}
ierr = PetscFunctionListFind(MatMFFDList,ftype,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE,"Unknown MatMFFD type %s given",ftype);
ierr = (*r)(ctx);CHKERRQ(ierr);
ierr = PetscObjectChangeTypeName((PetscObject)ctx,ftype);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
PFSetType - Builds PF for a particular function
Collective on PF
Input Parameter:
+ pf - the function context.
. type - a known method
- ctx - optional type dependent context
Options Database Key:
. -pf_type <type> - Sets PF type
Notes:
See "petsc/include/petscpf.h" for available methods (for instance,
PFCONSTANT)
Level: intermediate
.keywords: PF, set, method, type
.seealso: PFSet(), PFRegister(), PFCreate(), DMDACreatePF()
@*/
PetscErrorCode PFSetType(PF pf,PFType type,void *ctx)
{
PetscErrorCode ierr,(*r)(PF,void*);
PetscBool match;
PetscFunctionBegin;
PetscValidHeaderSpecific(pf,PF_CLASSID,1);
PetscValidCharPointer(type,2);
ierr = PetscObjectTypeCompare((PetscObject)pf,type,&match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
if (pf->ops->destroy) {ierr = (*pf->ops->destroy)(pf);CHKERRQ(ierr);}
pf->data = 0;
/* Determine the PFCreateXXX routine for a particular function */
ierr = PetscFunctionListFind(PFList,type,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE,"Unable to find requested PF type %s",type);
pf->ops->destroy = 0;
pf->ops->view = 0;
pf->ops->apply = 0;
pf->ops->applyvec = 0;
/* Call the PFCreateXXX routine for this particular function */
ierr = (*r)(pf,ctx);CHKERRQ(ierr);
ierr = PetscObjectChangeTypeName((PetscObject)pf,type);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
PCSetType - Builds PC for a particular preconditioner type
Collective on PC
Input Parameter:
+ pc - the preconditioner context.
- type - a known method
Options Database Key:
. -pc_type <type> - Sets PC type
Use -help for a list of available methods (for instance,
jacobi or bjacobi)
Notes:
See "petsc/include/petscpc.h" for available methods (for instance,
PCJACOBI, PCILU, or PCBJACOBI).
Normally, it is best to use the KSPSetFromOptions() command and
then set the PC type from the options database rather than by using
this routine. Using the options database provides the user with
maximum flexibility in evaluating the many different preconditioners.
The PCSetType() routine is provided for those situations where it
is necessary to set the preconditioner independently of the command
line or options database. This might be the case, for example, when
the choice of preconditioner changes during the execution of the
program, and the user's application is taking responsibility for
choosing the appropriate preconditioner. In other words, this
routine is not for beginners.
Level: intermediate
Developer Note: PCRegister() is used to add preconditioner types to PCList from which they
are accessed by PCSetType().
.keywords: PC, set, method, type
.seealso: KSPSetType(), PCType, PCRegister(), PCCreate(), KSPGetPC()
@*/
PetscErrorCode PCSetType(PC pc,PCType type)
{
PetscErrorCode ierr,(*r)(PC);
PetscBool match;
PetscFunctionBegin;
PetscValidHeaderSpecific(pc,PC_CLASSID,1);
PetscValidCharPointer(type,2);
ierr = PetscObjectTypeCompare((PetscObject)pc,type,&match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
ierr = PetscFunctionListFind(PCList,type,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_UNKNOWN_TYPE,"Unable to find requested PC type %s",type);
/* Destroy the previous private PC context */
if (pc->ops->destroy) {
ierr = (*pc->ops->destroy)(pc);CHKERRQ(ierr);
pc->ops->destroy = NULL;
pc->data = 0;
}
ierr = PetscFunctionListDestroy(&((PetscObject)pc)->qlist);CHKERRQ(ierr);
/* Reinitialize function pointers in PCOps structure */
ierr = PetscMemzero(pc->ops,sizeof(struct _PCOps));CHKERRQ(ierr);
/* XXX Is this OK?? */
pc->modifysubmatrices = 0;
pc->modifysubmatricesP = 0;
/* Call the PCCreate_XXX routine for this particular preconditioner */
pc->setupcalled = 0;
ierr = PetscObjectChangeTypeName((PetscObject)pc,type);CHKERRQ(ierr);
ierr = (*r)(pc);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
EPSSetType - Selects the particular solver to be used in the EPS object.
Logically Collective on EPS
Input Parameters:
+ eps - the eigensolver context
- type - a known method
Options Database Key:
. -eps_type <method> - Sets the method; use -help for a list
of available methods
Notes:
See "slepc/include/slepceps.h" for available methods. The default
is EPSKRYLOVSCHUR.
Normally, it is best to use the EPSSetFromOptions() command and
then set the EPS type from the options database rather than by using
this routine. Using the options database provides the user with
maximum flexibility in evaluating the different available methods.
The EPSSetType() routine is provided for those situations where it
is necessary to set the iterative solver independently of the command
line or options database.
Level: intermediate
.seealso: STSetType(), EPSType
@*/
PetscErrorCode EPSSetType(EPS eps,EPSType type)
{
PetscErrorCode ierr,(*r)(EPS);
PetscBool match;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidCharPointer(type,2);
ierr = PetscObjectTypeCompare((PetscObject)eps,type,&match);
CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
ierr = PetscFunctionListFind(EPSList,type,&r);
CHKERRQ(ierr);
if (!r) SETERRQ1(PetscObjectComm((PetscObject)eps),PETSC_ERR_ARG_UNKNOWN_TYPE,"Unknown EPS type given: %s",type);
if (eps->ops->destroy) {
ierr = (*eps->ops->destroy)(eps);
CHKERRQ(ierr);
}
ierr = PetscMemzero(eps->ops,sizeof(struct _EPSOps));
CHKERRQ(ierr);
eps->state = EPS_STATE_INITIAL;
ierr = PetscObjectChangeTypeName((PetscObject)eps,type);
CHKERRQ(ierr);
ierr = (*r)(eps);
CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
TSSetType - Sets the method for the timestepping solver.
Collective on TS
Input Parameters:
+ ts - The TS context
- type - A known method
Options Database Command:
. -ts_type <type> - Sets the method; use -help for a list of available methods (for instance, euler)
Notes:
See "petsc/include/petscts.h" for available methods (for instance)
+ TSEULER - Euler
. TSSUNDIALS - SUNDIALS interface
. TSBEULER - Backward Euler
- TSPSEUDO - Pseudo-timestepping
Normally, it is best to use the TSSetFromOptions() command and
then set the TS type from the options database rather than by using
this routine. Using the options database provides the user with
maximum flexibility in evaluating the many different solvers.
The TSSetType() routine is provided for those situations where it
is necessary to set the timestepping solver independently of the
command line or options database. This might be the case, for example,
when the choice of solver changes during the execution of the
program, and the user's application is taking responsibility for
choosing the appropriate method. In other words, this routine is
not for beginners.
Level: intermediate
.keywords: TS, set, type
@*/
PetscErrorCode TSSetType(TS ts,TSType type)
{
PetscErrorCode (*r)(TS);
PetscBool match;
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(ts, TS_CLASSID,1);
ierr = PetscObjectTypeCompare((PetscObject) ts, type, &match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
ierr = PetscFunctionListFind(((PetscObject)ts)->comm,TSList, type,PETSC_TRUE, (void (**)(void)) &r);CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE, "Unknown TS type: %s", type);
if (ts->ops->destroy) {
ierr = (*(ts)->ops->destroy)(ts);CHKERRQ(ierr);
ts->ops->destroy = PETSC_NULL;
}
ierr = PetscMemzero(ts->ops,sizeof(*ts->ops));CHKERRQ(ierr);
ts->setupcalled = PETSC_FALSE;
ierr = PetscObjectChangeTypeName((PetscObject)ts, type);CHKERRQ(ierr);
ierr = (*r)(ts);CHKERRQ(ierr);
#if defined(PETSC_HAVE_AMS)
if (PetscAMSPublishAll) {
ierr = PetscObjectAMSPublish((PetscObject)ts);CHKERRQ(ierr);
}
#endif
PetscFunctionReturn(0);
}
PetscErrorCode PetscObjectQueryFunction_Petsc(PetscObject obj,const char name[],void (**ptr)(void))
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeader(obj,1);
ierr = PetscFunctionListFind(obj->qlist,name,ptr);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
PetscDrawSetType - Builds graphics object for a particular implementation
Collective on PetscDraw
Input Parameter:
+ draw - the graphics context
- type - for example, PETSC_DRAW_X
Options Database Command:
. -draw_type <type> - Sets the type; use -help for a list
of available methods (for instance, x)
Level: intermediate
Notes:
See "petsc/include/petscdraw.h" for available methods (for instance,
PETSC_DRAW_X)
Concepts: drawing^X windows
Concepts: X windows^graphics
Concepts: drawing^Microsoft Windows
.seealso: PetscDrawSetFromOptions(), PetscDrawCreate(), PetscDrawDestroy()
@*/
PetscErrorCode PetscDrawSetType(PetscDraw draw,PetscDrawType type)
{
PetscErrorCode ierr,(*r)(PetscDraw);
PetscBool match;
PetscBool flg=PETSC_FALSE;
PetscFunctionBegin;
PetscValidHeaderSpecific(draw,PETSC_DRAW_CLASSID,1);
PetscValidCharPointer(type,2);
ierr = PetscObjectTypeCompare((PetscObject)draw,type,&match);
CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
/* User requests no graphics */
ierr = PetscOptionsHasName(NULL,"-nox",&flg);
CHKERRQ(ierr);
/*
This is not ideal, but it allows codes to continue to run if X graphics
was requested but is not installed on this machine. Mostly this is for
testing.
*/
#if !defined(PETSC_HAVE_X)
if (!flg) {
ierr = PetscStrcmp(type,PETSC_DRAW_X,&match);
CHKERRQ(ierr);
if (match) {
PetscBool dontwarn = PETSC_TRUE;
flg = PETSC_TRUE;
ierr = PetscOptionsHasName(NULL,"-nox_warning",&dontwarn);
CHKERRQ(ierr);
if (!dontwarn) (*PetscErrorPrintf)("PETSc installed without X windows on this machine\nproceeding without graphics\n");
}
}
#endif
if (flg) type = PETSC_DRAW_NULL;
if (draw->data) {
/* destroy the old private PetscDraw context */
ierr = (*draw->ops->destroy)(draw);
CHKERRQ(ierr);
draw->ops->destroy = NULL;
draw->data = 0;
}
ierr = PetscFunctionListFind(PetscDrawList,type,&r);
CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE,"Unknown PetscDraw type given: %s",type);
ierr = PetscObjectChangeTypeName((PetscObject)draw,type);
CHKERRQ(ierr);
draw->data = 0;
ierr = (*r)(draw);
CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode TSGLLEAdaptSetType(TSGLLEAdapt adapt,TSGLLEAdaptType type)
{
PetscErrorCode ierr,(*r)(TSGLLEAdapt);
PetscFunctionBegin;
ierr = PetscFunctionListFind(TSGLLEAdaptList,type,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE,"Unknown TSGLLEAdapt type \"%s\" given",type);
if (((PetscObject)adapt)->type_name) {ierr = (*adapt->ops->destroy)(adapt);CHKERRQ(ierr);}
ierr = (*r)(adapt);CHKERRQ(ierr);
ierr = PetscObjectChangeTypeName((PetscObject)adapt,type);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode TSSSPSetType_SSP(TS ts,TSSSPType type)
{
PetscErrorCode ierr,(*r)(TS,PetscReal,PetscReal,Vec);
TS_SSP *ssp = (TS_SSP*)ts->data;
PetscFunctionBegin;
ierr = PetscFunctionListFind(TSSSPList,type,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE,"Unknown TS_SSP type %s given",type);
ssp->onestep = r;
ierr = PetscFree(ssp->type_name);CHKERRQ(ierr);
ierr = PetscStrallocpy(type,&ssp->type_name);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode PCGAMGProlongator_Classical(PC pc, const Mat A, const Mat G, PetscCoarsenData *agg_lists,Mat *P)
{
PetscErrorCode ierr;
PetscErrorCode (*f)(PC,Mat,Mat,PetscCoarsenData*,Mat*);
PC_MG *mg = (PC_MG*)pc->data;
PC_GAMG *pc_gamg = (PC_GAMG*)mg->innerctx;
PC_GAMG_Classical *cls = (PC_GAMG_Classical*)pc_gamg->subctx;
PetscFunctionBegin;
ierr = PetscFunctionListFind(PCGAMGClassicalProlongatorList,cls->prolongtype,&f);CHKERRQ(ierr);
if (!f)SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"Cannot find PCGAMG Classical prolongator type");
ierr = (*f)(pc,A,G,agg_lists,P);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
TSAdaptSetType - sets the approach used for the error adapter, currently there is only TSADAPTBASIC and TSADAPTNONE
Logicially Collective on TSAdapt
Input Parameter:
+ adapt - the TS error adapter, most likely obtained with TSGetAdapt()
- type - either TSADAPTBASIC or TSADAPTNONE
Options Database:
. -ts_adapt_type basic or none - to setting the adapter type
Level: intermediate
.keywords: TSAdapt, create
.seealso: TSGetAdapt(), TSAdaptDestroy(), TSAdaptType, TSAdaptGetType()
@*/
PetscErrorCode TSAdaptSetType(TSAdapt adapt,TSAdaptType type)
{
PetscBool match;
PetscErrorCode ierr,(*r)(TSAdapt);
PetscFunctionBegin;
PetscValidHeaderSpecific(adapt,TSADAPT_CLASSID,1);
ierr = PetscObjectTypeCompare((PetscObject)adapt,type,&match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
ierr = PetscFunctionListFind(TSAdaptList,type,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE,"Unknown TSAdapt type \"%s\" given",type);
if (adapt->ops->destroy) {ierr = (*adapt->ops->destroy)(adapt);CHKERRQ(ierr);}
ierr = PetscMemzero(adapt->ops,sizeof(struct _TSAdaptOps));CHKERRQ(ierr);
ierr = PetscObjectChangeTypeName((PetscObject)adapt,type);CHKERRQ(ierr);
ierr = (*r)(adapt);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode TaoLineSearchSetType(TaoLineSearch ls, const TaoLineSearchType type)
{
PetscErrorCode ierr;
PetscErrorCode (*r)(TaoLineSearch);
PetscBool flg;
PetscFunctionBegin;
PetscValidHeaderSpecific(ls,TAOLINESEARCH_CLASSID,1);
PetscValidCharPointer(type,2);
ierr = PetscObjectTypeCompare((PetscObject)ls, type, &flg);CHKERRQ(ierr);
if (flg) PetscFunctionReturn(0);
ierr = PetscFunctionListFind(TaoLineSearchList,type, (void (**)(void)) &r);CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE,"Unable to find requested TaoLineSearch type %s",type);
if (ls->ops->destroy) {
ierr = (*(ls)->ops->destroy)(ls);CHKERRQ(ierr);
}
ls->max_funcs=30;
ls->ftol = 0.0001;
ls->gtol = 0.9;
#if defined(PETSC_USE_REAL_SINGLE)
ls->rtol = 1.0e-5;
#else
ls->rtol = 1.0e-10;
#endif
ls->stepmin=1.0e-20;
ls->stepmax=1.0e+20;
ls->nfeval=0;
ls->ngeval=0;
ls->nfgeval=0;
ls->ops->setup=0;
ls->ops->apply=0;
ls->ops->view=0;
ls->ops->setfromoptions=0;
ls->ops->destroy=0;
ls->setupcalled = PETSC_FALSE;
ierr = (*r)(ls);CHKERRQ(ierr);
ierr = PetscObjectChangeTypeName((PetscObject)ls, type);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
AOSetType - Builds an application ordering for a particular implementation.
Collective on AO
Input Parameters:
+ ao - The AO object
- method - The name of the AO type
Options Database Key:
. -ao_type <type> - Sets the AO type; use -help for a list of available types
Notes:
See "petsc/include/petscao.h" for available AO types (for instance, AOBASIC and AOMEMORYSCALABLE).
Level: intermediate
.keywords: ao, set, type
.seealso: AOGetType(), AOCreate()
@*/
PetscErrorCode AOSetType(AO ao, AOType method)
{
PetscErrorCode (*r)(AO);
PetscBool match;
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(ao, AO_CLASSID,1);
ierr = PetscObjectTypeCompare((PetscObject)ao, method, &match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
ierr = AORegisterAll();CHKERRQ(ierr);
ierr = PetscFunctionListFind(AOList,method,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE, "Unknown AO type: %s", method);
if (ao->ops->destroy) {
ierr = (*ao->ops->destroy)(ao);CHKERRQ(ierr);
ao->ops->destroy = NULL;
}
ierr = (*r)(ao);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
ISSetType - Builds a index set, for a particular implementation.
Collective on IS
Input Parameters:
+ is - The index set object
- method - The name of the index set type
Options Database Key:
. -is_type <type> - Sets the index set type; use -help for a list of available types
Notes:
See "petsc/include/petscis.h" for available istor types (for instance, ISGENERAL, ISSTRIDE, or ISBLOCK).
Use ISDuplicate() to make a duplicate
Level: intermediate
.seealso: ISGetType(), ISCreate()
@*/
PetscErrorCode ISSetType(IS is, ISType method)
{
PetscErrorCode (*r)(IS);
PetscBool match;
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(is, IS_CLASSID,1);
ierr = PetscObjectTypeCompare((PetscObject) is, method, &match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
if (!ISRegisterAllCalled) {ierr = ISRegisterAll(PETSC_NULL);CHKERRQ(ierr);}
ierr = PetscFunctionListFind( ((PetscObject)is)->comm,ISList, method,PETSC_TRUE,(void (**)(void)) &r);CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE, "Unknown IS type: %s", method);
if (is->ops->destroy) {
ierr = (*is->ops->destroy)(is);CHKERRQ(ierr);
is->ops->destroy = PETSC_NULL;
}
ierr = (*r)(is);CHKERRQ(ierr);
ierr = PetscObjectChangeTypeName((PetscObject)is,method);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
RGSetType - Selects the type for the RG object.
Logically Collective on RG
Input Parameter:
+ rg - the region context
- type - a known type
Level: intermediate
.seealso: RGGetType()
@*/
PetscErrorCode RGSetType(RG rg,RGType type)
{
PetscErrorCode ierr,(*r)(RG);
PetscBool match;
PetscFunctionBegin;
PetscValidHeaderSpecific(rg,RG_CLASSID,1);
PetscValidCharPointer(type,2);
ierr = PetscObjectTypeCompare((PetscObject)rg,type,&match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
ierr = PetscFunctionListFind(RGList,type,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PetscObjectComm((PetscObject)rg),PETSC_ERR_ARG_UNKNOWN_TYPE,"Unable to find requested RG type %s",type);
if (rg->ops->destroy) { ierr = (*rg->ops->destroy)(rg);CHKERRQ(ierr); }
ierr = PetscMemzero(rg->ops,sizeof(struct _RGOps));CHKERRQ(ierr);
ierr = PetscObjectChangeTypeName((PetscObject)rg,type);CHKERRQ(ierr);
ierr = (*r)(rg);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
PetscSFSetType - set the PetscSF communication implementation
Collective on PetscSF
Input Parameters:
+ sf - the PetscSF context
- type - a known method
Options Database Key:
. -sf_type <type> - Sets the method; use -help for a list
of available methods (for instance, window, pt2pt, neighbor)
Notes:
See "include/petscsf.h" for available methods (for instance)
+ PETSCSFWINDOW - MPI-2/3 one-sided
- PETSCSFBASIC - basic implementation using MPI-1 two-sided
Level: intermediate
.keywords: PetscSF, set, type
.seealso: PetscSFType, PetscSFCreate()
@*/
PetscErrorCode PetscSFSetType(PetscSF sf,PetscSFType type)
{
PetscErrorCode ierr,(*r)(PetscSF);
PetscBool match;
PetscFunctionBegin;
PetscValidHeaderSpecific(sf,PETSCSF_CLASSID,1);
PetscValidCharPointer(type,2);
ierr = PetscObjectTypeCompare((PetscObject)sf,type,&match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
ierr = PetscFunctionListFind(PetscSFList,type,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE,"Unable to find requested PetscSF type %s",type);
/* Destroy the previous private PetscSF context */
if (sf->ops->Destroy) {
ierr = (*(sf)->ops->Destroy)(sf);CHKERRQ(ierr);
}
ierr = PetscMemzero(sf->ops,sizeof(*sf->ops));CHKERRQ(ierr);
ierr = PetscObjectChangeTypeName((PetscObject)sf,type);CHKERRQ(ierr);
ierr = (*r)(sf);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode OpCreateFromOptions(MPI_Comm comm,Op *op)
{
PetscErrorCode ierr,(*f)(Op);
Op o;
char opname[256] = "poisson1";
PetscFunctionBegin;
ierr = OpInitializePackage();CHKERRQ(ierr);
ierr = PetscNew(&o);CHKERRQ(ierr);
ierr = PetscCommDuplicate(comm,&o->comm,NULL);CHKERRQ(ierr);
ierr = OpSetFEDegree(o,1);CHKERRQ(ierr);
ierr = OpSetDof(o,1);CHKERRQ(ierr);
ierr = PetscOptionsBegin(comm,NULL,"Operator options",NULL);CHKERRQ(ierr);
ierr = PetscOptionsFList("-op_type","Operator type","",OpList,opname,opname,sizeof opname,NULL);CHKERRQ(ierr);
ierr = PetscFunctionListFind(OpList,opname,&f);CHKERRQ(ierr);
if (!f) SETERRQ1(comm,PETSC_ERR_USER,"Operator type '%s' not found",opname);
ierr = (*f)(o);CHKERRQ(ierr);
ierr = PetscOptionsEnd();CHKERRQ(ierr);
ierr = TensorCreate(o->ne,o->dof,o->fedegree+1,o->fedegree+1,&o->TensorDOF);CHKERRQ(ierr);
ierr = TensorCreate(o->ne,3,o->fedegree+1,o->fedegree+1,&o->Tensor3);CHKERRQ(ierr);
*op = o;
PetscFunctionReturn(0);
}
/*@C
MatGetColoring - Gets a coloring for a matrix, from its sparsity structure,
to reduce the number of function evaluations needed to compute a sparse Jacobian via differencing.
Collective on Mat
Input Parameters:
. mat - the matrix
. type - type of coloring, one of the following:
$ MATCOLORINGNATURAL - natural (one color for each column, very slow)
$ MATCOLORINGSL - smallest-last
$ MATCOLORINGLF - largest-first
$ MATCOLORINGID - incidence-degree
Output Parameters:
. iscoloring - the coloring
Options Database Keys:
To specify the coloring through the options database, use one of
the following
$ -mat_coloring_type natural, -mat_coloring_type sl, -mat_coloring_type lf,
$ -mat_coloring_type id
To see the coloring use
$ -mat_coloring_view
Level: intermediate
Notes:
$ A graph coloring C(A) is a division of vertices so that two vertices of the same color do not share any common edges.
$ A suitable coloring for a smoother is simply C(A).
$ A suitable coloring for efficient Jacobian computation is a division of the columns so that two columns of the same color do not share any common rows.
$ This corresponds to C(A^{T} A). This is what MatGetColoring() computes.
The user can define additional colorings; see MatColoringRegisterDynamic().
For parallel matrices currently converts to sequential matrix and uses the sequential coloring
on that.
The colorings SL, LF, and ID are obtained via the Minpack software that was
converted to C using f2c.
For BAIJ matrices this colors the blocks. The true number of colors would be block size times the number of colors
returned here.
References:
$ Thomas F. Coleman and Jorge J. More, Estimation of Sparse {J}acobian Matrices and Graph Coloring Problems,
$ SIAM Journal on Numerical Analysis, 1983, pages 187-209, volume 20
$ Jorge J. Mor\'{e} and Danny C. Sorenson and Burton S. Garbow and Kenneth E. Hillstrom, The {MINPACK} Project,
$ Sources and Development of Mathematical Software, Wayne R. Cowell editor, 1984, pages 88-111
.keywords: matrix, get, coloring
.seealso: MatGetColoringTypeFromOptions(), MatColoringRegisterDynamic(), MatFDColoringCreate(),
SNESDefaultComputeJacobianColor()
@*/
PetscErrorCode MatGetColoring(Mat mat,MatColoringType type,ISColoring *iscoloring)
{
PetscBool flag;
PetscErrorCode ierr,(*r)(Mat,MatColoringType,ISColoring *);
char tname[PETSC_MAX_PATH_LEN];
MPI_Comm comm;
PetscFunctionBegin;
PetscValidHeaderSpecific(mat,MAT_CLASSID,1);
PetscValidPointer(iscoloring,3);
if (!mat->assembled) SETERRQ(((PetscObject)mat)->comm,PETSC_ERR_ARG_WRONGSTATE,"Not for unassembled matrix");
if (mat->factortype) SETERRQ(((PetscObject)mat)->comm,PETSC_ERR_ARG_WRONGSTATE,"Not for factored matrix");
/* look for type on command line */
if (!MatColoringRegisterAllCalled) {ierr = MatColoringRegisterAll(PETSC_NULL);CHKERRQ(ierr);}
ierr = PetscOptionsGetString(((PetscObject)mat)->prefix,"-mat_coloring_type",tname,256,&flag);CHKERRQ(ierr);
if (flag) { type = tname; }
ierr = PetscObjectGetComm((PetscObject)mat,&comm);CHKERRQ(ierr);
ierr = PetscFunctionListFind(comm,MatColoringList,type,PETSC_TRUE,(void (**)(void)) &r);CHKERRQ(ierr);
if (!r) SETERRQ1(((PetscObject)mat)->comm,PETSC_ERR_ARG_OUTOFRANGE,"Unknown or unregistered type: %s",type);
ierr = PetscLogEventBegin(MAT_GetColoring,mat,0,0,0);CHKERRQ(ierr);
ierr = (*r)(mat,type,iscoloring);CHKERRQ(ierr);
ierr = PetscLogEventEnd(MAT_GetColoring,mat,0,0,0);CHKERRQ(ierr);
ierr = PetscInfo1(mat,"Number of colors %d\n",(*iscoloring)->n);CHKERRQ(ierr);
flag = PETSC_FALSE;
ierr = PetscOptionsGetBool(PETSC_NULL,"-mat_coloring_view",&flag,PETSC_NULL);CHKERRQ(ierr);
if (flag) {
PetscViewer viewer;
ierr = PetscViewerASCIIGetStdout((*iscoloring)->comm,&viewer);CHKERRQ(ierr);
ierr = ISColoringView(*iscoloring,viewer);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/*@C
TSTrajectorySetType - Sets the storage method to be used as in a trajectory
Collective on TS
Input Parameters:
+ tj - the TSTrajectory context
. ts - the TS context
- type - a known method
Options Database Command:
. -ts_trajectory_type <type> - Sets the method; use -help for a list of available methods (for instance, basic)
Level: intermediate
.keywords: TS, trajectory, timestep, set, type
.seealso: TS, TSTrajectoryCreate(), TSTrajectorySetFromOptions(), TSTrajectoryDestroy()
@*/
PetscErrorCode TSTrajectorySetType(TSTrajectory tj,TS ts,const TSTrajectoryType type)
{
PetscErrorCode (*r)(TSTrajectory,TS);
PetscBool match;
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(tj,TSTRAJECTORY_CLASSID,1);
ierr = PetscObjectTypeCompare((PetscObject)tj,type,&match);CHKERRQ(ierr);
if (match) PetscFunctionReturn(0);
ierr = PetscFunctionListFind(TSTrajectoryList,type,&r);CHKERRQ(ierr);
if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE,"Unknown TSTrajectory type: %s",type);
if (tj->ops->destroy) {
ierr = (*(tj)->ops->destroy)(tj);CHKERRQ(ierr);
tj->ops->destroy = NULL;
}
ierr = PetscMemzero(tj->ops,sizeof(*tj->ops));CHKERRQ(ierr);
ierr = PetscObjectChangeTypeName((PetscObject)tj,type);CHKERRQ(ierr);
ierr = (*r)(tj,ts);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
PetscFunctionList plist = NULL;
char pname[256];
TS ts; /* nonlinear solver */
Vec x,r; /* solution, residual vectors */
Mat A; /* Jacobian matrix */
Problem problem;
PetscBool use_monitor;
PetscInt steps,maxsteps = 1000,nonlinits,linits,snesfails,rejects;
PetscReal ftime;
MonitorCtx mon;
PetscErrorCode ierr;
PetscMPIInt size;
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Initialize program
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
PetscInitialize(&argc,&argv,(char*)0,help);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
if (size > 1) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"Only for sequential runs");
/* Register the available problems */
ierr = PetscFunctionListAdd(&plist,"rober",&RoberCreate);CHKERRQ(ierr);
ierr = PetscFunctionListAdd(&plist,"ce",&CECreate);CHKERRQ(ierr);
ierr = PetscFunctionListAdd(&plist,"orego",&OregoCreate);CHKERRQ(ierr);
ierr = PetscStrcpy(pname,"ce");CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Set runtime options
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = PetscOptionsBegin(PETSC_COMM_WORLD,NULL,"Timestepping benchmark options","");CHKERRQ(ierr);
{
ierr = PetscOptionsFList("-problem_type","Name of problem to run","",plist,pname,pname,sizeof(pname),NULL);CHKERRQ(ierr);
use_monitor = PETSC_FALSE;
ierr = PetscOptionsBool("-monitor_error","Display errors relative to exact solutions","",use_monitor,&use_monitor,NULL);CHKERRQ(ierr);
}
ierr = PetscOptionsEnd();CHKERRQ(ierr);
/* Create the new problem */
ierr = PetscNew(&problem);CHKERRQ(ierr);
problem->comm = MPI_COMM_WORLD;
{
PetscErrorCode (*pcreate)(Problem);
ierr = PetscFunctionListFind(plist,pname,&pcreate);CHKERRQ(ierr);
if (!pcreate) SETERRQ1(PETSC_COMM_SELF,1,"No problem '%s'",pname);
ierr = (*pcreate)(problem);CHKERRQ(ierr);
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create necessary matrix and vectors
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatSetSizes(A,problem->n,problem->n,PETSC_DETERMINE,PETSC_DETERMINE);CHKERRQ(ierr);
ierr = MatSetFromOptions(A);CHKERRQ(ierr);
ierr = MatSetUp(A);CHKERRQ(ierr);
ierr = MatGetVecs(A,&x,NULL);CHKERRQ(ierr);
ierr = VecDuplicate(x,&r);CHKERRQ(ierr);
mon.comm = PETSC_COMM_WORLD;
mon.problem = problem;
ierr = VecDuplicate(x,&mon.x);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create timestepping solver context
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = TSCreate(PETSC_COMM_WORLD,&ts);CHKERRQ(ierr);
ierr = TSSetProblemType(ts,TS_NONLINEAR);CHKERRQ(ierr);
ierr = TSSetType(ts,TSROSW);CHKERRQ(ierr); /* Rosenbrock-W */
ierr = TSSetIFunction(ts,NULL,problem->function,problem->data);CHKERRQ(ierr);
ierr = TSSetIJacobian(ts,A,A,problem->jacobian,problem->data);CHKERRQ(ierr);
ierr = TSSetDuration(ts,maxsteps,problem->final_time);CHKERRQ(ierr);
ierr = TSSetMaxStepRejections(ts,10);CHKERRQ(ierr);
ierr = TSSetMaxSNESFailures(ts,-1);CHKERRQ(ierr); /* unlimited */
if (use_monitor) {
ierr = TSMonitorSet(ts,&MonitorError,&mon,NULL);CHKERRQ(ierr);
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Set initial conditions
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = (*problem->solution)(0,x,problem->data);CHKERRQ(ierr);
ierr = TSSetInitialTimeStep(ts,0.0,.001);CHKERRQ(ierr);
ierr = TSSetSolution(ts,x);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Set runtime options
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = TSSetFromOptions(ts);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Solve nonlinear system
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = TSSolve(ts,x);CHKERRQ(ierr);
ierr = TSGetSolveTime(ts,&ftime);CHKERRQ(ierr);
ierr = TSGetTimeStepNumber(ts,&steps);CHKERRQ(ierr);
ierr = TSGetSNESFailures(ts,&snesfails);CHKERRQ(ierr);
ierr = TSGetStepRejections(ts,&rejects);CHKERRQ(ierr);
ierr = TSGetSNESIterations(ts,&nonlinits);CHKERRQ(ierr);
ierr = TSGetKSPIterations(ts,&linits);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"steps %D (%D rejected, %D SNES fails), ftime %G, nonlinits %D, linits %D\n",steps,rejects,snesfails,ftime,nonlinits,linits);CHKERRQ(ierr);
if (problem->hasexact) {
ierr = MonitorError(ts,steps,ftime,x,&mon);CHKERRQ(ierr);
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Free work space. All PETSc objects should be destroyed when they
are no longer needed.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&r);CHKERRQ(ierr);
ierr = VecDestroy(&mon.x);CHKERRQ(ierr);
ierr = TSDestroy(&ts);CHKERRQ(ierr);
if (problem->destroy) {
ierr = (*problem->destroy)(problem);CHKERRQ(ierr);
}
ierr = PetscFree(problem);CHKERRQ(ierr);
ierr = PetscFunctionListDestroy(&plist);CHKERRQ(ierr);
ierr = PetscFinalize();
PetscFunctionReturn(0);
}
