void PETSc::Solve_withPureNeumann_GMRES(void)
{
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);
ierr = VecAssemblyBegin(x);
ierr = VecAssemblyEnd(x);
ierr = VecAssemblyBegin(b);
ierr = VecAssemblyEnd(b);
MatNullSpaceCreate(PETSC_COMM_WORLD,PETSC_TRUE,0,PETSC_NULL,&nullsp);
KSPSetNullSpace(ksp,nullsp);
MatNullSpaceRemove(nullsp,b,PETSC_NULL);
KSPSetOperators(ksp,A,A,DIFFERENT_NONZERO_PATTERN);
KSPSetType(ksp,KSPGMRES);
//KSPGetPC(ksp, &pc);
//PCSetType(pc, PCASM);
KSPSetFromOptions(ksp);
KSPSetUp(ksp);
//start_clock("Before Petsc Solve in pure neumann solver");
KSPSolve(ksp,b,x);
//stop_clock("After Petsc Solve in pure neumann solver");
}
int main(int argc,char **argv)
{
KSP ksp;
DM da;
UserContext user;
PetscInt bc;
PetscErrorCode ierr;
PetscInitialize(&argc,&argv,(char *)0,help);
ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);CHKERRQ(ierr);
ierr = DMDACreate2d(PETSC_COMM_WORLD, DMDA_BOUNDARY_NONE, DMDA_BOUNDARY_NONE,DMDA_STENCIL_STAR,-11,-11,PETSC_DECIDE,PETSC_DECIDE,1,1,PETSC_NULL,PETSC_NULL,&da);CHKERRQ(ierr);
ierr = KSPSetDM(ksp,(DM)da);
ierr = DMSetApplicationContext(da,&user);CHKERRQ(ierr);
user.uu = 1.0;
user.tt = 1.0;
bc = (PetscInt)NEUMANN; // Use Neumann Boundary Conditions
user.bcType = (BCType)bc;
ierr = KSPSetComputeRHS(ksp,ComputeRHS,&user);CHKERRQ(ierr);
ierr = KSPSetComputeOperators(ksp,ComputeJacobian,&user);CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr);
ierr = KSPSolve(ksp,PETSC_NULL,PETSC_NULL);CHKERRQ(ierr);
ierr = DMDestroy(&da);CHKERRQ(ierr);
ierr = KSPDestroy(&ksp);CHKERRQ(ierr);
ierr = PetscFinalize();CHKERRQ(ierr);
return 0;
}
/// Do what is necessary to build this instance
void p_build(const std::string& option_prefix)
{
PetscErrorCode ierr;
try {
parallel::Communicator comm(this->communicator());
if (this->p_doSerial) {
comm = this->communicator().self();
}
ierr = KSPCreate(comm, &p_KSP); CHKERRXX(ierr);
if (!this->p_guessZero) {
ierr = KSPSetInitialGuessNonzero(p_KSP,PETSC_TRUE); CHKERRXX(ierr);
} else {
ierr = KSPSetInitialGuessNonzero(p_KSP,PETSC_FALSE); CHKERRXX(ierr);
}
ierr = KSPSetOptionsPrefix(p_KSP, option_prefix.c_str()); CHKERRXX(ierr);
PC pc;
ierr = KSPGetPC(p_KSP, &pc); CHKERRXX(ierr);
ierr = PCSetOptionsPrefix(pc, option_prefix.c_str()); CHKERRXX(ierr);
ierr = KSPSetTolerances(p_KSP,
LinearSolverImplementation<T, I>::p_relativeTolerance,
LinearSolverImplementation<T, I>::p_solutionTolerance,
PETSC_DEFAULT,
LinearSolverImplementation<T, I>::p_maxIterations); CHKERRXX(ierr);
ierr = KSPSetFromOptions(p_KSP);CHKERRXX(ierr);
} catch (const PETSC_EXCEPTION_TYPE& e) {
throw PETScException(ierr, e);
}
}
PetscErrorCode SolvePressure(UserContext *uc)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscLogEventBegin(EVENT_SolvePressure,0,0,0,0);
ierr = KSPCreate(PETSC_COMM_WORLD, &uc->ksp); CHKERRQ(ierr);
ierr = KSPSetType(uc->ksp,KSPCG); CHKERRQ(ierr);
ierr = KSPSetOperators(uc->ksp,uc->A,uc->A,SAME_NONZERO_PATTERN); CHKERRQ(ierr);
ierr = KSPSetFromOptions(uc->ksp); CHKERRQ(ierr);
ierr = KSPSetTolerances(uc->ksp, 0.000001, PETSC_DEFAULT, PETSC_DEFAULT, PETSC_DEFAULT); CHKERRQ(ierr);
ierr = KSPSetType( uc->ksp, KSPPREONLY); CHKERRQ(ierr);
PC pc;
ierr = KSPGetPC(uc->ksp, &pc); CHKERRQ(ierr);
ierr = PCSetType(pc, PCLU); CHKERRQ(ierr);
ierr = KSPSolve(uc->ksp,uc->b,uc->p);CHKERRQ(ierr);
KSPConvergedReason reason;
KSPGetConvergedReason(uc->ksp,&reason);
PetscPrintf(PETSC_COMM_WORLD,"Pressure KSPConvergedReason: %D\n", reason);
// if( reason < 0 ) SETERRQ(PETSC_ERR_CONV_FAILED, "Exiting: Failed to converge\n");
PetscLogEventEnd(EVENT_SolvePressure,0,0,0,0);
PetscFunctionReturn(0);
}
int main(int argc, char **argv)
{
Mat A;
KSP ksp;
DM shell;
Vec *left, *right;
MPI_Comm c;
PetscErrorCode ierr;
ierr = PetscInitialize(&argc, &argv, NULL, NULL);if (ierr) return ierr;
c = PETSC_COMM_WORLD;
ierr = MatCreate(c, &A); CHKERRQ(ierr);
ierr = MatSetSizes(A, 1, 1, PETSC_DECIDE, PETSC_DECIDE); CHKERRQ(ierr);
ierr = MatSetFromOptions(A); CHKERRQ(ierr);
ierr = MatSetUp(A); CHKERRQ(ierr);
ierr = KSPCreate(c, &ksp); CHKERRQ(ierr);
ierr = KSPSetOperators(ksp, A, A); CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksp); CHKERRQ(ierr);
ierr = DMShellCreate(c, &shell); CHKERRQ(ierr);
ierr = DMSetFromOptions(shell); CHKERRQ(ierr);
ierr = DMSetUp(shell); CHKERRQ(ierr);
ierr = KSPSetDM(ksp, shell); CHKERRQ(ierr);
ierr = KSPCreateVecs(ksp, 1, &right, 1, &left); CHKERRQ(ierr);
ierr = VecView(right[0], PETSC_VIEWER_STDOUT_(c));CHKERRQ(ierr);
ierr = VecDestroyVecs(1,&right); CHKERRQ(ierr);
ierr = VecDestroyVecs(1,&left); CHKERRQ(ierr);
ierr = DMDestroy(&shell); CHKERRQ(ierr);
ierr = KSPDestroy(&ksp); CHKERRQ(ierr);
ierr = MatDestroy(&A); CHKERRQ(ierr);
PetscFinalize();
return 0;
}
void PetscPreconditioner::set_petsc_subpreconditioner_type(const PCType type, PC& pc) {
int ierr;
KSP* subksps;
int nlocal;
ierr = PCASMGetSubKSP(pc, &nlocal, PETSC_NULL, &subksps);
CHKERRABORT(MPI_COMM_WORLD, ierr);
PetscReal epsilon = 1.e-16;
for(int i = 0; i < nlocal; i++) {
PC subpc;
ierr = KSPGetPC(subksps[i], &subpc);
CHKERRABORT(MPI_COMM_WORLD, ierr);
ierr = KSPSetTolerances(subksps[i], PETSC_DEFAULT, PETSC_DEFAULT, PETSC_DEFAULT, 1);
CHKERRABORT(MPI_COMM_WORLD, ierr);
ierr = KSPSetFromOptions(subksps[i]);
CHKERRABORT(MPI_COMM_WORLD, ierr);
ierr = PCSetType(subpc, type);
CHKERRABORT(MPI_COMM_WORLD, ierr);
ierr = PCFactorSetZeroPivot(subpc, epsilon);
CHKERRABORT(MPI_COMM_WORLD, ierr);
ierr = PCFactorSetShiftType(subpc, MAT_SHIFT_NONZERO);
CHKERRABORT(MPI_COMM_WORLD, ierr);
}
}
int main(int argc,char **argv)
{
KSP ksp;
DM da;
UserContext user;
PetscErrorCode ierr;
ierr = PetscInitialize(&argc,&argv,(char*)0,help);if (ierr) return ierr;
ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);CHKERRQ(ierr);
ierr = DMDACreate2d(PETSC_COMM_WORLD, DM_BOUNDARY_PERIODIC, DM_BOUNDARY_MIRROR,DMDA_STENCIL_STAR,11,11,PETSC_DECIDE,PETSC_DECIDE,1,1,NULL,NULL,&da);CHKERRQ(ierr);
ierr = DMSetFromOptions(da);CHKERRQ(ierr);
ierr = DMSetUp(da);CHKERRQ(ierr);
ierr = KSPSetDM(ksp,(DM)da);CHKERRQ(ierr);
ierr = DMSetApplicationContext(da,&user);CHKERRQ(ierr);
user.uu = 1.0;
user.tt = 1.0;
ierr = KSPSetComputeRHS(ksp,ComputeRHS,&user);CHKERRQ(ierr);
ierr = KSPSetComputeOperators(ksp,ComputeJacobian,&user);CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr);
ierr = KSPSolve(ksp,NULL,NULL);CHKERRQ(ierr);
ierr = DMDestroy(&da);CHKERRQ(ierr);
ierr = KSPDestroy(&ksp);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
int main(int argc,char **args)
{
KSP ksp; /* linear solver context */
Mat A; /* matrix */
Vec x,b; /* approx solution, RHS, exact solution */
PetscViewer fd; /* viewer */
PetscErrorCode ierr;
PetscInitialize(&argc,&args,(char *)0,help);
fd = PETSC_VIEWER_SOCKET_WORLD;
ierr = VecCreate(PETSC_COMM_WORLD,&b);CHKERRQ(ierr);
ierr = VecLoad(b,fd);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatLoad(A,fd);CHKERRQ(ierr);
ierr = VecDuplicate(b,&x);CHKERRQ(ierr);
ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);CHKERRQ(ierr);
ierr = KSPSetOperators(ksp,A,A,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr);
ierr = KSPSetUp(ksp);CHKERRQ(ierr);
ierr = KSPSolve(ksp,b,x);CHKERRQ(ierr);
ierr = VecView(x,fd);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = VecDestroy(&b);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = KSPDestroy(&ksp);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
KSP ksp;
DM da,shell;
PetscInt levels;
PetscInitialize(&argc,&argv,(char*)0,help);
ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);CHKERRQ(ierr);
ierr = DMDACreate1d(PETSC_COMM_WORLD,DM_BOUNDARY_NONE,-129,1,1,0,&da);CHKERRQ(ierr);
ierr = MyDMShellCreate(PETSC_COMM_WORLD,da,&shell);CHKERRQ(ierr);
/* these two lines are not needed but allow PCMG to automatically know how many multigrid levels the user wants */
ierr = DMGetRefineLevel(da,&levels);CHKERRQ(ierr);
ierr = DMSetRefineLevel(shell,levels);CHKERRQ(ierr);
ierr = KSPSetDM(ksp,shell);CHKERRQ(ierr);
ierr = KSPSetComputeRHS(ksp,ComputeRHS,NULL);CHKERRQ(ierr);
ierr = KSPSetComputeOperators(ksp,ComputeMatrix,NULL);CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr);
ierr = KSPSolve(ksp,NULL,NULL);CHKERRQ(ierr);
ierr = KSPDestroy(&ksp);CHKERRQ(ierr);
ierr = DMDestroy(&shell);CHKERRQ(ierr);
ierr = DMDestroy(&da);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
static PetscErrorCode TaoSetFromOptions_BQNLS(PetscOptionItems *PetscOptionsObject,Tao tao)
{
TAO_BNK *bnk = (TAO_BNK *)tao->data;
TAO_BQNK *bqnk = (TAO_BQNK*)bnk->ctx;
PetscErrorCode ierr;
KSPType ksp_type;
PetscBool is_spd;
PetscFunctionBegin;
ierr = PetscOptionsHead(PetscOptionsObject,"Quasi-Newton-Krylov method for bound constrained optimization");CHKERRQ(ierr);
ierr = PetscOptionsEList("-tao_bqnls_as_type", "active set estimation method", "", BNK_AS, BNK_AS_TYPES, BNK_AS[bnk->as_type], &bnk->as_type, 0);CHKERRQ(ierr);
ierr = PetscOptionsReal("-tao_bqnls_epsilon", "(developer) tolerance used when computing actual and predicted reduction", "", bnk->epsilon, &bnk->epsilon,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-tao_bqnls_as_tol", "(developer) initial tolerance used when estimating actively bounded variables", "", bnk->as_tol, &bnk->as_tol,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-tao_bqnls_as_step", "(developer) step length used when estimating actively bounded variables", "", bnk->as_step, &bnk->as_step,NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-tao_bqnls_max_cg_its", "number of BNCG iterations to take for each Newton step", "", bnk->max_cg_its, &bnk->max_cg_its,NULL);CHKERRQ(ierr);
ierr = PetscOptionsTail();CHKERRQ(ierr);
ierr = TaoSetFromOptions(bnk->bncg);CHKERRQ(ierr);
ierr = TaoLineSearchSetFromOptions(tao->linesearch);CHKERRQ(ierr);
ierr = KSPSetFromOptions(tao->ksp);CHKERRQ(ierr);
ierr = KSPGetType(tao->ksp,&ksp_type);CHKERRQ(ierr);
bnk->is_nash = bnk->is_gltr = bnk->is_stcg = PETSC_FALSE;
ierr = MatSetFromOptions(bqnk->B);CHKERRQ(ierr);
ierr = MatGetOption(bqnk->B, MAT_SPD, &is_spd);CHKERRQ(ierr);
if (!is_spd) SETERRQ(PetscObjectComm((PetscObject)tao), PETSC_ERR_ARG_INCOMP, "LMVM matrix must be symmetric positive-definite");
PetscFunctionReturn(0);
}
/*@C
TSMonitorSPEigCtxCreate - Creates a context for use with TS to monitor the eigenvalues of the linearized operator
Collective on TS
Input Parameters:
+ host - the X display to open, or null for the local machine
. label - the title to put in the title bar
. x, y - the screen coordinates of the upper left coordinate of the window
. m, n - the screen width and height in pixels
- howoften - if positive then determines the frequency of the plotting, if -1 then only at the final time
Output Parameter:
. ctx - the context
Options Database Key:
. -ts_monitor_sp_eig - plot egienvalues of linearized right hand side
Notes:
Use TSMonitorSPEigCtxDestroy() to destroy.
Currently only works if the Jacobian is provided explicitly.
Currently only works for ODEs u_t - F(t,u) = 0; that is with no mass matrix.
Level: intermediate
.keywords: TS, monitor, line graph, residual, seealso
.seealso: TSMonitorSPEigTimeStep(), TSMonitorSet(), TSMonitorLGSolution(), TSMonitorLGError()
@*/
PetscErrorCode TSMonitorSPEigCtxCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscInt howoften,TSMonitorSPEigCtx *ctx)
{
PetscDraw win;
PetscErrorCode ierr;
PC pc;
PetscFunctionBegin;
ierr = PetscNew(ctx);CHKERRQ(ierr);
ierr = PetscRandomCreate(comm,&(*ctx)->rand);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions((*ctx)->rand);CHKERRQ(ierr);
ierr = PetscDrawCreate(comm,host,label,x,y,m,n,&win);CHKERRQ(ierr);
ierr = PetscDrawSetFromOptions(win);CHKERRQ(ierr);
ierr = PetscDrawSPCreate(win,1,&(*ctx)->drawsp);CHKERRQ(ierr);
ierr = KSPCreate(comm,&(*ctx)->ksp);CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix((*ctx)->ksp,"ts_monitor_sp_eig_");CHKERRQ(ierr); /* this is wrong, used use also prefix from the TS */
ierr = KSPSetType((*ctx)->ksp,KSPGMRES);CHKERRQ(ierr);
ierr = KSPGMRESSetRestart((*ctx)->ksp,200);CHKERRQ(ierr);
ierr = KSPSetTolerances((*ctx)->ksp,1.e-10,PETSC_DEFAULT,PETSC_DEFAULT,200);CHKERRQ(ierr);
ierr = KSPSetComputeSingularValues((*ctx)->ksp,PETSC_TRUE);CHKERRQ(ierr);
ierr = KSPSetFromOptions((*ctx)->ksp);CHKERRQ(ierr);
ierr = KSPGetPC((*ctx)->ksp,&pc);CHKERRQ(ierr);
ierr = PCSetType(pc,PCNONE);CHKERRQ(ierr);
(*ctx)->howoften = howoften;
(*ctx)->computeexplicitly = PETSC_FALSE;
ierr = PetscOptionsGetBool(NULL,"-ts_monitor_sp_eig_explicitly",&(*ctx)->computeexplicitly,NULL);CHKERRQ(ierr);
(*ctx)->comm = comm;
(*ctx)->xmin = -2.1;
(*ctx)->xmax = 1.1;
(*ctx)->ymin = -1.1;
(*ctx)->ymax = 1.1;
PetscFunctionReturn(0);
}
/*!
\brief KSP and PC type
KSPRICHARDSON "richardson"
KSPCHEBYCHEV "chebychev"
KSPCG "cg"
KSPCGNE "cgne"
KSPNASH "nash"
KSPSTCG "stcg"
KSPGLTR "gltr"
KSPGMRES "gmres"
KSPFGMRES "fgmres"
KSPLGMRES "lgmres"
KSPDGMRES "dgmres"
KSPTCQMR "tcqmr"
KSPBCGS "bcgs"
KSPIBCGS "ibcgs"
KSPBCGSL "bcgsl"
KSPCGS "cgs"
KSPTFQMR "tfqmr"
KSPCR "cr"
KSPLSQR "lsqr"
KSPPREONLY "preonly"
KSPQCG "qcg"
KSPBICG "bicg"
KSPMINRES "minres"
KSPSYMMLQ "symmlq"
KSPLCD "lcd"
KSPPYTHON "python"
KSPBROYDEN "broyden"
KSPGCR "gcr"
KSPNGMRES "ngmres"
KSPSPECEST "specest"
PCNONE "none"
PCJACOBI "jacobi"
PCSOR "sor"
PCLU "lu"
PCSHELL "shell"
PCBJACOBI "bjacobi"
PCMG "mg"
PCEISENSTAT "eisenstat"
PCILU "ilu"
PCICC "icc"
PCASM "asm"
PCGASM "gasm"
PCKSP "ksp"
PCCOMPOSITE "composite"
PCREDUNDANT "redundant"
PCSPAI "spai"
PCNN "nn"
PCCHOLESKY "cholesky"
PCPBJACOBI "pbjacobi"
PCMAT "mat"
PCHYPRE "hypre"
PCPARMS "parms"
PCFIELDSPLIT "fieldsplit"
PCTFS "tfs"
PCML "ml"
PCPROMETHEUS "prometheus"
PCGALERKIN "galerkin"
PCEXOTIC "exotic"
PCHMPI "hmpi"
PCSUPPORTGRAPH "supportgraph"
PCASA "asa"
PCCP "cp"
PCBFBT "bfbt"
PCLSC "lsc"
PCPYTHON "python"
PCPFMG "pfmg"
PCSYSPFMG "syspfmg"
PCREDISTRIBUTE "redistribute"
PCSACUSP "sacusp"
PCSACUSPPOLY "sacusppoly"
PCBICGSTABCUSP "bicgstabcusp"
PCSVD "svd"
PCAINVCUSP "ainvcusp"
PCGAMG "gamg"
*/
void PETScLinearSolver::Config(const PetscReal tol, const PetscInt maxits, const KSPType lsol,
const PCType prec_type, const std::string &prefix)
{
ltolerance = tol;
sol_type = lsol;
pc_type = prec_type;
KSPCreate(PETSC_COMM_WORLD,&lsolver);
#if (PETSC_VERSION_MAJOR == 3) && (PETSC_VERSION_MINOR > 4)
KSPSetOperators(lsolver, A, A);
#else
KSPSetOperators(lsolver, A, A, DIFFERENT_NONZERO_PATTERN);
#endif
KSPSetType(lsolver,lsol);
KSPGetPC(lsolver, &prec);
PCSetType(prec, prec_type); // PCJACOBI); //PCNONE);
KSPSetTolerances(lsolver,ltolerance, PETSC_DEFAULT, PETSC_DEFAULT, maxits);
if( !prefix.empty() )
{
KSPSetOptionsPrefix(lsolver, prefix.c_str());
PCSetOptionsPrefix(prec, prefix.c_str());
}
KSPSetFromOptions(lsolver);
}
static PetscErrorCode PCSetUp_KSP(PC pc)
{
PetscErrorCode ierr;
PC_KSP *jac = (PC_KSP*)pc->data;
Mat mat;
PetscBool A;
PetscFunctionBegin;
if (!jac->ksp) {ierr = PCKSPCreateKSP_KSP(pc);CHKERRQ(ierr);}
ierr = KSPSetFromOptions(jac->ksp);CHKERRQ(ierr);
if (jac->use_true_matrix) mat = pc->mat;
else mat = pc->pmat;
ierr = KSPGetOperatorsSet(jac->ksp,&A,PETSC_NULL);CHKERRQ(ierr);
if (!A) {
ierr = KSPSetOperators(jac->ksp,mat,pc->pmat,pc->flag);CHKERRQ(ierr);
} else if (pc->flag != SAME_PRECONDITIONER) {
Mat Amat,Bmat;
ierr = KSPGetOperators(jac->ksp,&Amat,&Bmat,PETSC_NULL);CHKERRQ(ierr);
if (Amat == mat && Bmat == pc->pmat) {
/* The user has not replaced the matrices so we are expected to forward the update. This incorrectly diagnoses
* changed matrices at the top level as the user manually changing the inner matrices, but we have no way to
* identify that in this context. The longer term solution is to track matrix state internally.
*/
ierr = KSPSetOperators(jac->ksp,mat,pc->pmat,pc->flag);CHKERRQ(ierr);
}
}
ierr = KSPSetUp(jac->ksp);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
PetscInt i;
KSP ksp;
DM da;
Vec x;
PetscInitialize(&argc,&argv,(char*)0,help);
ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);CHKERRQ(ierr);
ierr = DMDACreate1d(PETSC_COMM_WORLD,DMDA_BOUNDARY_PERIODIC,-3,2,1,0,&da);CHKERRQ(ierr);
ierr = KSPSetDM(ksp,da);CHKERRQ(ierr);
ierr = KSPSetComputeRHS(ksp,ComputeRHS,NULL);CHKERRQ(ierr);
ierr = KSPSetComputeOperators(ksp,ComputeMatrix,NULL);CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr);
ierr = DMCreateGlobalVector(da,&x);CHKERRQ(ierr);
ierr = ComputeInitialSolution(da,x);CHKERRQ(ierr);
ierr = DMSetApplicationContext(da,x);CHKERRQ(ierr);
ierr = KSPSetUp(ksp);CHKERRQ(ierr);
ierr = VecView(x,PETSC_VIEWER_DRAW_WORLD);CHKERRQ(ierr);
for (i=0; i<10; i++) {
ierr = KSPSolve(ksp,NULL,x);CHKERRQ(ierr);
ierr = VecView(x,PETSC_VIEWER_DRAW_WORLD);CHKERRQ(ierr);
}
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = KSPDestroy(&ksp);CHKERRQ(ierr);
ierr = DMDestroy(&da);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
static PetscErrorCode PCSetUp_LSC(PC pc)
{
PC_LSC *lsc = (PC_LSC*)pc->data;
Mat L,Lp,B,C;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PCLSCAllocate_Private(pc);CHKERRQ(ierr);
ierr = PetscObjectQuery((PetscObject)pc->mat,"LSC_L",(PetscObject*)&L);CHKERRQ(ierr);
if (!L) {ierr = PetscObjectQuery((PetscObject)pc->pmat,"LSC_L",(PetscObject*)&L);CHKERRQ(ierr);}
ierr = PetscObjectQuery((PetscObject)pc->pmat,"LSC_Lp",(PetscObject*)&Lp);CHKERRQ(ierr);
if (!Lp) {ierr = PetscObjectQuery((PetscObject)pc->mat,"LSC_Lp",(PetscObject*)&Lp);CHKERRQ(ierr);}
if (!L) {
ierr = MatSchurComplementGetSubMatrices(pc->mat,NULL,NULL,&B,&C,NULL);CHKERRQ(ierr);
if (!lsc->L) {
ierr = MatMatMult(C,B,MAT_INITIAL_MATRIX,PETSC_DEFAULT,&lsc->L);CHKERRQ(ierr);
} else {
ierr = MatMatMult(C,B,MAT_REUSE_MATRIX,PETSC_DEFAULT,&lsc->L);CHKERRQ(ierr);
}
Lp = L = lsc->L;
}
if (lsc->scale) {
Mat Ap;
ierr = MatSchurComplementGetSubMatrices(pc->mat,NULL,&Ap,NULL,NULL,NULL);CHKERRQ(ierr);
ierr = MatGetDiagonal(Ap,lsc->scale);CHKERRQ(ierr); /* Should be the mass matrix, but we don't have plumbing for that yet */
ierr = VecReciprocal(lsc->scale);CHKERRQ(ierr);
}
ierr = KSPSetOperators(lsc->kspL,L,Lp);CHKERRQ(ierr);
ierr = KSPSetFromOptions(lsc->kspL);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
void PetscDMNonlinearSolver<T>::init()
{
PetscErrorCode ierr;
DM dm;
this->PetscNonlinearSolver<T>::init();
// Attaching a DM with the function and Jacobian callbacks to SNES.
ierr = DMCreateLibMesh(libMesh::COMM_WORLD, this->system(), &dm); CHKERRABORT(libMesh::COMM_WORLD, ierr);
ierr = DMSetFromOptions(dm); CHKERRABORT(libMesh::COMM_WORLD, ierr);
ierr = DMSetUp(dm); CHKERRABORT(libMesh::COMM_WORLD, ierr);
ierr = SNESSetDM(this->_snes, dm); CHKERRABORT(libMesh::COMM_WORLD, ierr);
// SNES now owns the reference to dm.
ierr = DMDestroy(&dm); CHKERRABORT(libMesh::COMM_WORLD, ierr);
KSP ksp;
ierr = SNESGetKSP (this->_snes, &ksp); CHKERRABORT(libMesh::COMM_WORLD,ierr);
// Set the tolerances for the iterative solver. Use the user-supplied
// tolerance for the relative residual & leave the others at default values
ierr = KSPSetTolerances (ksp, this->initial_linear_tolerance, PETSC_DEFAULT,PETSC_DEFAULT, this->max_linear_iterations); CHKERRABORT(libMesh::COMM_WORLD,ierr);
// Set the tolerances for the non-linear solver.
ierr = SNESSetTolerances(this->_snes,
this->absolute_residual_tolerance,
this->relative_residual_tolerance,
this->absolute_step_tolerance,
this->max_nonlinear_iterations,
this->max_function_evaluations);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
//Pull in command-line options
KSPSetFromOptions(ksp);
SNESSetFromOptions(this->_snes);
}
void PETSc::Solve(void)
{
//start_clock("Before Assemble matrix and vector");
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);
ierr = VecAssemblyBegin(x);
ierr = VecAssemblyEnd(x);
ierr = VecAssemblyBegin(b);
ierr = VecAssemblyEnd(b);
//stop_clock("After Assembly matrix and vector");
KSPSetOperators(ksp,A,A,DIFFERENT_NONZERO_PATTERN);
KSPSetType(ksp,KSPBCGSL);
KSPBCGSLSetEll(ksp,2);
//KSPGetPC(ksp, &pc);
//PCSetType(pc, PCJACOBI);
KSPSetFromOptions(ksp);
KSPSetUp(ksp);
//start_clock("Before KSPSolve");
KSPSolve(ksp,b,x);
//stop_clock("After KSPSolve");
}
static PetscErrorCode KSPComputeShifts_GMRES(KSP ksp)
{
PetscErrorCode ierr;
KSP_AGMRES *agmres = (KSP_AGMRES*)(ksp->data);
KSP kspgmres;
Mat Amat, Pmat;
MatStructure flag;
PetscInt max_k = agmres->max_k;
PC pc;
PetscInt m;
PetscScalar *Rshift, *Ishift;
PetscFunctionBegin;
/* Perform one cycle of classical GMRES (with the Arnoldi process) to get the Hessenberg matrix
We assume here that the ksp is AGMRES and that the operators for the
linear system have been set in this ksp */
ierr = KSPCreate(PetscObjectComm((PetscObject)ksp), &kspgmres);CHKERRQ(ierr);
if (!ksp->pc) { ierr = KSPGetPC(ksp,&ksp->pc);CHKERRQ(ierr); }
ierr = PCGetOperators(ksp->pc, &Amat, &Pmat);CHKERRQ(ierr);
ierr = KSPSetOperators(kspgmres, Amat, Pmat);CHKERRQ(ierr);
ierr = KSPSetFromOptions(kspgmres);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL, "-ksp_view", &flg);CHKERRQ(ierr);
if (flag) { ierr = PetscOptionsClearValue("-ksp_view");CHKERRQ(ierr); }
ierr = KSPSetType(kspgmres, KSPGMRES);CHKERRQ(ierr);
ierr = KSPGMRESSetRestart(kspgmres, max_k);CHKERRQ(ierr);
ierr = KSPGetPC(ksp, &pc);CHKERRQ(ierr);
ierr = KSPSetPC(kspgmres, pc);CHKERRQ(ierr);
/* Copy common options */
kspgmres->pc_side = ksp->pc_side;
/* Setup KSP context */
ierr = KSPSetComputeEigenvalues(kspgmres, PETSC_TRUE);CHKERRQ(ierr);
ierr = KSPSetUp(kspgmres);CHKERRQ(ierr);
kspgmres->max_it = max_k; /* Restrict the maximum number of iterations to one cycle of GMRES */
kspgmres->rtol = ksp->rtol;
ierr = KSPSolve(kspgmres, ksp->vec_rhs, ksp->vec_sol);CHKERRQ(ierr);
ksp->guess_zero = PETSC_FALSE;
ksp->rnorm = kspgmres->rnorm;
ksp->its = kspgmres->its;
if (kspgmres->reason == KSP_CONVERGED_RTOL) {
ksp->reason = KSP_CONVERGED_RTOL;
PetscFunctionReturn(0);
} else ksp->reason = KSP_CONVERGED_ITERATING;
/* Now, compute the Shifts values */
ierr = PetscMalloc2(max_k,&Rshift,max_k,&Ishift);CHKERRQ(ierr);
ierr = KSPComputeEigenvalues(kspgmres, max_k, Rshift, Ishift, &m);CHKERRQ(ierr);
if (m < max_k) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_PLIB, "Unable to compute the Shifts for the Newton basis");
else {
ierr = KSPAGMRESLejaOrdering(Rshift, Ishift, agmres->Rshift, agmres->Ishift, max_k);CHKERRQ(ierr);
agmres->HasShifts = PETSC_TRUE;
}
/* Restore KSP view options */
if (flg) { ierr = PetscOptionsSetValue("-ksp_view", "");CHKERRQ(ierr); }
PetscFunctionReturn(0);
}
static PetscErrorCode PCBDDCScalingSetUp_Deluxe_Private(PC pc)
{
PC_BDDC *pcbddc=(PC_BDDC*)pc->data;
PCBDDCDeluxeScaling deluxe_ctx=pcbddc->deluxe_ctx;
PCBDDCSubSchurs sub_schurs = pcbddc->sub_schurs;
PetscErrorCode ierr;
PetscFunctionBegin;
if (!sub_schurs->n_subs) {
PetscFunctionReturn(0);
}
/* Create work vectors for sequential part of deluxe */
ierr = MatCreateVecs(sub_schurs->S_Ej_all,&deluxe_ctx->seq_work1,&deluxe_ctx->seq_work2);CHKERRQ(ierr);
/* Compute deluxe sequential scatter */
if (sub_schurs->reuse_mumps && !sub_schurs->is_dir) {
PCBDDCReuseMumps reuse_mumps = sub_schurs->reuse_mumps;
ierr = PetscObjectReference((PetscObject)reuse_mumps->correction_scatter_B);CHKERRQ(ierr);
deluxe_ctx->seq_scctx = reuse_mumps->correction_scatter_B;
} else {
ierr = VecScatterCreate(pcbddc->work_scaling,sub_schurs->is_Ej_all,deluxe_ctx->seq_work1,NULL,&deluxe_ctx->seq_scctx);CHKERRQ(ierr);
}
/* Create Mat object for deluxe scaling */
ierr = PetscObjectReference((PetscObject)sub_schurs->S_Ej_all);CHKERRQ(ierr);
deluxe_ctx->seq_mat = sub_schurs->S_Ej_all;
if (sub_schurs->sum_S_Ej_all) { /* if this matrix is present, then we need to create the KSP object to invert it */
PC pc_temp;
MatSolverPackage solver=NULL;
char ksp_prefix[256];
size_t len;
ierr = KSPCreate(PETSC_COMM_SELF,&deluxe_ctx->seq_ksp);CHKERRQ(ierr);
ierr = KSPSetOperators(deluxe_ctx->seq_ksp,sub_schurs->sum_S_Ej_all,sub_schurs->sum_S_Ej_all);CHKERRQ(ierr);
ierr = KSPSetType(deluxe_ctx->seq_ksp,KSPPREONLY);CHKERRQ(ierr);
ierr = KSPGetPC(deluxe_ctx->seq_ksp,&pc_temp);CHKERRQ(ierr);
ierr = PCSetType(pc_temp,PCLU);CHKERRQ(ierr);
ierr = KSPGetPC(pcbddc->ksp_D,&pc_temp);CHKERRQ(ierr);
ierr = PCFactorGetMatSolverPackage(pc_temp,(const MatSolverPackage*)&solver);CHKERRQ(ierr);
if (solver) {
PC new_pc;
PCType type;
ierr = PCGetType(pc_temp,&type);CHKERRQ(ierr);
ierr = KSPGetPC(deluxe_ctx->seq_ksp,&new_pc);CHKERRQ(ierr);
ierr = PCSetType(new_pc,type);CHKERRQ(ierr);
ierr = PCFactorSetMatSolverPackage(new_pc,solver);CHKERRQ(ierr);
}
ierr = PetscStrlen(((PetscObject)(pcbddc->ksp_D))->prefix,&len);CHKERRQ(ierr);
len -= 10; /* remove "dirichlet_" */
ierr = PetscStrncpy(ksp_prefix,((PetscObject)(pcbddc->ksp_D))->prefix,len+1);CHKERRQ(ierr);
ierr = PetscStrcat(ksp_prefix,"deluxe_");CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix(deluxe_ctx->seq_ksp,ksp_prefix);CHKERRQ(ierr);
ierr = KSPSetFromOptions(deluxe_ctx->seq_ksp);CHKERRQ(ierr);
ierr = KSPSetUp(deluxe_ctx->seq_ksp);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
KSP ksp;
DM da;
UserContext user;
const char *bcTypes[2] = {"dirichlet","neumann"};
PetscErrorCode ierr;
PetscInt bc;
Vec b,x;
PetscInitialize(&argc,&argv,(char *)0,help);
ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);
CHKERRQ(ierr);
ierr = DMDACreate2d(PETSC_COMM_WORLD, DMDA_BOUNDARY_NONE, DMDA_BOUNDARY_NONE,DMDA_STENCIL_STAR,-3,-3,PETSC_DECIDE,PETSC_DECIDE,1,1,0,0,&da);
CHKERRQ(ierr);
ierr = DMDASetUniformCoordinates(da,0,1,0,1,0,0);
CHKERRQ(ierr);
ierr = DMDASetFieldName(da,0,"Pressure");
CHKERRQ(ierr);
ierr = PetscOptionsBegin(PETSC_COMM_WORLD, "", "Options for the inhomogeneous Poisson equation", "DMqq");
user.rho = 1.0;
ierr = PetscOptionsReal("-rho", "The conductivity", "ex29.c", user.rho, &user.rho, PETSC_NULL);
CHKERRQ(ierr);
user.nu = 0.1;
ierr = PetscOptionsReal("-nu", "The width of the Gaussian source", "ex29.c", user.nu, &user.nu, PETSC_NULL);
CHKERRQ(ierr);
bc = (PetscInt)DIRICHLET;
ierr = PetscOptionsEList("-bc_type","Type of boundary condition","ex29.c",bcTypes,2,bcTypes[0],&bc,PETSC_NULL);
CHKERRQ(ierr);
user.bcType = (BCType)bc;
ierr = PetscOptionsEnd();
ierr = KSPSetComputeRHS(ksp,ComputeRHS,&user);
CHKERRQ(ierr);
ierr = KSPSetComputeOperators(ksp,ComputeMatrix,&user);
CHKERRQ(ierr);
ierr = KSPSetDM(ksp,da);
CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksp);
CHKERRQ(ierr);
ierr = KSPSetUp(ksp);
CHKERRQ(ierr);
ierr = KSPSolve(ksp,PETSC_NULL,PETSC_NULL);
CHKERRQ(ierr);
ierr = KSPGetSolution(ksp,&x);
CHKERRQ(ierr);
ierr = KSPGetRhs(ksp,&b);
CHKERRQ(ierr);
ierr = DMDestroy(&da);
CHKERRQ(ierr);
ierr = KSPDestroy(&ksp);
CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
/*@
KSPResetFromOptions - Sets various KSP parameters from user options ONLY if the KSP was previously set from options
Collective on KSP
Input Parameter:
. ksp - the KSP context
Level: beginner
.keywords: KSP, linear, set, options, database
.seealso: KSPSetFromOptions(), KSPSetOptionsPrefix()
@*/
PetscErrorCode KSPResetFromOptions(KSP ksp)
{
PetscErrorCode ierr;
PetscFunctionBegin;
if (ksp->setfromoptionscalled) {ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr);}
PetscFunctionReturn(0);
}
static PetscErrorCode PCSetFromOptions_Redistribute(PC pc)
{
PetscErrorCode ierr;
PC_Redistribute *red = (PC_Redistribute*)pc->data;
PetscFunctionBegin;
ierr = KSPSetFromOptions(red->ksp);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode MatSetFromOptions_SchurComplement(Mat N)
{
Mat_SchurComplement *Na = (Mat_SchurComplement*)N->data;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = KSPSetFromOptions(Na->ksp);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
KSP ksp;
PetscReal norm;
DM da;
Vec x,b,r;
Mat A;
PetscInitialize(&argc,&argv,(char *)0,help);
ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);
CHKERRQ(ierr);
ierr = DMDACreate3d(PETSC_COMM_WORLD,DMDA_BOUNDARY_NONE,DMDA_BOUNDARY_NONE,DMDA_BOUNDARY_NONE,DMDA_STENCIL_STAR,-7,-7,-7,PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE,1,1,0,0,0,&da);
CHKERRQ(ierr);
ierr = DMSetInitialGuess(da,ComputeInitialGuess);
CHKERRQ(ierr);
ierr = KSPSetComputeRHS(ksp,ComputeRHS,PETSC_NULL);
CHKERRQ(ierr);
ierr = KSPSetComputeOperators(ksp,ComputeMatrix,PETSC_NULL);
CHKERRQ(ierr);
ierr = KSPSetDM(ksp,da);
CHKERRQ(ierr);
ierr = DMDestroy(&da);
CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksp);
CHKERRQ(ierr);
ierr = KSPSolve(ksp,PETSC_NULL,PETSC_NULL);
CHKERRQ(ierr);
ierr = KSPGetSolution(ksp,&x);
CHKERRQ(ierr);
ierr = KSPGetRhs(ksp,&b);
CHKERRQ(ierr);
ierr = VecDuplicate(b,&r);
CHKERRQ(ierr);
ierr = KSPGetOperators(ksp,&A,PETSC_NULL,PETSC_NULL);
CHKERRQ(ierr);
ierr = MatMult(A,x,r);
CHKERRQ(ierr);
ierr = VecAXPY(r,-1.0,b);
CHKERRQ(ierr);
ierr = VecNorm(r,NORM_2,&norm);
CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Residual norm %G\n",norm);
CHKERRQ(ierr);
ierr = VecDestroy(&r);
CHKERRQ(ierr);
ierr = KSPDestroy(&ksp);
CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
PetscErrorCode KSPSetFromOptions_Chebyshev(KSP ksp)
{
KSP_Chebyshev *cheb = (KSP_Chebyshev*)ksp->data;
PetscErrorCode ierr;
PetscInt two = 2,four = 4;
PetscReal tform[4] = {PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE};
PetscBool flg;
PetscFunctionBegin;
ierr = PetscOptionsHead("KSP Chebyshev Options");CHKERRQ(ierr);
ierr = PetscOptionsInt("-ksp_chebyshev_eststeps","Number of est steps in Chebyshev","",cheb->eststeps,&cheb->eststeps,NULL);CHKERRQ(ierr);
ierr = PetscOptionsRealArray("-ksp_chebyshev_eigenvalues","extreme eigenvalues","KSPChebyshevSetEigenvalues",&cheb->emin,&two,0);CHKERRQ(ierr);
ierr = PetscOptionsRealArray("-ksp_chebyshev_estimate_eigenvalues","estimate eigenvalues using a Krylov method, then use this transform for Chebyshev eigenvalue bounds","KSPChebyshevSetEstimateEigenvalues",tform,&four,&flg);CHKERRQ(ierr);
if (flg) {
switch (four) {
case 0:
ierr = KSPChebyshevSetEstimateEigenvalues(ksp,PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE);CHKERRQ(ierr);
break;
case 2: /* Base everything on the max eigenvalues */
ierr = KSPChebyshevSetEstimateEigenvalues(ksp,PETSC_DECIDE,tform[0],PETSC_DECIDE,tform[1]);CHKERRQ(ierr);
break;
case 4: /* Use the full 2x2 linear transformation */
ierr = KSPChebyshevSetEstimateEigenvalues(ksp,tform[0],tform[1],tform[2],tform[3]);CHKERRQ(ierr);
break;
default: SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_ARG_INCOMP,"Must specify either 0, 2, or 4 parameters for eigenvalue estimation");
}
}
if (cheb->kspest) {
PetscBool estrand = PETSC_FALSE;
ierr = PetscOptionsBool("-ksp_chebyshev_estimate_eigenvalues_random","Use Random right hand side for eigenvalue estimation","KSPChebyshevEstEigSetRandom",estrand,&estrand,NULL);CHKERRQ(ierr);
if (estrand) {
PetscRandom random;
ierr = PetscRandomCreate(PetscObjectComm((PetscObject)ksp),&random);CHKERRQ(ierr);
ierr = PetscObjectSetOptionsPrefix((PetscObject)random,((PetscObject)ksp)->prefix);CHKERRQ(ierr);
ierr = PetscObjectAppendOptionsPrefix((PetscObject)random,"ksp_chebyshev_estimate_eigenvalues_");CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(random);CHKERRQ(ierr);
ierr = KSPChebyshevEstEigSetRandom(ksp,random);CHKERRQ(ierr);
ierr = PetscRandomDestroy(&random);CHKERRQ(ierr);
}
}
if (cheb->kspest) {
/* Mask the PC so that PCSetFromOptions does not do anything */
ierr = KSPSetPC(cheb->kspest,cheb->pcnone);CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix(cheb->kspest,((PetscObject)ksp)->prefix);CHKERRQ(ierr);
ierr = KSPAppendOptionsPrefix(cheb->kspest,"est_");CHKERRQ(ierr);
if (!((PetscObject)cheb->kspest)->type_name) {
ierr = KSPSetType(cheb->kspest,KSPGMRES);CHKERRQ(ierr);
}
ierr = KSPSetFromOptions(cheb->kspest);CHKERRQ(ierr);
ierr = KSPSetPC(cheb->kspest,ksp->pc);CHKERRQ(ierr);
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode RunTest(void)
{
PetscInt N = 100;
PetscBool draw = PETSC_FALSE;
PetscReal rnorm;
Mat A;
Vec b,x,r;
KSP ksp;
PC pc;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscOptionsGetInt(0,"-N",&N,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(0,"-draw",&draw,NULL);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatSetSizes(A,PETSC_DECIDE,PETSC_DECIDE,N,N);CHKERRQ(ierr);
ierr = MatSetType(A,MATPYTHON);CHKERRQ(ierr);
ierr = MatPythonSetType(A,"example1.py:Laplace1D");CHKERRQ(ierr);
ierr = MatSetUp(A);CHKERRQ(ierr);
ierr = MatGetVecs(A,&x,&b);CHKERRQ(ierr);
ierr = VecSet(b,1);CHKERRQ(ierr);
ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);CHKERRQ(ierr);
ierr = KSPSetType(ksp,KSPPYTHON);CHKERRQ(ierr);
ierr = KSPPythonSetType(ksp,"example1.py:ConjGrad");CHKERRQ(ierr);
ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr);
ierr = PCSetType(pc,PCPYTHON);CHKERRQ(ierr);
ierr = PCPythonSetType(pc,"example1.py:Jacobi");CHKERRQ(ierr);
ierr = KSPSetOperators(ksp,A,A);CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr);
ierr = KSPSolve(ksp,b,x);CHKERRQ(ierr);
ierr = VecDuplicate(b,&r);CHKERRQ(ierr);
ierr = MatMult(A,x,r);CHKERRQ(ierr);
ierr = VecAYPX(r,-1,b);CHKERRQ(ierr);
ierr = VecNorm(r,NORM_2,&rnorm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"error norm = %g\n",rnorm);CHKERRQ(ierr);
if (draw) {
ierr = VecView(x,PETSC_VIEWER_DRAW_WORLD);CHKERRQ(ierr);
ierr = PetscSleep(2);CHKERRQ(ierr);
}
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&b);CHKERRQ(ierr);
ierr = VecDestroy(&r);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = KSPDestroy(&ksp);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
void _Stokes_SLE_UzawaSolver_SolverSetup( void* solver, void* stokesSLE ) {
Stokes_SLE_UzawaSolver* self = (Stokes_SLE_UzawaSolver*) solver;
Stokes_SLE* sle = (Stokes_SLE*) stokesSLE;
Journal_DPrintf( self->debug, "In %s:\n", __func__ );
Stream_IndentBranch( StgFEM_Debug );
Journal_DPrintfL( self->debug, 1, "Setting up MatrixSolver for the velocity eqn.\n" );
Stg_KSPSetOperators( self->velSolver, sle->kStiffMat->matrix, sle->kStiffMat->matrix, DIFFERENT_NONZERO_PATTERN );
KSPSetFromOptions( self->velSolver );
if( self->pcSolver ) {
Journal_DPrintfL( self->debug, 1, "Setting up MatrixSolver for the Preconditioner.\n" );
Stg_KSPSetOperators( self->pcSolver, self->preconditioner->matrix, self->preconditioner->matrix, DIFFERENT_NONZERO_PATTERN );
KSPSetFromOptions( self->pcSolver );
}
Stream_UnIndentBranch( StgFEM_Debug );
}
// --- Protected methods
void FETI_Operations::set_inverse_precond_solver()
{
homemade_assert_msg(m_bC_RR_MatrixSet,"Preconditioner matrix not set yet!");
KSPCreate(m_comm.get(), &m_coupling_precond_solver);
KSPSetOperators(m_coupling_precond_solver, m_C_RR, m_C_RR);
KSPSetFromOptions(m_coupling_precond_solver);
m_bCreatedPrecondSolver = true;
}
/* ---------------------------------------------------------- */
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "TaoCreate_ASILS"
PetscErrorCode TaoCreate_ASILS(Tao tao)
{
TAO_SSLS *asls;
PetscErrorCode ierr;
const char *armijo_type = TAOLINESEARCHARMIJO;
PetscFunctionBegin;
ierr = PetscNewLog(tao,&asls);CHKERRQ(ierr);
tao->data = (void*)asls;
tao->ops->solve = TaoSolve_ASILS;
tao->ops->setup = TaoSetUp_ASILS;
tao->ops->view = TaoView_SSLS;
tao->ops->setfromoptions = TaoSetFromOptions_SSLS;
tao->ops->destroy = TaoDestroy_ASILS;
tao->subset_type = TAO_SUBSET_SUBVEC;
asls->delta = 1e-10;
asls->rho = 2.1;
asls->fixed = NULL;
asls->free = NULL;
asls->J_sub = NULL;
asls->Jpre_sub = NULL;
asls->w = NULL;
asls->r1 = NULL;
asls->r2 = NULL;
asls->r3 = NULL;
asls->t1 = NULL;
asls->t2 = NULL;
asls->dxfree = NULL;
asls->identifier = 1e-5;
ierr = TaoLineSearchCreate(((PetscObject)tao)->comm, &tao->linesearch);CHKERRQ(ierr);
ierr = TaoLineSearchSetType(tao->linesearch, armijo_type);CHKERRQ(ierr);
ierr = TaoLineSearchSetFromOptions(tao->linesearch);CHKERRQ(ierr);
ierr = KSPCreate(((PetscObject)tao)->comm, &tao->ksp);CHKERRQ(ierr);
ierr = KSPSetFromOptions(tao->ksp);CHKERRQ(ierr);
tao->max_it = 2000;
tao->max_funcs = 4000;
tao->fatol = 0;
tao->frtol = 0;
tao->gttol = 0;
tao->grtol = 0;
#if defined(PETSC_USE_REAL_SINGLE)
tao->gatol = 1.0e-6;
tao->fmin = 1.0e-4;
#else
tao->gatol = 1.0e-16;
tao->fmin = 1.0e-8;
#endif
PetscFunctionReturn(0);
}
static PetscErrorCode KSPSetFromOptions_Chebyshev(PetscOptions *PetscOptionsObject,KSP ksp)
{
KSP_Chebyshev *cheb = (KSP_Chebyshev*)ksp->data;
PetscErrorCode ierr;
PetscInt neigarg = 2, nestarg = 4;
PetscReal eminmax[2] = {0., 0.};
PetscReal tform[4] = {PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE};
PetscBool flgeig, flgest;
PetscFunctionBegin;
ierr = PetscOptionsHead(PetscOptionsObject,"KSP Chebyshev Options");CHKERRQ(ierr);
ierr = PetscOptionsInt("-ksp_chebyshev_esteig_steps","Number of est steps in Chebyshev","",cheb->eststeps,&cheb->eststeps,NULL);CHKERRQ(ierr);
ierr = PetscOptionsRealArray("-ksp_chebyshev_eigenvalues","extreme eigenvalues","KSPChebyshevSetEigenvalues",eminmax,&neigarg,&flgeig);CHKERRQ(ierr);
if (flgeig) {
if (neigarg != 2) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_ARG_INCOMP,"-ksp_chebyshev_eigenvalues: must specify 2 parameters, min and max eigenvalues");
ierr = KSPChebyshevSetEigenvalues(ksp, eminmax[1], eminmax[0]);CHKERRQ(ierr);
}
ierr = PetscOptionsRealArray("-ksp_chebyshev_esteig","estimate eigenvalues using a Krylov method, then use this transform for Chebyshev eigenvalue bounds","KSPChebyshevEstEigSet",tform,&nestarg,&flgest);CHKERRQ(ierr);
if (flgest) {
switch (nestarg) {
case 0:
ierr = KSPChebyshevEstEigSet(ksp,PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE);CHKERRQ(ierr);
break;
case 2: /* Base everything on the max eigenvalues */
ierr = KSPChebyshevEstEigSet(ksp,PETSC_DECIDE,tform[0],PETSC_DECIDE,tform[1]);CHKERRQ(ierr);
break;
case 4: /* Use the full 2x2 linear transformation */
ierr = KSPChebyshevEstEigSet(ksp,tform[0],tform[1],tform[2],tform[3]);CHKERRQ(ierr);
break;
default: SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_ARG_INCOMP,"Must specify either 0, 2, or 4 parameters for eigenvalue estimation");
}
}
/* We need to estimate eigenvalues; need to set this here so that KSPSetFromOptions() is called on the estimator */
if ((cheb->emin == 0. || cheb->emax == 0.) && !cheb->kspest) {
ierr = KSPChebyshevEstEigSet(ksp,PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE);CHKERRQ(ierr);
}
if (cheb->kspest) {
ierr = PetscOptionsBool("-ksp_chebyshev_esteig_random","Use random right hand side for estimate","KSPChebyshevEstEigSetUseRandom",cheb->userandom,&cheb->userandom,NULL);CHKERRQ(ierr);
if (cheb->userandom) {
const char *ksppre;
if (!cheb->random) {
ierr = PetscRandomCreate(PetscObjectComm((PetscObject)ksp),&cheb->random);CHKERRQ(ierr);
}
ierr = KSPGetOptionsPrefix(cheb->kspest, &ksppre);CHKERRQ(ierr);
ierr = PetscObjectSetOptionsPrefix((PetscObject)cheb->random,ksppre);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(cheb->random);CHKERRQ(ierr);
}
ierr = KSPSetFromOptions(cheb->kspest);CHKERRQ(ierr);
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
