/*MC
SNESMULTIBLOCK - Multiblock nonlinear solver that can use overlapping or nonoverlapping blocks, organized
additively (Jacobi) or multiplicatively (Gauss-Seidel).
Level: beginner
.seealso: SNESCreate(), SNES, SNESSetType(), SNESNEWTONLS, SNESNEWTONTR, SNESNRICHARDSON
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "SNESCreate_Multiblock"
PetscErrorCode SNESCreate_Multiblock(SNES snes)
{
SNES_Multiblock *mb;
PetscErrorCode ierr;
PetscFunctionBegin;
snes->ops->destroy = SNESDestroy_Multiblock;
snes->ops->setup = SNESSetUp_Multiblock;
snes->ops->setfromoptions = SNESSetFromOptions_Multiblock;
snes->ops->view = SNESView_Multiblock;
snes->ops->solve = SNESSolve_Multiblock;
snes->ops->reset = SNESReset_Multiblock;
snes->usesksp = PETSC_FALSE;
ierr = PetscNewLog(snes, SNES_Multiblock, &mb);CHKERRQ(ierr);
snes->data = (void*) mb;
mb->defined = PETSC_FALSE;
mb->numBlocks = 0;
mb->bs = -1;
mb->type = PC_COMPOSITE_MULTIPLICATIVE;
/* We attach functions so that they can be called on another PC without crashing the program */
ierr = PetscObjectComposeFunctionDynamic((PetscObject) snes, "SNESMultiblockSetFields_C", "SNESMultiblockSetFields_Default", SNESMultiblockSetFields_Default);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject) snes, "SNESMultiblockSetIS_C", "SNESMultiblockSetIS_Default", SNESMultiblockSetIS_Default);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject) snes, "SNESMultiblockSetType_C", "SNESMultiblockSetType_Default", SNESMultiblockSetType_Default);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject) snes, "SNESMultiblockSetBlockSize_C", "SNESMultiblockSetBlockSize_Default", SNESMultiblockSetBlockSize_Default);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject) snes, "SNESMultiblockGetSubSNES_C", "SNESMultiblockGetSubSNES_Default", SNESMultiblockGetSubSNES_Default);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
EXTERN_C_END
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "SNESMultiblockSetType_Default"
PetscErrorCode SNESMultiblockSetType_Default(SNES snes, PCCompositeType type)
{
SNES_Multiblock *mb = (SNES_Multiblock *) snes->data;
PetscErrorCode ierr;
PetscFunctionBegin;
mb->type = type;
if (type == PC_COMPOSITE_SCHUR) {
#if 1
SETERRQ(((PetscObject) snes)->comm, PETSC_ERR_SUP, "The Schur composite type is not yet supported");
#else
snes->ops->solve = SNESSolve_Multiblock_Schur;
snes->ops->view = SNESView_Multiblock_Schur;
ierr = PetscObjectComposeFunctionDynamic((PetscObject) snes, "SNESMultiblockGetSubSNES_C", "SNESMultiblockGetSubSNES_Schur", SNESMultiblockGetSubSNES_Schur);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject) snes, "SNESMultiblockSchurPrecondition_C", "SNESMultiblockSchurPrecondition_Default", SNESMultiblockSchurPrecondition_Default);CHKERRQ(ierr);
#endif
} else {
snes->ops->solve = SNESSolve_Multiblock;
snes->ops->view = SNESView_Multiblock;
ierr = PetscObjectComposeFunctionDynamic((PetscObject) snes, "SNESMultiblockGetSubSNES_C", "SNESMultiblockGetSubSNES_Default", SNESMultiblockGetSubSNES_Default);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject) snes, "SNESMultiblockSchurPrecondition_C", "", 0);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/*MC
SNESVINEWTONRSLS - Reduced space active set solvers for variational inequalities based on Newton's method
Options Database:
+ -snes_vi_type <ss,rs,rsaug> a semi-smooth solver, a reduced space active set method, and a reduced space active set method that does not eliminate the active constraints from the Jacobian instead augments the Jacobian with additional variables that enforce the constraints
- -snes_vi_monitor - prints the number of active constraints at each iteration.
Level: beginner
References:
- T. S. Munson, and S. Benson. Flexible Complementarity Solvers for Large-Scale
Applications, Optimization Methods and Software, 21 (2006).
.seealso: SNESVISetVariableBounds(), SNESVISetComputeVariableBounds(), SNESCreate(), SNES, SNESSetType(), SNESVINEWTONRSLS, SNESVINEWTONSSLS, SNESNEWTONTR, SNESLineSearchSet(),
SNESLineSearchSetPostCheck(), SNESLineSearchNo(), SNESLineSearchCubic(), SNESLineSearchQuadratic(),
SNESLineSearchSet(), SNESLineSearchNoNorms(), SNESLineSearchSetPreCheck(), SNESLineSearchSetParams(), SNESLineSearchGetParams()
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "SNESCreate_VINEWTONRSLS"
PetscErrorCode SNESCreate_VINEWTONRSLS(SNES snes)
{
PetscErrorCode ierr;
SNES_VINEWTONRSLS *vi;
PetscFunctionBegin;
snes->ops->reset = SNESReset_VINEWTONRSLS;
snes->ops->setup = SNESSetUp_VINEWTONRSLS;
snes->ops->solve = SNESSolve_VINEWTONRSLS;
snes->ops->destroy = SNESDestroy_VI;
snes->ops->setfromoptions = SNESSetFromOptions_VI;
snes->ops->view = PETSC_NULL;
snes->ops->converged = SNESDefaultConverged_VI;
snes->usesksp = PETSC_TRUE;
snes->usespc = PETSC_FALSE;
ierr = PetscNewLog(snes,SNES_VINEWTONRSLS,&vi);CHKERRQ(ierr);
snes->data = (void*)vi;
vi->checkredundancy = PETSC_NULL;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)snes,"SNESVISetVariableBounds_C","SNESVISetVariableBounds_VI",SNESVISetVariableBounds_VI);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)snes,"SNESVISetComputeVariableBounds_C","SNESVISetComputeVariableBounds_VI",SNESVISetComputeVariableBounds_VI);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*MC
TSSSP - Explicit strong stability preserving ODE solver
Most hyperbolic conservation laws have exact solutions that are total variation diminishing (TVD) or total variation
bounded (TVB) although these solutions often contain discontinuities. Spatial discretizations such as Godunov's
scheme and high-resolution finite volume methods (TVD limiters, ENO/WENO) are designed to preserve these properties,
but they are usually formulated using a forward Euler time discretization or by coupling the space and time
discretization as in the classical Lax-Wendroff scheme. When the space and time discretization is coupled, it is very
difficult to produce schemes with high temporal accuracy while preserving TVD properties. An alternative is the
semidiscrete formulation where we choose a spatial discretization that is TVD with forward Euler and then choose a
time discretization that preserves the TVD property. Such integrators are called strong stability preserving (SSP).
Let c_eff be the minimum number of function evaluations required to step as far as one step of forward Euler while
still being SSP. Some theoretical bounds
1. There are no explicit methods with c_eff > 1.
2. There are no explicit methods beyond order 4 (for nonlinear problems) and c_eff > 0.
3. There are no implicit methods with order greater than 1 and c_eff > 2.
This integrator provides Runge-Kutta methods of order 2, 3, and 4 with maximal values of c_eff. More stages allows
for larger values of c_eff which improves efficiency. These implementations are low-memory and only use 2 or 3 work
vectors regardless of the total number of stages, so e.g. 25-stage 3rd order methods may be an excellent choice.
Methods can be chosen with -ts_ssp_type {rks2,rks3,rk104}
rks2: Second order methods with any number s>1 of stages. c_eff = (s-1)/s
rks3: Third order methods with s=n^2 stages, n>1. c_eff = (s-n)/s
rk104: A 10-stage fourth order method. c_eff = 0.6
Level: beginner
References:
Ketcheson, Highly efficient strong stability preserving Runge-Kutta methods with low-storage implementations, SISC, 2008.
Gottlieb, Ketcheson, and Shu, High order strong stability preserving time discretizations, J Scientific Computing, 2009.
.seealso: TSCreate(), TS, TSSetType()
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "TSCreate_SSP"
PetscErrorCode TSCreate_SSP(TS ts)
{
TS_SSP *ssp;
PetscErrorCode ierr;
PetscFunctionBegin;
if (!TSSSPList) {
ierr = PetscFListAdd(&TSSSPList,TSSSPRKS2, "TSSSPStep_RK_2", (void(*)(void))TSSSPStep_RK_2);CHKERRQ(ierr);
ierr = PetscFListAdd(&TSSSPList,TSSSPRKS3, "TSSSPStep_RK_3", (void(*)(void))TSSSPStep_RK_3);CHKERRQ(ierr);
ierr = PetscFListAdd(&TSSSPList,TSSSPRK104, "TSSSPStep_RK_10_4",(void(*)(void))TSSSPStep_RK_10_4);CHKERRQ(ierr);
}
ts->ops->setup = TSSetUp_SSP;
ts->ops->step = TSStep_SSP;
ts->ops->reset = TSReset_SSP;
ts->ops->destroy = TSDestroy_SSP;
ts->ops->setfromoptions = TSSetFromOptions_SSP;
ts->ops->view = TSView_SSP;
ierr = PetscNewLog(ts,TS_SSP,&ssp);CHKERRQ(ierr);
ts->data = (void*)ssp;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSSSPGetType_C","TSSSPGetType_SSP",TSSSPGetType_SSP);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSSSPSetType_C","TSSSPSetType_SSP",TSSSPSetType_SSP);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSSSPGetNumStages_C","TSSSPGetNumStages_SSP",TSSSPGetNumStages_SSP);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSSSPSetNumStages_C","TSSSPSetNumStages_SSP",TSSSPSetNumStages_SSP);CHKERRQ(ierr);
ierr = TSSSPSetType(ts,TSSSPRKS2);CHKERRQ(ierr);
ssp->nstages = 5;
PetscFunctionReturn(0);
}
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "MatPartitioningCreate_Party"
PetscErrorCode MatPartitioningCreate_Party(MatPartitioning part)
{
PetscErrorCode ierr;
MatPartitioning_Party *party;
PetscFunctionBegin;
ierr = PetscNewLog(part,MatPartitioning_Party,&party);CHKERRQ(ierr);
part->data = (void*)party;
ierr = PetscStrcpy(party->global,"gcf,gbf");CHKERRQ(ierr);
ierr = PetscStrcpy(party->local,"kl");CHKERRQ(ierr);
party->redm = PETSC_TRUE;
party->redo = PETSC_TRUE;
party->recursive = PETSC_TRUE;
party->verbose = PETSC_FALSE;
party->nbvtxcoarsed = 200;
part->ops->apply = MatPartitioningApply_Party;
part->ops->view = MatPartitioningView_Party;
part->ops->destroy = MatPartitioningDestroy_Party;
part->ops->setfromoptions = MatPartitioningSetFromOptions_Party;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)part,"MatPartitioningPartySetGlobal_C","MatPartitioningPartySetGlobal_Party",MatPartitioningPartySetGlobal_Party);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)part,"MatPartitioningPartySetLocal_C","MatPartitioningPartySetLocal_Party",MatPartitioningPartySetLocal_Party);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)part,"MatPartitioningPartySetCoarseLevel_C","MatPartitioningPartySetCoarseLevel_Party",MatPartitioningPartySetCoarseLevel_Party);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)part,"MatPartitioningPartySetMatchOptimization_C","MatPartitioningPartySetMatchOptimization_Party",MatPartitioningPartySetMatchOptimization_Party);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)part,"MatPartitioningPartySetBipart_C","MatPartitioningPartySetBipart_Party",MatPartitioningPartySetBipart_Party);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
EXTERN_C_END
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "PetscViewerCreate_HDF5"
PetscErrorCode PetscViewerCreate_HDF5(PetscViewer v)
{
PetscViewer_HDF5 *hdf5;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscNewLog(v, PetscViewer_HDF5, &hdf5);CHKERRQ(ierr);
v->data = (void *) hdf5;
v->ops->destroy = PetscViewerDestroy_HDF5;
v->ops->flush = 0;
v->iformat = 0;
hdf5->btype = (PetscFileMode) -1;
hdf5->filename = 0;
hdf5->timestep = -1;
hdf5->groups = PETSC_NULL;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)v,"PetscViewerFileSetName_C","PetscViewerFileSetName_HDF5",
PetscViewerFileSetName_HDF5);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)v,"PetscViewerFileSetMode_C","PetscViewerFileSetMode_HDF5",
PetscViewerFileSetMode_HDF5);CHKERRQ(ierr);
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__ "PCCreate_Redundant"
PetscErrorCode PETSCKSP_DLLEXPORT PCCreate_Redundant(PC pc)
{
PetscErrorCode ierr;
PC_Redundant *red;
PetscMPIInt size;
PetscFunctionBegin;
ierr = PetscNewLog(pc,PC_Redundant,&red);CHKERRQ(ierr);
ierr = MPI_Comm_size(((PetscObject)pc)->comm,&size);CHKERRQ(ierr);
red->nsubcomm = size;
red->useparallelmat = PETSC_TRUE;
pc->data = (void*)red;
pc->ops->apply = PCApply_Redundant;
pc->ops->applytranspose = 0;
pc->ops->setup = PCSetUp_Redundant;
pc->ops->destroy = PCDestroy_Redundant;
pc->ops->setfromoptions = PCSetFromOptions_Redundant;
pc->ops->view = PCView_Redundant;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCRedundantSetScatter_C","PCRedundantSetScatter_Redundant",
PCRedundantSetScatter_Redundant);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCRedundantSetNumber_C","PCRedundantSetNumber_Redundant",
PCRedundantSetNumber_Redundant);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCRedundantGetPC_C","PCRedundantGetPC_Redundant",
PCRedundantGetPC_Redundant);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCRedundantGetOperators_C","PCRedundantGetOperators_Redundant",
PCRedundantGetOperators_Redundant);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
EXTERN_C_END
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "PetscViewerCreate_VTK"
PetscErrorCode PetscViewerCreate_VTK(PetscViewer v)
{
PetscViewer_VTK *vtk;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscNewLog(v,PetscViewer_VTK,&vtk);CHKERRQ(ierr);
v->data = (void*)vtk;
v->ops->destroy = PetscViewerDestroy_VTK;
v->ops->flush = PetscViewerFlush_VTK;
v->iformat = 0;
vtk->btype = (PetscFileMode) -1;
vtk->filename = 0;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)v,"PetscViewerFileSetName_C","PetscViewerFileSetName_VTK",
PetscViewerFileSetName_VTK);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)v,"PetscViewerFileSetMode_C","PetscViewerFileSetMode_VTK",
PetscViewerFileSetMode_VTK);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)v,"PetscViewerVTKAddField_C","PetscViewerVTKAddField_VTK",
PetscViewerVTKAddField_VTK);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode MatDestroy_SuperLU(Mat A)
{
PetscErrorCode ierr;
Mat_SuperLU *lu=(Mat_SuperLU*)A->spptr;
PetscFunctionBegin;
if (lu && lu->CleanUpSuperLU) { /* Free the SuperLU datastructures */
Destroy_SuperMatrix_Store(&lu->A);
Destroy_SuperMatrix_Store(&lu->B);
Destroy_SuperMatrix_Store(&lu->X);
StatFree(&lu->stat);
if (lu->lwork >= 0) {
Destroy_SuperNode_Matrix(&lu->L);
Destroy_CompCol_Matrix(&lu->U);
}
}
if (lu) {
ierr = PetscFree(lu->etree);CHKERRQ(ierr);
ierr = PetscFree(lu->perm_r);CHKERRQ(ierr);
ierr = PetscFree(lu->perm_c);CHKERRQ(ierr);
ierr = PetscFree(lu->R);CHKERRQ(ierr);
ierr = PetscFree(lu->C);CHKERRQ(ierr);
ierr = PetscFree(lu->rhs_dup);CHKERRQ(ierr);
ierr = MatDestroy(&lu->A_dup);CHKERRQ(ierr);
}
ierr = PetscFree(A->spptr);CHKERRQ(ierr);
/* clear composed functions */
ierr = PetscObjectComposeFunctionDynamic((PetscObject)A,"MatFactorGetSolverPackage_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)A,"MatSuperluSetILUDropTol_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = MatDestroy_SeqAIJ(A);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "PCCreate_Eisenstat"
PetscErrorCode PCCreate_Eisenstat(PC pc)
{
PetscErrorCode ierr;
PC_Eisenstat *eis;
PetscFunctionBegin;
ierr = PetscNewLog(pc,PC_Eisenstat,&eis);CHKERRQ(ierr);
pc->ops->apply = PCApply_Eisenstat;
pc->ops->presolve = PCPreSolve_Eisenstat;
pc->ops->postsolve = PCPostSolve_Eisenstat;
pc->ops->applyrichardson = 0;
pc->ops->setfromoptions = PCSetFromOptions_Eisenstat;
pc->ops->destroy = PCDestroy_Eisenstat;
pc->ops->reset = PCReset_Eisenstat;
pc->ops->view = PCView_Eisenstat;
pc->ops->setup = PCSetUp_Eisenstat;
pc->data = (void*)eis;
eis->omega = 1.0;
eis->b[0] = 0;
eis->b[1] = 0;
eis->diag = 0;
eis->usediag = PETSC_TRUE;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCEisenstatSetOmega_C","PCEisenstatSetOmega_Eisenstat",
PCEisenstatSetOmega_Eisenstat);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCEisenstatNoDiagonalScaling_C",
"PCEisenstatNoDiagonalScaling_Eisenstat",
PCEisenstatNoDiagonalScaling_Eisenstat);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "PCCreate_KSP"
PetscErrorCode PETSCKSP_DLLEXPORT PCCreate_KSP(PC pc)
{
PetscErrorCode ierr;
PC_KSP *jac;
PetscFunctionBegin;
ierr = PetscNewLog(pc,PC_KSP,&jac);CHKERRQ(ierr);
pc->ops->apply = PCApply_KSP;
pc->ops->applytranspose = PCApplyTranspose_KSP;
pc->ops->setup = PCSetUp_KSP;
pc->ops->destroy = PCDestroy_KSP;
pc->ops->setfromoptions = PCSetFromOptions_KSP;
pc->ops->view = PCView_KSP;
pc->ops->applyrichardson = 0;
pc->data = (void*)jac;
jac->use_true_matrix = PETSC_FALSE;
jac->its = 0;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCKSPSetUseTrue_C","PCKSPSetUseTrue_KSP",
PCKSPSetUseTrue_KSP);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCKSPGetKSP_C","PCKSPGetKSP_KSP",
PCKSPGetKSP_KSP);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode PetscViewerDestroy_VTK(PetscViewer viewer)
{
PetscViewer_VTK *vtk = (PetscViewer_VTK*)viewer->data;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscFree(vtk->filename);CHKERRQ(ierr);
ierr = PetscFree(vtk);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)viewer,"PetscViewerFileSetName_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)viewer,"PetscViewerFileSetMode_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)viewer,"PetscViewerVTKAddField_C","",PETSC_NULL);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode TSDestroy_Theta(TS ts)
{
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = TSReset_Theta(ts);CHKERRQ(ierr);
ierr = PetscFree(ts->data);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSThetaGetTheta_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSThetaSetTheta_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSThetaGetEndpoint_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSThetaSetEndpoint_C","",PETSC_NULL);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode TSDestroy_Alpha(TS ts)
{
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = TSReset_Alpha(ts);CHKERRQ(ierr);
ierr = PetscFree(ts->data);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSAlphaSetRadius_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSAlphaSetParams_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSAlphaGetParams_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSAlphaSetAdapt_C","",PETSC_NULL);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode TSDestroy_SSP(TS ts)
{
TS_SSP *ssp = (TS_SSP*)ts->data;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = TSReset_SSP(ts);CHKERRQ(ierr);
ierr = PetscFree(ssp->type_name);CHKERRQ(ierr);
ierr = PetscFree(ts->data);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSSSPGetType_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSSSPSetType_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSSSPGetNumStages_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ts,"TSSSPSetNumStages_C","",PETSC_NULL);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode KSPDestroy_CG(KSP ksp)
{
KSP_CG *cg = (KSP_CG*)ksp->data;
PetscErrorCode ierr;
PetscFunctionBegin;
/* free space used for singular value calculations */
if (ksp->calc_sings) {
ierr = PetscFree4(cg->e,cg->d,cg->ee,cg->dd);CHKERRQ(ierr);
}
ierr = KSPDefaultDestroy(ksp);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPCGSetType_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPCGUseSingleReduction_C","",PETSC_NULL);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode MatPartitioningDestroy_Party(MatPartitioning part)
{
MatPartitioning_Party *party = (MatPartitioning_Party*)part->data;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscFree(party);CHKERRQ(ierr);
/* clear composed functions */
ierr = PetscObjectComposeFunctionDynamic((PetscObject)part,"MatPartitioningPartySetGlobal_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)part,"MatPartitioningPartySetLocal_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)part,"MatPartitioningPartySetCoarseLevel_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)part,"MatPartitioningPartySetMatchOptimization_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)part,"MatPartitioningPartySetBipart_C","",PETSC_NULL);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "PCCreate_Jacobi"
PetscErrorCode PCCreate_Jacobi(PC pc)
{
PC_Jacobi *jac;
PetscErrorCode ierr;
PetscFunctionBegin;
/*
Creates the private data structure for this preconditioner and
attach it to the PC object.
*/
ierr = PetscNewLog(pc,PC_Jacobi,&jac);CHKERRQ(ierr);
pc->data = (void*)jac;
/*
Initialize the pointers to vectors to ZERO; these will be used to store
diagonal entries of the matrix for fast preconditioner application.
*/
jac->diag = 0;
jac->diagsqrt = 0;
jac->userowmax = PETSC_FALSE;
jac->userowsum = PETSC_FALSE;
jac->useabs = PETSC_FALSE;
/*
Set the pointers for the functions that are provided above.
Now when the user-level routines (such as PCApply(), PCDestroy(), etc.)
are called, they will automatically call these functions. Note we
choose not to provide a couple of these functions since they are
not needed.
*/
pc->ops->apply = PCApply_Jacobi;
pc->ops->applytranspose = PCApply_Jacobi;
pc->ops->setup = PCSetUp_Jacobi;
pc->ops->reset = PCReset_Jacobi;
pc->ops->destroy = PCDestroy_Jacobi;
pc->ops->setfromoptions = PCSetFromOptions_Jacobi;
pc->ops->view = 0;
pc->ops->applyrichardson = 0;
pc->ops->applysymmetricleft = PCApplySymmetricLeftOrRight_Jacobi;
pc->ops->applysymmetricright = PCApplySymmetricLeftOrRight_Jacobi;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCJacobiSetUseRowMax_C","PCJacobiSetUseRowMax_Jacobi",PCJacobiSetUseRowMax_Jacobi);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCJacobiSetUseRowSum_C","PCJacobiSetUseRowSum_Jacobi",PCJacobiSetUseRowSum_Jacobi);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCJacobiSetUseAbs_C","PCJacobiSetUseAbs_Jacobi",PCJacobiSetUseAbs_Jacobi);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*MC
SNESNCG - Nonlinear Conjugate-Gradient method for the solution of general nonlinear systems.
Level: beginner
Options Database:
+ -snes_ncg_type <fr, prp, dy, hs, cd> - Choice of conjugate-gradient update parameter.
. -snes_linesearch_type <cp,l2,basic> - Line search type.
- -snes_ncg_monitor - Print relevant information about the ncg iteration.
Notes: This solves the nonlinear system of equations F(x) = 0 using the nonlinear generalization of the conjugate
gradient method. This may be used with a nonlinear preconditioner used to pick the new search directions, but otherwise
chooses the initial search direction as F(x) for the initial guess x.
.seealso: SNESCreate(), SNES, SNESSetType(), SNESNEWTONLS, SNESNEWTONTR, SNESNGMRES, SNESNQN
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "SNESCreate_NCG"
PetscErrorCode SNESCreate_NCG(SNES snes)
{
PetscErrorCode ierr;
SNES_NCG * neP;
PetscFunctionBegin;
snes->ops->destroy = SNESDestroy_NCG;
snes->ops->setup = SNESSetUp_NCG;
snes->ops->setfromoptions = SNESSetFromOptions_NCG;
snes->ops->view = SNESView_NCG;
snes->ops->solve = SNESSolve_NCG;
snes->ops->reset = SNESReset_NCG;
snes->usesksp = PETSC_FALSE;
snes->usespc = PETSC_TRUE;
if (!snes->tolerancesset) {
snes->max_funcs = 30000;
snes->max_its = 10000;
snes->stol = 1e-20;
}
ierr = PetscNewLog(snes, SNES_NCG, &neP);
CHKERRQ(ierr);
snes->data = (void*) neP;
neP->monitor = PETSC_NULL;
neP->type = SNES_NCG_PRP;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)snes,"SNESNCGSetType_C","SNESNCGSetType_NCG", SNESNCGSetType_NCG);
CHKERRQ(ierr);
PetscFunctionReturn(0);
}
EXTERN_C_END
/*MC
SNESSHELL - a user provided nonlinear solver
Level: advanced
.seealso: SNESCreate(), SNES, SNESSetType(), SNESType (for list of available types)
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "SNESCreate_Shell"
PetscErrorCode SNESCreate_Shell(SNES snes)
{
SNES_Shell *shell;
PetscErrorCode ierr;
PetscFunctionBegin;
snes->ops->destroy = SNESDestroy_Shell;
snes->ops->setup = SNESSetUp_Shell;
snes->ops->setfromoptions = SNESSetFromOptions_Shell;
snes->ops->view = SNESView_Shell;
snes->ops->solve = SNESSolve_Shell;
snes->ops->reset = SNESReset_Shell;
snes->usesksp = PETSC_FALSE;
snes->usespc = PETSC_FALSE;
ierr = PetscNewLog(snes, SNES_Shell, &shell);CHKERRQ(ierr);
snes->data = (void*) shell;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)snes,"SNESShellSetSolve_C","SNESShellSetSolve_Shell",SNESShellSetSolve_Shell);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "KSPCreate_Chebychev"
PetscErrorCode PETSCKSP_DLLEXPORT KSPCreate_Chebychev(KSP ksp)
{
PetscErrorCode ierr;
KSP_Chebychev *chebychevP;
PetscFunctionBegin;
ierr = PetscNewLog(ksp,KSP_Chebychev,&chebychevP);CHKERRQ(ierr);
ksp->data = (void*)chebychevP;
if (ksp->pc_side != PC_LEFT) {
ierr = PetscInfo(ksp,"WARNING! Setting PC_SIDE for Chebychev to left!\n");CHKERRQ(ierr);
}
ksp->pc_side = PC_LEFT;
chebychevP->emin = 1.e-2;
chebychevP->emax = 1.e+2;
ksp->ops->setup = KSPSetUp_Chebychev;
ksp->ops->solve = KSPSolve_Chebychev;
ksp->ops->destroy = KSPDestroy_Chebychev;
ksp->ops->buildsolution = KSPDefaultBuildSolution;
ksp->ops->buildresidual = KSPDefaultBuildResidual;
ksp->ops->setfromoptions = KSPSetFromOptions_Chebychev;
ksp->ops->view = KSPView_Chebychev;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ksp,"KSPChebychevSetEigenvalues_C",
"KSPChebychevSetEigenvalues_Chebychev",
KSPChebychevSetEigenvalues_Chebychev);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*MC
SNESMS - multi-stage smoothers
Options Database:
+ -snes_ms_type - type of multi-stage smoother
- -snes_ms_damping - damping for multi-stage method
Notes:
These multistage methods are explicit Runge-Kutta methods that are often used as smoothers for
FAS multigrid for transport problems. In the linear case, these are equivalent to polynomial smoothers (such as Chebyshev).
Multi-stage smoothers should usually be preconditioned by point-block Jacobi to ensure proper scaling and to normalize the wave speeds.
The methods are specified in low storage form (Ketcheson 2010). New methods can be registered with SNESMSRegister().
References:
Ketcheson (2010) Runge-Kutta methods with minimum storage implementations.
Jameson (1983) Solution of the Euler equations for two dimensional transonic flow by a multigrid method.
Pierce and Giles (1997) Preconditioned multigrid methods for compressible flow calculations on stretched meshes.
Level: beginner
.seealso: SNESCreate(), SNES, SNESSetType(), SNESMS, SNESFAS, KSPCHEBYSHEV
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "SNESCreate_MS"
PetscErrorCode SNESCreate_MS(SNES snes)
{
PetscErrorCode ierr;
SNES_MS *ms;
PetscFunctionBegin;
#if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
ierr = SNESMSInitializePackage(PETSC_NULL);CHKERRQ(ierr);
#endif
snes->ops->setup = SNESSetUp_MS;
snes->ops->solve = SNESSolve_MS;
snes->ops->destroy = SNESDestroy_MS;
snes->ops->setfromoptions = SNESSetFromOptions_MS;
snes->ops->view = SNESView_MS;
snes->ops->reset = SNESReset_MS;
snes->usespc = PETSC_FALSE;
snes->usesksp = PETSC_TRUE;
ierr = PetscNewLog(snes,SNES_MS,&ms);CHKERRQ(ierr);
snes->data = (void*)ms;
ms->damping = 0.9;
ms->norms = PETSC_FALSE;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)snes,"SNESMSSetType_C","SNESMSSetType_MS",SNESMSSetType_MS);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "MatGetFactor_seqsbaij_sbstrm"
PetscErrorCode MatGetFactor_seqsbaij_sbstrm(Mat A,MatFactorType ftype,Mat *F)
{
Mat B;
PetscInt bs = A->rmap->bs;
Mat_SeqSBSTRM *sbstrm;
PetscErrorCode ierr;
PetscFunctionBegin;
if (A->cmap->N != A->rmap->N) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Must be square matrix, rows %D columns %D",A->rmap->n,A->cmap->n);
ierr = MatCreate(((PetscObject)A)->comm,&B);CHKERRQ(ierr);
ierr = MatSetSizes(B,A->rmap->n,A->cmap->n,PETSC_DETERMINE,PETSC_DETERMINE);CHKERRQ(ierr);
ierr = MatSetType(B,((PetscObject)A)->type_name);CHKERRQ(ierr);
ierr = MatSeqSBAIJSetPreallocation_SeqSBAIJ(B,bs,MAT_SKIP_ALLOCATION,PETSC_NULL);CHKERRQ(ierr);
B->ops->iccfactorsymbolic = MatICCFactorSymbolic_sbstrm;
B->ops->choleskyfactorsymbolic = MatCholeskyFactorSymbolic_sbstrm;
B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_sbstrm;
B->ops->destroy = MatDestroy_SeqSBSTRM;
B->factortype = ftype;
B->assembled = PETSC_TRUE; /* required by -ksp_view */
B->preallocated = PETSC_TRUE;
ierr = PetscNewLog(B,Mat_SeqSBSTRM,&sbstrm);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)B,"MatFactorGetSolverPackage_C","MatFactorGetSolverPackage_seqsbaij_sbstrm",MatFactorGetSolverPackage_seqsbaij_sbstrm);CHKERRQ(ierr);
B->spptr = sbstrm;
*F = B;
PetscFunctionReturn(0);
}
/*
TAOCreate_BCG - Creates the data structure for the nonlinear BCG method
and sets the function pointers for all the routines it needs to call
(TAOSolve_BCG() etc.)
It must be wrapped in EXTERN_C_BEGIN to be dynamically linkable in C++
*/
EXTERN_C_BEGIN
#undef __FUNC__
#define __FUNC__ "TaoCreate_BCG"
int TaoCreate_BCG(TAO_SOLVER tao)
{
TAO_BCG *cg;
int info;
TaoFunctionBegin;
cg = TaoNew(TAO_BCG);CHKPTRQ(cg);
PLogObjectMemory(tao,sizeof(TAO_BCG));
info = TaoSetSolver(tao,TaoSetUp_BCG,TaoSetOptions_BCG,TaoSolve_BCG,
TaoView_BCG,TaoDestroy_BCG,(void*)cg); CHKERRQ(info);
info = TaoSetMaximumIterates(tao,2000); CHKERRQ(info);
info = TaoSetTolerances(tao,1e-4,0,0,0); CHKERRQ(info);
info = TaoSetMaximumFunctionEvaluations(tao,4000); CHKERRQ(info);
info = TaoCreateProjectedLineSearch(tao); CHKERRQ(info);
cg->eta = 100.0;
cg->type = TAO_CG_PRplus;
info = PetscObjectComposeFunctionDynamic((PetscObject)tao,"TaoBCGSetRestartTol_C",
"TaoBCGSetRestartTol_TaoBCG",
(void*)TaoBCGSetRestartTol_TaoBCG);CHKERRQ(info);
TaoFunctionReturn(0);
}
/*MC
MATMFFD_DS - the code for compute the "h" used in the finite difference
matrix-free matrix vector product. This code
implements the strategy in Dennis and Schnabel, "Numerical Methods for Unconstrained
Optimization and Nonlinear Equations".
Options Database Keys:
. -mat_mffd_umin <umin> see MatMFFDDSSetUmin()
Level: intermediate
Notes: Requires 2 norms and 1 inner product, but they are computed together
so only one parallel collective operation is needed. See MATMFFD_WP for a method
(with GMRES) that requires NO collective operations.
Formula used:
F'(u)*a = [F(u+h*a) - F(u)]/h where
h = error_rel*u'a/||a||^2 if |u'a| > umin*||a||_{1}
= error_rel*umin*sign(u'a)*||a||_{1}/||a||^2 otherwise
where
error_rel = square root of relative error in function evaluation
umin = minimum iterate parameter
.seealso: MATMFFD, MatCreateMFFD(), MatCreateSNESMF(), MATMFFD_WP, MatMFFDDSSetUmin()
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "MatCreateMFFD_DS"
PetscErrorCode MatCreateMFFD_DS(MatMFFD ctx)
{
MatMFFD_DS *hctx;
PetscErrorCode ierr;
PetscFunctionBegin;
/* allocate my own private data structure */
ierr = PetscNewLog(ctx,MatMFFD_DS,&hctx);CHKERRQ(ierr);
ctx->hctx = (void*)hctx;
/* set a default for my parameter */
hctx->umin = 1.e-6;
/* set the functions I am providing */
ctx->ops->compute = MatMFFDCompute_DS;
ctx->ops->destroy = MatMFFDDestroy_DS;
ctx->ops->view = MatMFFDView_DS;
ctx->ops->setfromoptions = MatMFFDSetFromOptions_DS;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ctx->mat,"MatMFFDDSSetUmin_C",
"MatMFFDDSSetUmin_DS",
MatMFFDDSSetUmin_DS);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "MatCreateMFFD_WP"
/*
MatCreateMFFD_WP - Standard PETSc code for
computing h with matrix-free finite differences.
Input Parameter:
. ctx - the matrix free context created by MatCreateMFFD()
*/
PetscErrorCode MatCreateMFFD_WP(MatMFFD ctx)
{
PetscErrorCode ierr;
MatMFFD_WP *hctx;
PetscFunctionBegin;
/* allocate my own private data structure */
ierr = PetscNewLog(ctx,MatMFFD_WP,&hctx);CHKERRQ(ierr);
ctx->hctx = (void*)hctx;
hctx->computenormU = PETSC_FALSE;
/* set the functions I am providing */
ctx->ops->compute = MatMFFDCompute_WP;
ctx->ops->destroy = MatMFFDDestroy_WP;
ctx->ops->view = MatMFFDView_WP;
ctx->ops->setfromoptions = MatMFFDSetFromOptions_WP;
ierr = PetscObjectComposeFunctionDynamic((PetscObject)ctx->mat,"MatMFFDWPSetComputeNormU_C","MatMFFDWPSetComputeNormU_P",MatMFFDWPSetComputeNormU_P);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "PCCreate_SPAI"
PetscErrorCode PCCreate_SPAI(PC pc)
{
PC_SPAI *ispai;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscNewLog(pc,PC_SPAI,&ispai);CHKERRQ(ierr);
pc->data = ispai;
pc->ops->destroy = PCDestroy_SPAI;
pc->ops->apply = PCApply_SPAI;
pc->ops->applyrichardson = 0;
pc->ops->setup = PCSetUp_SPAI;
pc->ops->view = PCView_SPAI;
pc->ops->setfromoptions = PCSetFromOptions_SPAI;
ispai->epsilon = .4;
ispai->nbsteps = 5;
ispai->max = 5000;
ispai->maxnew = 5;
ispai->block_size = 1;
ispai->cache_size = 5;
ispai->verbose = 0;
ispai->sp = 1;
ierr = MPI_Comm_dup(((PetscObject)pc)->comm,&(ispai->comm_spai));CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCSPAISetEpsilon_C",
"PCSPAISetEpsilon_SPAI",
PCSPAISetEpsilon_SPAI);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCSPAISetNBSteps_C",
"PCSPAISetNBSteps_SPAI",
PCSPAISetNBSteps_SPAI);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCSPAISetMax_C",
"PCSPAISetMax_SPAI",
PCSPAISetMax_SPAI);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCSPAISetMaxNew_CC",
"PCSPAISetMaxNew_SPAI",
PCSPAISetMaxNew_SPAI);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCSPAISetBlockSize_C",
"PCSPAISetBlockSize_SPAI",
PCSPAISetBlockSize_SPAI);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCSPAISetCacheSize_C",
"PCSPAISetCacheSize_SPAI",
PCSPAISetCacheSize_SPAI);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCSPAISetVerbose_C",
"PCSPAISetVerbose_SPAI",
PCSPAISetVerbose_SPAI);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCSPAISetSp_C",
"PCSPAISetSp_SPAI",
PCSPAISetSp_SPAI);CHKERRQ(ierr);
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);
}
EXTERN_C_END
/*MC
MATDAAD - MATDAAD = "daad" - A matrix type that can do matrix-vector products using a local function that
is differentiated with ADIFOR or ADIC.
Level: intermediate
.seealso: MatCreateDAAD
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "MatCreate_DAAD"
PetscErrorCode MatCreate_DAAD(Mat B)
{
Mat_DAAD *b;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscNewLog(B,Mat_DAAD,&b);
CHKERRQ(ierr);
B->data = (void*)b;
ierr = PetscMemcpy(B->ops,&MatOps_Values,sizeof(struct _MatOps));
CHKERRQ(ierr);
ierr = PetscLayoutSetUp(B->rmap);
CHKERRQ(ierr);
ierr = PetscLayoutSetUp(B->cmap);
CHKERRQ(ierr);
ierr = PetscObjectChangeTypeName((PetscObject)B,MATDAAD);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)B,"MatMFFDSetBase_C","MatMFFDSetBase_AD",MatMFFDSetBase_AD);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)B,"MatDAADSetDA_C","MatDAADSetDA_AD",MatDAADSetDA_AD);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)B,"MatDAADSetSNES_C","MatDAADSetSNES_AD",MatDAADSetSNES_AD);
CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)B,"MatDAADSetCtx_C","MatDAADSetCtx_AD",MatDAADSetCtx_AD);
CHKERRQ(ierr);
ierr = PetscObjectChangeTypeName((PetscObject)B,MATDAAD);
CHKERRQ(ierr);
PetscFunctionReturn(0);
}