static PetscErrorCode TSStage_EIMEX(TS ts,PetscInt istage)
{
TS_EIMEX *ext = (TS_EIMEX*)ts->data;
PetscReal h;
Vec Y=ext->Y, Z=ext->Z;
SNES snes;
TSAdapt adapt;
PetscInt i,its,lits;
PetscBool accept;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr);
h = ts->time_step/ext->N[istage];/* step size for the istage-th stage */
ext->shift = 1./h;
ierr = SNESSetLagJacobian(snes,-2);CHKERRQ(ierr); /* Recompute the Jacobian on this solve, but not again */
ierr = VecCopy(ext->VecSolPrev,Y);CHKERRQ(ierr); /* Take the previous solution as intial step */
for(i=0; i<ext->N[istage]; i++){
ext->ctime = ts->ptime + h*i;
ierr = VecCopy(Y,Z);CHKERRQ(ierr);/* Save the solution of the previous substep */
ierr = SNESSolve(snes,NULL,Y);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
ierr = SNESGetLinearSolveIterations(snes,&lits);CHKERRQ(ierr);
ts->snes_its += its; ts->ksp_its += lits;
ierr = TSGetAdapt(ts,&adapt);CHKERRQ(ierr);
ierr = TSAdaptCheckStage(adapt,ts,ext->ctime,Y,&accept);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/*
PostSetSubKSP - Optional user-defined routine that reset SubKSP options when hierarchical bjacobi PC is used
e.g,
mpiexec -n 8 ./ex3 -nox -n 10000 -ksp_type fgmres -pc_type bjacobi -pc_bjacobi_blocks 4 -sub_ksp_type gmres -sub_ksp_max_it 3 -post_setsubksp -sub_ksp_rtol 1.e-16
Set by SNESLineSearchSetPostCheck().
Input Parameters:
linesearch - the LineSearch context
xcurrent - current solution
y - search direction and length
x - the new candidate iterate
Output Parameters:
y - proposed step (search direction and length) (possibly changed)
x - current iterate (possibly modified)
*/
PetscErrorCode PostSetSubKSP(SNESLineSearch linesearch,Vec xcurrent,Vec y,Vec x,PetscBool *changed_y,PetscBool *changed_x, void * ctx)
{
PetscErrorCode ierr;
SetSubKSPCtx *check;
PetscInt iter,its,sub_its,maxit;
KSP ksp,sub_ksp,*sub_ksps;
PC pc;
PetscReal ksp_ratio;
SNES snes;
PetscFunctionBeginUser;
ierr = SNESLineSearchGetSNES(linesearch, &snes);CHKERRQ(ierr);
check = (SetSubKSPCtx*)ctx;
ierr = SNESGetIterationNumber(snes,&iter);CHKERRQ(ierr);
ierr = SNESGetKSP(snes,&ksp);CHKERRQ(ierr);
ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr);
ierr = PCBJacobiGetSubKSP(pc,NULL,NULL,&sub_ksps);CHKERRQ(ierr);
sub_ksp = sub_ksps[0];
ierr = KSPGetIterationNumber(ksp,&its);CHKERRQ(ierr); /* outer KSP iteration number */
ierr = KSPGetIterationNumber(sub_ksp,&sub_its);CHKERRQ(ierr); /* inner KSP iteration number */
if (iter) {
ierr = PetscPrintf(PETSC_COMM_WORLD," ...PostCheck snes iteration %D, ksp_it %d %d, subksp_it %d\n",iter,check->its0,its,sub_its);CHKERRQ(ierr);
ksp_ratio = ((PetscReal)(its))/check->its0;
maxit = (PetscInt)(ksp_ratio*sub_its + 0.5);
if (maxit < 2) maxit = 2;
ierr = KSPSetTolerances(sub_ksp,PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT,maxit);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," ...ksp_ratio %g, new maxit %d\n\n",ksp_ratio,maxit);CHKERRQ(ierr);
}
check->its0 = its; /* save current outer KSP iteration number */
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
SNES snes;
PetscErrorCode ierr;
PetscInt its,lits;
PetscReal litspit;
DM da;
PetscInitialize(&argc,&argv,PETSC_NULL,help);
/*
Set the DMDA (grid structure) for the grids.
*/
ierr = DMDACreate2d(PETSC_COMM_WORLD, DMDA_BOUNDARY_NONE, DMDA_BOUNDARY_NONE,DMDA_STENCIL_STAR,-5,-5,PETSC_DECIDE,PETSC_DECIDE,1,1,0,0,&da);CHKERRQ(ierr);
ierr = DMDASNESSetFunctionLocal(da,INSERT_VALUES,(PetscErrorCode (*)(DMDALocalInfo*,void*,void*,void*))FormFunctionLocal,PETSC_NULL);CHKERRQ(ierr);
ierr = SNESCreate(PETSC_COMM_WORLD,&snes);CHKERRQ(ierr);
ierr = SNESSetDM(snes,da);CHKERRQ(ierr);
ierr = DMDestroy(&da);CHKERRQ(ierr);
ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);
ierr = SNESSolve(snes,0,0);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
ierr = SNESGetLinearSolveIterations(snes,&lits);CHKERRQ(ierr);
litspit = ((PetscReal)lits)/((PetscReal)its);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Number of SNES iterations = %D\n",its);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Number of Linear iterations = %D\n",lits);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Average Linear its / SNES = %e\n",litspit);CHKERRQ(ierr);
ierr = SNESDestroy(&snes);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
// -------------------------------------------------------------
// PetscNonlinearSolverImplementation::p_solve
// -------------------------------------------------------------
void
PetscNonlinearSolverImplementation::p_solve(void)
{
PetscErrorCode ierr(0);
p_petsc_X = PETScVector(*p_X);
int me(this->processor_rank());
try {
ierr = SNESSolve(p_snes, NULL, *p_petsc_X); CHKERRXX(ierr);
SNESConvergedReason reason;
PetscInt iter;
ierr = SNESGetConvergedReason(p_snes, &reason); CHKERRXX(ierr);
ierr = SNESGetIterationNumber(p_snes, &iter); CHKERRXX(ierr);
std::string msg;
if (reason < 0) {
msg =
boost::str(boost::format("%d: PETSc SNES diverged after %d iterations, reason: %d") %
me % iter % reason);
throw Exception(msg);
} else if (me == 0) {
msg =
boost::str(boost::format("%d: PETSc SNES converged after %d iterations, reason: %d") %
me % iter % reason);
std::cerr << msg << std::endl;
}
} catch (const PETSC_EXCEPTION_TYPE& e) {
throw PETScException(ierr, e);
} catch (const Exception& e) {
throw e;
}
}
int main(int argc,char **argv)
{
DMMG *dmmg; /* multilevel grid structure */
AppCtx user; /* user-defined work context */
PetscInt mx,my,its;
PetscErrorCode ierr;
MPI_Comm comm;
SNES snes;
DA da2;
PetscInitialize(&argc,&argv,(char *)0,help);
comm = PETSC_COMM_WORLD;
/* Problem parameters (velocity of lid, prandtl, and grashof numbers) */
ierr = PetscOptionsGetReal(PETSC_NULL,"-lidvelocity",&user.lidvelocity,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(PETSC_NULL,"-prandtl",&user.prandtl,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(PETSC_NULL,"-grashof",&user.grashof,PETSC_NULL);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create user context, set problem data, create vector data structures.
Also, compute the initial guess.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Setup Physics 2:
- Lap(T) + PR*Div([U*T,V*T]) = 0
where U and V are given by the given x.u and x.v
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = DACreate2d(comm,DA_NONPERIODIC,DA_STENCIL_STAR,-4,-4,PETSC_DECIDE,PETSC_DECIDE,1,1,0,0,&da2);CHKERRQ(ierr);
ierr = DASetFieldName(da2,0,"temperature");CHKERRQ(ierr);
/* Create the solver object and attach the grid/physics info */
ierr = DMMGCreate(comm,1,&user,&dmmg);CHKERRQ(ierr);
ierr = DMMGSetDM(dmmg,(DM)da2);CHKERRQ(ierr);
ierr = DMMGSetISColoringType(dmmg,IS_COLORING_GLOBAL);CHKERRQ(ierr);
ierr = DMMGSetInitialGuess(dmmg,FormInitialGuess);CHKERRQ(ierr);
ierr = DMMGSetSNES(dmmg,FormFunction,0);CHKERRQ(ierr);
ierr = DMMGSetFromOptions(dmmg);CHKERRQ(ierr);
ierr = DAGetInfo(da2,PETSC_NULL,&mx,&my,0,0,0,0,0,0,0,0);CHKERRQ(ierr);
user.lidvelocity = 1.0/(mx*my);
user.prandtl = 1.0;
user.grashof = 1.0;
/* Solve the nonlinear system */
ierr = DMMGSolve(dmmg);CHKERRQ(ierr);
snes = DMMGGetSNES(dmmg);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"Physics 2: Number of Newton iterations = %D\n\n", its);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Free spaces
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = DADestroy(da2);CHKERRQ(ierr);
ierr = DMMGDestroy(dmmg);CHKERRQ(ierr);
ierr = PetscFinalize();CHKERRQ(ierr);
return 0;
}
std::pair<unsigned int, Real>
PetscDMNonlinearSolver<T>::solve (SparseMatrix<T>& jac_in, // System Jacobian Matrix
NumericVector<T>& x_in, // Solution vector
NumericVector<T>& r_in, // Residual vector
const double, // Stopping tolerance
const unsigned int)
{
START_LOG("solve()", "PetscNonlinearSolver");
this->init ();
// Make sure the data passed in are really of Petsc types
libmesh_cast_ptr<PetscMatrix<T>*>(&jac_in);
libmesh_cast_ptr<PetscVector<T>*>(&r_in);
// Extract solution vector
PetscVector<T>* x = libmesh_cast_ptr<PetscVector<T>*>(&x_in);
int ierr=0;
int n_iterations =0;
// Should actually be a PetscReal, but I don't know which version of PETSc first introduced PetscReal
Real final_residual_norm=0.;
if (this->user_presolve)
this->user_presolve(this->system());
//Set the preconditioning matrix
if (this->_preconditioner)
this->_preconditioner->set_matrix(jac_in);
ierr = SNESSolve (this->_snes, PETSC_NULL, x->vec());
CHKERRABORT(libMesh::COMM_WORLD,ierr);
ierr = SNESGetIterationNumber(this->_snes,&n_iterations);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
ierr = SNESGetLinearSolveIterations(this->_snes, &this->_n_linear_iterations);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
ierr = SNESGetFunctionNorm(this->_snes,&final_residual_norm);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
// Get and store the reason for convergence
SNESGetConvergedReason(this->_snes, &this->_reason);
//Based on Petsc 2.3.3 documentation all diverged reasons are negative
this->converged = (this->_reason >= 0);
this->clear();
STOP_LOG("solve()", "PetscNonlinearSolver");
// return the # of its. and the final residual norm.
return std::make_pair(n_iterations, final_residual_norm);
}
/*
PostCheck - Optional user-defined routine that checks the validity of
candidate steps of a line search method. Set by SNESLineSearchSetPostCheck().
Input Parameters:
snes - the SNES context
ctx - optional user-defined context for private data for the
monitor routine, as set by SNESLineSearchSetPostCheck()
xcurrent - current solution
y - search direction and length
x - the new candidate iterate
Output Parameters:
y - proposed step (search direction and length) (possibly changed)
x - current iterate (possibly modified)
*/
PetscErrorCode PostCheck(SNESLineSearch linesearch,Vec xcurrent,Vec y,Vec x,PetscBool *changed_y,PetscBool *changed_x, void * ctx)
{
PetscErrorCode ierr;
PetscInt i,iter,xs,xm;
StepCheckCtx *check;
ApplicationCtx *user;
PetscScalar *xa,*xa_last,tmp;
PetscReal rdiff;
DM da;
SNES snes;
PetscFunctionBeginUser;
*changed_x = PETSC_FALSE;
*changed_y = PETSC_FALSE;
ierr = SNESLineSearchGetSNES(linesearch, &snes);CHKERRQ(ierr);
check = (StepCheckCtx*)ctx;
user = check->user;
ierr = SNESGetIterationNumber(snes,&iter);CHKERRQ(ierr);
ierr = SNESLineSearchGetPreCheck(linesearch, NULL, (void**)&check);CHKERRQ(ierr);
/* iteration 1 indicates we are working on the second iteration */
if (iter > 0) {
da = user->da;
ierr = PetscPrintf(PETSC_COMM_WORLD,"Checking candidate step at iteration %D with tolerance %G\n",iter,check->tolerance);CHKERRQ(ierr);
/* Access local array data */
ierr = DMDAVecGetArray(da,check->last_step,&xa_last);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da,x,&xa);CHKERRQ(ierr);
ierr = DMDAGetCorners(da,&xs,NULL,NULL,&xm,NULL,NULL);CHKERRQ(ierr);
/*
If we fail the user-defined check for validity of the candidate iterate,
then modify the iterate as we like. (Note that the particular modification
below is intended simply to demonstrate how to manipulate this data, not
as a meaningful or appropriate choice.)
*/
for (i=xs; i<xs+xm; i++) {
if (!PetscAbsScalar(xa[i])) rdiff = 2*check->tolerance;
else rdiff = PetscAbsScalar((xa[i] - xa_last[i])/xa[i]);
if (rdiff > check->tolerance) {
tmp = xa[i];
xa[i] = .5*(xa[i] + xa_last[i]);
*changed_x = PETSC_TRUE;
ierr = PetscPrintf(PETSC_COMM_WORLD," Altering entry %D: x=%G, x_last=%G, diff=%G, x_new=%G\n",
i,PetscAbsScalar(tmp),PetscAbsScalar(xa_last[i]),rdiff,PetscAbsScalar(xa[i]));CHKERRQ(ierr);
}
}
ierr = DMDAVecRestoreArray(da,check->last_step,&xa_last);CHKERRQ(ierr);
ierr = DMDAVecRestoreArray(da,x,&xa);CHKERRQ(ierr);
}
ierr = VecCopy(x,check->last_step);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode TS_SNESSolve(TS ts,Vec b,Vec x)
{
PetscInt nits,lits;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = SNESSolve(ts->snes,b,x);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(ts->snes,&nits);CHKERRQ(ierr);
ierr = SNESGetLinearSolveIterations(ts->snes,&lits);CHKERRQ(ierr);
ts->snes_its += nits; ts->ksp_its += lits;
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
PetscInt its;
Vec U,FU;
SNES snes;
UserCtx user;
ierr = PetscInitialize(&argc,&argv,(char*)0,help);CHKERRQ(ierr);
/* Create a global vector that includes a single redundant array and two da arrays */
ierr = DMCompositeCreate(PETSC_COMM_WORLD,&user.packer);CHKERRQ(ierr);
ierr = DMRedundantCreate(PETSC_COMM_WORLD,0,1,&user.red1);CHKERRQ(ierr);
ierr = DMCompositeAddDM(user.packer,user.red1);CHKERRQ(ierr);
ierr = DMDACreate1d(PETSC_COMM_WORLD,DM_BOUNDARY_NONE,-5,1,1,NULL,&user.da1);CHKERRQ(ierr);
ierr = DMCompositeAddDM(user.packer,user.da1);CHKERRQ(ierr);
ierr = DMDACreate1d(PETSC_COMM_WORLD,DM_BOUNDARY_NONE,-5,1,1,NULL,&user.da2);CHKERRQ(ierr);
ierr = DMCompositeAddDM(user.packer,user.da2);CHKERRQ(ierr);
ierr = DMCreateGlobalVector(user.packer,&U);CHKERRQ(ierr);
ierr = VecDuplicate(U,&FU);CHKERRQ(ierr);
/* create graphics windows */
ierr = PetscViewerDrawOpen(PETSC_COMM_WORLD,0,"u - state variables",-1,-1,-1,-1,&user.u_viewer);CHKERRQ(ierr);
ierr = PetscViewerDrawOpen(PETSC_COMM_WORLD,0,"lambda - Lagrange multipliers",-1,-1,-1,-1,&user.lambda_viewer);CHKERRQ(ierr);
ierr = PetscViewerDrawOpen(PETSC_COMM_WORLD,0,"fu - derivate w.r.t. state variables",-1,-1,-1,-1,&user.fu_viewer);CHKERRQ(ierr);
ierr = PetscViewerDrawOpen(PETSC_COMM_WORLD,0,"flambda - derivate w.r.t. Lagrange multipliers",-1,-1,-1,-1,&user.flambda_viewer);CHKERRQ(ierr);
/* create nonlinear solver */
ierr = SNESCreate(PETSC_COMM_WORLD,&snes);CHKERRQ(ierr);
ierr = SNESSetFunction(snes,FU,FormFunction,&user);CHKERRQ(ierr);
ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);
ierr = SNESMonitorSet(snes,Monitor,&user,0);CHKERRQ(ierr);
ierr = SNESSolve(snes,NULL,U);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
ierr = SNESDestroy(&snes);CHKERRQ(ierr);
ierr = DMDestroy(&user.red1);CHKERRQ(ierr);
ierr = DMDestroy(&user.da1);CHKERRQ(ierr);
ierr = DMDestroy(&user.da2);CHKERRQ(ierr);
ierr = DMDestroy(&user.packer);CHKERRQ(ierr);
ierr = VecDestroy(&U);CHKERRQ(ierr);
ierr = VecDestroy(&FU);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&user.u_viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&user.lambda_viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&user.fu_viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&user.flambda_viewer);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
/*
Compare the direction of the current and previous step, modify the current step accordingly
*/
PetscErrorCode PreCheckFunction(SNESLineSearch linesearch,Vec X,Vec Y,PetscBool *changed, void *ctx)
{
PetscErrorCode ierr;
PreCheck precheck;
Vec Ylast;
PetscScalar dot;
PetscInt iter;
PetscReal ynorm,ylastnorm,theta,angle_radians;
SNES snes;
PetscFunctionBegin;
ierr = SNESLineSearchGetSNES(linesearch, &snes);CHKERRQ(ierr);
precheck = (PreCheck)ctx;
if (!precheck->Ylast) {ierr = VecDuplicate(Y,&precheck->Ylast);CHKERRQ(ierr);}
Ylast = precheck->Ylast;
ierr = SNESGetIterationNumber(snes,&iter);CHKERRQ(ierr);
if (iter < 1) {
ierr = VecCopy(Y,Ylast);CHKERRQ(ierr);
*changed = PETSC_FALSE;
PetscFunctionReturn(0);
}
ierr = VecDot(Y,Ylast,&dot);CHKERRQ(ierr);
ierr = VecNorm(Y,NORM_2,&ynorm);CHKERRQ(ierr);
ierr = VecNorm(Ylast,NORM_2,&ylastnorm);CHKERRQ(ierr);
/* Compute the angle between the vectors Y and Ylast, clip to keep inside the domain of acos() */
theta = acos((double)PetscClipInterval(PetscAbsScalar(dot) / (ynorm * ylastnorm),-1.0,1.0));
angle_radians = precheck->angle * PETSC_PI / 180.;
if (PetscAbsReal(theta) < angle_radians || PetscAbsReal(theta - PETSC_PI) < angle_radians) {
/* Modify the step Y */
PetscReal alpha,ydiffnorm;
ierr = VecAXPY(Ylast,-1.0,Y);CHKERRQ(ierr);
ierr = VecNorm(Ylast,NORM_2,&ydiffnorm);CHKERRQ(ierr);
alpha = ylastnorm / ydiffnorm;
ierr = VecCopy(Y,Ylast);CHKERRQ(ierr);
ierr = VecScale(Y,alpha);CHKERRQ(ierr);
if (precheck->monitor) {
ierr = PetscViewerASCIIPrintf(precheck->monitor,"Angle %E degrees less than threshold %G, corrected step by alpha=%G\n",theta*180./PETSC_PI,precheck->angle,alpha);CHKERRQ(ierr);
}
} else {
ierr = VecCopy(Y,Ylast);CHKERRQ(ierr);
*changed = PETSC_FALSE;
if (precheck->monitor) {
ierr = PetscViewerASCIIPrintf(precheck->monitor,"Angle %E degrees exceeds threshold %G, no correction applied\n",theta*180./PETSC_PI,precheck->angle);CHKERRQ(ierr);
}
}
PetscFunctionReturn(0);
}
static PetscErrorCode TSStep_Theta(TS ts)
{
TS_Theta *th = (TS_Theta*)ts->data;
PetscInt its,lits;
PetscReal next_time_step;
SNESConvergedReason snesreason;
PetscErrorCode ierr;
PetscFunctionBegin;
next_time_step = ts->time_step;
th->stage_time = ts->ptime + (th->endpoint ? 1. : th->Theta)*ts->time_step;
th->shift = 1./(th->Theta*ts->time_step);
ierr = TSPreStep(ts);CHKERRQ(ierr);
ierr = TSPreStage(ts,th->stage_time);CHKERRQ(ierr);
if (th->endpoint) { /* This formulation assumes linear time-independent mass matrix */
ierr = VecZeroEntries(th->Xdot);CHKERRQ(ierr);
if (!th->affine) {ierr = VecDuplicate(ts->vec_sol,&th->affine);CHKERRQ(ierr);}
ierr = TSComputeIFunction(ts,ts->ptime,ts->vec_sol,th->Xdot,th->affine,PETSC_FALSE);CHKERRQ(ierr);
ierr = VecScale(th->affine,(th->Theta-1.)/th->Theta);CHKERRQ(ierr);
}
if (th->extrapolate) {
ierr = VecWAXPY(th->X,1./th->shift,th->Xdot,ts->vec_sol);CHKERRQ(ierr);
} else {
ierr = VecCopy(ts->vec_sol,th->X);CHKERRQ(ierr);
}
ierr = SNESSolve(ts->snes,th->affine,th->X);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(ts->snes,&its);CHKERRQ(ierr);
ierr = SNESGetLinearSolveIterations(ts->snes,&lits);CHKERRQ(ierr);
ierr = SNESGetConvergedReason(ts->snes,&snesreason);CHKERRQ(ierr);
ts->snes_its += its; ts->ksp_its += lits;
if (snesreason < 0 && ts->max_snes_failures > 0 && ++ts->num_snes_failures >= ts->max_snes_failures) {
ts->reason = TS_DIVERGED_NONLINEAR_SOLVE;
ierr = PetscInfo2(ts,"Step=%D, nonlinear solve solve failures %D greater than current TS allowed, stopping solve\n",ts->steps,ts->num_snes_failures);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
if (th->endpoint) {
ierr = VecCopy(th->X,ts->vec_sol);CHKERRQ(ierr);
} else {
ierr = VecAXPBYPCZ(th->Xdot,-th->shift,th->shift,0,ts->vec_sol,th->X);CHKERRQ(ierr);
ierr = VecAXPY(ts->vec_sol,ts->time_step,th->Xdot);CHKERRQ(ierr);
}
ts->ptime += ts->time_step;
ts->time_step = next_time_step;
ts->steps++;
PetscFunctionReturn(0);
}
static PetscErrorCode TSStep_Pseudo(TS ts)
{
TS_Pseudo *pseudo = (TS_Pseudo*)ts->data;
PetscInt its,lits,reject;
PetscBool stepok;
PetscReal next_time_step;
SNESConvergedReason snesreason = SNES_CONVERGED_ITERATING;
PetscErrorCode ierr;
PetscFunctionBegin;
if (ts->steps == 0) pseudo->dt_initial = ts->time_step;
ierr = VecCopy(ts->vec_sol,pseudo->update);CHKERRQ(ierr);
next_time_step = ts->time_step;
ierr = TSPseudoComputeTimeStep(ts,&next_time_step);CHKERRQ(ierr);
for (reject=0; reject<ts->max_reject; reject++,ts->reject++) {
ts->time_step = next_time_step;
ierr = TSPreStep(ts);CHKERRQ(ierr);
ierr = TSPreStage(ts,ts->ptime+ts->time_step);CHKERRQ(ierr);
ierr = SNESSolve(ts->snes,NULL,pseudo->update);CHKERRQ(ierr);
ierr = SNESGetConvergedReason(ts->snes,&snesreason);CHKERRQ(ierr);
ierr = SNESGetLinearSolveIterations(ts->snes,&lits);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(ts->snes,&its);CHKERRQ(ierr);
ierr = TSPostStage(ts,ts->ptime+ts->time_step,0,&(pseudo->update));CHKERRQ(ierr);
ts->snes_its += its; ts->ksp_its += lits;
ierr = PetscInfo3(ts,"step=%D, nonlinear solve iterations=%D, linear solve iterations=%D\n",ts->steps,its,lits);CHKERRQ(ierr);
pseudo->fnorm = -1; /* The current norm is no longer valid, monitor must recompute it. */
ierr = TSPseudoVerifyTimeStep(ts,pseudo->update,&next_time_step,&stepok);CHKERRQ(ierr);
if (stepok) break;
}
if (snesreason < 0 && ts->max_snes_failures > 0 && ++ts->num_snes_failures >= ts->max_snes_failures) {
ts->reason = TS_DIVERGED_NONLINEAR_SOLVE;
ierr = PetscInfo2(ts,"step=%D, nonlinear solve solve failures %D greater than current TS allowed, stopping solve\n",ts->steps,ts->num_snes_failures);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
if (reject >= ts->max_reject) {
ts->reason = TS_DIVERGED_STEP_REJECTED;
ierr = PetscInfo2(ts,"step=%D, step rejections %D greater than current TS allowed, stopping solve\n",ts->steps,reject);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
ierr = VecCopy(pseudo->update,ts->vec_sol);CHKERRQ(ierr);
ts->ptime += ts->time_step;
ts->time_step = next_time_step;
ts->steps++;
PetscFunctionReturn(0);
}
static PetscErrorCode MonitorObjective(TS ts,PetscInt step,PetscReal t,Vec X,void *ictx)
{
Ctx *ctx = (Ctx*)ictx;
PetscErrorCode ierr;
const PetscScalar *x;
PetscScalar f;
PetscReal dt,gnorm;
PetscInt i,snesit,linit;
SNES snes;
Vec Xdot,F;
PetscFunctionBeginUser;
/* Compute objective functional */
ierr = VecGetArrayRead(X,&x);CHKERRQ(ierr);
f = 0;
for (i=0; i<ctx->n-1; i++) {
f += PetscSqr(1. - x[i]) + 100. * PetscSqr(x[i+1] - PetscSqr(x[i]));
}
ierr = VecRestoreArrayRead(X,&x);CHKERRQ(ierr);
/* Compute norm of gradient */
ierr = VecDuplicate(X,&Xdot);CHKERRQ(ierr);
ierr = VecDuplicate(X,&F);CHKERRQ(ierr);
ierr = VecZeroEntries(Xdot);CHKERRQ(ierr);
ierr = FormIFunction(ts,t,X,Xdot,F,ictx);CHKERRQ(ierr);
ierr = VecNorm(F,NORM_2,&gnorm);CHKERRQ(ierr);
ierr = VecDestroy(&Xdot);CHKERRQ(ierr);
ierr = VecDestroy(&F);CHKERRQ(ierr);
ierr = TSGetTimeStep(ts,&dt);CHKERRQ(ierr);
ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(snes,&snesit);CHKERRQ(ierr);
ierr = SNESGetLinearSolveIterations(snes,&linit);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,
(ctx->monitor_short
? "%3D t=%10.1e dt=%10.1e f=%10.1e df=%10.1e it=(%2D,%3D)\n"
: "%3D t=%10.4e dt=%10.4e f=%10.4e df=%10.4e it=(%2D,%3D)\n"),
step,(double)t,(double)dt,(double)PetscRealPart(f),(double)gnorm,snesit,linit);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
//---------------------------------------------------------------
// this function is called by PETSc to evaluate the residual at X
PetscErrorCode
__libmesh_petsc_snes_residual (SNES snes, Vec x, Vec r, void *ctx)
{
START_LOG("residual()", "PetscNonlinearSolver");
PetscErrorCode ierr=0;
libmesh_assert(x);
libmesh_assert(r);
libmesh_assert(ctx);
PetscNonlinearSolver<Number>* solver =
static_cast<PetscNonlinearSolver<Number>*> (ctx);
// Get the current iteration number from the snes object,
// store it in the PetscNonlinearSolver object for possible use
// by the user's residual function.
{
PetscInt n_iterations = 0;
ierr = SNESGetIterationNumber(snes, &n_iterations);
CHKERRABORT(solver->comm().get(),ierr);
solver->set_current_nonlinear_iteration_number( static_cast<unsigned>(n_iterations) );
}
NonlinearImplicitSystem &sys = solver->system();
PetscVector<Number>& X_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.solution.get());
PetscVector<Number>& R_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.rhs);
PetscVector<Number> X_global(x, sys.comm()), R(r, sys.comm());
// Use the systems update() to get a good local version of the parallel solution
X_global.swap(X_sys);
R.swap(R_sys);
sys.get_dof_map().enforce_constraints_exactly(sys);
sys.update();
//Swap back
X_global.swap(X_sys);
R.swap(R_sys);
R.zero();
//-----------------------------------------------------------------------------
// if the user has provided both function pointers and objects only the pointer
// will be used, so catch that as an error
if (solver->residual && solver->residual_object)
{
libMesh::err << "ERROR: cannot specifiy both a function and object to compute the Residual!" << std::endl;
libmesh_error();
}
if (solver->matvec && solver->residual_and_jacobian_object)
{
libMesh::err << "ERROR: cannot specifiy both a function and object to compute the combined Residual & Jacobian!" << std::endl;
libmesh_error();
}
//-----------------------------------------------------------------------------
if (solver->residual != NULL) solver->residual (*sys.current_local_solution.get(), R, sys);
else if (solver->residual_object != NULL) solver->residual_object->residual (*sys.current_local_solution.get(), R, sys);
else if (solver->matvec != NULL) solver->matvec (*sys.current_local_solution.get(), &R, NULL, sys);
else if (solver->residual_and_jacobian_object != NULL) solver->residual_and_jacobian_object->residual_and_jacobian (*sys.current_local_solution.get(), &R, NULL, sys);
else libmesh_error();
R.close();
X_global.close();
STOP_LOG("residual()", "PetscNonlinearSolver");
return ierr;
}
std::pair<unsigned int, Real>
PetscNonlinearSolver<T>::solve (SparseMatrix<T>& jac_in, // System Jacobian Matrix
NumericVector<T>& x_in, // Solution vector
NumericVector<T>& r_in, // Residual vector
const double, // Stopping tolerance
const unsigned int)
{
START_LOG("solve()", "PetscNonlinearSolver");
this->init ();
// Make sure the data passed in are really of Petsc types
PetscMatrix<T>* jac = libmesh_cast_ptr<PetscMatrix<T>*>(&jac_in);
PetscVector<T>* x = libmesh_cast_ptr<PetscVector<T>*>(&x_in);
PetscVector<T>* r = libmesh_cast_ptr<PetscVector<T>*>(&r_in);
PetscErrorCode ierr=0;
PetscInt n_iterations =0;
// Should actually be a PetscReal, but I don't know which version of PETSc first introduced PetscReal
Real final_residual_norm=0.;
ierr = SNESSetFunction (_snes, r->vec(), __libmesh_petsc_snes_residual, this);
LIBMESH_CHKERRABORT(ierr);
// Only set the jacobian function if we've been provided with something to call.
// This allows a user to set their own jacobian function if they want to
if (this->jacobian || this->jacobian_object || this->residual_and_jacobian_object)
{
ierr = SNESSetJacobian (_snes, jac->mat(), jac->mat(), __libmesh_petsc_snes_jacobian, this);
LIBMESH_CHKERRABORT(ierr);
}
#if !PETSC_VERSION_LESS_THAN(3,3,0)
// Only set the nullspace if we have a way of computing it and the result is non-empty.
if (this->nullspace || this->nullspace_object)
{
MatNullSpace msp;
this->build_mat_null_space(this->nullspace_object, this->nullspace, &msp);
if (msp)
{
ierr = MatSetNullSpace(jac->mat(), msp);
LIBMESH_CHKERRABORT(ierr);
ierr = MatNullSpaceDestroy(&msp);
LIBMESH_CHKERRABORT(ierr);
}
}
// Only set the nearnullspace if we have a way of computing it and the result is non-empty.
if (this->nearnullspace || this->nearnullspace_object)
{
MatNullSpace msp = PETSC_NULL;
this->build_mat_null_space(this->nearnullspace_object, this->nearnullspace, &msp);
if(msp) {
ierr = MatSetNearNullSpace(jac->mat(), msp);
LIBMESH_CHKERRABORT(ierr);
ierr = MatNullSpaceDestroy(&msp);
LIBMESH_CHKERRABORT(ierr);
}
}
#endif
// Have the Krylov subspace method use our good initial guess rather than 0
KSP ksp;
ierr = SNESGetKSP (_snes, &ksp);
LIBMESH_CHKERRABORT(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);
LIBMESH_CHKERRABORT(ierr);
// Set the tolerances for the non-linear solver.
ierr = SNESSetTolerances(_snes, this->absolute_residual_tolerance, this->relative_residual_tolerance,
this->relative_step_tolerance, this->max_nonlinear_iterations, this->max_function_evaluations);
LIBMESH_CHKERRABORT(ierr);
//Pull in command-line options
KSPSetFromOptions(ksp);
SNESSetFromOptions(_snes);
if (this->user_presolve)
this->user_presolve(this->system());
//Set the preconditioning matrix
if(this->_preconditioner)
{
this->_preconditioner->set_matrix(jac_in);
this->_preconditioner->init();
}
// ierr = KSPSetInitialGuessNonzero (ksp, PETSC_TRUE);
// LIBMESH_CHKERRABORT(ierr);
// Older versions (at least up to 2.1.5) of SNESSolve took 3 arguments,
// the last one being a pointer to an int to hold the number of iterations required.
# if PETSC_VERSION_LESS_THAN(2,2,0)
ierr = SNESSolve (_snes, x->vec(), &n_iterations);
LIBMESH_CHKERRABORT(ierr);
// 2.2.x style
#elif PETSC_VERSION_LESS_THAN(2,3,0)
ierr = SNESSolve (_snes, x->vec());
LIBMESH_CHKERRABORT(ierr);
// 2.3.x & newer style
#else
ierr = SNESSolve (_snes, PETSC_NULL, x->vec());
LIBMESH_CHKERRABORT(ierr);
ierr = SNESGetIterationNumber(_snes,&n_iterations);
LIBMESH_CHKERRABORT(ierr);
ierr = SNESGetLinearSolveIterations(_snes, &_n_linear_iterations);
LIBMESH_CHKERRABORT(ierr);
ierr = SNESGetFunctionNorm(_snes,&final_residual_norm);
LIBMESH_CHKERRABORT(ierr);
#endif
// Get and store the reason for convergence
SNESGetConvergedReason(_snes, &_reason);
//Based on Petsc 2.3.3 documentation all diverged reasons are negative
this->converged = (_reason >= 0);
this->clear();
STOP_LOG("solve()", "PetscNonlinearSolver");
// return the # of its. and the final residual norm.
return std::make_pair(n_iterations, final_residual_norm);
}
//---------------------------------------------------------------
// this function is called by PETSc to evaluate the Jacobian at X
PetscErrorCode
__libmesh_petsc_snes_jacobian (SNES snes, Vec x, Mat *jac, Mat *pc, MatStructure *msflag, void *ctx)
{
START_LOG("jacobian()", "PetscNonlinearSolver");
PetscErrorCode ierr=0;
libmesh_assert(ctx);
PetscNonlinearSolver<Number>* solver =
static_cast<PetscNonlinearSolver<Number>*> (ctx);
// Get the current iteration number from the snes object,
// store it in the PetscNonlinearSolver object for possible use
// by the user's Jacobian function.
{
PetscInt n_iterations = 0;
ierr = SNESGetIterationNumber(snes, &n_iterations);
CHKERRABORT(solver->comm().get(),ierr);
solver->set_current_nonlinear_iteration_number( static_cast<unsigned>(n_iterations) );
}
NonlinearImplicitSystem &sys = solver->system();
PetscMatrix<Number> PC(*pc, sys.comm());
PetscMatrix<Number> Jac(*jac, sys.comm());
PetscVector<Number>& X_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.solution.get());
PetscMatrix<Number>& Jac_sys = *libmesh_cast_ptr<PetscMatrix<Number>*>(sys.matrix);
PetscVector<Number> X_global(x, sys.comm());
// Set the dof maps
PC.attach_dof_map(sys.get_dof_map());
Jac.attach_dof_map(sys.get_dof_map());
// Use the systems update() to get a good local version of the parallel solution
X_global.swap(X_sys);
Jac.swap(Jac_sys);
sys.get_dof_map().enforce_constraints_exactly(sys);
sys.update();
X_global.swap(X_sys);
Jac.swap(Jac_sys);
PC.zero();
//-----------------------------------------------------------------------------
// if the user has provided both function pointers and objects only the pointer
// will be used, so catch that as an error
if (solver->jacobian && solver->jacobian_object)
{
libMesh::err << "ERROR: cannot specifiy both a function and object to compute the Jacobian!" << std::endl;
libmesh_error();
}
if (solver->matvec && solver->residual_and_jacobian_object)
{
libMesh::err << "ERROR: cannot specifiy both a function and object to compute the combined Residual & Jacobian!" << std::endl;
libmesh_error();
}
//-----------------------------------------------------------------------------
if (solver->jacobian != NULL) solver->jacobian (*sys.current_local_solution.get(), PC, sys);
else if (solver->jacobian_object != NULL) solver->jacobian_object->jacobian (*sys.current_local_solution.get(), PC, sys);
else if (solver->matvec != NULL) solver->matvec (*sys.current_local_solution.get(), NULL, &PC, sys);
else if (solver->residual_and_jacobian_object != NULL) solver->residual_and_jacobian_object->residual_and_jacobian (*sys.current_local_solution.get(), NULL, &PC, sys);
else libmesh_error();
PC.close();
Jac.close();
X_global.close();
*msflag = SAME_NONZERO_PATTERN;
STOP_LOG("jacobian()", "PetscNonlinearSolver");
return ierr;
}
int main(int argc, char **argv)
{
SNES snes; /* nonlinear solver */
DM dm; /* problem definition */
Vec u,r; /* solution, residual vectors */
Mat A,J; /* Jacobian matrix */
MatNullSpace nullSpace; /* May be necessary for pressure */
AppCtx user; /* user-defined work context */
JacActionCtx userJ; /* context for Jacobian MF action */
PetscInt its; /* iterations for convergence */
PetscReal error = 0.0; /* L_2 error in the solution */
PetscInt numComponents = 0, f;
PetscErrorCode ierr;
ierr = PetscInitialize(&argc, &argv, NULL, help);CHKERRQ(ierr);
ierr = ProcessOptions(PETSC_COMM_WORLD, &user);CHKERRQ(ierr);
ierr = SNESCreate(PETSC_COMM_WORLD, &snes);CHKERRQ(ierr);
ierr = CreateMesh(PETSC_COMM_WORLD, &user, &dm);CHKERRQ(ierr);
ierr = SNESSetDM(snes, dm);CHKERRQ(ierr);
ierr = SetupElement(dm, &user);CHKERRQ(ierr);
for (f = 0; f < NUM_FIELDS; ++f) {
PetscInt numComp;
ierr = PetscFEGetNumComponents(user.fe[f], &numComp);CHKERRQ(ierr);
numComponents += numComp;
}
ierr = PetscMalloc(NUM_FIELDS * sizeof(void (*)(const PetscReal[], PetscScalar *)), &user.exactFuncs);CHKERRQ(ierr);
user.fem.bcFuncs = (void (**)(const PetscReal[], PetscScalar *)) user.exactFuncs;
ierr = SetupExactSolution(dm, &user);CHKERRQ(ierr);
ierr = SetupSection(dm, &user);CHKERRQ(ierr);
ierr = DMPlexCreateClosureIndex(dm, NULL);CHKERRQ(ierr);
ierr = DMCreateGlobalVector(dm, &u);CHKERRQ(ierr);
ierr = VecDuplicate(u, &r);CHKERRQ(ierr);
ierr = DMSetMatType(dm,MATAIJ);CHKERRQ(ierr);
ierr = DMCreateMatrix(dm, &J);CHKERRQ(ierr);
if (user.jacobianMF) {
PetscInt M, m, N, n;
ierr = MatGetSize(J, &M, &N);CHKERRQ(ierr);
ierr = MatGetLocalSize(J, &m, &n);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD, &A);CHKERRQ(ierr);
ierr = MatSetSizes(A, m, n, M, N);CHKERRQ(ierr);
ierr = MatSetType(A, MATSHELL);CHKERRQ(ierr);
ierr = MatSetUp(A);CHKERRQ(ierr);
ierr = MatShellSetOperation(A, MATOP_MULT, (void (*)(void))FormJacobianAction);CHKERRQ(ierr);
userJ.dm = dm;
userJ.J = J;
userJ.user = &user;
ierr = DMCreateLocalVector(dm, &userJ.u);CHKERRQ(ierr);
ierr = DMPlexProjectFunctionLocal(dm, user.fe, user.exactFuncs, INSERT_BC_VALUES, userJ.u);CHKERRQ(ierr);
ierr = MatShellSetContext(A, &userJ);CHKERRQ(ierr);
} else {
A = J;
}
ierr = CreatePressureNullSpace(dm, &user, &nullSpace);CHKERRQ(ierr);
ierr = MatSetNullSpace(J, nullSpace);CHKERRQ(ierr);
if (A != J) {
ierr = MatSetNullSpace(A, nullSpace);CHKERRQ(ierr);
}
ierr = DMSNESSetFunctionLocal(dm, (PetscErrorCode (*)(DM,Vec,Vec,void*))DMPlexComputeResidualFEM,&user);CHKERRQ(ierr);
ierr = DMSNESSetJacobianLocal(dm, (PetscErrorCode (*)(DM,Vec,Mat,Mat,MatStructure*,void*))DMPlexComputeJacobianFEM,&user);CHKERRQ(ierr);
ierr = SNESSetJacobian(snes, A, J, NULL, NULL);CHKERRQ(ierr);
ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);
ierr = DMPlexProjectFunction(dm, user.fe, user.exactFuncs, INSERT_ALL_VALUES, u);CHKERRQ(ierr);
if (user.showInitial) {ierr = DMVecViewLocal(dm, u, PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);}
if (user.runType == RUN_FULL) {
ierr = DMPlexProjectFunction(dm, user.fe, user.initialGuess, INSERT_VALUES, u);CHKERRQ(ierr);
if (user.showInitial) {ierr = DMVecViewLocal(dm, u, PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);}
if (user.debug) {
ierr = PetscPrintf(PETSC_COMM_WORLD, "Initial guess\n");CHKERRQ(ierr);
ierr = VecView(u, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
ierr = SNESSolve(snes, NULL, u);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(snes, &its);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "Number of SNES iterations = %D\n", its);CHKERRQ(ierr);
ierr = DMPlexComputeL2Diff(dm, user.fe, user.exactFuncs, u, &error);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "L_2 Error: %.3g\n", error);CHKERRQ(ierr);
if (user.showSolution) {
ierr = PetscPrintf(PETSC_COMM_WORLD, "Solution\n");CHKERRQ(ierr);
ierr = VecChop(u, 3.0e-9);CHKERRQ(ierr);
ierr = VecView(u, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
} else {
PetscReal res = 0.0;
/* Check discretization error */
ierr = PetscPrintf(PETSC_COMM_WORLD, "Initial guess\n");CHKERRQ(ierr);
ierr = VecView(u, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = DMPlexComputeL2Diff(dm, user.fe, user.exactFuncs, u, &error);CHKERRQ(ierr);
if (error >= 1.0e-11) {
ierr = PetscPrintf(PETSC_COMM_WORLD, "L_2 Error: %g\n", error);CHKERRQ(ierr);
} else {
ierr = PetscPrintf(PETSC_COMM_WORLD, "L_2 Error: < 1.0e-11\n", error);CHKERRQ(ierr);
}
/* Check residual */
ierr = SNESComputeFunction(snes, u, r);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "Initial Residual\n");CHKERRQ(ierr);
ierr = VecChop(r, 1.0e-10);CHKERRQ(ierr);
ierr = VecView(r, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = VecNorm(r, NORM_2, &res);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "L_2 Residual: %g\n", res);CHKERRQ(ierr);
/* Check Jacobian */
{
Vec b;
MatStructure flag;
PetscBool isNull;
ierr = SNESComputeJacobian(snes, u, &A, &A, &flag);CHKERRQ(ierr);
ierr = MatNullSpaceTest(nullSpace, J, &isNull);CHKERRQ(ierr);
if (!isNull) SETERRQ(PETSC_COMM_WORLD, PETSC_ERR_PLIB, "The null space calculated for the system operator is invalid.");
ierr = VecDuplicate(u, &b);CHKERRQ(ierr);
ierr = VecSet(r, 0.0);CHKERRQ(ierr);
ierr = SNESComputeFunction(snes, r, b);CHKERRQ(ierr);
ierr = MatMult(A, u, r);CHKERRQ(ierr);
ierr = VecAXPY(r, 1.0, b);CHKERRQ(ierr);
ierr = VecDestroy(&b);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "Au - b = Au + F(0)\n");CHKERRQ(ierr);
ierr = VecChop(r, 1.0e-10);CHKERRQ(ierr);
ierr = VecView(r, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = VecNorm(r, NORM_2, &res);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "Linear L_2 Residual: %g\n", res);CHKERRQ(ierr);
}
}
if (user.runType == RUN_FULL) {
PetscViewer viewer;
Vec uLocal;
const char *name;
ierr = PetscViewerCreate(PETSC_COMM_WORLD, &viewer);CHKERRQ(ierr);
ierr = PetscViewerSetType(viewer, PETSCVIEWERVTK);CHKERRQ(ierr);
ierr = PetscViewerSetFormat(viewer, PETSC_VIEWER_ASCII_VTK);CHKERRQ(ierr);
ierr = PetscViewerFileSetName(viewer, "ex62_sol.vtk");CHKERRQ(ierr);
ierr = DMGetLocalVector(dm, &uLocal);CHKERRQ(ierr);
ierr = PetscObjectGetName((PetscObject) u, &name);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) uLocal, name);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(dm, u, INSERT_VALUES, uLocal);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(dm, u, INSERT_VALUES, uLocal);CHKERRQ(ierr);
ierr = VecView(uLocal, viewer);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(dm, &uLocal);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
}
ierr = PetscFree(user.exactFuncs);CHKERRQ(ierr);
ierr = DestroyElement(&user);CHKERRQ(ierr);
ierr = MatNullSpaceDestroy(&nullSpace);CHKERRQ(ierr);
if (user.jacobianMF) {
ierr = VecDestroy(&userJ.u);CHKERRQ(ierr);
}
if (A != J) {
ierr = MatDestroy(&A);CHKERRQ(ierr);
}
ierr = MatDestroy(&J);CHKERRQ(ierr);
ierr = VecDestroy(&u);CHKERRQ(ierr);
ierr = VecDestroy(&r);CHKERRQ(ierr);
ierr = SNESDestroy(&snes);CHKERRQ(ierr);
ierr = DMDestroy(&dm);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
int main(int argc,char **argv)
{
SNES snes; /* nonlinear solver */
AppCtx user; /* user-defined work context */
PetscInt its; /* iterations for convergence */
PetscErrorCode ierr;
DM da;
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Initialize program
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
PetscInitialize(&argc,&argv,(char *)0,help);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Initialize problem parameters
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = PetscOptionsBegin(PETSC_COMM_WORLD, "", "Surface Process Problem Options", "SNES");CHKERRQ(ierr);
user.D = 1.0;
ierr = PetscOptionsReal("-D", "The diffusion coefficient D", __FILE__, user.D, &user.D, PETSC_NULL);CHKERRQ(ierr);
user.K = 1.0;
ierr = PetscOptionsReal("-K", "The advection coefficient K", __FILE__, user.K, &user.K, PETSC_NULL);CHKERRQ(ierr);
user.m = 1;
ierr = PetscOptionsInt("-m", "The exponent for A", __FILE__, user.m, &user.m, PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnd();CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create distributed array (DMDA) to manage parallel grid and vectors
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = DMDACreate2d(PETSC_COMM_WORLD, DMDA_BOUNDARY_NONE, DMDA_BOUNDARY_NONE,DMDA_STENCIL_STAR,-4,-4,PETSC_DECIDE,PETSC_DECIDE,1,1,PETSC_NULL,PETSC_NULL,&da);CHKERRQ(ierr);
ierr = DMDASetUniformCoordinates(da, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0);CHKERRQ(ierr);
ierr = DMSetApplicationContext(da,&user);CHKERRQ(ierr);
ierr = SNESCreate(PETSC_COMM_WORLD, &snes);CHKERRQ(ierr);
ierr = SNESSetDM(snes, da);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Set local function evaluation routine
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = DMDASetLocalFunction(da, (DMDALocalFunction1) FormFunctionLocal);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Customize solver; set runtime options
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Solve nonlinear system
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = SNESSolve(snes,0,0);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = PetscPrintf(PETSC_COMM_WORLD,"Number of SNES iterations = %D\n",its);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Free work space. All PETSc objects should be destroyed when they
are no longer needed.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = SNESDestroy(&snes);CHKERRQ(ierr);
ierr = DMDestroy(&da);CHKERRQ(ierr);
ierr = PetscFinalize();
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
SNES snes; /* nonlinear solver context */
KSP ksp; /* linear solver context */
PC pc; /* preconditioner context */
Vec x,r; /* solution, residual vectors */
Mat J; /* Jacobian matrix */
PetscErrorCode ierr;
PetscInt its;
PetscMPIInt size,rank;
PetscScalar pfive = .5,*xx;
PetscBool flg;
AppCtx user; /* user-defined work context */
IS isglobal,islocal;
PetscInitialize(&argc,&argv,(char *)0,help);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create nonlinear solver context
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = SNESCreate(PETSC_COMM_WORLD,&snes);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create matrix and vector data structures; set corresponding routines
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Create vectors for solution and nonlinear function
*/
ierr = VecCreate(PETSC_COMM_WORLD,&x);CHKERRQ(ierr);
ierr = VecSetSizes(x,PETSC_DECIDE,2);CHKERRQ(ierr);
ierr = VecSetFromOptions(x);CHKERRQ(ierr);
ierr = VecDuplicate(x,&r);CHKERRQ(ierr);
if (size > 1){
ierr = VecCreateSeq(PETSC_COMM_SELF,2,&user.xloc);CHKERRQ(ierr);
ierr = VecDuplicate(user.xloc,&user.rloc);CHKERRQ(ierr);
/* Create the scatter between the global x and local xloc */
ierr = ISCreateStride(MPI_COMM_SELF,2,0,1,&islocal);CHKERRQ(ierr);
ierr = ISCreateStride(MPI_COMM_SELF,2,0,1,&isglobal);CHKERRQ(ierr);
ierr = VecScatterCreate(x,isglobal,user.xloc,islocal,&user.scatter);CHKERRQ(ierr);
ierr = ISDestroy(&isglobal);CHKERRQ(ierr);
ierr = ISDestroy(&islocal);CHKERRQ(ierr);
}
/*
Create Jacobian matrix data structure
*/
ierr = MatCreate(PETSC_COMM_WORLD,&J);CHKERRQ(ierr);
ierr = MatSetSizes(J,PETSC_DECIDE,PETSC_DECIDE,2,2);CHKERRQ(ierr);
ierr = MatSetFromOptions(J);CHKERRQ(ierr);
ierr = MatSetUp(J);CHKERRQ(ierr);
ierr = PetscOptionsHasName(PETSC_NULL,"-hard",&flg);CHKERRQ(ierr);
if (!flg) {
/*
Set function evaluation routine and vector.
*/
ierr = SNESSetFunction(snes,r,FormFunction1,&user);CHKERRQ(ierr);
/*
Set Jacobian matrix data structure and Jacobian evaluation routine
*/
ierr = SNESSetJacobian(snes,J,J,FormJacobian1,PETSC_NULL);CHKERRQ(ierr);
} else {
if (size != 1) SETERRQ(PETSC_COMM_SELF,1,"This case is a uniprocessor example only!");
ierr = SNESSetFunction(snes,r,FormFunction2,PETSC_NULL);CHKERRQ(ierr);
ierr = SNESSetJacobian(snes,J,J,FormJacobian2,PETSC_NULL);CHKERRQ(ierr);
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Customize nonlinear solver; set runtime options
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Set linear solver defaults for this problem. By extracting the
KSP, KSP, and PC contexts from the SNES context, we can then
directly call any KSP, KSP, and PC routines to set various options.
*/
ierr = SNESGetKSP(snes,&ksp);CHKERRQ(ierr);
ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr);
ierr = PCSetType(pc,PCNONE);CHKERRQ(ierr);
ierr = KSPSetTolerances(ksp,1.e-4,PETSC_DEFAULT,PETSC_DEFAULT,20);CHKERRQ(ierr);
/*
Set SNES/KSP/KSP/PC runtime options, e.g.,
-snes_view -snes_monitor -ksp_type <ksp> -pc_type <pc>
These options will override those specified above as long as
SNESSetFromOptions() is called _after_ any other customization
routines.
*/
ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Evaluate initial guess; then solve nonlinear system
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
if (!flg) {
ierr = VecSet(x,pfive);CHKERRQ(ierr);
} else {
ierr = VecGetArray(x,&xx);CHKERRQ(ierr);
xx[0] = 2.0; xx[1] = 3.0;
ierr = VecRestoreArray(x,&xx);CHKERRQ(ierr);
}
/*
Note: The user should initialize the vector, x, with the initial guess
for the nonlinear solver prior to calling SNESSolve(). In particular,
to employ an initial guess of zero, the user should explicitly set
this vector to zero by calling VecSet().
*/
ierr = SNESSolve(snes,PETSC_NULL,x);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
if (flg) {
Vec f;
ierr = VecView(x,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = SNESGetFunction(snes,&f,0,0);CHKERRQ(ierr);
ierr = VecView(r,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
ierr = PetscPrintf(PETSC_COMM_WORLD,"number of SNES iterations = %D\n",its);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Free work space. All PETSc objects should be destroyed when they
are no longer needed.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = VecDestroy(&x);CHKERRQ(ierr); ierr = VecDestroy(&r);CHKERRQ(ierr);
ierr = MatDestroy(&J);CHKERRQ(ierr); ierr = SNESDestroy(&snes);CHKERRQ(ierr);
if (size > 1){
ierr = VecDestroy(&user.xloc);CHKERRQ(ierr);
ierr = VecDestroy(&user.rloc);CHKERRQ(ierr);
ierr = VecScatterDestroy(&user.scatter);CHKERRQ(ierr);
}
ierr = PetscFinalize();
return 0;
}
int main(int argc, char **argv)
{
SNES snes; /* nonlinear solver */
Vec u,r; /* solution, residual vectors */
Mat A,J; /* Jacobian matrix */
MatNullSpace nullSpace; /* May be necessary for pressure */
AppCtx user; /* user-defined work context */
JacActionCtx userJ; /* context for Jacobian MF action */
PetscInt its; /* iterations for convergence */
PetscReal error = 0.0; /* L_2 error in the solution */
const PetscInt numComponents = NUM_BASIS_COMPONENTS_TOTAL;
PetscErrorCode ierr;
ierr = PetscInitialize(&argc, &argv, NULL, help);CHKERRQ(ierr);
ierr = ProcessOptions(PETSC_COMM_WORLD, &user);CHKERRQ(ierr);
ierr = SNESCreate(PETSC_COMM_WORLD, &snes);CHKERRQ(ierr);
ierr = CreateMesh(PETSC_COMM_WORLD, &user, &user.dm);CHKERRQ(ierr);
ierr = SNESSetDM(snes, user.dm);CHKERRQ(ierr);
ierr = SetupExactSolution(user.dm, &user);CHKERRQ(ierr);
ierr = SetupQuadrature(&user);CHKERRQ(ierr);
ierr = SetupSection(user.dm, &user);CHKERRQ(ierr);
ierr = DMCreateGlobalVector(user.dm, &u);CHKERRQ(ierr);
ierr = VecDuplicate(u, &r);CHKERRQ(ierr);
ierr = DMCreateMatrix(user.dm, MATAIJ, &J);CHKERRQ(ierr);
if (user.jacobianMF) {
PetscInt M, m, N, n;
ierr = MatGetSize(J, &M, &N);CHKERRQ(ierr);
ierr = MatGetLocalSize(J, &m, &n);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD, &A);CHKERRQ(ierr);
ierr = MatSetSizes(A, m, n, M, N);CHKERRQ(ierr);
ierr = MatSetType(A, MATSHELL);CHKERRQ(ierr);
ierr = MatSetUp(A);CHKERRQ(ierr);
ierr = MatShellSetOperation(A, MATOP_MULT, (void (*)(void))FormJacobianAction);CHKERRQ(ierr);
userJ.dm = user.dm;
userJ.J = J;
userJ.user = &user;
ierr = DMCreateLocalVector(user.dm, &userJ.u);CHKERRQ(ierr);
ierr = DMPlexProjectFunctionLocal(user.dm, numComponents, user.exactFuncs, INSERT_BC_VALUES, userJ.u);CHKERRQ(ierr);
ierr = MatShellSetContext(A, &userJ);CHKERRQ(ierr);
} else {
A = J;
}
ierr = CreatePressureNullSpace(user.dm, &user, &nullSpace);CHKERRQ(ierr);
ierr = MatSetNullSpace(J, nullSpace);CHKERRQ(ierr);
if (A != J) {
ierr = MatSetNullSpace(A, nullSpace);CHKERRQ(ierr);
}
ierr = DMSNESSetFunctionLocal(user.dm, (PetscErrorCode (*)(DM,Vec,Vec,void*))DMPlexComputeResidualFEM,&user);CHKERRQ(ierr);
ierr = DMSNESSetJacobianLocal(user.dm, (PetscErrorCode (*)(DM,Vec,Mat,Mat,MatStructure*,void*))DMPlexComputeJacobianFEM,&user);CHKERRQ(ierr);
ierr = SNESSetJacobian(snes, A, J, NULL, NULL);CHKERRQ(ierr);
ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);
ierr = DMPlexProjectFunction(user.dm, numComponents, user.exactFuncs, INSERT_ALL_VALUES, u);CHKERRQ(ierr);
if (user.showInitial) {ierr = DMVecViewLocal(user.dm, u, PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);}
if (user.runType == RUN_FULL) {
PetscScalar (*initialGuess[numComponents])(const PetscReal x[]);
PetscInt c;
for (c = 0; c < numComponents; ++c) initialGuess[c] = zero;
ierr = DMPlexProjectFunction(user.dm, numComponents, initialGuess, INSERT_VALUES, u);CHKERRQ(ierr);
if (user.showInitial) {ierr = DMVecViewLocal(user.dm, u, PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);}
if (user.debug) {
ierr = PetscPrintf(PETSC_COMM_WORLD, "Initial guess\n");CHKERRQ(ierr);
ierr = VecView(u, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
ierr = SNESSolve(snes, NULL, u);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(snes, &its);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "Number of SNES iterations = %D\n", its);CHKERRQ(ierr);
ierr = DMPlexComputeL2Diff(user.dm, user.fem.quad, user.exactFuncs, u, &error);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "L_2 Error: %.3g\n", error);CHKERRQ(ierr);
if (user.showSolution) {
ierr = PetscPrintf(PETSC_COMM_WORLD, "Solution\n");CHKERRQ(ierr);
ierr = VecChop(u, 3.0e-9);CHKERRQ(ierr);
ierr = VecView(u, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
} else {
PetscReal res = 0.0;
/* Check discretization error */
ierr = PetscPrintf(PETSC_COMM_WORLD, "Initial guess\n");CHKERRQ(ierr);
ierr = VecView(u, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = DMPlexComputeL2Diff(user.dm, user.fem.quad, user.exactFuncs, u, &error);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "L_2 Error: %g\n", error);CHKERRQ(ierr);
/* Check residual */
ierr = SNESComputeFunction(snes, u, r);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "Initial Residual\n");CHKERRQ(ierr);
ierr = VecChop(r, 1.0e-10);CHKERRQ(ierr);
ierr = VecView(r, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = VecNorm(r, NORM_2, &res);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "L_2 Residual: %g\n", res);CHKERRQ(ierr);
/* Check Jacobian */
{
Vec b;
MatStructure flag;
PetscBool isNull;
ierr = SNESComputeJacobian(snes, u, &A, &A, &flag);CHKERRQ(ierr);
ierr = MatNullSpaceTest(nullSpace, J, &isNull);CHKERRQ(ierr);
if (!isNull) SETERRQ(PETSC_COMM_WORLD, PETSC_ERR_PLIB, "The null space calculated for the system operator is invalid.");
ierr = VecDuplicate(u, &b);CHKERRQ(ierr);
ierr = VecSet(r, 0.0);CHKERRQ(ierr);
ierr = SNESComputeFunction(snes, r, b);CHKERRQ(ierr);
ierr = MatMult(A, u, r);CHKERRQ(ierr);
ierr = VecAXPY(r, 1.0, b);CHKERRQ(ierr);
ierr = VecDestroy(&b);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "Au - b = Au + F(0)\n");CHKERRQ(ierr);
ierr = VecChop(r, 1.0e-10);CHKERRQ(ierr);
ierr = VecView(r, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = VecNorm(r, NORM_2, &res);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "Linear L_2 Residual: %g\n", res);CHKERRQ(ierr);
}
}
if (user.runType == RUN_FULL) {
PetscViewer viewer;
Vec uLocal;
ierr = PetscViewerCreate(PETSC_COMM_WORLD, &viewer);CHKERRQ(ierr);
ierr = PetscViewerSetType(viewer, PETSCVIEWERVTK);CHKERRQ(ierr);
ierr = PetscViewerSetFormat(viewer, PETSC_VIEWER_ASCII_VTK);CHKERRQ(ierr);
ierr = PetscViewerFileSetName(viewer, "ex62_sol.vtk");CHKERRQ(ierr);
ierr = DMGetLocalVector(user.dm, &uLocal);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(user.dm, u, INSERT_VALUES, uLocal);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(user.dm, u, INSERT_VALUES, uLocal);CHKERRQ(ierr);
ierr = PetscObjectReference((PetscObject) user.dm);CHKERRQ(ierr); /* Needed because viewer destroys the DM */
ierr = PetscObjectReference((PetscObject) uLocal);CHKERRQ(ierr); /* Needed because viewer destroys the Vec */
ierr = PetscViewerVTKAddField(viewer, (PetscObject) user.dm, DMPlexVTKWriteAll, PETSC_VTK_POINT_FIELD, (PetscObject) uLocal);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(user.dm, &uLocal);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
}
ierr = DestroyQuadrature(&user);CHKERRQ(ierr);
ierr = MatNullSpaceDestroy(&nullSpace);CHKERRQ(ierr);
if (user.jacobianMF) {
ierr = VecDestroy(&userJ.u);CHKERRQ(ierr);
}
if (A != J) {
ierr = MatDestroy(&A);CHKERRQ(ierr);
}
ierr = MatDestroy(&J);CHKERRQ(ierr);
ierr = VecDestroy(&u);CHKERRQ(ierr);
ierr = VecDestroy(&r);CHKERRQ(ierr);
ierr = SNESDestroy(&snes);CHKERRQ(ierr);
ierr = DMDestroy(&user.dm);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
PetscErrorCode SNESDiffParameterCompute_More(SNES snes,void *nePv,Vec x,Vec p,double *fnoise,double *hopt)
{
DIFFPAR_MORE *neP = (DIFFPAR_MORE*)nePv;
Vec w, xp, fvec; /* work vectors to use in computing h */
double zero = 0.0, hl, hu, h, fnoise_s, fder2_s;
PetscScalar alpha;
PetscScalar fval[7], tab[7][7], eps[7], f = -1;
double rerrf = -1., fder2;
PetscErrorCode ierr;
PetscInt iter, k, i, j, info;
PetscInt nf = 7; /* number of function evaluations */
PetscInt fcount;
MPI_Comm comm;
FILE *fp;
PetscBool noise_test = PETSC_FALSE;
PetscFunctionBegin;
ierr = PetscObjectGetComm((PetscObject)snes,&comm);CHKERRQ(ierr);
/* Call to SNESSetUp() just to set data structures in SNES context */
if (!snes->setupcalled) {ierr = SNESSetUp(snes);CHKERRQ(ierr);}
w = neP->workv[0];
xp = neP->workv[1];
fvec = neP->workv[2];
fp = neP->fp;
/* Initialize parameters */
hl = zero;
hu = zero;
h = neP->h_first_try;
fnoise_s = zero;
fder2_s = zero;
fcount = neP->function_count;
/* We have 5 tries to attempt to compute a good hopt value */
ierr = SNESGetIterationNumber(snes,&i);CHKERRQ(ierr);
ierr = PetscFPrintf(comm,fp,"\n ------- SNES iteration %D ---------\n",i);CHKERRQ(ierr);
for (iter=0; iter<5; iter++) {
neP->h_first_try = h;
/* Compute the nf function values needed to estimate the noise from
the difference table */
for (k=0; k<nf; k++) {
alpha = h * (k+1 - (nf+1)/2);
ierr = VecWAXPY(xp,alpha,p,x);CHKERRQ(ierr);
ierr = SNESComputeFunction(snes,xp,fvec);CHKERRQ(ierr);
neP->function_count++;
ierr = VecDot(fvec,w,&fval[k]);CHKERRQ(ierr);
}
f = fval[(nf+1)/2 - 1];
/* Construct the difference table */
for (i=0; i<nf; i++) tab[i][0] = fval[i];
for (j=0; j<6; j++) {
for (i=0; i<nf-j; i++) {
tab[i][j+1] = tab[i+1][j] - tab[i][j];
}
}
/* Print the difference table */
ierr = PetscFPrintf(comm,fp,"Difference Table: iter = %D\n",iter);CHKERRQ(ierr);
for (i=0; i<nf; i++) {
for (j=0; j<nf-i; j++) {
ierr = PetscFPrintf(comm,fp," %10.2e ",tab[i][j]);CHKERRQ(ierr);
}
ierr = PetscFPrintf(comm,fp,"\n");CHKERRQ(ierr);
}
/* Call the noise estimator */
ierr = SNESNoise_dnest_(&nf,fval,&h,fnoise,&fder2,hopt,&info,eps);CHKERRQ(ierr);
/* Output statements */
rerrf = *fnoise/PetscAbsScalar(f);
if (info == 1) {ierr = PetscFPrintf(comm,fp,"%s\n","Noise detected");CHKERRQ(ierr);}
if (info == 2) {ierr = PetscFPrintf(comm,fp,"%s\n","Noise not detected; h is too small");CHKERRQ(ierr);}
if (info == 3) {ierr = PetscFPrintf(comm,fp,"%s\n","Noise not detected; h is too large");CHKERRQ(ierr);}
if (info == 4) {ierr = PetscFPrintf(comm,fp,"%s\n","Noise detected, but unreliable hopt");CHKERRQ(ierr);}
ierr = PetscFPrintf(comm,fp,"Approximate epsfcn %g %g %g %g %g %g\n",(double)eps[0],(double)eps[1],(double)eps[2],(double)eps[3],(double)eps[4],(double)eps[5]);CHKERRQ(ierr);
ierr = PetscFPrintf(comm,fp,"h = %g, fnoise = %g, fder2 = %g, rerrf = %g, hopt = %g\n\n",(double)h, (double)*fnoise, (double)fder2, (double)rerrf, (double)*hopt);CHKERRQ(ierr);
/* Save fnoise and fder2. */
if (*fnoise) fnoise_s = *fnoise;
if (fder2) fder2_s = fder2;
/* Check for noise detection. */
if (fnoise_s && fder2_s) {
*fnoise = fnoise_s;
fder2 = fder2_s;
*hopt = 1.68*sqrt(*fnoise/PetscAbsScalar(fder2));
goto theend;
} else {
/* Update hl and hu, and determine new h */
if (info == 2 || info == 4) {
hl = h;
if (hu == zero) h = 100*h;
else h = PetscMin(100*h,0.1*hu);
} else if (info == 3) {
hu = h;
h = PetscMax(1.0e-3,sqrt(hl/hu))*hu;
}
}
}
theend:
if (*fnoise < neP->fnoise_min) {
ierr = PetscFPrintf(comm,fp,"Resetting fnoise: fnoise1 = %g, fnoise_min = %g\n",(double)*fnoise,(double)neP->fnoise_min);CHKERRQ(ierr);
*fnoise = neP->fnoise_min;
neP->fnoise_resets++;
}
if (*hopt < neP->hopt_min) {
ierr = PetscFPrintf(comm,fp,"Resetting hopt: hopt1 = %g, hopt_min = %g\n",(double)*hopt,(double)neP->hopt_min);CHKERRQ(ierr);
*hopt = neP->hopt_min;
neP->hopt_resets++;
}
ierr = PetscFPrintf(comm,fp,"Errors in derivative:\n");CHKERRQ(ierr);
ierr = PetscFPrintf(comm,fp,"f = %g, fnoise = %g, fder2 = %g, hopt = %g\n",(double)f,(double)*fnoise,(double)fder2,(double)*hopt);CHKERRQ(ierr);
/* For now, compute h **each** MV Mult!! */
/*
ierr = PetscOptionsHasName(NULL,"-matrix_free_jorge_each_mvp",&flg);CHKERRQ(ierr);
if (!flg) {
Mat mat;
ierr = SNESGetJacobian(snes,&mat,NULL,NULL);CHKERRQ(ierr);
ierr = SNESDefaultMatrixFreeSetParameters2(mat,PETSC_DEFAULT,PETSC_DEFAULT,*hopt);CHKERRQ(ierr);
}
*/
fcount = neP->function_count - fcount;
ierr = PetscInfo5(snes,"fct_now = %D, fct_cum = %D, rerrf=%g, sqrt(noise)=%g, h_more=%g\n",fcount,neP->function_count,(double)rerrf,(double)PetscSqrtReal(*fnoise),(double)*hopt);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(NULL,"-noise_test",&noise_test,NULL);CHKERRQ(ierr);
if (noise_test) {
ierr = JacMatMultCompare(snes,x,p,*hopt);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
SNES snes;
Vec u, r; /* solution, residual vector */
PetscInt Mx,My,its;
SNESConvergedReason reason;
DM da;
ObsCtx user;
PetscReal dx,dy,error1,errorinf;
PetscBool feasible = PETSC_FALSE,fdflg = PETSC_FALSE;
PetscInitialize(&argc,&argv,(char *)0,help);
ierr = DMDACreate2d(PETSC_COMM_WORLD,
DMDA_BOUNDARY_NONE, DMDA_BOUNDARY_NONE,
DMDA_STENCIL_STAR, /* nonlinear diffusion but diffusivity depends on soln W not grad W */
-11,-11, /* default to 10x10 grid but override with -da_grid_x, -da_grid_y (or -da_refine) */
PETSC_DECIDE,PETSC_DECIDE, /* num of procs in each dim */
1, /* dof = 1 */
1, /* s = 1 (stencil extends out one cell) */
PETSC_NULL,PETSC_NULL, /* no specify proc decomposition */
&da);CHKERRQ(ierr);
ierr = DMCreateGlobalVector(da,&u);CHKERRQ(ierr);
ierr = VecDuplicate(u,&r);CHKERRQ(ierr);
ierr = VecDuplicate(u,&(user.uexact));CHKERRQ(ierr);
ierr = VecDuplicate(u,&(user.psi));CHKERRQ(ierr);
ierr = PetscOptionsBegin(PETSC_COMM_WORLD,"","options to obstacle problem","");CHKERRQ(ierr);
ierr = PetscOptionsBool("-fd","use coloring to compute Jacobian by finite differences",PETSC_NULL,fdflg,&fdflg,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-feasible","use feasible initial guess",PETSC_NULL,feasible,&feasible,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnd();CHKERRQ(ierr);
ierr = DMDASetUniformCoordinates(da,-2.0,2.0,-2.0,2.0,0.0,1.0);CHKERRQ(ierr);
ierr = DMSetApplicationContext(da,&user);CHKERRQ(ierr);
ierr = FormPsiAndInitialGuess(da,u,feasible);CHKERRQ(ierr);
ierr = SNESCreate(PETSC_COMM_WORLD,&snes);CHKERRQ(ierr);
ierr = SNESSetDM(snes,da);CHKERRQ(ierr);
ierr = SNESSetApplicationContext(snes,&user);CHKERRQ(ierr);
ierr = SNESSetType(snes,SNESVINEWTONRSLS);CHKERRQ(ierr);
ierr = SNESVISetComputeVariableBounds(snes,&FormBounds);CHKERRQ(ierr);
ierr = DMDASNESSetFunctionLocal(da,INSERT_VALUES,(PetscErrorCode (*)(DMDALocalInfo*,void*,void*,void*))FormFunctionLocal,&user);CHKERRQ(ierr);
if (!fdflg) {
ierr = DMDASNESSetJacobianLocal(da,(PetscErrorCode (*)(DMDALocalInfo*,void*,Mat,Mat,MatStructure*,void*))FormJacobianLocal,&user);CHKERRQ(ierr);
}
ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);
/* report on setup */
ierr = DMDAGetInfo(da,PETSC_IGNORE,&Mx,&My,
PETSC_IGNORE,PETSC_IGNORE,PETSC_IGNORE,
PETSC_IGNORE,PETSC_IGNORE,PETSC_IGNORE,PETSC_IGNORE,
PETSC_IGNORE,PETSC_IGNORE,PETSC_IGNORE);CHKERRQ(ierr);
dx = 4.0 / (PetscReal)(Mx-1);
dy = 4.0 / (PetscReal)(My-1);
ierr = PetscPrintf(PETSC_COMM_WORLD,
"setup done: square side length = %.3f\n"
" grid Mx,My = %D,%D\n"
" spacing dx,dy = %.3f,%.3f\n",
4.0, Mx, My, (double)dx, (double)dy);CHKERRQ(ierr);
/* solve nonlinear system */
ierr = SNESSolve(snes,PETSC_NULL,u);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
ierr = SNESGetConvergedReason(snes,&reason);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"number of Newton iterations = %D; result = %s\n",
its,SNESConvergedReasons[reason]);CHKERRQ(ierr);
/* compare to exact */
ierr = VecWAXPY(r,-1.0,user.uexact,u);CHKERRQ(ierr); /* r = W - Wexact */
ierr = VecNorm(r,NORM_1,&error1);CHKERRQ(ierr);
error1 /= (PetscReal)Mx * (PetscReal)My;
ierr = VecNorm(r,NORM_INFINITY,&errorinf);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"errors: av |u-uexact| = %.3e\n |u-uexact|_inf = %.3e\n",error1,errorinf);CHKERRQ(ierr);
/* Free work space. */
ierr = VecDestroy(&u);CHKERRQ(ierr);
ierr = VecDestroy(&r);CHKERRQ(ierr);
ierr = VecDestroy(&(user.psi));CHKERRQ(ierr);
ierr = VecDestroy(&(user.uexact));CHKERRQ(ierr);
ierr = SNESDestroy(&snes);CHKERRQ(ierr);
ierr = DMDestroy(&da);CHKERRQ(ierr);
ierr = PetscFinalize();CHKERRQ(ierr);
return 0;
}
int main(int argc,char **argv)
{
DMMG *dmmg_comp; /* multilevel grid structure */
AppCtx user; /* user-defined work context */
PetscInt mx,my,its,max_its,i;
PetscErrorCode ierr;
MPI_Comm comm;
SNES snes;
DA da1,da2;
DMComposite pack;
DMMG *dmmg1,*dmmg2;
PetscTruth SolveSubPhysics=PETSC_FALSE,GaussSeidel=PETSC_TRUE,Jacobi=PETSC_FALSE;
Vec X1,X1_local,X2,X2_local;
PetscViewer viewer;
PetscInitialize(&argc,&argv,(char *)0,help);
comm = PETSC_COMM_WORLD;
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create user context, set problem data, create vector data structures.
Also, compute the initial guess.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Setup Physics 1:
- Lap(U) - Grad_y(Omega) = 0
- Lap(V) + Grad_x(Omega) = 0
- Lap(Omega) + Div([U*Omega,V*Omega]) - GR*Grad_x(T) = 0
where T is given by the given x.temp
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = DACreate2d(comm,DA_NONPERIODIC,DA_STENCIL_STAR,-4,-4,PETSC_DECIDE,PETSC_DECIDE,3,1,0,0,&da1);CHKERRQ(ierr);
ierr = DASetFieldName(da1,0,"x-velocity");CHKERRQ(ierr);
ierr = DASetFieldName(da1,1,"y-velocity");CHKERRQ(ierr);
ierr = DASetFieldName(da1,2,"Omega");CHKERRQ(ierr);
/* Create the solver object and attach the grid/physics info */
ierr = DMMGCreate(comm,1,&user,&dmmg1);CHKERRQ(ierr);
ierr = DMMGSetDM(dmmg1,(DM)da1);CHKERRQ(ierr);
ierr = DMMGSetISColoringType(dmmg1,IS_COLORING_GLOBAL);CHKERRQ(ierr);
ierr = DMMGSetInitialGuess(dmmg1,FormInitialGuess1);CHKERRQ(ierr);
ierr = DMMGSetSNES(dmmg1,FormFunction1,0);CHKERRQ(ierr);
ierr = DMMGSetFromOptions(dmmg1);CHKERRQ(ierr);
/* Set problem parameters (velocity of lid, prandtl, and grashof numbers) */
ierr = DAGetInfo(da1,PETSC_NULL,&mx,&my,0,0,0,0,0,0,0,0);CHKERRQ(ierr);
user.lidvelocity = 1.0/(mx*my);
user.prandtl = 1.0;
user.grashof = 1000.0;
ierr = PetscOptionsGetReal(PETSC_NULL,"-lidvelocity",&user.lidvelocity,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(PETSC_NULL,"-prandtl",&user.prandtl,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(PETSC_NULL,"-grashof",&user.grashof,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsHasName(PETSC_NULL,"-solvesubphysics",&SolveSubPhysics);CHKERRQ(ierr);
ierr = PetscOptionsHasName(PETSC_NULL,"-Jacobi",&Jacobi);CHKERRQ(ierr);
if (Jacobi) GaussSeidel=PETSC_FALSE;
ierr = PetscPrintf(comm,"grashof: %g, ",user.grashof);CHKERRQ(ierr);
if (GaussSeidel){
ierr = PetscPrintf(comm,"use Block Gauss-Seidel\n");CHKERRQ(ierr);
} else {
ierr = PetscPrintf(comm,"use Block Jacobi\n");CHKERRQ(ierr);
}
ierr = PetscPrintf(comm,"===========================================\n");CHKERRQ(ierr);
/* Solve the nonlinear system 1 */
if (SolveSubPhysics){
ierr = DMMGSolve(dmmg1);CHKERRQ(ierr);
snes = DMMGGetSNES(dmmg1);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"Physics 1: Number of Newton iterations = %D\n\n", its);CHKERRQ(ierr);
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Setup Physics 2:
- Lap(T) + PR*Div([U*T,V*T]) = 0
where U and V are given by the given x.u and x.v
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = DACreate2d(comm,DA_NONPERIODIC,DA_STENCIL_STAR,-4,-4,PETSC_DECIDE,PETSC_DECIDE,1,1,0,0,&da2);CHKERRQ(ierr);
ierr = DASetFieldName(da2,0,"temperature");CHKERRQ(ierr);
/* Create the solver object and attach the grid/physics info */
ierr = DMMGCreate(comm,1,&user,&dmmg2);CHKERRQ(ierr);
ierr = DMMGSetDM(dmmg2,(DM)da2);CHKERRQ(ierr);
ierr = DMMGSetISColoringType(dmmg2,IS_COLORING_GLOBAL);CHKERRQ(ierr);
ierr = DMMGSetInitialGuess(dmmg2,FormInitialGuess2);CHKERRQ(ierr);
ierr = DMMGSetSNES(dmmg2,FormFunction2,0);CHKERRQ(ierr);
ierr = DMMGSetFromOptions(dmmg2);CHKERRQ(ierr);
/* Solve the nonlinear system 2 */
if (SolveSubPhysics){
ierr = DMMGSolve(dmmg2);CHKERRQ(ierr);
snes = DMMGGetSNES(dmmg2);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"Physics 2: Number of Newton iterations = %D\n\n", its);CHKERRQ(ierr);
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Solve system 1 and 2 iteratively
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = DACreateLocalVector(da1,&X1_local);CHKERRQ(ierr);
ierr = DACreateLocalVector(da2,&X2_local);CHKERRQ(ierr);
/* Only 1 snes iteration is allowed for each subphysics */
/*
snes = DMMGGetSNES(dmmg1);
ierr = SNESSetTolerances(snes,PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT,1,PETSC_DEFAULT);CHKERRQ(ierr);
snes = DMMGGetSNES(dmmg2);
ierr = SNESSetTolerances(snes,PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT,1,PETSC_DEFAULT);CHKERRQ(ierr);
*/
max_its = 5;
ierr = PetscOptionsGetInt(PETSC_NULL,"-mp_max_it",&max_its,PETSC_NULL);CHKERRQ(ierr);
user.nsolve = 0;
for (i=0; i<max_its; i++){
ierr = PetscPrintf(comm,"\nIterative nsolve %D ...\n", user.nsolve);CHKERRQ(ierr);
if (!GaussSeidel){
/* get the ghosted X1_local for Physics 2 */
X1 = DMMGGetx(dmmg1); //Jacobian
if (i){ierr = DAVecRestoreArray(da1,X1_local,(Field1 **)&user.x1);CHKERRQ(ierr);}
ierr = DAGlobalToLocalBegin(da1,X1,INSERT_VALUES,X1_local);CHKERRQ(ierr);
ierr = DAGlobalToLocalEnd(da1,X1,INSERT_VALUES,X1_local);CHKERRQ(ierr);
ierr = DAVecGetArray(da1,X1_local,(Field1 **)&user.x1);CHKERRQ(ierr);
}
ierr = DMMGSolve(dmmg1);CHKERRQ(ierr);
snes = DMMGGetSNES(dmmg1);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
if (GaussSeidel){
/* get the ghosted X1_local for Physics 2 */
X1 = DMMGGetx(dmmg1);
if (i){ierr = DAVecRestoreArray(da1,X1_local,(Field1 **)&user.x1);CHKERRQ(ierr);}
ierr = DAGlobalToLocalBegin(da1,X1,INSERT_VALUES,X1_local);CHKERRQ(ierr);
ierr = DAGlobalToLocalEnd(da1,X1,INSERT_VALUES,X1_local);CHKERRQ(ierr);
ierr = DAVecGetArray(da1,X1_local,(Field1 **)&user.x1);CHKERRQ(ierr);
}
ierr = PetscPrintf(comm," Iterative physics 1: Number of Newton iterations = %D\n", its);CHKERRQ(ierr);
user.nsolve++;
ierr = DMMGSolve(dmmg2);CHKERRQ(ierr);
snes = DMMGGetSNES(dmmg2);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
/* get the ghosted X2_local for Physics 1 */
X2 = DMMGGetx(dmmg2);
if (i){ierr = DAVecRestoreArray(da2,X2_local,(Field2 **)&user.x2);CHKERRQ(ierr);}
ierr = DAGlobalToLocalBegin(da2,X2,INSERT_VALUES,X2_local);CHKERRQ(ierr);
ierr = DAGlobalToLocalEnd(da2,X2,INSERT_VALUES,X2_local);CHKERRQ(ierr);
ierr = DAVecGetArray(da2,X2_local,(Field2 **)&user.x2);CHKERRQ(ierr);
ierr = PetscPrintf(comm," Iterative physics 2: Number of Newton iterations = %D\n", its);CHKERRQ(ierr);
//user.nsolve++;
}
ierr = DAVecRestoreArray(da1,X1_local,(Field1 **)&user.x1);CHKERRQ(ierr);
ierr = DAVecRestoreArray(da2,X2_local,(Field2 **)&user.x2);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create the DMComposite object to manage the two grids/physics.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = PetscPrintf(comm," \n\n DMComposite iteration......\n");CHKERRQ(ierr);
ierr = DMCompositeCreate(comm,&pack);CHKERRQ(ierr);
ierr = DMCompositeAddDM(pack,(DM)da1);CHKERRQ(ierr);
ierr = DMCompositeAddDM(pack,(DM)da2);CHKERRQ(ierr);
/* Create the solver object and attach the grid/physics info */
ierr = DMMGCreate(comm,1,&user,&dmmg_comp);CHKERRQ(ierr);
ierr = DMMGSetDM(dmmg_comp,(DM)pack);CHKERRQ(ierr);
ierr = DMMGSetISColoringType(dmmg_comp,IS_COLORING_GLOBAL);CHKERRQ(ierr);
ierr = DMMGSetInitialGuess(dmmg_comp,FormInitialGuessComp);CHKERRQ(ierr);
ierr = DMMGSetSNES(dmmg_comp,FormFunctionComp,0);CHKERRQ(ierr);
ierr = DMMGSetFromOptions(dmmg_comp);CHKERRQ(ierr);
/* Solve the nonlinear system */
/* ierr = DMMGSolve(dmmg_comp);CHKERRQ(ierr);
snes = DMMGGetSNES(dmmg_comp);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"Composite Physics: Number of Newton iterations = %D\n\n", its);CHKERRQ(ierr);*/
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Free spaces
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = DMCompositeDestroy(pack);CHKERRQ(ierr);
ierr = DADestroy(da1);CHKERRQ(ierr);
ierr = DADestroy(da2);CHKERRQ(ierr);
ierr = DMMGDestroy(dmmg_comp);CHKERRQ(ierr);
ierr = PetscViewerASCIIOpen(comm,"log.py",&viewer);CHKERRQ(ierr);
/* -log_summary */
ierr = PetscLogPrintSummaryToPy(comm,viewer);CHKERRQ(ierr);
/* -snes_view */
//snes = DMMGGetSNES(dmmg1);CHKERRQ(ierr);
ierr = PetscViewerDestroy(viewer);CHKERRQ(ierr);
ierr = DMMGDestroy(dmmg1);CHKERRQ(ierr);
ierr = DMMGDestroy(dmmg2);CHKERRQ(ierr);
ierr = VecDestroy(X1_local);CHKERRQ(ierr);
ierr = VecDestroy(X2_local);CHKERRQ(ierr);
ierr = PetscFinalize();CHKERRQ(ierr);
return 0;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
SNES snes; /* nonlinear solver */
Vec Hu,r; /* solution, residual vectors */
Mat J; /* Jacobian matrix */
AppCtx user; /* user-defined work context */
PetscInt its, i, tmpxs, tmpxm; /* iteration count, index, etc. */
PetscReal tmp1, tmp2, tmp3, tmp4, tmp5,
errnorms[2], descaleNode[2];
PetscTruth eps_set = PETSC_FALSE, dump = PETSC_FALSE, exactinitial = PETSC_FALSE,
snes_mf_set, snes_fd_set;
MatFDColoring matfdcoloring = 0;
ISColoring iscoloring;
SNESConvergedReason reason; /* Check convergence */
PetscInitialize(&argc,&argv,(char *)0,help);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD, &user.rank); CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,
"BODVARDSSON solves for thickness and velocity in 1D, steady ice stream\n"
" [run with -help for info and options]\n");CHKERRQ(ierr);
user.n = 3.0; /* Glen flow law exponent */
user.secpera = 31556926.0;
user.rho = 910.0; /* kg m^-3 */
user.rhow = 1028.0; /* kg m^-3 */
user.g = 9.81; /* m s^-2 */
/* ask Test N for its parameters, but only those we need to solve */
ierr = params_exactN(&(user.H0), &tmp1, &(user.xc), &tmp2, &tmp3, &tmp4, &tmp5,
&(user.Txc)); CHKERRQ(ierr);
/* regularize using strain rate of 1/xc per year */
user.epsilon = (1.0 / user.secpera) / user.xc;
/* tools for non-dimensionalizing to improve equation scaling */
user.scaleNode[0] = 1000.0; user.scaleNode[1] = 100.0 / user.secpera;
ierr = PetscOptionsTruth("-snes_mf","","",PETSC_FALSE,&snes_mf_set,NULL);CHKERRQ(ierr);
ierr = PetscOptionsTruth("-snes_fd","","",PETSC_FALSE,&snes_fd_set,NULL);CHKERRQ(ierr);
if (!snes_mf_set && !snes_fd_set) {
PetscPrintf(PETSC_COMM_WORLD,
"\n***ERROR: bodvardsson needs one or zero of '-snes_mf', '-snes_fd'***\n\n"
"USAGE FOLLOWS ...\n\n%s",help);
PetscEnd();
}
if (snes_fd_set) {
ierr = PetscPrintf(PETSC_COMM_WORLD,
" using approximate Jacobian; finite-differencing using coloring\n");
CHKERRQ(ierr);
} else if (snes_mf_set) {
ierr = PetscPrintf(PETSC_COMM_WORLD,
" matrix free; no preconditioner\n"); CHKERRQ(ierr);
} else {
ierr = PetscPrintf(PETSC_COMM_WORLD,
" true Jacobian\n"); CHKERRQ(ierr);
}
ierr = PetscOptionsBegin(PETSC_COMM_WORLD,NULL,
"bodvardsson program options",__FILE__);CHKERRQ(ierr);
{
ierr = PetscOptionsTruth("-bod_up_one","","",PETSC_FALSE,&user.upwind1,NULL);CHKERRQ(ierr);
ierr = PetscOptionsTruth("-bod_exact_init","","",PETSC_FALSE,&exactinitial,NULL);CHKERRQ(ierr);
ierr = PetscOptionsTruth("-bod_dump",
"dump out exact and approximate solution and residual, as asci","",
dump,&dump,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-bod_epsilon","regularization (a strain rate in units of 1/a)","",
user.epsilon * user.secpera,&user.epsilon,&eps_set);CHKERRQ(ierr);
if (eps_set) user.epsilon *= 1.0 / user.secpera;
}
ierr = PetscOptionsEnd();CHKERRQ(ierr);
/* Create machinery for parallel grid management (DA), nonlinear solver (SNES),
and Vecs for fields (solution, RHS). Note default Mx=46 grid points means
dx=10 km. Also degrees of freedom = 2 (thickness and velocity
at each point) and stencil radius = ghost width = 2 for 2nd-order upwinding. */
user.solnghostwidth = 2;
ierr = DACreate1d(PETSC_COMM_WORLD,DA_NONPERIODIC,-46,2,user.solnghostwidth,PETSC_NULL,&user.da);
CHKERRQ(ierr);
ierr = DASetUniformCoordinates(user.da,0.0,user.xc,
PETSC_NULL,PETSC_NULL,PETSC_NULL,PETSC_NULL);CHKERRQ(ierr);
ierr = DASetFieldName(user.da,0,"ice thickness [non-dimensional]"); CHKERRQ(ierr);
ierr = DASetFieldName(user.da,1,"ice velocity [non-dimensional]"); CHKERRQ(ierr);
ierr = DAGetInfo(user.da,PETSC_IGNORE,&user.Mx,PETSC_IGNORE,PETSC_IGNORE,PETSC_IGNORE,PETSC_IGNORE,
PETSC_IGNORE,PETSC_IGNORE,PETSC_IGNORE,PETSC_IGNORE,PETSC_IGNORE);
ierr = DAGetCorners(user.da,&user.xs,PETSC_NULL,PETSC_NULL,&user.xm,PETSC_NULL,PETSC_NULL);
CHKERRQ(ierr);
user.dx = user.xc / (PetscReal)(user.Mx-1);
/* another DA for scalar parameters, with same length */
ierr = DACreate1d(PETSC_COMM_WORLD,DA_NONPERIODIC,user.Mx,1,1,PETSC_NULL,&user.scalarda);CHKERRQ(ierr);
ierr = DASetUniformCoordinates(user.scalarda,0.0,user.xc,
PETSC_NULL,PETSC_NULL,PETSC_NULL,PETSC_NULL);CHKERRQ(ierr);
/* check that parallel layout of scalar DA is same as dof=2 DA */
ierr = DAGetCorners(user.scalarda,&tmpxs,PETSC_NULL,PETSC_NULL,&tmpxm,PETSC_NULL,PETSC_NULL);
CHKERRQ(ierr);
if ((tmpxs != user.xs) || (tmpxm != user.xm)) {
PetscPrintf(PETSC_COMM_SELF,
"\n***ERROR: rank %d gets different ownership range for the two DAs! ENDING ...***\n\n",
user.rank);
PetscEnd();
}
ierr = PetscPrintf(PETSC_COMM_WORLD,
" Mx = %D points, dx = %.3f m\n H0 = %.2f m, xc = %.2f km, Txc = %.5e Pa m\n",
user.Mx, user.dx, user.H0, user.xc/1000.0, user.Txc);CHKERRQ(ierr);
/* Extract/allocate global vectors from DAs and duplicate for remaining same types */
ierr = DACreateGlobalVector(user.da,&Hu);CHKERRQ(ierr);
ierr = VecSetBlockSize(Hu,2);CHKERRQ(ierr);
ierr = VecDuplicate(Hu,&r);CHKERRQ(ierr); /* inherits block size */
ierr = VecDuplicate(Hu,&user.Huexact);CHKERRQ(ierr); /* ditto */
ierr = DACreateGlobalVector(user.scalarda,&user.M);CHKERRQ(ierr);
ierr = VecDuplicate(user.M,&user.Bstag);CHKERRQ(ierr);
ierr = VecDuplicate(user.M,&user.beta);CHKERRQ(ierr);
ierr = DASetLocalFunction(user.da,(DALocalFunction1)scshell);CHKERRQ(ierr);
ierr = DASetLocalJacobian(user.da,(DALocalFunction1)BodJacobianMatrixLocal);CHKERRQ(ierr);
ierr = SNESCreate(PETSC_COMM_WORLD,&snes);CHKERRQ(ierr);
ierr = SNESSetFunction(snes,r,SNESDAFormFunction,&user);CHKERRQ(ierr);
/* setting up a matrix is only actually needed for -snes_fd case */
ierr = DAGetMatrix(user.da,MATAIJ,&J);CHKERRQ(ierr);
if (snes_fd_set) {
/* tools needed so DA can use sparse matrix for its F.D. Jacobian approx */
ierr = DAGetColoring(user.da,IS_COLORING_GLOBAL,MATAIJ,&iscoloring);CHKERRQ(ierr);
ierr = MatFDColoringCreate(J,iscoloring,&matfdcoloring);CHKERRQ(ierr);
ierr = ISColoringDestroy(iscoloring);CHKERRQ(ierr);
ierr = MatFDColoringSetFunction(matfdcoloring,
(PetscErrorCode (*)(void))SNESDAFormFunction,&user);CHKERRQ(ierr);
ierr = MatFDColoringSetFromOptions(matfdcoloring);CHKERRQ(ierr);
ierr = SNESSetJacobian(snes,J,J,SNESDefaultComputeJacobianColor,matfdcoloring);CHKERRQ(ierr);
} else {
ierr = SNESSetJacobian(snes,J,J,SNESDAComputeJacobian,&user);CHKERRQ(ierr);
}
ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);
/* the the Bodvardsson (1955) exact solution allows setting M(x), B(x), beta(x), T(xc) */
ierr = FillDistributedParams(&user);CHKERRQ(ierr);
/* the exact thickness and exact ice velocity (user.uHexact) are known from Bodvardsson (1955) */
ierr = FillExactSoln(&user); CHKERRQ(ierr);
if (exactinitial) {
ierr = PetscPrintf(PETSC_COMM_WORLD," using exact solution as initial guess\n");
CHKERRQ(ierr);
/* the initial guess is the exact continuum solution */
ierr = VecCopy(user.Huexact,Hu); CHKERRQ(ierr);
} else {
ierr = FillInitial(&user, &Hu); CHKERRQ(ierr);
}
/************ SOLVE NONLINEAR SYSTEM ************/
/* recall that RHS r is used internally by KSP, and is set by the SNES */
for (i = 0; i < 2; i++) descaleNode[i] = 1.0 / user.scaleNode[i];
ierr = VecStrideScaleAll(Hu,descaleNode); CHKERRQ(ierr); /* de-dimensionalize initial guess */
ierr = SNESSolve(snes,PETSC_NULL,Hu);CHKERRQ(ierr);
ierr = VecStrideScaleAll(Hu,user.scaleNode); CHKERRQ(ierr); /* put back in "real" scale */
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
ierr = SNESGetConvergedReason(snes,&reason);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,
" %s Number of Newton iterations = %D\n",
SNESConvergedReasons[reason],its);CHKERRQ(ierr);
if (dump) {
ierr = PetscPrintf(PETSC_COMM_WORLD,
" viewing combined result Hu\n");CHKERRQ(ierr);
ierr = VecView(Hu,PETSC_VIEWER_STDOUT_WORLD); CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,
" viewing combined exact result Huexact\n");CHKERRQ(ierr);
ierr = VecView(user.Huexact,PETSC_VIEWER_STDOUT_WORLD); CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,
" viewing final combined residual at Hu\n");CHKERRQ(ierr);
ierr = VecView(r,PETSC_VIEWER_STDOUT_WORLD); CHKERRQ(ierr);
}
/* evaluate error relative to exact solution */
ierr = VecAXPY(Hu,-1.0,user.Huexact); CHKERRQ(ierr); /* Hu = - Huexact + Hu */
ierr = VecStrideNormAll(Hu,NORM_INFINITY,errnorms); CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,
"(dx,errHinf,erruinf) %.3f %.4e %.4e\n",
user.dx,errnorms[0],errnorms[1]*user.secpera);CHKERRQ(ierr);
ierr = VecDestroy(Hu);CHKERRQ(ierr);
ierr = VecDestroy(r);CHKERRQ(ierr);
ierr = VecDestroy(user.Huexact);CHKERRQ(ierr);
ierr = VecDestroy(user.M);CHKERRQ(ierr);
ierr = VecDestroy(user.Bstag);CHKERRQ(ierr);
ierr = VecDestroy(user.beta);CHKERRQ(ierr);
ierr = MatDestroy(J); CHKERRQ(ierr);
ierr = SNESDestroy(snes);CHKERRQ(ierr);
ierr = DADestroy(user.da);CHKERRQ(ierr);
ierr = DADestroy(user.scalarda);CHKERRQ(ierr);
ierr = PetscFinalize();CHKERRQ(ierr);
return 0;
}
static PetscErrorCode TSStep_Theta(TS ts)
{
TS_Theta *th = (TS_Theta*)ts->data;
PetscInt its,lits,reject,next_scheme;
PetscReal next_time_step;
TSAdapt adapt;
PetscBool stageok,accept = PETSC_TRUE;
PetscErrorCode ierr;
PetscFunctionBegin;
th->status = TS_STEP_INCOMPLETE;
ierr = VecCopy(ts->vec_sol,th->X0);CHKERRQ(ierr);
for (reject=0; !ts->reason && th->status != TS_STEP_COMPLETE; ts->reject++) {
PetscReal shift = 1./(th->Theta*ts->time_step);
th->stage_time = ts->ptime + (th->endpoint ? 1. : th->Theta)*ts->time_step;
ierr = TSPreStep(ts);CHKERRQ(ierr);
ierr = TSPreStage(ts,th->stage_time);CHKERRQ(ierr);
if (th->endpoint) { /* This formulation assumes linear time-independent mass matrix */
ierr = VecZeroEntries(th->Xdot);CHKERRQ(ierr);
if (!th->affine) {ierr = VecDuplicate(ts->vec_sol,&th->affine);CHKERRQ(ierr);}
ierr = TSComputeIFunction(ts,ts->ptime,ts->vec_sol,th->Xdot,th->affine,PETSC_FALSE);CHKERRQ(ierr);
ierr = VecScale(th->affine,(th->Theta-1.)/th->Theta);CHKERRQ(ierr);
}
if (th->extrapolate) {
ierr = VecWAXPY(th->X,1./shift,th->Xdot,ts->vec_sol);CHKERRQ(ierr);
} else {
ierr = VecCopy(ts->vec_sol,th->X);CHKERRQ(ierr);
}
ierr = SNESSolve(ts->snes,th->affine,th->X);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(ts->snes,&its);CHKERRQ(ierr);
ierr = SNESGetLinearSolveIterations(ts->snes,&lits);CHKERRQ(ierr);
ts->snes_its += its; ts->ksp_its += lits;
ierr = TSPostStage(ts,th->stage_time,0,&(th->X));CHKERRQ(ierr);
ierr = TSGetAdapt(ts,&adapt);CHKERRQ(ierr);
ierr = TSAdaptCheckStage(adapt,ts,&stageok);CHKERRQ(ierr);
if (!stageok) {accept = PETSC_FALSE; goto reject_step;}
ierr = TSEvaluateStep(ts,th->order,ts->vec_sol,NULL);CHKERRQ(ierr);
th->status = TS_STEP_PENDING;
/* Register only the current method as a candidate because we're not supporting multiple candidates yet. */
ierr = TSGetAdapt(ts,&adapt);CHKERRQ(ierr);
ierr = TSAdaptCandidatesClear(adapt);CHKERRQ(ierr);
ierr = TSAdaptCandidateAdd(adapt,NULL,th->order,1,th->ccfl,1.0,PETSC_TRUE);CHKERRQ(ierr);
ierr = TSAdaptChoose(adapt,ts,ts->time_step,&next_scheme,&next_time_step,&accept);CHKERRQ(ierr);
if (!accept) { /* Roll back the current step */
ts->ptime += next_time_step; /* This will be undone in rollback */
th->status = TS_STEP_INCOMPLETE;
ierr = TSRollBack(ts);CHKERRQ(ierr);
goto reject_step;
}
/* ignore next_scheme for now */
ts->ptime += ts->time_step;
ts->time_step = next_time_step;
ts->steps++;
th->status = TS_STEP_COMPLETE;
break;
reject_step:
if (!ts->reason && ++reject > ts->max_reject && ts->max_reject >= 0) {
ts->reason = TS_DIVERGED_STEP_REJECTED;
ierr = PetscInfo2(ts,"Step=%D, step rejections %D greater than current TS allowed, stopping solve\n",ts->steps,reject);CHKERRQ(ierr);
}
continue;
}
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
SNES snes; /* SNES context */
Vec x,r,F,U; /* vectors */
Mat J; /* Jacobian matrix */
MonitorCtx monP; /* monitoring context */
PetscErrorCode ierr;
PetscInt its,n = 5,i,maxit,maxf;
PetscMPIInt size;
PetscScalar h,xp,v,none = -1.0;
PetscReal abstol,rtol,stol,norm;
PetscInitialize(&argc,&argv,(char*)0,help);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
if (size != 1) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"This is a uniprocessor example only!");
ierr = PetscOptionsGetInt(NULL,"-n",&n,NULL);CHKERRQ(ierr);
h = 1.0/(n-1);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create nonlinear solver context
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = SNESCreate(PETSC_COMM_WORLD,&snes);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create vector data structures; set function evaluation routine
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Note that we form 1 vector from scratch and then duplicate as needed.
*/
ierr = VecCreate(PETSC_COMM_WORLD,&x);CHKERRQ(ierr);
ierr = VecSetSizes(x,PETSC_DECIDE,n);CHKERRQ(ierr);
ierr = VecSetFromOptions(x);CHKERRQ(ierr);
ierr = VecDuplicate(x,&r);CHKERRQ(ierr);
ierr = VecDuplicate(x,&F);CHKERRQ(ierr);
ierr = VecDuplicate(x,&U);CHKERRQ(ierr);
/*
Set function evaluation routine and vector
*/
ierr = SNESSetFunction(snes,r,FormFunction,(void*)F);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create matrix data structure; set Jacobian evaluation routine
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = MatCreate(PETSC_COMM_WORLD,&J);CHKERRQ(ierr);
ierr = MatSetSizes(J,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(J);CHKERRQ(ierr);
ierr = MatSeqAIJSetPreallocation(J,3,NULL);CHKERRQ(ierr);
/*
Set Jacobian matrix data structure and default Jacobian evaluation
routine. User can override with:
-snes_fd : default finite differencing approximation of Jacobian
-snes_mf : matrix-free Newton-Krylov method with no preconditioning
(unless user explicitly sets preconditioner)
-snes_mf_operator : form preconditioning matrix as set by the user,
but use matrix-free approx for Jacobian-vector
products within Newton-Krylov method
*/
ierr = SNESSetJacobian(snes,J,J,FormJacobian,NULL);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Customize nonlinear solver; set runtime options
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Set an optional user-defined monitoring routine
*/
ierr = PetscViewerDrawOpen(PETSC_COMM_WORLD,0,0,0,0,400,400,&monP.viewer);CHKERRQ(ierr);
ierr = SNESMonitorSet(snes,Monitor,&monP,0);CHKERRQ(ierr);
/*
Set names for some vectors to facilitate monitoring (optional)
*/
ierr = PetscObjectSetName((PetscObject)x,"Approximate Solution");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject)U,"Exact Solution");CHKERRQ(ierr);
/*
Set SNES/KSP/KSP/PC runtime options, e.g.,
-snes_view -snes_monitor -ksp_type <ksp> -pc_type <pc>
*/
ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);
/*
Print parameters used for convergence testing (optional) ... just
to demonstrate this routine; this information is also printed with
the option -snes_view
*/
ierr = SNESGetTolerances(snes,&abstol,&rtol,&stol,&maxit,&maxf);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"atol=%G, rtol=%G, stol=%G, maxit=%D, maxf=%D\n",abstol,rtol,stol,maxit,maxf);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Initialize application:
Store right-hand-side of PDE and exact solution
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
xp = 0.0;
for (i=0; i<n; i++) {
v = 6.0*xp + PetscPowScalar(xp+1.e-12,6.0); /* +1.e-12 is to prevent 0^6 */
ierr = VecSetValues(F,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
v = xp*xp*xp;
ierr = VecSetValues(U,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
xp += h;
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Evaluate initial guess; then solve nonlinear system
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Note: The user should initialize the vector, x, with the initial guess
for the nonlinear solver prior to calling SNESSolve(). In particular,
to employ an initial guess of zero, the user should explicitly set
this vector to zero by calling VecSet().
*/
ierr = FormInitialGuess(x);CHKERRQ(ierr);
ierr = SNESSolve(snes,NULL,x);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"number of SNES iterations = %D\n\n",its);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Check solution and clean up
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Check the error
*/
ierr = VecAXPY(x,none,U);CHKERRQ(ierr);
ierr = VecNorm(x,NORM_2,&norm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Norm of error %G, Iterations %D\n",norm,its);CHKERRQ(ierr);
/*
Free work space. All PETSc objects should be destroyed when they
are no longer needed.
*/
ierr = VecDestroy(&x);CHKERRQ(ierr); ierr = VecDestroy(&r);CHKERRQ(ierr);
ierr = VecDestroy(&U);CHKERRQ(ierr); ierr = VecDestroy(&F);CHKERRQ(ierr);
ierr = MatDestroy(&J);CHKERRQ(ierr); ierr = SNESDestroy(&snes);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&monP.viewer);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
int main(int argc,char **argv) {
PetscErrorCode ierr;
DM da, da_after;
SNES snes;
Vec u_initial, u;
PoissonCtx user;
SNESConvergedReason reason;
int snesits;
double lflops,flops;
DMDALocalInfo info;
PetscInitialize(&argc,&argv,NULL,help);
ierr = PetscOptionsBegin(PETSC_COMM_WORLD,"el_",
"elasto-plastic torsion solver options",""); CHKERRQ(ierr);
ierr = PetscOptionsReal("-C","f(x,y)=2C is source term",
"elasto.c",C,&C,NULL); CHKERRQ(ierr);
ierr = PetscOptionsEnd(); CHKERRQ(ierr);
ierr = DMDACreate2d(PETSC_COMM_WORLD,
DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DMDA_STENCIL_STAR,
3,3, // override with -da_grid_x,_y
PETSC_DECIDE,PETSC_DECIDE, // num of procs in each dim
1,1,NULL,NULL, // dof = 1 and stencil width = 1
&da);CHKERRQ(ierr);
ierr = DMSetFromOptions(da); CHKERRQ(ierr);
ierr = DMSetUp(da); CHKERRQ(ierr);
ierr = DMDASetUniformCoordinates(da,0.0,1.0,0.0,1.0,-1.0,-1.0);CHKERRQ(ierr);
user.cx = 1.0;
user.cy = 1.0;
user.cz = 1.0;
user.g_bdry = &zero;
user.f_rhs = &f_fcn;
user.addctx = NULL;
ierr = DMSetApplicationContext(da,&user);CHKERRQ(ierr);
ierr = SNESCreate(PETSC_COMM_WORLD,&snes);CHKERRQ(ierr);
ierr = SNESSetDM(snes,da);CHKERRQ(ierr);
ierr = SNESSetApplicationContext(snes,&user);CHKERRQ(ierr);
ierr = SNESSetType(snes,SNESVINEWTONRSLS);CHKERRQ(ierr);
ierr = SNESVISetComputeVariableBounds(snes,&FormBounds);CHKERRQ(ierr);
// reuse residual and jacobian from ch6/
ierr = DMDASNESSetFunctionLocal(da,INSERT_VALUES,
(DMDASNESFunction)Poisson2DFunctionLocal,&user); CHKERRQ(ierr);
ierr = DMDASNESSetJacobianLocal(da,
(DMDASNESJacobian)Poisson2DJacobianLocal,&user); CHKERRQ(ierr);
ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);
// initial iterate is zero
ierr = DMCreateGlobalVector(da,&u_initial);CHKERRQ(ierr);
ierr = VecSet(u_initial,0.0); CHKERRQ(ierr);
/* solve; then get solution and DM after solution*/
ierr = SNESSolve(snes,NULL,u_initial);CHKERRQ(ierr);
ierr = VecDestroy(&u_initial); CHKERRQ(ierr);
ierr = DMDestroy(&da); CHKERRQ(ierr);
ierr = SNESGetDM(snes,&da_after); CHKERRQ(ierr);
ierr = SNESGetSolution(snes,&u); CHKERRQ(ierr); /* do not destroy u */
/* performance measures */
ierr = SNESGetConvergedReason(snes,&reason); CHKERRQ(ierr);
if (reason <= 0) {
ierr = PetscPrintf(PETSC_COMM_WORLD,
"WARNING: SNES not converged ... use -snes_converged_reason to check\n"); CHKERRQ(ierr);
}
ierr = SNESGetIterationNumber(snes,&snesits); CHKERRQ(ierr);
ierr = PetscGetFlops(&lflops); CHKERRQ(ierr);
ierr = MPI_Allreduce(&lflops,&flops,1,MPI_DOUBLE,MPI_SUM,PETSC_COMM_WORLD); CHKERRQ(ierr);
ierr = DMDAGetLocalInfo(da_after,&info); CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,
"done on %4d x %4d grid; total flops = %.3e; SNES iterations %d\n",
info.mx,info.my,flops,snesits); CHKERRQ(ierr);
SNESDestroy(&snes);
return PetscFinalize();
}
static PetscErrorCode TSStep_Alpha(TS ts)
{
TS_Alpha *th = (TS_Alpha*)ts->data;
PetscInt its,lits,reject;
PetscReal next_time_step;
SNESConvergedReason snesreason = SNES_CONVERGED_ITERATING;
PetscErrorCode ierr;
PetscFunctionBegin;
if (ts->steps == 0) {
ierr = VecSet(th->V0,0.0);CHKERRQ(ierr);
} else {
ierr = VecCopy(th->V1,th->V0);CHKERRQ(ierr);
}
ierr = VecCopy(ts->vec_sol,th->X0);CHKERRQ(ierr);
next_time_step = ts->time_step;
for (reject=0; reject<ts->max_reject; reject++,ts->reject++) {
ts->time_step = next_time_step;
th->stage_time = ts->ptime + th->Alpha_f*ts->time_step;
th->shift = th->Alpha_m/(th->Alpha_f*th->Gamma*ts->time_step);
ierr = TSPreStep(ts);CHKERRQ(ierr);
ierr = TSPreStage(ts,th->stage_time);CHKERRQ(ierr);
/* predictor */
ierr = VecCopy(th->X0,th->X1);CHKERRQ(ierr);
/* solve R(X,V) = 0 */
ierr = SNESSolve(ts->snes,PETSC_NULL,th->X1);CHKERRQ(ierr);
/* V1 = (1-1/Gamma)*V0 + 1/(Gamma*dT)*(X1-X0) */
ierr = VecWAXPY(th->V1,-1,th->X0,th->X1);CHKERRQ(ierr);
ierr = VecAXPBY(th->V1,1-1/th->Gamma,1/(th->Gamma*ts->time_step),th->V0);CHKERRQ(ierr);
/* nonlinear solve convergence */
ierr = SNESGetConvergedReason(ts->snes,&snesreason);CHKERRQ(ierr);
if (snesreason < 0 && !th->adapt) break;
ierr = SNESGetIterationNumber(ts->snes,&its);CHKERRQ(ierr);
ierr = SNESGetLinearSolveIterations(ts->snes,&lits);CHKERRQ(ierr);
ts->snes_its += its; ts->ksp_its += lits;
ierr = PetscInfo3(ts,"step=%D, nonlinear solve iterations=%D, linear solve iterations=%D\n",ts->steps,its,lits);CHKERRQ(ierr);
/* time step adaptativity */
if (!th->adapt) break;
else {
PetscReal t1 = ts->ptime + ts->time_step;
PetscBool stepok = (reject==0) ? PETSC_TRUE : PETSC_FALSE;
ierr = th->adapt(ts,t1,th->X1,th->V1,&next_time_step,&stepok,th->adaptctx);CHKERRQ(ierr);
ierr = PetscInfo5(ts,"Step %D (t=%G,dt=%G) %s, next dt=%G\n",ts->steps,ts->ptime,ts->time_step,stepok?"accepted":"rejected",next_time_step);CHKERRQ(ierr);
if (stepok) break;
}
}
if (snesreason < 0 && ts->max_snes_failures > 0 && ++ts->num_snes_failures >= ts->max_snes_failures) {
ts->reason = TS_DIVERGED_NONLINEAR_SOLVE;
ierr = PetscInfo2(ts,"Step=%D, nonlinear solve solve failures %D greater than current TS allowed, stopping solve\n",ts->steps,ts->num_snes_failures);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
if (reject >= ts->max_reject) {
ts->reason = TS_DIVERGED_STEP_REJECTED;
ierr = PetscInfo2(ts,"Step=%D, step rejections %D greater than current TS allowed, stopping solve\n",ts->steps,reject);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
ierr = VecCopy(th->X1,ts->vec_sol);CHKERRQ(ierr);
ts->ptime += ts->time_step;
ts->time_step = next_time_step;
ts->steps++;
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
SNES snes; /* nonlinear solver context */
Vec x,r; /* solution, residual vectors */
Mat J; /* Jacobian matrix */
PetscErrorCode ierr;
PetscInt its;
PetscScalar *xx;
SNESConvergedReason reason;
PetscInitialize(&argc,&argv,(char *)0,help);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create nonlinear solver context
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = SNESCreate(PETSC_COMM_WORLD,&snes);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create matrix and vector data structures; set corresponding routines
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Create vectors for solution and nonlinear function
*/
ierr = VecCreate(PETSC_COMM_WORLD,&x);CHKERRQ(ierr);
ierr = VecSetSizes(x,PETSC_DECIDE,2);CHKERRQ(ierr);
ierr = VecSetFromOptions(x);CHKERRQ(ierr);
ierr = VecDuplicate(x,&r);CHKERRQ(ierr);
/*
Create Jacobian matrix data structure
*/
ierr = MatCreate(PETSC_COMM_WORLD,&J);CHKERRQ(ierr);
ierr = MatSetSizes(J,PETSC_DECIDE,PETSC_DECIDE,2,2);CHKERRQ(ierr);
ierr = MatSetFromOptions(J);CHKERRQ(ierr);
ierr = MatSetUp(J);CHKERRQ(ierr);
/*
Set function evaluation routine and vector.
*/
ierr = SNESSetFunction(snes,r,FormFunction1,PETSC_NULL);CHKERRQ(ierr);
/*
Set Jacobian matrix data structure and Jacobian evaluation routine
*/
ierr = SNESSetJacobian(snes,J,J,FormJacobian1,PETSC_NULL);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Customize nonlinear solver; set runtime options
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Evaluate initial guess; then solve nonlinear system
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = VecGetArray(x,&xx);CHKERRQ(ierr);
xx[0] = -1.2; xx[1] = 1.0;
ierr = VecRestoreArray(x,&xx);CHKERRQ(ierr);
/*
Note: The user should initialize the vector, x, with the initial guess
for the nonlinear solver prior to calling SNESSolve(). In particular,
to employ an initial guess of zero, the user should explicitly set
this vector to zero by calling VecSet().
*/
ierr = SNESSolve(snes,PETSC_NULL,x);CHKERRQ(ierr);
ierr = VecView(x,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
ierr = SNESGetConvergedReason(snes,&reason);CHKERRQ(ierr);
/*
Some systems computes a residual that is identically zero, thus converging
due to FNORM_ABS, others converge due to FNORM_RELATIVE. Here, we only
report the reason if the iteration did not converge so that the tests are
reproducible.
*/
ierr = PetscPrintf(PETSC_COMM_WORLD,"%s number of SNES iterations = %D\n\n",reason>0?"CONVERGED":SNESConvergedReasons[reason],its);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Free work space. All PETSc objects should be destroyed when they
are no longer needed.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = VecDestroy(&x);CHKERRQ(ierr); ierr = VecDestroy(&r);CHKERRQ(ierr);
ierr = MatDestroy(&J);CHKERRQ(ierr); ierr = SNESDestroy(&snes);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
bool PETScNewtonKrylovSolver::solveSystem(SAMRAIVectorReal<NDIM, double>& x,
SAMRAIVectorReal<NDIM, double>& b)
{
IBTK_TIMER_START(t_solve_system);
int ierr;
// Initialize the solver, when necessary.
const bool deallocate_after_solve = !d_is_initialized;
if (deallocate_after_solve) initializeSolverState(x, b);
#if !defined(NDEBUG)
TBOX_ASSERT(d_petsc_snes);
#endif
resetSNESOptions();
Pointer<PETScKrylovLinearSolver> p_krylov_solver = d_krylov_solver;
if (p_krylov_solver) p_krylov_solver->resetKSPOptions();
// Allocate scratch data.
if (d_b) d_b->allocateVectorData();
if (d_r) d_r->allocateVectorData();
// Solve the system using a PETSc SNES object.
PETScSAMRAIVectorReal::replaceSAMRAIVector(
d_petsc_x, Pointer<SAMRAIVectorReal<NDIM, double> >(&x, false));
Pointer<LinearOperator> A = d_F;
if (A)
{
d_b->copyVector(Pointer<SAMRAIVectorReal<NDIM, double> >(&b, false));
A->modifyRhsForInhomogeneousBc(*d_b);
ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(d_petsc_b));
IBTK_CHKERRQ(ierr);
PETScSAMRAIVectorReal::replaceSAMRAIVector(d_petsc_b, d_b);
}
else
{
PETScSAMRAIVectorReal::replaceSAMRAIVector(
d_petsc_b, Pointer<SAMRAIVectorReal<NDIM, double> >(&b, false));
}
ierr = SNESSolve(d_petsc_snes, d_petsc_b, d_petsc_x);
IBTK_CHKERRQ(ierr);
ierr = SNESGetIterationNumber(d_petsc_snes, &d_current_iterations);
IBTK_CHKERRQ(ierr);
ierr = SNESGetLinearSolveIterations(d_petsc_snes, &d_current_linear_iterations);
IBTK_CHKERRQ(ierr);
ierr = SNESGetFunctionNorm(d_petsc_snes, &d_current_residual_norm);
IBTK_CHKERRQ(ierr);
// Determine the convergence reason.
SNESConvergedReason reason;
ierr = SNESGetConvergedReason(d_petsc_snes, &reason);
IBTK_CHKERRQ(ierr);
const bool converged = (static_cast<int>(reason) > 0);
if (d_enable_logging) reportSNESConvergedReason(reason, plog);
// Deallocate scratch data.
if (d_b) d_b->deallocateVectorData();
if (d_r) d_r->deallocateVectorData();
// Deallocate the solver, when necessary.
if (deallocate_after_solve) deallocateSolverState();
IBTK_TIMER_STOP(t_solve_system);
return converged;
} // solveSystem
