PetscErrorCode MatPartitioningSetFromOptions_Chaco(MatPartitioning part)
{
PetscErrorCode ierr;
PetscInt i;
PetscReal r;
PetscBool flag;
MatPartitioning_Chaco *chaco = (MatPartitioning_Chaco*)part->data;
MPChacoGlobalType global;
MPChacoLocalType local;
MPChacoEigenType eigen;
PetscFunctionBegin;
ierr = PetscOptionsHead("Chaco partitioning options");CHKERRQ(ierr);
ierr = PetscOptionsEnum("-mat_partitioning_chaco_global","Global method","MatPartitioningChacoSetGlobal",MPChacoGlobalTypes,(PetscEnum)chaco->global_method,(PetscEnum*)&global,&flag);CHKERRQ(ierr);
if (flag) { ierr = MatPartitioningChacoSetGlobal(part,global);CHKERRQ(ierr); }
ierr = PetscOptionsEnum("-mat_partitioning_chaco_local","Local method","MatPartitioningChacoSetLocal",MPChacoLocalTypes,(PetscEnum)chaco->local_method,(PetscEnum*)&local,&flag);CHKERRQ(ierr);
if (flag) { ierr = MatPartitioningChacoSetLocal(part,local);CHKERRQ(ierr); }
ierr = PetscOptionsReal("-mat_partitioning_chaco_coarse","Coarse level","MatPartitioningChacoSetCoarseLevel",0.0,&r,&flag);CHKERRQ(ierr);
if (flag) { ierr = MatPartitioningChacoSetCoarseLevel(part,r);CHKERRQ(ierr); }
ierr = PetscOptionsEnum("-mat_partitioning_chaco_eigen_solver","Eigensolver method","MatPartitioningChacoSetEigenSolver",MPChacoEigenTypes,(PetscEnum)chaco->eigen_method,(PetscEnum*)&eigen,&flag);CHKERRQ(ierr);
if (flag) { ierr = MatPartitioningChacoSetEigenSolver(part,eigen);CHKERRQ(ierr); }
ierr = PetscOptionsReal("-mat_partitioning_chaco_eigen_tol","Eigensolver tolerance","MatPartitioningChacoSetEigenTol",chaco->eigtol,&r,&flag);CHKERRQ(ierr);
if (flag) { ierr = MatPartitioningChacoSetEigenTol(part,r);CHKERRQ(ierr); }
ierr = PetscOptionsInt("-mat_partitioning_chaco_eigen_number","Number of eigenvectors: 1, 2, or 3 (bi-, quadri-, or octosection)","MatPartitioningChacoSetEigenNumber",chaco->eignum,&i,&flag);CHKERRQ(ierr);
if (flag) { ierr = MatPartitioningChacoSetEigenNumber(part,i);CHKERRQ(ierr); }
ierr = PetscOptionsBool("-mat_partitioning_chaco_verbose","Show library output","",chaco->verbose,&chaco->verbose,NULL);CHKERRQ(ierr);
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode SNESSetFromOptions_QN(SNES snes)
{
PetscErrorCode ierr;
SNES_QN *qn = (SNES_QN*)snes->data;
PetscBool monflg = PETSC_FALSE,flg;
SNESLineSearch linesearch;
SNESQNRestartType rtype = qn->restart_type;
SNESQNScaleType stype = qn->scale_type;
PetscFunctionBegin;
ierr = PetscOptionsHead("SNES QN options");CHKERRQ(ierr);
ierr = PetscOptionsInt("-snes_qn_m","Number of past states saved for L-BFGS methods","SNESQN",qn->m,&qn->m,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-snes_qn_powell_gamma","Powell angle tolerance", "SNESQN", qn->powell_gamma, &qn->powell_gamma, NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-snes_qn_powell_downhill","Powell descent tolerance", "SNESQN", qn->powell_downhill, &qn->powell_downhill, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-snes_qn_monitor", "Monitor for the QN methods", "SNESQN", monflg, &monflg, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-snes_qn_single_reduction", "Aggregate reductions", "SNESQN", qn->singlereduction, &qn->singlereduction, NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-snes_qn_scale_type","Scaling type","SNESQNSetScaleType",SNESQNScaleTypes,(PetscEnum)stype,(PetscEnum*)&stype,&flg);CHKERRQ(ierr);
if (flg) ierr = SNESQNSetScaleType(snes,stype);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-snes_qn_restart_type","Restart type","SNESQNSetRestartType",SNESQNRestartTypes,(PetscEnum)rtype,(PetscEnum*)&rtype,&flg);CHKERRQ(ierr);
if (flg) ierr = SNESQNSetRestartType(snes,rtype);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-snes_qn_type","Quasi-Newton update type","",SNESQNTypes,
(PetscEnum)qn->type,(PetscEnum*)&qn->type,NULL);CHKERRQ(ierr);
ierr = PetscOptionsTail();CHKERRQ(ierr);
if (!snes->linesearch) {
ierr = SNESGetLineSearch(snes, &linesearch);CHKERRQ(ierr);
ierr = SNESLineSearchSetType(linesearch, SNESLINESEARCHCP);CHKERRQ(ierr);
}
if (monflg) {
qn->monitor = PETSC_VIEWER_STDOUT_(PetscObjectComm((PetscObject)snes));CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/*
TSAdaptSetFromOptions - Sets various TSAdapt parameters from user options.
Collective on TSAdapt
Input Parameter:
. adapt - the TSAdapt context
Options Database Keys:
. -ts_adapt_type <type> - basic
Level: advanced
Notes:
This function is automatically called by TSSetFromOptions()
.keywords: TS, TSGetAdapt(), TSAdaptSetType()
.seealso: TSGetType()
*/
PetscErrorCode TSAdaptSetFromOptions(PetscOptionItems *PetscOptionsObject,TSAdapt adapt)
{
PetscErrorCode ierr;
char type[256] = TSADAPTBASIC;
PetscBool set,flg;
PetscFunctionBegin;
PetscValidHeaderSpecific(adapt,TSADAPT_CLASSID,1);
/* This should use PetscOptionsBegin() if/when this becomes an object used outside of TS, but currently this
* function can only be called from inside TSSetFromOptions() */
ierr = PetscOptionsHead(PetscOptionsObject,"TS Adaptivity options");CHKERRQ(ierr);
ierr = PetscOptionsFList("-ts_adapt_type","Algorithm to use for adaptivity","TSAdaptSetType",TSAdaptList,
((PetscObject)adapt)->type_name ? ((PetscObject)adapt)->type_name : type,type,sizeof(type),&flg);CHKERRQ(ierr);
if (flg || !((PetscObject)adapt)->type_name) {
ierr = TSAdaptSetType(adapt,type);CHKERRQ(ierr);
}
ierr = PetscOptionsReal("-ts_adapt_dt_min","Minimum time step considered","TSAdaptSetStepLimits",adapt->dt_min,&adapt->dt_min,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-ts_adapt_dt_max","Maximum time step considered","TSAdaptSetStepLimits",adapt->dt_max,&adapt->dt_max,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-ts_adapt_scale_solve_failed","Scale step by this factor if solve fails","",adapt->scale_solve_failed,&adapt->scale_solve_failed,NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ts_adapt_monitor","Print choices made by adaptive controller","TSAdaptSetMonitor",adapt->monitor ? PETSC_TRUE : PETSC_FALSE,&flg,&set);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-ts_adapt_wnormtype","Type of norm computed for error estimation","",NormTypes,(PetscEnum)adapt->wnormtype,(PetscEnum*)&adapt->wnormtype,NULL);CHKERRQ(ierr);
if (adapt->wnormtype != NORM_2 && adapt->wnormtype != NORM_INFINITY) SETERRQ(PetscObjectComm((PetscObject)adapt),PETSC_ERR_SUP,"Only 2-norm and infinite norm supported");
if (set) {ierr = TSAdaptSetMonitor(adapt,flg);CHKERRQ(ierr);}
if (adapt->ops->setfromoptions) {ierr = (*adapt->ops->setfromoptions)(PetscOptionsObject,adapt);CHKERRQ(ierr);}
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode PCSetFromOptions_Composite(PC pc)
{
PC_Composite *jac = (PC_Composite*)pc->data;
PetscErrorCode ierr;
PetscInt nmax = 8,i;
PC_CompositeLink next;
char *pcs[8];
PetscBool flg;
PetscFunctionBegin;
ierr = PetscOptionsHead("Composite preconditioner options");CHKERRQ(ierr);
ierr = PetscOptionsEnum("-pc_composite_type","Type of composition","PCCompositeSetType",PCCompositeTypes,(PetscEnum)jac->type,(PetscEnum*)&jac->type,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCCompositeSetType(pc,jac->type);CHKERRQ(ierr);
}
ierr = PetscOptionsStringArray("-pc_composite_pcs","List of composite solvers","PCCompositeAddPC",pcs,&nmax,&flg);CHKERRQ(ierr);
if (flg) {
for (i=0; i<nmax; i++) {
ierr = PCCompositeAddPC(pc,pcs[i]);CHKERRQ(ierr);
ierr = PetscFree(pcs[i]);CHKERRQ(ierr); /* deallocate string pcs[i], which is allocated in PetscOptionsStringArray() */
}
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
next = jac->head;
while (next) {
ierr = PCSetFromOptions(next->pc);CHKERRQ(ierr);
next = next->next;
}
PetscFunctionReturn(0);
}
static PetscErrorCode SNESSetFromOptions_NCG(SNES snes)
{
SNES_NCG *ncg = (SNES_NCG*)snes->data;
PetscErrorCode ierr;
PetscBool debug;
SNESLineSearch linesearch;
SNESNCGType ncgtype=ncg->type;
PetscFunctionBegin;
ierr = PetscOptionsHead("SNES NCG options");CHKERRQ(ierr);
ierr = PetscOptionsBool("-snes_ncg_monitor","Monitor NCG iterations","SNES",ncg->monitor ? PETSC_TRUE : PETSC_FALSE, &debug, NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-snes_ncg_type","NCG Beta type used","SNESNCGSetType",SNESNCGTypes,(PetscEnum)ncg->type,(PetscEnum*)&ncgtype,NULL);CHKERRQ(ierr);
ierr = SNESNCGSetType(snes, ncgtype);CHKERRQ(ierr);
if (debug) {
ncg->monitor = PETSC_VIEWER_STDOUT_(PetscObjectComm((PetscObject)snes));CHKERRQ(ierr);
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
if (!snes->linesearch) {
ierr = SNESGetLineSearch(snes, &linesearch);CHKERRQ(ierr);
if (!snes->pc) {
ierr = SNESLineSearchSetType(linesearch, SNESLINESEARCHCP);CHKERRQ(ierr);
} else {
ierr = SNESLineSearchSetType(linesearch, SNESLINESEARCHL2);CHKERRQ(ierr);
}
}
ierr = SNESLineSearchRegister(SNESLINESEARCHNCGLINEAR, SNESLineSearchCreate_NCGLinear);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode SNESSetFromOptions_Anderson(PetscOptions *PetscOptionsObject,SNES snes)
{
SNES_NGMRES *ngmres = (SNES_NGMRES*) snes->data;
PetscErrorCode ierr;
PetscBool debug;
SNESLineSearch linesearch;
PetscFunctionBegin;
ierr = PetscOptionsHead(PetscOptionsObject,"SNES NGMRES options");CHKERRQ(ierr);
ierr = PetscOptionsInt("-snes_anderson_m", "Number of directions","SNES",ngmres->msize,&ngmres->msize,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-snes_anderson_beta", "Mixing parameter","SNES",ngmres->andersonBeta,&ngmres->andersonBeta,NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-snes_anderson_monitor", "Monitor steps of Anderson Mixing","SNES",ngmres->monitor ? PETSC_TRUE : PETSC_FALSE,&debug,NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-snes_anderson_restart", "Iterations before forced restart", "SNES",ngmres->restart_periodic,&ngmres->restart_periodic,NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-snes_anderson_restart_it", "Tolerance iterations before restart","SNES",ngmres->restart_it,&ngmres->restart_it,NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-snes_anderson_restart_type","Restart type","SNESNGMRESSetRestartType",SNESNGMRESRestartTypes,
(PetscEnum)ngmres->restart_type,(PetscEnum*)&ngmres->restart_type,NULL);CHKERRQ(ierr);
if (debug) {
ngmres->monitor = PETSC_VIEWER_STDOUT_(PetscObjectComm((PetscObject)snes));CHKERRQ(ierr);
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
/* set the default type of the line search if the user hasn't already. */
if (!snes->linesearch) {
ierr = SNESGetLineSearch(snes,&linesearch);CHKERRQ(ierr);
ierr = SNESLineSearchSetType(linesearch,SNESLINESEARCHBASIC);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
PetscErrorCode PetscSubcommSetFromOptions(PetscSubcomm psubcomm)
{
PetscErrorCode ierr;
PetscSubcommType type;
PetscBool flg;
PetscFunctionBegin;
if (!psubcomm) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NULL,"Must call PetscSubcommCreate firt");
type = psubcomm->type;
ierr = PetscOptionsEnum("-psubcomm_type","PETSc subcommunicator","PetscSubcommSetType",PetscSubcommTypes,(PetscEnum)type,(PetscEnum*)&type,&flg);CHKERRQ(ierr);
if (flg && psubcomm->type != type) {
/* free old structures */
ierr = PetscCommDestroy(&(psubcomm)->dupparent);CHKERRQ(ierr);
ierr = PetscCommDestroy(&(psubcomm)->comm);CHKERRQ(ierr);
ierr = PetscFree((psubcomm)->subsize);CHKERRQ(ierr);
switch (type) {
case PETSC_SUBCOMM_GENERAL:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Runtime option PETSC_SUBCOMM_GENERAL is not supported, use PetscSubcommSetTypeGeneral()");
case PETSC_SUBCOMM_CONTIGUOUS:
ierr = PetscSubcommCreate_contiguous(psubcomm);CHKERRQ(ierr);
break;
case PETSC_SUBCOMM_INTERLACED:
ierr = PetscSubcommCreate_interlaced(psubcomm);CHKERRQ(ierr);
break;
default:
SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"PetscSubcommType %s is not supported yet",PetscSubcommTypes[type]);
}
}
ierr = PetscOptionsHasName(NULL, "-psubcomm_view", &flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscSubcommView(psubcomm,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
static PetscErrorCode SNESSetFromOptions_Multiblock(SNES snes)
{
SNES_Multiblock *mb = (SNES_Multiblock *) snes->data;
PCCompositeType ctype;
PetscInt bs;
PetscBool flg;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscOptionsHead("SNES Multiblock options");CHKERRQ(ierr);
ierr = PetscOptionsInt("-snes_multiblock_block_size", "Blocksize that defines number of fields", "PCFieldSplitSetBlockSize", mb->bs, &bs, &flg);CHKERRQ(ierr);
if (flg) {ierr = SNESMultiblockSetBlockSize(snes, bs);CHKERRQ(ierr);}
ierr = PetscOptionsEnum("-snes_multiblock_type", "Type of composition", "PCFieldSplitSetType", PCCompositeTypes, (PetscEnum) mb->type, (PetscEnum *) &ctype, &flg);CHKERRQ(ierr);
if (flg) {
ierr = SNESMultiblockSetType(snes,ctype);CHKERRQ(ierr);
}
/* Only setup fields once */
if ((mb->bs > 0) && (mb->numBlocks == 0)) {
/* only allow user to set fields from command line if bs is already known, otherwise user can set them in SNESMultiblockSetDefaults() */
ierr = SNESMultiblockSetFieldsRuntime_Private(snes);CHKERRQ(ierr);
if (mb->defined) {ierr = PetscInfo(snes, "Blocks defined using the options database\n");CHKERRQ(ierr);}
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode SNESSetFromOptions_NASM(SNES snes)
{
PetscErrorCode ierr;
PCASMType asmtype;
PetscBool flg,monflg,subviewflg;
SNES_NASM *nasm = (SNES_NASM*)snes->data;
PetscFunctionBegin;
ierr = PetscOptionsHead("Nonlinear Additive Schwartz options");CHKERRQ(ierr);
ierr = PetscOptionsEnum("-snes_nasm_type","Type of restriction/extension","",SNESNASMTypes,(PetscEnum)nasm->type,(PetscEnum*)&asmtype,&flg);CHKERRQ(ierr);
if (flg) nasm->type = asmtype;
flg = PETSC_FALSE;
monflg = PETSC_TRUE;
ierr = PetscOptionsReal("-snes_nasm_damping","Log times for subSNES solves and restriction","SNESNASMSetDamping",nasm->damping,&nasm->damping,&flg);CHKERRQ(ierr);
if (flg) {ierr = SNESNASMSetDamping(snes,nasm->damping);CHKERRQ(ierr);}
subviewflg = PETSC_FALSE;
ierr = PetscOptionsBool("-snes_nasm_sub_view","Print detailed information for every processor when using -snes_view","",subviewflg,&subviewflg,&flg);CHKERRQ(ierr);
if (flg) {
nasm->same_local_solves = PETSC_FALSE;
if (!subviewflg) {
nasm->same_local_solves = PETSC_TRUE;
}
}
ierr = PetscOptionsBool("-snes_nasm_finaljacobian","Compute the global jacobian of the final iterate (for ASPIN)","",nasm->finaljacobian,&nasm->finaljacobian,NULL);CHKERRQ(ierr);
ierr = PetscOptionsEList("-snes_nasm_finaljacobian_type","The type of the final jacobian computed.","",SNESNASMFJTypes,3,SNESNASMFJTypes[0],&nasm->fjtype,NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-snes_nasm_log","Log times for subSNES solves and restriction","",monflg,&monflg,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscLogEventRegister("SNESNASMSubSolve",((PetscObject)snes)->classid,&nasm->eventsubsolve);CHKERRQ(ierr);
ierr = PetscLogEventRegister("SNESNASMRestrict",((PetscObject)snes)->classid,&nasm->eventrestrictinterp);CHKERRQ(ierr);
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
MatColoringSetFromOptions - Sets MatColoring options from user parameters
Collective on MatColoring
Input Parameters:
. mc - MatColoring context
Options Database Keys:
+ -mat_coloring_type - the type of coloring algorithm used
. -mat_coloring_maxcolors - the maximum number of relevant colors, all nodes not in a color are in maxcolors+1
. -mat_coloring_distance - compute a distance 1,2,... coloring.
. -mat_coloring_view - print information about the coloring and the produced index sets
Level: beginner
.keywords: Coloring, Matrix
.seealso: MatColoring, MatColoringApply()
@*/
PetscErrorCode MatColoringSetFromOptions(MatColoring mc)
{
PetscBool flg;
MatColoringType deft = MATCOLORINGSL;
char type[256];
PetscErrorCode ierr;
PetscInt dist,maxcolors;
PetscFunctionBegin;
PetscValidHeaderSpecific(mc,MAT_COLORING_CLASSID,1);
ierr = MatColoringGetDistance(mc,&dist);CHKERRQ(ierr);
ierr = MatColoringGetMaxColors(mc,&maxcolors);CHKERRQ(ierr);
if (!MatColoringRegisterAllCalled) {ierr = MatColoringRegisterAll();CHKERRQ(ierr);}
ierr = PetscObjectOptionsBegin((PetscObject)mc);CHKERRQ(ierr);
if (((PetscObject)mc)->type_name) deft = ((PetscObject)mc)->type_name;
ierr = PetscOptionsFList("-mat_coloring_type","The coloring method used","MatColoringSetType",MatColoringList,deft,type,256,&flg);CHKERRQ(ierr);
if (flg) {
ierr = MatColoringSetType(mc,type);CHKERRQ(ierr);
} else if (!((PetscObject)mc)->type_name) {
ierr = MatColoringSetType(mc,deft);CHKERRQ(ierr);
}
ierr = PetscOptionsInt("-mat_coloring_distance","Distance of the coloring","MatColoringSetDistance",dist,&dist,&flg);CHKERRQ(ierr);
if (flg) {ierr = MatColoringSetDistance(mc,dist);CHKERRQ(ierr);}
ierr = PetscOptionsInt("-mat_coloring_maxcolors","Maximum colors returned at the end. 1 returns an independent set","MatColoringSetMaxColors",maxcolors,&maxcolors,&flg);CHKERRQ(ierr);
if (flg) {ierr = MatColoringSetMaxColors(mc,maxcolors);CHKERRQ(ierr);}
if (mc->ops->setfromoptions) {
ierr = (*mc->ops->setfromoptions)(mc);CHKERRQ(ierr);
}
ierr = PetscOptionsBool("-mat_coloring_valid","Check that a valid coloring has been produced","",mc->valid,&mc->valid,NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-mat_coloring_weight_type","Sets the type of vertex weighting used","MatColoringSetWeightType",MatColoringWeightTypes,(PetscEnum)mc->weight_type,(PetscEnum*)&mc->weight_type,NULL);CHKERRQ(ierr);
ierr = PetscObjectProcessOptionsHandlers((PetscObject)mc);CHKERRQ(ierr);
ierr = PetscOptionsEnd();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode KSPSetFromOptions_GMRES(KSP ksp)
{
PetscErrorCode ierr;
PetscInt restart;
PetscReal haptol;
KSP_GMRES *gmres = (KSP_GMRES*)ksp->data;
PetscBool flg;
PetscFunctionBegin;
ierr = PetscOptionsHead("KSP GMRES Options");CHKERRQ(ierr);
ierr = PetscOptionsInt("-ksp_gmres_restart","Number of Krylov search directions","KSPGMRESSetRestart",gmres->max_k,&restart,&flg);CHKERRQ(ierr);
if (flg) { ierr = KSPGMRESSetRestart(ksp,restart);CHKERRQ(ierr); }
ierr = PetscOptionsReal("-ksp_gmres_haptol","Tolerance for exact convergence (happy ending)","KSPGMRESSetHapTol",gmres->haptol,&haptol,&flg);CHKERRQ(ierr);
if (flg) { ierr = KSPGMRESSetHapTol(ksp,haptol);CHKERRQ(ierr); }
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_gmres_preallocate","Preallocate Krylov vectors","KSPGMRESSetPreAllocateVectors",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {ierr = KSPGMRESSetPreAllocateVectors(ksp);CHKERRQ(ierr);}
ierr = PetscOptionsBoolGroupBegin("-ksp_gmres_classicalgramschmidt","Classical (unmodified) Gram-Schmidt (fast)","KSPGMRESSetOrthogonalization",&flg);CHKERRQ(ierr);
if (flg) {ierr = KSPGMRESSetOrthogonalization(ksp,KSPGMRESClassicalGramSchmidtOrthogonalization);CHKERRQ(ierr);}
ierr = PetscOptionsBoolGroupEnd("-ksp_gmres_modifiedgramschmidt","Modified Gram-Schmidt (slow,more stable)","KSPGMRESSetOrthogonalization",&flg);CHKERRQ(ierr);
if (flg) {ierr = KSPGMRESSetOrthogonalization(ksp,KSPGMRESModifiedGramSchmidtOrthogonalization);CHKERRQ(ierr);}
ierr = PetscOptionsEnum("-ksp_gmres_cgs_refinement_type","Type of iterative refinement for classical (unmodified) Gram-Schmidt","KSPGMRESSetCGSRefinementType",
KSPGMRESCGSRefinementTypes,(PetscEnum)gmres->cgstype,(PetscEnum*)&gmres->cgstype,&flg);CHKERRQ(ierr);
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_gmres_krylov_monitor","Plot the Krylov directions","KSPMonitorSet",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
PetscViewers viewers;
ierr = PetscViewersCreate(PetscObjectComm((PetscObject)ksp),&viewers);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPGMRESMonitorKrylov,viewers,(PetscErrorCode (*)(void**))PetscViewersDestroy);CHKERRQ(ierr);
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
PetscBagSetFromOptions - Allows setting options from a bag
Collective on PetscBag
Input Parameter:
. bag - the bag of values
Level: beginner
.seealso: PetscBag, PetscBagSetName(), PetscBagDestroy(), PetscBagLoad(), PetscBagGetData()
PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagView(), PetscBagRegisterEnum()
@*/
PetscErrorCode PetscBagSetFromOptions(PetscBag bag)
{
PetscErrorCode ierr;
PetscBagItem nitem = bag->bagitems;
char name[PETSC_BAG_NAME_LENGTH+1],helpname[PETSC_BAG_NAME_LENGTH+PETSC_BAG_HELP_LENGTH+3];
PetscInt n;
PetscFunctionBegin;
ierr = PetscStrcpy(helpname,bag->bagname);CHKERRQ(ierr);
ierr = PetscStrcat(helpname," ");CHKERRQ(ierr);
ierr = PetscStrcat(helpname,bag->baghelp);CHKERRQ(ierr);
ierr = PetscOptionsBegin(bag->bagcomm,bag->bagprefix,helpname,0);CHKERRQ(ierr);
while (nitem) {
name[0] = '-';
name[1] = 0;
ierr = PetscStrcat(name,nitem->name);CHKERRQ(ierr);
if (nitem->dtype == PETSC_CHAR) { /* special handling for fortran required? [due to space padding vs null termination] */
char *value = (char*)(((char*)bag) + nitem->offset);
ierr = PetscOptionsString(name,nitem->help,"",value,value,nitem->msize,NULL);CHKERRQ(ierr);
} else if (nitem->dtype == PETSC_REAL) {
PetscReal *value = (PetscReal*)(((char*)bag) + nitem->offset);
if (nitem->msize == 1) {
ierr = PetscOptionsReal(name,nitem->help,"",*value,value,NULL);CHKERRQ(ierr);
} else {
n = nitem->msize;
ierr = PetscOptionsRealArray(name,nitem->help,"",value,&n,NULL);CHKERRQ(ierr);
}
} else if (nitem->dtype == PETSC_SCALAR) {
PetscScalar *value = (PetscScalar*)(((char*)bag) + nitem->offset);
ierr = PetscOptionsScalar(name,nitem->help,"",*value,value,NULL);CHKERRQ(ierr);
} else if (nitem->dtype == PETSC_INT) {
PetscInt *value = (PetscInt*)(((char*)bag) + nitem->offset);
if (nitem->msize == 1) {
ierr = PetscOptionsInt(name,nitem->help,"",*value,value,NULL);CHKERRQ(ierr);
} else {
n = nitem->msize;
ierr = PetscOptionsIntArray(name,nitem->help,"",value,&n,NULL);CHKERRQ(ierr);
}
} else if (nitem->dtype == PETSC_ENUM) {
PetscEnum *value = (PetscEnum*)(((char*)bag) + nitem->offset);
PetscInt i = 0;
while (nitem->list[i++]) ;
ierr = PetscOptionsEnum(name,nitem->help,nitem->list[i-3],(const char*const*)nitem->list,*value,value,NULL);CHKERRQ(ierr);
} else if (nitem->dtype == PETSC_BOOL) {
PetscBool *value = (PetscBool*)(((char*)bag) + nitem->offset);
if (nitem->msize == 1) {
ierr = PetscOptionsBool(name,nitem->help,"",*value,value,NULL);CHKERRQ(ierr);
} else {
n = nitem->msize;
ierr = PetscOptionsBoolArray(name,nitem->help,"",value,&n,NULL);CHKERRQ(ierr);
}
}
nitem = nitem->next;
}
PetscOptionsEnd();
PetscFunctionReturn(0);
}
PetscErrorCode PCSetFromOptions_Factor(PC pc)
{
PC_Factor *factor = (PC_Factor*)pc->data;
PetscErrorCode ierr;
PetscBool flg = PETSC_FALSE,set;
char tname[256], solvertype[64];
PetscFunctionList ordlist;
PetscEnum etmp;
PetscFunctionBegin;
if (!MatOrderingRegisterAllCalled) {ierr = MatOrderingRegisterAll();CHKERRQ(ierr);}
ierr = PetscOptionsBool("-pc_factor_in_place","Form factored matrix in the same memory as the matrix","PCFactorSetUseInPlace",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
ierr = PCFactorSetUseInPlace(pc);CHKERRQ(ierr);
}
ierr = PetscOptionsReal("-pc_factor_fill","Expected non-zeros in factored matrix","PCFactorSetFill",((PC_Factor*)factor)->info.fill,&((PC_Factor*)factor)->info.fill,0);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-pc_factor_shift_type","Type of shift to add to diagonal","PCFactorSetShiftType",
MatFactorShiftTypes,(PetscEnum)(int)((PC_Factor*)factor)->info.shifttype,&etmp,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCFactorSetShiftType(pc,(MatFactorShiftType)etmp);CHKERRQ(ierr);
}
ierr = PetscOptionsReal("-pc_factor_shift_amount","Shift added to diagonal","PCFactorSetShiftAmount",((PC_Factor*)factor)->info.shiftamount,&((PC_Factor*)factor)->info.shiftamount,0);CHKERRQ(ierr);
ierr = PetscOptionsReal("-pc_factor_zeropivot","Pivot is considered zero if less than","PCFactorSetZeroPivot",((PC_Factor*)factor)->info.zeropivot,&((PC_Factor*)factor)->info.zeropivot,0);CHKERRQ(ierr);
ierr = PetscOptionsReal("-pc_factor_column_pivot","Column pivot tolerance (used only for some factorization)","PCFactorSetColumnPivot",((PC_Factor*)factor)->info.dtcol,&((PC_Factor*)factor)->info.dtcol,&flg);CHKERRQ(ierr);
flg = ((PC_Factor*)factor)->info.pivotinblocks ? PETSC_TRUE : PETSC_FALSE;
ierr = PetscOptionsBool("-pc_factor_pivot_in_blocks","Pivot inside matrix dense blocks for BAIJ and SBAIJ","PCFactorSetPivotInBlocks",flg,&flg,&set);CHKERRQ(ierr);
if (set) {
ierr = PCFactorSetPivotInBlocks(pc,flg);CHKERRQ(ierr);
}
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-pc_factor_reuse_fill","Use fill from previous factorization","PCFactorSetReuseFill",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
ierr = PCFactorSetReuseFill(pc,PETSC_TRUE);CHKERRQ(ierr);
}
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-pc_factor_reuse_ordering","Reuse ordering from previous factorization","PCFactorSetReuseOrdering",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
ierr = PCFactorSetReuseOrdering(pc,PETSC_TRUE);CHKERRQ(ierr);
}
ierr = MatGetOrderingList(&ordlist);CHKERRQ(ierr);
ierr = PetscOptionsList("-pc_factor_mat_ordering_type","Reordering to reduce nonzeros in factored matrix","PCFactorSetMatOrderingType",ordlist,((PC_Factor*)factor)->ordering,tname,256,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCFactorSetMatOrderingType(pc,tname);CHKERRQ(ierr);
}
/* maybe should have MatGetSolverTypes(Mat,&list) like the ordering list */
ierr = PetscOptionsString("-pc_factor_mat_solver_package","Specific direct solver to use","MatGetFactor",((PC_Factor*)factor)->solvertype,solvertype,64,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCFactorSetMatSolverPackage(pc,solvertype);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
static PetscErrorCode PCSetFromOptions_PARMS(PC pc)
{
PC_PARMS *parms = (PC_PARMS*)pc->data;
PetscBool flag;
PCPARMSGlobalType global;
PCPARMSLocalType local;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscOptionsHead("PARMS Options");CHKERRQ(ierr);
ierr = PetscOptionsEnum("-pc_parms_global","Global preconditioner","PCPARMSSetGlobal",PCPARMSGlobalTypes,(PetscEnum)parms->global,(PetscEnum*)&global,&flag);CHKERRQ(ierr);
if (flag) { ierr = PCPARMSSetGlobal(pc,global);CHKERRQ(ierr); }
ierr = PetscOptionsEnum("-pc_parms_local","Local preconditioner","PCPARMSSetLocal",PCPARMSLocalTypes,(PetscEnum)parms->local,(PetscEnum*)&local,&flag);CHKERRQ(ierr);
if (flag) { ierr = PCPARMSSetLocal(pc,local);CHKERRQ(ierr); }
ierr = PetscOptionsReal("-pc_parms_solve_tol","Tolerance for local solve","PCPARMSSetSolveTolerances",parms->solvetol,&parms->solvetol,&flag);CHKERRQ(ierr);
ierr = PetscOptionsInt("-pc_parms_levels","Number of levels","None",parms->levels,&parms->levels,&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-pc_parms_nonsymmetric_perm","Use nonsymmetric permutation","PCPARMSSetNonsymPerm",parms->nonsymperm,&parms->nonsymperm,&flag);CHKERRQ(ierr);
ierr = PetscOptionsInt("-pc_parms_blocksize","Block size","None",parms->blocksize,&parms->blocksize,&flag);CHKERRQ(ierr);
ierr = PetscOptionsReal("-pc_parms_ind_tol","Tolerance for independent sets","None",parms->indtol,&parms->indtol,&flag);CHKERRQ(ierr);
ierr = PetscOptionsInt("-pc_parms_max_dim","Inner Krylov dimension","PCPARMSSetSolveRestart",parms->maxdim,&parms->maxdim,&flag);CHKERRQ(ierr);
ierr = PetscOptionsInt("-pc_parms_max_it","Maximum number of inner iterations","PCPARMSSetSolveTolerances",parms->maxits,&parms->maxits,&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-pc_parms_inter_nonsymmetric_perm","nonsymmetric permutation for interlevel blocks","None",parms->meth[0],&parms->meth[0],&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-pc_parms_inter_column_perm","column permutation for interlevel blocks","None",parms->meth[1],&parms->meth[1],&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-pc_parms_inter_row_scaling","row scaling for interlevel blocks","None",parms->meth[2],&parms->meth[2],&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-pc_parms_inter_column_scaling","column scaling for interlevel blocks","None",parms->meth[3],&parms->meth[3],&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-pc_parms_last_nonsymmetric_perm","nonsymmetric permutation for last level blocks","None",parms->meth[4],&parms->meth[4],&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-pc_parms_last_column_perm","column permutation for last level blocks","None",parms->meth[5],&parms->meth[5],&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-pc_parms_last_row_scaling","row scaling for last level blocks","None",parms->meth[6],&parms->meth[6],&flag);CHKERRQ(ierr);
ierr = PetscOptionsBool("-pc_parms_last_column_scaling","column scaling for last level blocks","None",parms->meth[7],&parms->meth[7],&flag);CHKERRQ(ierr);
ierr = PetscOptionsInt("-pc_parms_lfil_ilu_arms","amount of fill-in for ilut, iluk and arms","PCPARMSSetFill",parms->lfil[0],&parms->lfil[0],&flag);CHKERRQ(ierr);
if (flag) parms->lfil[1] = parms->lfil[2] = parms->lfil[3] = parms->lfil[0];
ierr = PetscOptionsInt("-pc_parms_lfil_schur","amount of fill-in for schur","PCPARMSSetFill",parms->lfil[4],&parms->lfil[4],&flag);CHKERRQ(ierr);
ierr = PetscOptionsInt("-pc_parms_lfil_ilut_L_U","amount of fill-in for ILUT L and U","PCPARMSSetFill",parms->lfil[5],&parms->lfil[5],&flag);CHKERRQ(ierr);
if (flag) parms->lfil[6] = parms->lfil[5];
ierr = PetscOptionsReal("-pc_parms_droptol_factors","drop tolerance for L, U, L^{-1}F and EU^{-1}","None",parms->droptol[0],&parms->droptol[0],&flag);CHKERRQ(ierr);
ierr = PetscOptionsReal("-pc_parms_droptol_schur_compl","drop tolerance for schur complement at each level","None",parms->droptol[4],&parms->droptol[4],&flag);CHKERRQ(ierr);
if (flag) parms->droptol[1] = parms->droptol[2] = parms->droptol[3] = parms->droptol[0];
ierr = PetscOptionsReal("-pc_parms_droptol_last_schur","drop tolerance for ILUT in last level schur complement","None",parms->droptol[5],&parms->droptol[5],&flag);CHKERRQ(ierr);
if (flag) parms->droptol[6] = parms->droptol[5];
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode PetscSFSetFromOptions_Window(PetscOptionItems *PetscOptionsObject,PetscSF sf)
{
PetscSF_Window *w = (PetscSF_Window*)sf->data;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscOptionsHead(PetscOptionsObject,"PetscSF Window options");CHKERRQ(ierr);
ierr = PetscOptionsEnum("-sf_window_sync","synchronization type to use for PetscSF Window communication","PetscSFWindowSetSyncType",PetscSFWindowSyncTypes,(PetscEnum)w->sync,(PetscEnum*)&w->sync,NULL);CHKERRQ(ierr);
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*
TSAdaptSetFromOptions - Sets various TSAdapt parameters from user options.
Collective on TSAdapt
Input Parameter:
. adapt - the TSAdapt context
Options Database Keys:
+ -ts_adapt_type <type> - algorithm to use for adaptivity
. -ts_adapt_always_accept - always accept steps regardless of error/stability goals
. -ts_adapt_safety <safety> - safety factor relative to target error/stability goal
. -ts_adapt_reject_safety <safety> - extra safety factor to apply if the last step was rejected
. -ts_adapt_clip <low,high> - admissible time step decrease and increase factors
. -ts_adapt_dt_min <min> - minimum timestep to use
. -ts_adapt_dt_max <max> - maximum timestep to use
. -ts_adapt_scale_solve_failed <scale> - scale timestep by this factor if a solve fails
. -ts_adapt_wnormtype <2 or infinity> - type of norm for computing error estimates
- -ts_adapt_time_step_increase_delay - number of timesteps to delay increasing the time step after it has been decreased due to failed solver
Level: advanced
Notes:
This function is automatically called by TSSetFromOptions()
.keywords: TS, TSGetAdapt(), TSAdaptSetType(), TSAdaptSetStepLimits()
.seealso: TSGetAdapt(), TSAdaptSetType(), TSAdaptSetAlwaysAccept(), TSAdaptSetSafety(),
TSAdaptSetClip(), TSAdaptSetStepLimits(), TSAdaptSetMonitor()
*/
PetscErrorCode TSAdaptSetFromOptions(PetscOptionItems *PetscOptionsObject,TSAdapt adapt)
{
PetscErrorCode ierr;
char type[256] = TSADAPTBASIC;
PetscReal safety,reject_safety,clip[2],hmin,hmax;
PetscBool set,flg;
PetscInt two;
PetscFunctionBegin;
PetscValidHeaderSpecific(adapt,TSADAPT_CLASSID,1);
/* This should use PetscOptionsBegin() if/when this becomes an object used outside of TS, but currently this
* function can only be called from inside TSSetFromOptions() */
ierr = PetscOptionsHead(PetscOptionsObject,"TS Adaptivity options");CHKERRQ(ierr);
ierr = PetscOptionsFList("-ts_adapt_type","Algorithm to use for adaptivity","TSAdaptSetType",TSAdaptList,((PetscObject)adapt)->type_name ? ((PetscObject)adapt)->type_name : type,type,sizeof(type),&flg);CHKERRQ(ierr);
if (flg || !((PetscObject)adapt)->type_name) {
ierr = TSAdaptSetType(adapt,type);CHKERRQ(ierr);
}
ierr = PetscOptionsBool("-ts_adapt_always_accept","Always accept the step","TSAdaptSetAlwaysAccept",adapt->always_accept,&flg,&set);CHKERRQ(ierr);
if (set) {ierr = TSAdaptSetAlwaysAccept(adapt,flg);CHKERRQ(ierr);}
safety = adapt->safety; reject_safety = adapt->reject_safety;
ierr = PetscOptionsReal("-ts_adapt_safety","Safety factor relative to target error/stability goal","TSAdaptSetSafety",safety,&safety,&set);CHKERRQ(ierr);
ierr = PetscOptionsReal("-ts_adapt_reject_safety","Extra safety factor to apply if the last step was rejected","TSAdaptSetSafety",reject_safety,&reject_safety,&flg);CHKERRQ(ierr);
if (set || flg) {ierr = TSAdaptSetSafety(adapt,safety,reject_safety);CHKERRQ(ierr);}
two = 2; clip[0] = adapt->clip[0]; clip[1] = adapt->clip[1];
ierr = PetscOptionsRealArray("-ts_adapt_clip","Admissible decrease/increase factor in step size","TSAdaptSetClip",clip,&two,&set);CHKERRQ(ierr);
if (set && (two != 2)) SETERRQ(PetscObjectComm((PetscObject)adapt),PETSC_ERR_ARG_OUTOFRANGE,"Must give exactly two values to -ts_adapt_clip");
if (set) {ierr = TSAdaptSetClip(adapt,clip[0],clip[1]);CHKERRQ(ierr);}
hmin = adapt->dt_min; hmax = adapt->dt_max;
ierr = PetscOptionsReal("-ts_adapt_dt_min","Minimum time step considered","TSAdaptSetStepLimits",hmin,&hmin,&set);CHKERRQ(ierr);
ierr = PetscOptionsReal("-ts_adapt_dt_max","Maximum time step considered","TSAdaptSetStepLimits",hmax,&hmax,&flg);CHKERRQ(ierr);
if (set || flg) {ierr = TSAdaptSetStepLimits(adapt,hmin,hmax);CHKERRQ(ierr);}
ierr = PetscOptionsReal("-ts_adapt_max_ignore","Adaptor ignores (absolute) solution values smaller than this value","",adapt->ignore_max,&adapt->ignore_max,&set);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ts_adapt_glee_use_local","GLEE adaptor uses local error estimation for step control","",adapt->glee_use_local,&adapt->glee_use_local,&set);CHKERRQ(ierr);
ierr = PetscOptionsReal("-ts_adapt_scale_solve_failed","Scale step by this factor if solve fails","",adapt->scale_solve_failed,&adapt->scale_solve_failed,NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-ts_adapt_wnormtype","Type of norm computed for error estimation","",NormTypes,(PetscEnum)adapt->wnormtype,(PetscEnum*)&adapt->wnormtype,NULL);CHKERRQ(ierr);
if (adapt->wnormtype != NORM_2 && adapt->wnormtype != NORM_INFINITY) SETERRQ(PetscObjectComm((PetscObject)adapt),PETSC_ERR_SUP,"Only 2-norm and infinite norm supported");
ierr = PetscOptionsInt("-ts_adapt_time_step_increase_delay","Number of timesteps to delay increasing the time step after it has been decreased due to failed solver","TSAdaptSetTimeStepIncreaseDelay",adapt->timestepjustdecreased_delay,&adapt->timestepjustdecreased_delay,NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-ts_adapt_monitor","Print choices made by adaptive controller","TSAdaptSetMonitor",adapt->monitor ? PETSC_TRUE : PETSC_FALSE,&flg,&set);CHKERRQ(ierr);
if (set) {ierr = TSAdaptSetMonitor(adapt,flg);CHKERRQ(ierr);}
if (adapt->ops->setfromoptions) {ierr = (*adapt->ops->setfromoptions)(PetscOptionsObject,adapt);CHKERRQ(ierr);}
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode MatSetFromOptions_SchurComplement(PetscOptions *PetscOptionsObject,Mat N)
{
Mat_SchurComplement *Na = (Mat_SchurComplement*)N->data;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscOptionsHead(PetscOptionsObject,"MatSchurComplementOptions");CHKERRQ(ierr);
Na->ainvtype = MAT_SCHUR_COMPLEMENT_AINV_DIAG;
ierr = PetscOptionsEnum("-mat_schur_complement_ainv_type","Type of approximation for inv(A00) used when assembling Sp = A11 - A10 inv(A00) A01","MatSchurComplementSetAinvType",MatSchurComplementAinvTypes,(PetscEnum)Na->ainvtype,(PetscEnum*)&Na->ainvtype,NULL);CHKERRQ(ierr);
ierr = PetscOptionsTail();CHKERRQ(ierr);
ierr = KSPSetFromOptions(Na->ksp);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode KSPSetFromOptions_CG(PetscOptionItems *PetscOptionsObject,KSP ksp)
{
PetscErrorCode ierr;
KSP_CG *cg = (KSP_CG*)ksp->data;
PetscFunctionBegin;
ierr = PetscOptionsHead(PetscOptionsObject,"KSP CG and CGNE options");CHKERRQ(ierr);
#if defined(PETSC_USE_COMPLEX)
ierr = PetscOptionsEnum("-ksp_cg_type","Matrix is Hermitian or complex symmetric","KSPCGSetType",KSPCGTypes,(PetscEnum)cg->type,
(PetscEnum*)&cg->type,NULL);CHKERRQ(ierr);
#endif
ierr = PetscOptionsBool("-ksp_cg_single_reduction","Merge inner products into single MPIU_Allreduce()","KSPCGUseSingleReduction",cg->singlereduction,&cg->singlereduction,NULL);CHKERRQ(ierr);
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode KSPSetFromOptions_BSSCR(PetscOptions *PetscOptionsObject, KSP ksp)
{
PetscTruth flg;
KSP_BSSCR *bsscr = (KSP_BSSCR *)ksp->data;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscOptionsHead(PetscOptionsObject,"KSP BSSCR options");CHKERRQ(ierr);
/* if this ksp has a prefix "XXX_" it will be automatically added to the options. e.g. -ksp_test -> -XXX_ksp_test */
/* ierr = PetscOptionsTruth("-ksp_test","Test KSP flag","nil",PETSC_FALSE,&test,PETSC_NULL);CHKERRQ(ierr); */
/* if(test){ PetscPrintf( PETSC_COMM_WORLD, "\n\n----- test flag set ------\n\n"); } */
ierr = PetscOptionsEnum("-ksp_k2_type","Augmented Lagrangian matrix type","",K2Types, bsscr->k2type,(PetscEnum*)&bsscr->k2type,&flg);CHKERRQ(ierr);
//if(flg){ PetscPrintf( PETSC_COMM_WORLD, "----- k2 type is ------\n"); }
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode EPSSetFromOptions_Lanczos(EPS eps)
{
PetscErrorCode ierr;
EPS_LANCZOS *lanczos = (EPS_LANCZOS*)eps->data;
PetscBool flg;
EPSLanczosReorthogType reorthog;
PetscFunctionBegin;
ierr = PetscOptionsHead("EPS Lanczos Options");CHKERRQ(ierr);
ierr = PetscOptionsEnum("-eps_lanczos_reorthog","Lanczos reorthogonalization","EPSLanczosSetReorthog",EPSLanczosReorthogTypes,(PetscEnum)lanczos->reorthog,(PetscEnum*)&reorthog,&flg);CHKERRQ(ierr);
if (flg) {
ierr = EPSLanczosSetReorthog(eps,reorthog);CHKERRQ(ierr);
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode KSPSetFromOptions_PIPEFCG(PetscOptionItems *PetscOptionsObject,KSP ksp)
{
PetscErrorCode ierr;
KSP_PIPEFCG *pipefcg=(KSP_PIPEFCG*)ksp->data;
PetscInt mmax,nprealloc;
PetscBool flg;
PetscFunctionBegin;
ierr = PetscOptionsHead(PetscOptionsObject,"KSP PIPEFCG options");CHKERRQ(ierr);
ierr = PetscOptionsInt("-ksp_pipefcg_mmax","Number of search directions to storue","KSPPIPEFCGSetMmax",pipefcg->mmax,&mmax,&flg);CHKERRQ(ierr);
if (flg) ierr = KSPPIPEFCGSetMmax(ksp,mmax);CHKERRQ(ierr);
ierr = PetscOptionsInt("-ksp_pipefcg_nprealloc","Number of directions to preallocate","KSPPIPEFCGSetNprealloc",pipefcg->nprealloc,&nprealloc,&flg);CHKERRQ(ierr);
if (flg) { ierr = KSPPIPEFCGSetNprealloc(ksp,nprealloc);CHKERRQ(ierr); }
ierr = PetscOptionsEnum("-ksp_pipefcg_truncation_type","Truncation approach for directions","KSPFCGSetTruncationType",KSPFCDTruncationTypes,(PetscEnum)pipefcg->truncstrat,(PetscEnum*)&pipefcg->truncstrat,NULL);CHKERRQ(ierr);
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode PCSetFromOptions_Jacobi(PetscOptionItems *PetscOptionsObject,PC pc)
{
PC_Jacobi *jac = (PC_Jacobi*)pc->data;
PetscErrorCode ierr;
PetscBool flg;
PCJacobiType deflt,type;
PetscFunctionBegin;
ierr = PCJacobiGetType(pc,&deflt);CHKERRQ(ierr);
ierr = PetscOptionsHead(PetscOptionsObject,"Jacobi options");CHKERRQ(ierr);
ierr = PetscOptionsEnum("-pc_jacobi_type","How to construct diagonal matrix","PCJacobiSetType",PCJacobiTypes,(PetscEnum)deflt,(PetscEnum*)&type,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCJacobiSetType(pc,type);CHKERRQ(ierr);
}
ierr = PetscOptionsBool("-pc_jacobi_abs","Use absolute values of diagaonal entries","PCJacobiSetUseAbs",jac->useabs,&jac->useabs,NULL);CHKERRQ(ierr);
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode MatPartitioningSetFromOptions_PTScotch(PetscOptionItems *PetscOptionsObject,MatPartitioning part)
{
PetscErrorCode ierr;
PetscBool flag;
PetscReal r;
MatPartitioning_PTScotch *scotch = (MatPartitioning_PTScotch*)part->data;
MPPTScotchStrategyType strat;
PetscFunctionBegin;
ierr = MatPartitioningPTScotchGetStrategy(part,&strat);CHKERRQ(ierr);
ierr = PetscOptionsHead(PetscOptionsObject,"PTScotch partitioning options");CHKERRQ(ierr);
ierr = PetscOptionsEnum("-mat_partitioning_ptscotch_strategy","Strategy","MatPartitioningPTScotchSetStrategy",MPPTScotchStrategyTypes,(PetscEnum)strat,(PetscEnum*)&strat,&flag);CHKERRQ(ierr);
if (flag) { ierr = MatPartitioningPTScotchSetStrategy(part,strat);CHKERRQ(ierr); }
ierr = PetscOptionsReal("-mat_partitioning_ptscotch_imbalance","Load imbalance ratio","MatPartitioningPTScotchSetImbalance",scotch->imbalance,&r,&flag);CHKERRQ(ierr);
if (flag) { ierr = MatPartitioningPTScotchSetImbalance(part,r);CHKERRQ(ierr); }
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode PCSetFromOptions_Exotic(PetscOptions *PetscOptionsObject,PC pc)
{
PetscErrorCode ierr;
PetscBool flg;
PC_MG *mg = (PC_MG*)pc->data;
PCExoticType mgctype;
PC_Exotic *ctx = (PC_Exotic*) mg->innerctx;
PetscFunctionBegin;
ierr = PetscOptionsHead(PetscOptionsObject,"Exotic coarse space options");
CHKERRQ(ierr);
ierr = PetscOptionsEnum("-pc_exotic_type","face or wirebasket","PCExoticSetType",PCExoticTypes,(PetscEnum)ctx->type,(PetscEnum*)&mgctype,&flg);
CHKERRQ(ierr);
if (flg) {
ierr = PCExoticSetType(pc,mgctype);
CHKERRQ(ierr);
}
ierr = PetscOptionsBool("-pc_exotic_direct_solver","use direct solver to construct interpolation","None",ctx->directSolve,&ctx->directSolve,NULL);
CHKERRQ(ierr);
if (!ctx->directSolve) {
if (!ctx->ksp) {
const char *prefix;
ierr = KSPCreate(PETSC_COMM_SELF,&ctx->ksp);
CHKERRQ(ierr);
ierr = KSPSetErrorIfNotConverged(ctx->ksp,pc->erroriffailure);
CHKERRQ(ierr);
ierr = PetscObjectIncrementTabLevel((PetscObject)ctx->ksp,(PetscObject)pc,1);
CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)ctx->ksp);
CHKERRQ(ierr);
ierr = PCGetOptionsPrefix(pc,&prefix);
CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix(ctx->ksp,prefix);
CHKERRQ(ierr);
ierr = KSPAppendOptionsPrefix(ctx->ksp,"exotic_");
CHKERRQ(ierr);
}
ierr = KSPSetFromOptions(ctx->ksp);
CHKERRQ(ierr);
}
ierr = PetscOptionsTail();
CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode SNESSetFromOptions_Composite(PetscOptionItems *PetscOptionsObject,SNES snes)
{
SNES_Composite *jac = (SNES_Composite*)snes->data;
PetscErrorCode ierr;
PetscInt nmax = 8,i;
SNES_CompositeLink next;
char *sneses[8];
PetscReal dmps[8];
PetscBool flg;
PetscFunctionBegin;
ierr = PetscOptionsHead(PetscOptionsObject,"Composite preconditioner options");CHKERRQ(ierr);
ierr = PetscOptionsEnum("-snes_composite_type","Type of composition","SNESCompositeSetType",SNESCompositeTypes,(PetscEnum)jac->type,(PetscEnum*)&jac->type,&flg);CHKERRQ(ierr);
if (flg) {
ierr = SNESCompositeSetType(snes,jac->type);CHKERRQ(ierr);
}
ierr = PetscOptionsStringArray("-snes_composite_sneses","List of composite solvers","SNESCompositeAddSNES",sneses,&nmax,&flg);CHKERRQ(ierr);
if (flg) {
for (i=0; i<nmax; i++) {
ierr = SNESCompositeAddSNES(snes,sneses[i]);CHKERRQ(ierr);
ierr = PetscFree(sneses[i]);CHKERRQ(ierr); /* deallocate string sneses[i], which is allocated in PetscOptionsStringArray() */
}
}
ierr = PetscOptionsRealArray("-snes_composite_damping","Damping of the additive composite solvers","SNESCompositeSetDamping",dmps,&nmax,&flg);CHKERRQ(ierr);
if (flg) {
for (i=0; i<nmax; i++) {
ierr = SNESCompositeSetDamping(snes,i,dmps[i]);CHKERRQ(ierr);
}
}
ierr = PetscOptionsReal("-snes_composite_stol","Step tolerance for restart on the additive composite solvers","",jac->stol,&jac->stol,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-snes_composite_rtol","Residual tolerance for the additive composite solvers","",jac->rtol,&jac->rtol,NULL);CHKERRQ(ierr);
ierr = PetscOptionsTail();CHKERRQ(ierr);
next = jac->head;
while (next) {
ierr = SNESSetFromOptions(next->snes);CHKERRQ(ierr);
next = next->next;
}
PetscFunctionReturn(0);
}
PetscErrorCode CholmodStart(Mat F)
{
PetscErrorCode ierr;
Mat_CHOLMOD *chol=(Mat_CHOLMOD*)F->spptr;
cholmod_common *c;
PetscBool flg;
PetscFunctionBegin;
if (chol->common) PetscFunctionReturn(0);
ierr = PetscMalloc(sizeof(*chol->common),&chol->common);CHKERRQ(ierr);
ierr = !cholmod_X_start(chol->common);CHKERRQ(ierr);
c = chol->common;
c->error_handler = CholmodErrorHandler;
#define CHOLMOD_OPTION_DOUBLE(name,help) do { \
PetscReal tmp = (PetscReal)c->name; \
ierr = PetscOptionsReal("-mat_cholmod_" #name,help,"None",tmp,&tmp,0);CHKERRQ(ierr); \
c->name = (double)tmp; \
} while (0)
#define CHOLMOD_OPTION_INT(name,help) do { \
PetscInt tmp = (PetscInt)c->name; \
ierr = PetscOptionsInt("-mat_cholmod_" #name,help,"None",tmp,&tmp,0);CHKERRQ(ierr); \
c->name = (int)tmp; \
} while (0)
#define CHOLMOD_OPTION_SIZE_T(name,help) do { \
PetscInt tmp = (PetscInt)c->name; \
ierr = PetscOptionsInt("-mat_cholmod_" #name,help,"None",tmp,&tmp,0);CHKERRQ(ierr); \
if (tmp < 0) SETERRQ(((PetscObject)F)->comm,PETSC_ERR_ARG_OUTOFRANGE,"value must be positive"); \
c->name = (size_t)tmp; \
} while (0)
#define CHOLMOD_OPTION_TRUTH(name,help) do { \
PetscBool tmp = (PetscBool)!!c->name; \
ierr = PetscOptionsBool("-mat_cholmod_" #name,help,"None",tmp,&tmp,0);CHKERRQ(ierr); \
c->name = (int)tmp; \
} while (0)
ierr = PetscOptionsBegin(((PetscObject)F)->comm,((PetscObject)F)->prefix,"CHOLMOD Options","Mat");CHKERRQ(ierr);
/* CHOLMOD handles first-time packing and refactor-packing separately, but we usually want them to be the same. */
chol->pack = (PetscBool)c->final_pack;
ierr = PetscOptionsBool("-mat_cholmod_pack","Pack factors after factorization [disable for frequent repeat factorization]","None",chol->pack,&chol->pack,0);CHKERRQ(ierr);
c->final_pack = (int)chol->pack;
CHOLMOD_OPTION_DOUBLE(dbound,"Minimum absolute value of diagonal entries of D");
CHOLMOD_OPTION_DOUBLE(grow0,"Global growth ratio when factors are modified");
CHOLMOD_OPTION_DOUBLE(grow1,"Column growth ratio when factors are modified");
CHOLMOD_OPTION_SIZE_T(grow2,"Affine column growth constant when factors are modified");
CHOLMOD_OPTION_SIZE_T(maxrank,"Max rank of update, larger values are faster but use more memory [2,4,8]");
{
static const char *const list[] = {"SIMPLICIAL","AUTO","SUPERNODAL","MatCholmodFactorType","MAT_CHOLMOD_FACTOR_",0};
PetscEnum choice = (PetscEnum)c->supernodal;
ierr = PetscOptionsEnum("-mat_cholmod_factor","Factorization method","None",list,(PetscEnum)c->supernodal,&choice,0);CHKERRQ(ierr);
c->supernodal = (int)choice;
}
if (c->supernodal) CHOLMOD_OPTION_DOUBLE(supernodal_switch,"flop/nnz_L threshold for switching to supernodal factorization");
CHOLMOD_OPTION_TRUTH(final_asis,"Leave factors \"as is\"");
CHOLMOD_OPTION_TRUTH(final_pack,"Pack the columns when finished (use FALSE if the factors will be updated later)");
if (!c->final_asis) {
CHOLMOD_OPTION_TRUTH(final_super,"Leave supernodal factors instead of converting to simplicial");
CHOLMOD_OPTION_TRUTH(final_ll,"Turn LDL' factorization into LL'");
CHOLMOD_OPTION_TRUTH(final_monotonic,"Ensure columns are monotonic when done");
CHOLMOD_OPTION_TRUTH(final_resymbol,"Remove numerically zero values resulting from relaxed supernodal amalgamation");
}
{
PetscReal tmp[] = {(PetscReal)c->zrelax[0],(PetscReal)c->zrelax[1],(PetscReal)c->zrelax[2]};
PetscInt n = 3;
ierr = PetscOptionsRealArray("-mat_cholmod_zrelax","3 real supernodal relaxed amalgamation parameters","None",tmp,&n,&flg);CHKERRQ(ierr);
if (flg && n != 3) SETERRQ(((PetscObject)F)->comm,PETSC_ERR_ARG_OUTOFRANGE,"must provide exactly 3 parameters to -mat_cholmod_zrelax");
if (flg) while (n--) c->zrelax[n] = (double)tmp[n];
}
{
PetscInt n,tmp[] = {(PetscInt)c->nrelax[0],(PetscInt)c->nrelax[1],(PetscInt)c->nrelax[2]};
ierr = PetscOptionsIntArray("-mat_cholmod_nrelax","3 size_t supernodal relaxed amalgamation parameters","None",tmp,&n,&flg);CHKERRQ(ierr);
if (flg && n != 3) SETERRQ(((PetscObject)F)->comm,PETSC_ERR_ARG_OUTOFRANGE,"must provide exactly 3 parameters to -mat_cholmod_nrelax");
if (flg) while (n--) c->nrelax[n] = (size_t)tmp[n];
}
CHOLMOD_OPTION_TRUTH(prefer_upper,"Work with upper triangular form [faster when using fill-reducing ordering, slower in natural ordering]");
CHOLMOD_OPTION_TRUTH(default_nesdis,"Use NESDIS instead of METIS for nested dissection");
CHOLMOD_OPTION_INT(print,"Verbosity level");
ierr = PetscOptionsEnd();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode PCSetFromOptions_MG(PetscOptionItems *PetscOptionsObject,PC pc)
{
PetscErrorCode ierr;
PetscInt m,levels = 1,cycles;
PetscBool flg,set;
PC_MG *mg = (PC_MG*)pc->data;
PC_MG_Levels **mglevels;
PCMGType mgtype;
PCMGCycleType mgctype;
PetscFunctionBegin;
ierr = PetscOptionsHead(PetscOptionsObject,"Multigrid options");CHKERRQ(ierr);
if (!mg->levels) {
ierr = PetscOptionsInt("-pc_mg_levels","Number of Levels","PCMGSetLevels",levels,&levels,&flg);CHKERRQ(ierr);
if (!flg && pc->dm) {
ierr = DMGetRefineLevel(pc->dm,&levels);CHKERRQ(ierr);
levels++;
mg->usedmfornumberoflevels = PETSC_TRUE;
}
ierr = PCMGSetLevels(pc,levels,NULL);CHKERRQ(ierr);
}
mglevels = mg->levels;
mgctype = (PCMGCycleType) mglevels[0]->cycles;
ierr = PetscOptionsEnum("-pc_mg_cycle_type","V cycle or for W-cycle","PCMGSetCycleType",PCMGCycleTypes,(PetscEnum)mgctype,(PetscEnum*)&mgctype,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCMGSetCycleType(pc,mgctype);CHKERRQ(ierr);
}
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-pc_mg_galerkin","Use Galerkin process to compute coarser operators","PCMGSetGalerkin",flg,&flg,&set);CHKERRQ(ierr);
if (set) {
ierr = PCMGSetGalerkin(pc,flg);CHKERRQ(ierr);
}
ierr = PetscOptionsInt("-pc_mg_smoothup","Number of post-smoothing steps","PCMGSetNumberSmoothUp",mg->default_smoothu,&m,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCMGSetNumberSmoothUp(pc,m);CHKERRQ(ierr);
}
ierr = PetscOptionsInt("-pc_mg_smoothdown","Number of pre-smoothing steps","PCMGSetNumberSmoothDown",mg->default_smoothd,&m,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCMGSetNumberSmoothDown(pc,m);CHKERRQ(ierr);
}
mgtype = mg->am;
ierr = PetscOptionsEnum("-pc_mg_type","Multigrid type","PCMGSetType",PCMGTypes,(PetscEnum)mgtype,(PetscEnum*)&mgtype,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCMGSetType(pc,mgtype);CHKERRQ(ierr);
}
if (mg->am == PC_MG_MULTIPLICATIVE) {
ierr = PetscOptionsInt("-pc_mg_multiplicative_cycles","Number of cycles for each preconditioner step","PCMGMultiplicativeSetCycles",mg->cyclesperpcapply,&cycles,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCMGMultiplicativeSetCycles(pc,cycles);CHKERRQ(ierr);
}
}
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-pc_mg_log","Log times for each multigrid level","None",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
PetscInt i;
char eventname[128];
if (!mglevels) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"Must set MG levels before calling");
levels = mglevels[0]->levels;
for (i=0; i<levels; i++) {
sprintf(eventname,"MGSetup Level %d",(int)i);
ierr = PetscLogEventRegister(eventname,((PetscObject)pc)->classid,&mglevels[i]->eventsmoothsetup);CHKERRQ(ierr);
sprintf(eventname,"MGSmooth Level %d",(int)i);
ierr = PetscLogEventRegister(eventname,((PetscObject)pc)->classid,&mglevels[i]->eventsmoothsolve);CHKERRQ(ierr);
if (i) {
sprintf(eventname,"MGResid Level %d",(int)i);
ierr = PetscLogEventRegister(eventname,((PetscObject)pc)->classid,&mglevels[i]->eventresidual);CHKERRQ(ierr);
sprintf(eventname,"MGInterp Level %d",(int)i);
ierr = PetscLogEventRegister(eventname,((PetscObject)pc)->classid,&mglevels[i]->eventinterprestrict);CHKERRQ(ierr);
}
}
#if defined(PETSC_USE_LOG)
{
const char *sname = "MG Apply";
PetscStageLog stageLog;
PetscInt st;
PetscFunctionBegin;
ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr);
for (st = 0; st < stageLog->numStages; ++st) {
PetscBool same;
ierr = PetscStrcmp(stageLog->stageInfo[st].name, sname, &same);CHKERRQ(ierr);
if (same) mg->stageApply = st;
}
if (!mg->stageApply) {
ierr = PetscLogStageRegister(sname, &mg->stageApply);CHKERRQ(ierr);
}
}
#endif
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode SNESSetFromOptions_FAS(PetscOptions *PetscOptionsObject,SNES snes)
{
SNES_FAS *fas = (SNES_FAS*) snes->data;
PetscInt levels = 1;
PetscBool flg = PETSC_FALSE, upflg = PETSC_FALSE, downflg = PETSC_FALSE, monflg = PETSC_FALSE, galerkinflg = PETSC_FALSE,continuationflg = PETSC_FALSE;
PetscErrorCode ierr;
char monfilename[PETSC_MAX_PATH_LEN];
SNESFASType fastype;
const char *optionsprefix;
SNESLineSearch linesearch;
PetscInt m, n_up, n_down;
SNES next;
PetscBool isFine;
PetscFunctionBegin;
ierr = SNESFASCycleIsFine(snes, &isFine);CHKERRQ(ierr);
ierr = PetscOptionsHead(PetscOptionsObject,"SNESFAS Options-----------------------------------");CHKERRQ(ierr);
/* number of levels -- only process most options on the finest level */
if (isFine) {
ierr = PetscOptionsInt("-snes_fas_levels", "Number of Levels", "SNESFASSetLevels", levels, &levels, &flg);CHKERRQ(ierr);
if (!flg && snes->dm) {
ierr = DMGetRefineLevel(snes->dm,&levels);CHKERRQ(ierr);
levels++;
fas->usedmfornumberoflevels = PETSC_TRUE;
}
ierr = SNESFASSetLevels(snes, levels, NULL);CHKERRQ(ierr);
fastype = fas->fastype;
ierr = PetscOptionsEnum("-snes_fas_type","FAS correction type","SNESFASSetType",SNESFASTypes,(PetscEnum)fastype,(PetscEnum*)&fastype,&flg);CHKERRQ(ierr);
if (flg) {
ierr = SNESFASSetType(snes, fastype);CHKERRQ(ierr);
}
ierr = SNESGetOptionsPrefix(snes, &optionsprefix);CHKERRQ(ierr);
ierr = PetscOptionsInt("-snes_fas_cycles","Number of cycles","SNESFASSetCycles",fas->n_cycles,&m,&flg);CHKERRQ(ierr);
if (flg) {
ierr = SNESFASSetCycles(snes, m);CHKERRQ(ierr);
}
ierr = PetscOptionsBool("-snes_fas_continuation","Corrected grid-sequence continuation","SNESFASSetContinuation",fas->continuation,&continuationflg,&flg);CHKERRQ(ierr);
if (flg) {
ierr = SNESFASSetContinuation(snes,continuationflg);CHKERRQ(ierr);
}
ierr = PetscOptionsBool("-snes_fas_galerkin", "Form coarse problems with Galerkin","SNESFASSetGalerkin",fas->galerkin,&galerkinflg,&flg);CHKERRQ(ierr);
if (flg) {
ierr = SNESFASSetGalerkin(snes, galerkinflg);CHKERRQ(ierr);
}
if (fas->fastype == SNES_FAS_FULL) {
ierr = PetscOptionsBool("-snes_fas_full_downsweep","Smooth on the initial upsweep for full FAS cycles","SNESFASFullSetDownSweep",fas->full_downsweep,&fas->full_downsweep,&flg);CHKERRQ(ierr);
if (flg) {SNESFASFullSetDownSweep(snes,fas->full_downsweep);CHKERRQ(ierr);}
}
ierr = PetscOptionsInt("-snes_fas_smoothup","Number of post-smoothing steps","SNESFASSetNumberSmoothUp",fas->max_up_it,&n_up,&upflg);CHKERRQ(ierr);
ierr = PetscOptionsInt("-snes_fas_smoothdown","Number of pre-smoothing steps","SNESFASSetNumberSmoothDown",fas->max_down_it,&n_down,&downflg);CHKERRQ(ierr);
ierr = PetscOptionsString("-snes_fas_monitor","Monitor FAS progress","SNESFASSetMonitor","stdout",monfilename,PETSC_MAX_PATH_LEN,&monflg);CHKERRQ(ierr);
if (monflg) ierr = SNESFASSetMonitor(snes, PETSC_TRUE);CHKERRQ(ierr);
flg = PETSC_FALSE;
monflg = PETSC_TRUE;
ierr = PetscOptionsBool("-snes_fas_log","Log times for each FAS level","SNESFASSetLog",monflg,&monflg,&flg);CHKERRQ(ierr);
if (flg) {ierr = SNESFASSetLog(snes,monflg);CHKERRQ(ierr);}
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
/* setup from the determined types if there is no pointwise procedure or smoother defined */
if (upflg) {
ierr = SNESFASSetNumberSmoothUp(snes,n_up);CHKERRQ(ierr);
}
if (downflg) {
ierr = SNESFASSetNumberSmoothDown(snes,n_down);CHKERRQ(ierr);
}
/* set up the default line search for coarse grid corrections */
if (fas->fastype == SNES_FAS_ADDITIVE) {
if (!snes->linesearch) {
ierr = SNESGetLineSearch(snes, &linesearch);CHKERRQ(ierr);
ierr = SNESLineSearchSetType(linesearch, SNESLINESEARCHL2);CHKERRQ(ierr);
}
}
ierr = SNESFASCycleGetCorrection(snes, &next);CHKERRQ(ierr);
/* recursive option setting for the smoothers */
if (next) {ierr = SNESSetFromOptions(next);CHKERRQ(ierr);}
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode PetscThreadCommCreate_PThread(PetscThreadComm tcomm)
{
PetscThreadComm_PThread ptcomm;
PetscErrorCode ierr;
PetscInt i;
PetscFunctionBegin;
ptcommcrtct++;
ierr = PetscStrcpy(tcomm->type,PTHREAD);CHKERRQ(ierr);
ierr = PetscNew(&ptcomm);CHKERRQ(ierr);
tcomm->data = (void*)ptcomm;
ptcomm->nthreads = 0;
ptcomm->sync = PTHREADSYNC_LOCKFREE;
ptcomm->aff = PTHREADAFFPOLICY_ONECORE;
ptcomm->spark = PTHREADPOOLSPARK_SELF;
ptcomm->ismainworker = PETSC_TRUE;
ptcomm->synchronizeafter = PETSC_TRUE;
tcomm->ops->destroy = PetscThreadCommDestroy_PThread;
tcomm->ops->runkernel = PetscThreadCommRunKernel_PThread_LockFree;
tcomm->ops->barrier = PetscThreadCommBarrier_PThread_LockFree;
tcomm->ops->getrank = PetscThreadCommGetRank_PThread;
ierr = PetscMalloc1(tcomm->nworkThreads,&ptcomm->granks);CHKERRQ(ierr);
if (!PetscPThreadCommInitializeCalled) { /* Only done for PETSC_THREAD_COMM_WORLD */
PetscBool flg1,flg2,flg3,flg4;
PetscPThreadCommInitializeCalled = PETSC_TRUE;
ierr = PetscOptionsBegin(PETSC_COMM_WORLD,NULL,"PThread communicator options",NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-threadcomm_pthread_main_is_worker","Main thread is also a worker thread",NULL,PETSC_TRUE,&ptcomm->ismainworker,&flg1);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-threadcomm_pthread_affpolicy","Thread affinity policy"," ",PetscPThreadCommAffinityPolicyTypes,(PetscEnum)ptcomm->aff,(PetscEnum*)&ptcomm->aff,&flg2);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-threadcomm_pthread_type","Thread pool type"," ",PetscPThreadCommSynchronizationTypes,(PetscEnum)ptcomm->sync,(PetscEnum*)&ptcomm->sync,&flg3);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-threadcomm_pthread_spark","Thread pool spark type"," ",PetscPThreadCommPoolSparkTypes,(PetscEnum)ptcomm->spark,(PetscEnum*)&ptcomm->spark,&flg4);CHKERRQ(ierr);
ierr = PetscOptionsBool("-threadcomm_pthread_synchronizeafter","Puts a barrier after every kernel call",NULL,PETSC_TRUE,&ptcomm->synchronizeafter,&flg1);CHKERRQ(ierr);
ierr = PetscOptionsEnd();CHKERRQ(ierr);
if (ptcomm->ismainworker) {
ptcomm->nthreads = tcomm->nworkThreads-1;
ptcomm->thread_num_start = 1;
} else {
ptcomm->nthreads = tcomm->nworkThreads;
ptcomm->thread_num_start = 0;
}
switch (ptcomm->sync) {
case PTHREADSYNC_LOCKFREE:
ptcomm->initialize = PetscPThreadCommInitialize_LockFree;
ptcomm->finalize = PetscPThreadCommFinalize_LockFree;
tcomm->ops->runkernel = PetscThreadCommRunKernel_PThread_LockFree;
tcomm->ops->barrier = PetscThreadCommBarrier_PThread_LockFree;
break;
default:
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Only Lock-free synchronization scheme supported currently");
}
/* Set up thread ranks */
for (i=0; i< tcomm->nworkThreads; i++) ptcomm->granks[i] = i;
if (ptcomm->ismainworker) {
#if defined(PETSC_PTHREAD_LOCAL)
PetscPThreadRank=0; /* Main thread rank */
#else
ierr = pthread_key_create(&PetscPThreadRankkey,NULL);CHKERRQ(ierr);
ierr = pthread_setspecific(PetscPThreadRankkey,&ptcomm->granks[0]);CHKERRQ(ierr);
#endif
}
/* Set the leader thread rank */
if (ptcomm->nthreads) {
if (ptcomm->ismainworker) tcomm->leader = ptcomm->granks[1];
else tcomm->leader = ptcomm->granks[0];
}
/* Create array holding pthread ids */
ierr = PetscMalloc1(tcomm->nworkThreads,&ptcomm->tid);CHKERRQ(ierr);
/* Create thread attributes */
ierr = PetscMalloc1(tcomm->nworkThreads,&ptcomm->attr);CHKERRQ(ierr);
ierr = PetscThreadCommSetPThreadAttributes(tcomm);CHKERRQ(ierr);
if (ptcomm->ismainworker) {
/* Pin main thread */
#if defined(PETSC_HAVE_SCHED_CPU_SET_T)
cpu_set_t mset;
PetscInt ncores,icorr;
ierr = PetscGetNCores(&ncores);CHKERRQ(ierr);
CPU_ZERO(&mset);
icorr = tcomm->affinities[0]%ncores;
CPU_SET(icorr,&mset);
sched_setaffinity(0,sizeof(cpu_set_t),&mset);
#endif
}
/* Initialize thread pool */
ierr = (*ptcomm->initialize)(tcomm);CHKERRQ(ierr);
} else {
PetscThreadComm gtcomm;
PetscThreadComm_PThread gptcomm;
PetscInt *granks,j,*gaffinities;
ierr = PetscCommGetThreadComm(PETSC_COMM_WORLD,>comm);CHKERRQ(ierr);
gaffinities = gtcomm->affinities;
gptcomm = (PetscThreadComm_PThread)tcomm->data;
granks = gptcomm->granks;
/* Copy over the data from the global thread communicator structure */
ptcomm->ismainworker = gptcomm->ismainworker;
ptcomm->thread_num_start = gptcomm->thread_num_start;
ptcomm->sync = gptcomm->sync;
ptcomm->aff = gptcomm->aff;
tcomm->ops->runkernel = gtcomm->ops->runkernel;
tcomm->ops->barrier = gtcomm->ops->barrier;
for (i=0; i < tcomm->nworkThreads; i++) {
for (j=0; j < gtcomm->nworkThreads; j++) {
if (tcomm->affinities[i] == gaffinities[j]) ptcomm->granks[i] = granks[j];
}
}
}
PetscFunctionReturn(0);
}
PetscErrorCode PCSetFromOptions_ML(PC pc)
{
PetscErrorCode ierr;
PetscInt indx,PrintLevel;
const char *scheme[] = {"Uncoupled","Coupled","MIS","METIS"};
PC_MG *mg = (PC_MG*)pc->data;
PC_ML *pc_ml = (PC_ML*)mg->innerctx;
PetscMPIInt size;
MPI_Comm comm = ((PetscObject)pc)->comm;
PetscFunctionBegin;
ierr = MPI_Comm_size(comm,&size);CHKERRQ(ierr);
ierr = PetscOptionsHead("ML options");CHKERRQ(ierr);
PrintLevel = 0;
indx = 0;
ierr = PetscOptionsInt("-pc_ml_PrintLevel","Print level","ML_Set_PrintLevel",PrintLevel,&PrintLevel,PETSC_NULL);CHKERRQ(ierr);
ML_Set_PrintLevel(PrintLevel);
ierr = PetscOptionsInt("-pc_ml_maxNlevels","Maximum number of levels","None",pc_ml->MaxNlevels,&pc_ml->MaxNlevels,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-pc_ml_maxCoarseSize","Maximum coarsest mesh size","ML_Aggregate_Set_MaxCoarseSize",pc_ml->MaxCoarseSize,&pc_ml->MaxCoarseSize,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsEList("-pc_ml_CoarsenScheme","Aggregate Coarsen Scheme","ML_Aggregate_Set_CoarsenScheme_*",scheme,4,scheme[0],&indx,PETSC_NULL);CHKERRQ(ierr);
pc_ml->CoarsenScheme = indx;
ierr = PetscOptionsReal("-pc_ml_DampingFactor","P damping factor","ML_Aggregate_Set_DampingFactor",pc_ml->DampingFactor,&pc_ml->DampingFactor,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-pc_ml_Threshold","Smoother drop tol","ML_Aggregate_Set_Threshold",pc_ml->Threshold,&pc_ml->Threshold,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-pc_ml_SpectralNormScheme_Anorm","Method used for estimating spectral radius","ML_Set_SpectralNormScheme_Anorm",pc_ml->SpectralNormScheme_Anorm,&pc_ml->SpectralNormScheme_Anorm,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-pc_ml_Symmetrize","Symmetrize aggregation","ML_Set_Symmetrize",pc_ml->Symmetrize,&pc_ml->Symmetrize,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-pc_ml_BlockScaling","Scale all dofs at each node together","None",pc_ml->BlockScaling,&pc_ml->BlockScaling,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-pc_ml_nullspace","Which type of null space information to use","None",PCMLNullSpaceTypes,(PetscEnum)pc_ml->nulltype,(PetscEnum*)&pc_ml->nulltype,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-pc_ml_EnergyMinimization","Energy minimization norm type (0=no minimization; see ML manual for 1,2,3; -1 and 4 undocumented)","None",pc_ml->EnergyMinimization,&pc_ml->EnergyMinimization,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-pc_ml_reuse_interpolation","Reuse the interpolation operators when possible (cheaper, weaker when matrix entries change a lot)","None",pc_ml->reuse_interpolation,&pc_ml->reuse_interpolation,PETSC_NULL);CHKERRQ(ierr);
/*
The following checks a number of conditions. If we let this stuff slip by, then ML's error handling will take over.
This is suboptimal because it amounts to calling exit(1) so we check for the most common conditions.
We also try to set some sane defaults when energy minimization is activated, otherwise it's hard to find a working
combination of options and ML's exit(1) explanations don't help matters.
*/
if (pc_ml->EnergyMinimization < -1 || pc_ml->EnergyMinimization > 4) SETERRQ(comm,PETSC_ERR_ARG_OUTOFRANGE,"EnergyMinimization must be in range -1..4");
if (pc_ml->EnergyMinimization == 4 && size > 1) SETERRQ(comm,PETSC_ERR_SUP,"Energy minimization type 4 does not work in parallel");
if (pc_ml->EnergyMinimization == 4) {ierr = PetscInfo(pc,"Mandel's energy minimization scheme is experimental and broken in ML-6.2");CHKERRQ(ierr);}
if (pc_ml->EnergyMinimization) {
ierr = PetscOptionsReal("-pc_ml_EnergyMinimizationDropTol","Energy minimization drop tolerance","None",pc_ml->EnergyMinimizationDropTol,&pc_ml->EnergyMinimizationDropTol,PETSC_NULL);CHKERRQ(ierr);
}
if (pc_ml->EnergyMinimization == 2) {
/* According to ml_MultiLevelPreconditioner.cpp, this option is only meaningful for norm type (2) */
ierr = PetscOptionsBool("-pc_ml_EnergyMinimizationCheap","Use cheaper variant of norm type 2","None",pc_ml->EnergyMinimizationCheap,&pc_ml->EnergyMinimizationCheap,PETSC_NULL);CHKERRQ(ierr);
}
/* energy minimization sometimes breaks if this is turned off, the more classical stuff should be okay without it */
if (pc_ml->EnergyMinimization) pc_ml->KeepAggInfo = PETSC_TRUE;
ierr = PetscOptionsBool("-pc_ml_KeepAggInfo","Allows the preconditioner to be reused, or auxilliary matrices to be generated","None",pc_ml->KeepAggInfo,&pc_ml->KeepAggInfo,PETSC_NULL);CHKERRQ(ierr);
/* Option (-1) doesn't work at all (calls exit(1)) if the tentative restriction operator isn't stored. */
if (pc_ml->EnergyMinimization == -1) pc_ml->Reusable = PETSC_TRUE;
ierr = PetscOptionsBool("-pc_ml_Reusable","Store intermedaiate data structures so that the multilevel hierarchy is reusable","None",pc_ml->Reusable,&pc_ml->Reusable,PETSC_NULL);CHKERRQ(ierr);
/*
ML's C API is severely underdocumented and lacks significant functionality. The C++ API calls
ML_Gen_MultiLevelHierarchy_UsingAggregation() which is a modified copy (!?) of the documented function
ML_Gen_MGHierarchy_UsingAggregation(). This modification, however, does not provide a strict superset of the
functionality in the old function, so some users may still want to use it. Note that many options are ignored in
this context, but ML doesn't provide a way to find out which ones.
*/
ierr = PetscOptionsBool("-pc_ml_OldHierarchy","Use old routine to generate hierarchy","None",pc_ml->OldHierarchy,&pc_ml->OldHierarchy,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
