PetscErrorCode MatRARtSymbolic_SeqAIJ_SeqAIJ(Mat A,Mat R,PetscReal fill,Mat *C)
{
PetscErrorCode ierr;
Mat Rt;
Mat_SeqAIJ *c;
Mat_RARt *rart;
PetscFunctionBegin;
ierr = MatTranspose_SeqAIJ(R,MAT_INITIAL_MATRIX,&Rt);CHKERRQ(ierr);
ierr = MatMatMatMultSymbolic_SeqAIJ_SeqAIJ_SeqAIJ(R,A,Rt,fill,C);CHKERRQ(ierr);
ierr = PetscNew(&rart);CHKERRQ(ierr);
rart->Rt = Rt;
c = (Mat_SeqAIJ*)(*C)->data;
c->rart = rart;
rart->destroy = (*C)->ops->destroy;
(*C)->ops->destroy = MatDestroy_SeqAIJ_RARt;
(*C)->ops->rartnumeric = MatRARtNumeric_SeqAIJ_SeqAIJ;
#if defined(PETSC_USE_INFO)
ierr = PetscInfo(*C,"Use Rt=R^T and C=R*A*Rt via MatMatMatMult() to avoid sparse inner products\n");CHKERRQ(ierr);
#endif
PetscFunctionReturn(0);
}
/*MC
KSPBICG - Implements the Biconjugate gradient method (similar to running the conjugate
gradient on the normal equations).
Options Database Keys:
. see KSPSolve()
Level: beginner
Notes: this method requires that one be apply to apply the transpose of the preconditioner and operator
as well as the operator and preconditioner.
Supports only left preconditioning
See KSPCGNE for code that EXACTLY runs the preconditioned conjugate gradient method on the
normal equations
.seealso: KSPCreate(), KSPSetType(), KSPType (for list of available types), KSP, KSPBCGS, KSPCGNE
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "KSPCreate_BiCG"
PetscErrorCode PETSCKSP_DLLEXPORT KSPCreate_BiCG(KSP ksp)
{
PetscErrorCode ierr;
PetscFunctionBegin;
ksp->data = (void*)0;
if (ksp->pc_side != PC_LEFT) {
ierr = PetscInfo(ksp,"WARNING! Setting PC_SIDE for BiCG to left!\n");CHKERRQ(ierr);
}
ksp->pc_side = PC_LEFT;
ksp->ops->setup = KSPSetUp_BiCG;
ksp->ops->solve = KSPSolve_BiCG;
ksp->ops->destroy = KSPDestroy_BiCG;
ksp->ops->view = 0;
ksp->ops->setfromoptions = 0;
ksp->ops->buildsolution = KSPDefaultBuildSolution;
ksp->ops->buildresidual = KSPDefaultBuildResidual;
PetscFunctionReturn(0);
}
PetscErrorCode KSPFischerGuessUpdate_Method2(KSPFischerGuess_Method2 *itg,Vec x)
{
PetscScalar norm;
PetscErrorCode ierr;
int curl = itg->curl,i;
PetscFunctionBegin;
PetscValidHeaderSpecific(x,VEC_CLASSID,2);
PetscValidPointer(itg,3);
if (curl == itg->maxl) {
ierr = KSP_MatMult(itg->ksp,itg->mat,x,itg->Ax);CHKERRQ(ierr); /* norm = sqrt(x'Ax) */
ierr = VecDot(x,itg->Ax,&norm);CHKERRQ(ierr);
ierr = VecCopy(x,itg->xtilde[0]);CHKERRQ(ierr);
ierr = VecScale(itg->xtilde[0],1.0/PetscSqrtScalar(norm));CHKERRQ(ierr);
itg->curl = 1;
} else {
if (!curl) {
ierr = VecCopy(x,itg->xtilde[curl]);CHKERRQ(ierr);
} else {
ierr = VecWAXPY(itg->xtilde[curl],-1.0,itg->guess,x);CHKERRQ(ierr);
}
ierr = KSP_MatMult(itg->ksp,itg->mat,itg->xtilde[curl],itg->Ax);CHKERRQ(ierr);
ierr = VecMDot(itg->Ax,curl,itg->xtilde,itg->alpha);CHKERRQ(ierr);
for (i=0; i<curl; i++) itg->alpha[i] = -itg->alpha[i];
ierr = VecMAXPY(itg->xtilde[curl],curl,itg->alpha,itg->xtilde);CHKERRQ(ierr);
ierr = KSP_MatMult(itg->ksp,itg->mat,itg->xtilde[curl],itg->Ax);CHKERRQ(ierr); /* norm = sqrt(xtilde[curl]'Axtilde[curl]) */
ierr = VecDot(itg->xtilde[curl],itg->Ax,&norm);CHKERRQ(ierr);
if (PetscAbsScalar(norm) != 0.0) {
ierr = VecScale(itg->xtilde[curl],1.0/PetscSqrtScalar(norm));CHKERRQ(ierr);
itg->curl++;
} else {
ierr = PetscInfo(itg->ksp,"Not increasing dimension of Fischer space because new direction is identical to previous\n");CHKERRQ(ierr);
}
}
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode PetscSFCreate_Window(PetscSF sf)
{
PetscSF_Window *w = (PetscSF_Window*)sf->data;
PetscErrorCode ierr;
PetscFunctionBegin;
sf->ops->SetUp = PetscSFSetUp_Window;
sf->ops->SetFromOptions = PetscSFSetFromOptions_Window;
sf->ops->Reset = PetscSFReset_Window;
sf->ops->Destroy = PetscSFDestroy_Window;
sf->ops->View = PetscSFView_Window;
sf->ops->Duplicate = PetscSFDuplicate_Window;
sf->ops->BcastBegin = PetscSFBcastBegin_Window;
sf->ops->BcastEnd = PetscSFBcastEnd_Window;
sf->ops->ReduceBegin = PetscSFReduceBegin_Window;
sf->ops->ReduceEnd = PetscSFReduceEnd_Window;
sf->ops->FetchAndOpBegin = PetscSFFetchAndOpBegin_Window;
sf->ops->FetchAndOpEnd = PetscSFFetchAndOpEnd_Window;
ierr = PetscNewLog(sf,&w);CHKERRQ(ierr);
sf->data = (void*)w;
w->sync = PETSCSF_WINDOW_SYNC_FENCE;
ierr = PetscObjectComposeFunction((PetscObject)sf,"PetscSFWindowSetSyncType_C",PetscSFWindowSetSyncType_Window);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)sf,"PetscSFWindowGetSyncType_C",PetscSFWindowGetSyncType_Window);CHKERRQ(ierr);
#if defined(OMPI_MAJOR_VERSION) && (OMPI_MAJOR_VERSION < 1 || (OMPI_MAJOR_VERSION == 1 && OMPI_MINOR_VERSION <= 6))
{
PetscBool ackbug = PETSC_FALSE;
ierr = PetscOptionsGetBool(NULL,NULL,"-acknowledge_ompi_onesided_bug",&ackbug,NULL);CHKERRQ(ierr);
if (ackbug) {
ierr = PetscInfo(sf,"Acknowledged Open MPI bug, proceeding anyway. Expect memory corruption.\n");CHKERRQ(ierr);
} else SETERRQ(PetscObjectComm((PetscObject)sf),PETSC_ERR_LIB,"Open MPI is known to be buggy (https://svn.open-mpi.org/trac/ompi/ticket/1905 and 2656), use -acknowledge_ompi_onesided_bug to proceed");
}
#endif
PetscFunctionReturn(0);
}
/*@C
TaoDefaultComputeHessian - Computes the Hessian using finite differences.
Collective on Tao
Input Parameters:
+ tao - the Tao context
. V - compute Hessian at this point
- dummy - not used
Output Parameters:
+ H - Hessian matrix (not altered in this routine)
- B - newly computed Hessian matrix to use with preconditioner (generally the same as H)
Options Database Key:
. -tao_fd_hessian - activates TaoDefaultComputeHessian()
Level: advanced
Notes:
This routine is slow and expensive, and is not currently optimized
to take advantage of sparsity in the problem. Although
TaoDefaultComputeHessian() is not recommended for general use
in large-scale applications, It can be useful in checking the
correctness of a user-provided Hessian.
.seealso: TaoSetHessianRoutine(), TaoDefaultComputeHessianColor(), SNESComputeJacobianDefault(), TaoSetGradientRoutine(), TaoDefaultComputeGradient()
@*/
PetscErrorCode TaoDefaultComputeHessian(Tao tao,Vec V,Mat H,Mat B,void *dummy)
{
PetscErrorCode ierr;
Vec G;
SNES snes;
DM dm;
PetscFunctionBegin;
ierr = VecDuplicate(V,&G);CHKERRQ(ierr);
ierr = PetscInfo(tao,"TAO Using finite differences w/o coloring to compute Hessian matrix\n");CHKERRQ(ierr);
ierr = TaoComputeGradient(tao,V,G);CHKERRQ(ierr);
ierr = SNESCreate(PetscObjectComm((PetscObject)H),&snes);CHKERRQ(ierr);
ierr = SNESSetFunction(snes,G,Fsnes,tao);CHKERRQ(ierr);
ierr = SNESGetDM(snes,&dm);CHKERRQ(ierr);
ierr = DMShellSetGlobalVector(dm,V);CHKERRQ(ierr);
ierr = SNESSetUp(snes);CHKERRQ(ierr);
if (H) {
PetscInt n,N;
ierr = VecGetSize(V,&N);CHKERRQ(ierr);
ierr = VecGetLocalSize(V,&n);CHKERRQ(ierr);
ierr = MatSetSizes(H,n,n,N,N);CHKERRQ(ierr);
ierr = MatSetUp(H);CHKERRQ(ierr);
}
if (B && B != H) {
PetscInt n,N;
ierr = VecGetSize(V,&N);CHKERRQ(ierr);
ierr = VecGetLocalSize(V,&n);CHKERRQ(ierr);
ierr = MatSetSizes(B,n,n,N,N);CHKERRQ(ierr);
ierr = MatSetUp(B);CHKERRQ(ierr);
}
ierr = SNESComputeJacobianDefault(snes,V,H,B,NULL);CHKERRQ(ierr);
ierr = SNESDestroy(&snes);CHKERRQ(ierr);
ierr = VecDestroy(&G);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode PetscDrawSetUpColormap_Shared(Display *display,int screen,Visual *visual,Colormap colormap)
{
XColor colordef,ecolordef;
unsigned char *red,*green,*blue;
int i,ncolors;
PetscErrorCode ierr;
PetscBool fast = PETSC_FALSE;
PetscFunctionBegin;
if (colormap) gColormap = colormap;
else gColormap = DefaultColormap(display,screen);
/* set the basic colors into the color map */
for (i=0; i<PETSC_DRAW_BASIC_COLORS; i++) {
XAllocNamedColor(display,gColormap,colornames[i],&colordef,&ecolordef);
gCmapping[i] = colordef.pixel;
}
/* set the uniform hue colors into the color map */
ncolors = 256-PETSC_DRAW_BASIC_COLORS;
ierr = PetscMalloc3(ncolors,&red,ncolors,&green,ncolors,&blue);CHKERRQ(ierr);
ierr = PetscDrawUtilitySetCmapHue(red,green,blue,ncolors);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(NULL,NULL,"-draw_fast",&fast,NULL);CHKERRQ(ierr);
if (!fast) {
for (i=PETSC_DRAW_BASIC_COLORS; i<ncolors+PETSC_DRAW_BASIC_COLORS; i++) {
colordef.red = ((int)red[i-PETSC_DRAW_BASIC_COLORS] * 65535) / 255;
colordef.green = ((int)green[i-PETSC_DRAW_BASIC_COLORS] * 65535) / 255;
colordef.blue = ((int)blue[i-PETSC_DRAW_BASIC_COLORS] * 65535) / 255;
colordef.flags = DoRed | DoGreen | DoBlue;
XAllocColor(display,gColormap,&colordef);
gCmapping[i] = colordef.pixel;
}
}
ierr = PetscFree3(red,green,blue);CHKERRQ(ierr);
ierr = PetscInfo(0,"Successfully allocated colors\n");CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*MC
KSPBCGSL - Implements a slight variant of the Enhanced
BiCGStab(L) algorithm in (3) and (2). The variation
concerns cases when either kappa0**2 or kappa1**2 is
negative due to round-off. Kappa0 has also been pulled
out of the denominator in the formula for ghat.
References:
1. G.L.G. Sleijpen, H.A. van der Vorst, "An overview of
approaches for the stable computation of hybrid BiCG
methods", Applied Numerical Mathematics: Transactions
f IMACS, 19(3), pp 235-54, 1996.
2. G.L.G. Sleijpen, H.A. van der Vorst, D.R. Fokkema,
"BiCGStab(L) and other hybrid Bi-CG methods",
Numerical Algorithms, 7, pp 75-109, 1994.
3. D.R. Fokkema, "Enhanced implementation of BiCGStab(L)
for solving linear systems of equations", preprint
from www.citeseer.com.
Contributed by: Joel M. Malard, email [email protected]
Options Database Keys:
+ -ksp_bcgsl_ell <ell> Number of Krylov search directions
- -ksp_bcgsl_cxpol Use a convex function of the MR and OR polynomials after the BiCG step
- -ksp_bcgsl_xres <res> Threshold used to decide when to refresh computed residuals
Notes: Supports left preconditioning only
Level: beginner
.seealso: KSPCreate(), KSPSetType(), KSPType (for list of available types), KSP, KSPFGMRES, KSPBCGS, KSPSetPreconditionerSide()
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "KSPCreate_BCGSL"
PetscErrorCode PETSCKSP_DLLEXPORT KSPCreate_BCGSL(KSP ksp)
{
PetscErrorCode ierr;
KSP_BCGSL *bcgsl;
PetscFunctionBegin;
/* allocate BiCGStab(L) context */
ierr = PetscNewLog(ksp, KSP_BCGSL, &bcgsl);
CHKERRQ(ierr);
ksp->data = (void*)bcgsl;
if (ksp->pc_side != PC_LEFT) {
ierr = PetscInfo(ksp,"WARNING! Setting PC_SIDE for BCGSL to left!\n");
CHKERRQ(ierr);
}
ksp->pc_side = PC_LEFT;
ksp->ops->setup = KSPSetUp_BCGSL;
ksp->ops->solve = KSPSolve_BCGSL;
ksp->ops->destroy = KSPDestroy_BCGSL;
ksp->ops->buildsolution = KSPDefaultBuildSolution;
ksp->ops->buildresidual = KSPDefaultBuildResidual;
ksp->ops->setfromoptions = KSPSetFromOptions_BCGSL;
ksp->ops->view = KSPView_BCGSL;
/* Let the user redefine the number of directions vectors */
bcgsl->ell = 2;
/*Choose between a single MR step or an averaged MR/OR */
bcgsl->bConvex = PETSC_FALSE;
/* Set the threshold for when exact residuals will be used */
bcgsl->delta = 0.0;
PetscFunctionReturn(0);
}
static PetscErrorCode PetscPythonLoadLibrary(const char pythonlib[])
{
PetscErrorCode ierr;
PetscFunctionBegin;
/* open the Python dynamic library */
ierr = PetscDLPyLibOpen(pythonlib);CHKERRQ(ierr);
ierr = PetscInfo1(0,"Python: loaded dynamic library %s\n", pythonlib);CHKERRQ(ierr);
/* look required symbols from the Python C-API */
ierr = PetscDLPyLibSym("_Py_NoneStruct" , &Py_None );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("Py_GetVersion" , &Py_GetVersion );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("Py_IsInitialized" , &Py_IsInitialized );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("Py_InitializeEx" , &Py_InitializeEx );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("Py_Finalize" , &Py_Finalize );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("PySys_GetObject" , &PySys_GetObject );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("PySys_SetArgv" , &PySys_SetArgv );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("PyObject_CallMethod" , &PyObject_CallMethod );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("PyImport_ImportModule" , &PyImport_ImportModule );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("Py_IncRef" , &Py_IncRef );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("Py_DecRef" , &Py_DecRef );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("PyErr_Clear" , &PyErr_Clear );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("PyErr_Occurred" , &PyErr_Occurred );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("PyErr_Fetch" , &PyErr_Fetch );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("PyErr_NormalizeException", &PyErr_NormalizeException);CHKERRQ(ierr);
ierr = PetscDLPyLibSym("PyErr_Display", &PyErr_Display );CHKERRQ(ierr);
ierr = PetscDLPyLibSym("PyErr_Restore", &PyErr_Restore );CHKERRQ(ierr);
/* XXX TODO: check that ALL symbols were there !!! */
if (!Py_None) SETERRQ(PETSC_COMM_SELF,1,"Python: failed to load symbols from dynamic library");
if (!Py_GetVersion) SETERRQ(PETSC_COMM_SELF,1,"Python: failed to load symbols from dynamic library");
if (!Py_IsInitialized) SETERRQ(PETSC_COMM_SELF,1,"Python: failed to load symbols from dynamic library");
if (!Py_InitializeEx) SETERRQ(PETSC_COMM_SELF,1,"Python: failed to load symbols from dynamic library");
if (!Py_Finalize) SETERRQ(PETSC_COMM_SELF,1,"Python: failed to load symbols from dynamic library");
ierr = PetscInfo(0,"Python: all required symbols loaded from Python dynamic library\n");CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
TaoDefaultComputeHessian - Computes the Hessian using finite differences.
Collective on Tao
Input Parameters:
+ tao - the Tao context
. V - compute Hessian at this point
- dummy - not used
Output Parameters:
+ H - Hessian matrix (not altered in this routine)
- B - newly computed Hessian matrix to use with preconditioner (generally the same as H)
Options Database Key:
+ -tao_fd - Activates TaoDefaultComputeHessian()
- -tao_view_hessian - view the hessian after each evaluation using PETSC_VIEWER_STDOUT_WORLD
Level: advanced
Notes:
This routine is slow and expensive, and is not currently optimized
to take advantage of sparsity in the problem. Although
TaoDefaultComputeHessian() is not recommended for general use
in large-scale applications, It can be useful in checking the
correctness of a user-provided Hessian.
.seealso: TaoSetHessianRoutine(), TaoDefaultComputeHessianColor(), SNESComputeJacobianDefault(), TaoSetGradientRoutine(), TaoDefaultComputeGradient()
@*/
PetscErrorCode TaoDefaultComputeHessian(Tao tao,Vec V,Mat H,Mat B,void *dummy)
{
PetscErrorCode ierr;
MPI_Comm comm;
Vec G;
SNES snes;
PetscFunctionBegin;
PetscValidHeaderSpecific(V,VEC_CLASSID,2);
ierr = VecDuplicate(V,&G);CHKERRQ(ierr);
ierr = PetscInfo(tao,"TAO Using finite differences w/o coloring to compute Hessian matrix\n");CHKERRQ(ierr);
ierr = TaoComputeGradient(tao,V,G);CHKERRQ(ierr);
ierr = PetscObjectGetComm((PetscObject)H,&comm);CHKERRQ(ierr);
ierr = SNESCreate(comm,&snes);CHKERRQ(ierr);
ierr = SNESSetFunction(snes,G,Fsnes,tao);CHKERRQ(ierr);
ierr = SNESComputeJacobianDefault(snes,V,H,B,tao);CHKERRQ(ierr);
ierr = SNESDestroy(&snes);CHKERRQ(ierr);
ierr = VecDestroy(&G);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
SNESDefaultConverged - Convergence test of the solvers for
systems of nonlinear equations (default).
Collective on SNES
Input Parameters:
+ snes - the SNES context
. it - the iteration (0 indicates before any Newton steps)
. xnorm - 2-norm of current iterate
. snorm - 2-norm of current step
. fnorm - 2-norm of function at current iterate
- dummy - unused context
Output Parameter:
. reason - one of
$ SNES_CONVERGED_FNORM_ABS - (fnorm < abstol),
$ SNES_CONVERGED_SNORM_RELATIVE - (snorm < stol*xnorm),
$ SNES_CONVERGED_FNORM_RELATIVE - (fnorm < rtol*fnorm0),
$ SNES_DIVERGED_FUNCTION_COUNT - (nfct > maxf),
$ SNES_DIVERGED_FNORM_NAN - (fnorm == NaN),
$ SNES_CONVERGED_ITERATING - (otherwise),
where
+ maxf - maximum number of function evaluations,
set with SNESSetTolerances()
. nfct - number of function evaluations,
. abstol - absolute function norm tolerance,
set with SNESSetTolerances()
- rtol - relative function norm tolerance, set with SNESSetTolerances()
Level: intermediate
.keywords: SNES, nonlinear, default, converged, convergence
.seealso: SNESSetConvergenceTest()
@*/
PetscErrorCode SNESDefaultConverged(SNES snes,PetscInt it,PetscReal xnorm,PetscReal snorm,PetscReal fnorm,SNESConvergedReason *reason,void *dummy)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(snes,SNES_CLASSID,1);
PetscValidPointer(reason,6);
*reason = SNES_CONVERGED_ITERATING;
if (!it) {
/* set parameter for default relative tolerance convergence test */
snes->ttol = fnorm*snes->rtol;
}
if (PetscIsInfOrNanReal(fnorm)) {
ierr = PetscInfo(snes,"Failed to converged, function norm is NaN\n");CHKERRQ(ierr);
*reason = SNES_DIVERGED_FNORM_NAN;
} else if (fnorm < snes->abstol) {
ierr = PetscInfo2(snes,"Converged due to function norm %14.12e < %14.12e\n",(double)fnorm,(double)snes->abstol);CHKERRQ(ierr);
*reason = SNES_CONVERGED_FNORM_ABS;
} else if (snes->nfuncs >= snes->max_funcs) {
ierr = PetscInfo2(snes,"Exceeded maximum number of function evaluations: %D > %D\n",snes->nfuncs,snes->max_funcs);CHKERRQ(ierr);
*reason = SNES_DIVERGED_FUNCTION_COUNT;
}
if (it && !*reason) {
if (fnorm <= snes->ttol) {
ierr = PetscInfo2(snes,"Converged due to function norm %14.12e < %14.12e (relative tolerance)\n",(double)fnorm,(double)snes->ttol);CHKERRQ(ierr);
*reason = SNES_CONVERGED_FNORM_RELATIVE;
} else if (snorm < snes->stol*xnorm) {
ierr = PetscInfo3(snes,"Converged due to small update length: %14.12e < %14.12e * %14.12e\n",(double)snorm,(double)snes->stol,(double)xnorm);CHKERRQ(ierr);
*reason = SNES_CONVERGED_SNORM_RELATIVE;
}
}
PetscFunctionReturn(0);
}
PetscErrorCode MatPtAPSymbolic_SeqAIJ_SeqAIJ_SparseAxpy(Mat A,Mat P,PetscReal fill,Mat *C)
{
PetscErrorCode ierr;
PetscFreeSpaceList free_space=NULL,current_space=NULL;
Mat_SeqAIJ *a = (Mat_SeqAIJ*)A->data,*p = (Mat_SeqAIJ*)P->data,*c;
PetscInt *pti,*ptj,*ptJ,*ai=a->i,*aj=a->j,*ajj,*pi=p->i,*pj=p->j,*pjj;
PetscInt *ci,*cj,*ptadenserow,*ptasparserow,*ptaj,nspacedouble=0;
PetscInt an=A->cmap->N,am=A->rmap->N,pn=P->cmap->N,pm=P->rmap->N;
PetscInt i,j,k,ptnzi,arow,anzj,ptanzi,prow,pnzj,cnzi,nlnk,*lnk;
MatScalar *ca;
PetscBT lnkbt;
PetscReal afill;
PetscFunctionBegin;
/* Get ij structure of P^T */
ierr = MatGetSymbolicTranspose_SeqAIJ(P,&pti,&ptj);CHKERRQ(ierr);
ptJ = ptj;
/* Allocate ci array, arrays for fill computation and */
/* free space for accumulating nonzero column info */
ierr = PetscMalloc1(pn+1,&ci);CHKERRQ(ierr);
ci[0] = 0;
ierr = PetscCalloc1(2*an+1,&ptadenserow);CHKERRQ(ierr);
ptasparserow = ptadenserow + an;
/* create and initialize a linked list */
nlnk = pn+1;
ierr = PetscLLCreate(pn,pn,nlnk,lnk,lnkbt);CHKERRQ(ierr);
/* Set initial free space to be fill*(nnz(A)+ nnz(P)) */
ierr = PetscFreeSpaceGet(PetscRealIntMultTruncate(fill,PetscIntSumTruncate(ai[am],pi[pm])),&free_space);CHKERRQ(ierr);
current_space = free_space;
/* Determine symbolic info for each row of C: */
for (i=0; i<pn; i++) {
ptnzi = pti[i+1] - pti[i];
ptanzi = 0;
/* Determine symbolic row of PtA: */
for (j=0; j<ptnzi; j++) {
arow = *ptJ++;
anzj = ai[arow+1] - ai[arow];
ajj = aj + ai[arow];
for (k=0; k<anzj; k++) {
if (!ptadenserow[ajj[k]]) {
ptadenserow[ajj[k]] = -1;
ptasparserow[ptanzi++] = ajj[k];
}
}
}
/* Using symbolic info for row of PtA, determine symbolic info for row of C: */
ptaj = ptasparserow;
cnzi = 0;
for (j=0; j<ptanzi; j++) {
prow = *ptaj++;
pnzj = pi[prow+1] - pi[prow];
pjj = pj + pi[prow];
/* add non-zero cols of P into the sorted linked list lnk */
ierr = PetscLLAddSorted(pnzj,pjj,pn,nlnk,lnk,lnkbt);CHKERRQ(ierr);
cnzi += nlnk;
}
/* If free space is not available, make more free space */
/* Double the amount of total space in the list */
if (current_space->local_remaining<cnzi) {
ierr = PetscFreeSpaceGet(PetscIntSumTruncate(cnzi,current_space->total_array_size),¤t_space);CHKERRQ(ierr);
nspacedouble++;
}
/* Copy data into free space, and zero out denserows */
ierr = PetscLLClean(pn,pn,cnzi,lnk,current_space->array,lnkbt);CHKERRQ(ierr);
current_space->array += cnzi;
current_space->local_used += cnzi;
current_space->local_remaining -= cnzi;
for (j=0; j<ptanzi; j++) ptadenserow[ptasparserow[j]] = 0;
/* Aside: Perhaps we should save the pta info for the numerical factorization. */
/* For now, we will recompute what is needed. */
ci[i+1] = ci[i] + cnzi;
}
/* nnz is now stored in ci[ptm], column indices are in the list of free space */
/* Allocate space for cj, initialize cj, and */
/* destroy list of free space and other temporary array(s) */
ierr = PetscMalloc1(ci[pn]+1,&cj);CHKERRQ(ierr);
ierr = PetscFreeSpaceContiguous(&free_space,cj);CHKERRQ(ierr);
ierr = PetscFree(ptadenserow);CHKERRQ(ierr);
ierr = PetscLLDestroy(lnk,lnkbt);CHKERRQ(ierr);
ierr = PetscCalloc1(ci[pn]+1,&ca);CHKERRQ(ierr);
/* put together the new matrix */
ierr = MatCreateSeqAIJWithArrays(PetscObjectComm((PetscObject)A),pn,pn,ci,cj,ca,C);CHKERRQ(ierr);
ierr = MatSetBlockSizes(*C,PetscAbs(P->cmap->bs),PetscAbs(P->cmap->bs));CHKERRQ(ierr);
/* MatCreateSeqAIJWithArrays flags matrix so PETSc doesn't free the user's arrays. */
/* Since these are PETSc arrays, change flags to free them as necessary. */
c = (Mat_SeqAIJ*)((*C)->data);
c->free_a = PETSC_TRUE;
c->free_ij = PETSC_TRUE;
c->nonew = 0;
(*C)->ops->ptapnumeric = MatPtAPNumeric_SeqAIJ_SeqAIJ_SparseAxpy;
/* set MatInfo */
afill = (PetscReal)ci[pn]/(ai[am]+pi[pm] + 1.e-5);
if (afill < 1.0) afill = 1.0;
c->maxnz = ci[pn];
c->nz = ci[pn];
(*C)->info.mallocs = nspacedouble;
(*C)->info.fill_ratio_given = fill;
(*C)->info.fill_ratio_needed = afill;
/* Clean up. */
ierr = MatRestoreSymbolicTranspose_SeqAIJ(P,&pti,&ptj);CHKERRQ(ierr);
#if defined(PETSC_USE_INFO)
if (ci[pn] != 0) {
ierr = PetscInfo3((*C),"Reallocs %D; Fill ratio: given %g needed %g.\n",nspacedouble,(double)fill,(double)afill);CHKERRQ(ierr);
ierr = PetscInfo1((*C),"Use MatPtAP(A,P,MatReuse,%g,&C) for best performance.\n",(double)afill);CHKERRQ(ierr);
} else {
ierr = PetscInfo((*C),"Empty matrix product\n");CHKERRQ(ierr);
}
#endif
PetscFunctionReturn(0);
}
static PetscErrorCode KSPPGMRESCycle(PetscInt *itcount,KSP ksp)
{
KSP_PGMRES *pgmres = (KSP_PGMRES*)(ksp->data);
PetscReal res_norm,res,newnorm;
PetscErrorCode ierr;
PetscInt it = 0,j,k;
PetscBool hapend = PETSC_FALSE;
PetscFunctionBegin;
if (itcount) *itcount = 0;
ierr = VecNormalize(VEC_VV(0),&res_norm);CHKERRQ(ierr);
res = res_norm;
*RS(0) = res_norm;
/* check for the convergence */
ierr = PetscObjectAMSTakeAccess((PetscObject)ksp);CHKERRQ(ierr);
ksp->rnorm = res;
ierr = PetscObjectAMSGrantAccess((PetscObject)ksp);CHKERRQ(ierr);
pgmres->it = it-2;
ierr = KSPLogResidualHistory(ksp,res);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,ksp->its,res);CHKERRQ(ierr);
if (!res) {
ksp->reason = KSP_CONVERGED_ATOL;
ierr = PetscInfo(ksp,"Converged due to zero residual norm on entry\n");CHKERRQ(ierr);
PetscFunctionReturn(0);
}
ierr = (*ksp->converged)(ksp,ksp->its,res,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
for (; !ksp->reason; it++) {
Vec Zcur,Znext;
if (pgmres->vv_allocated <= it + VEC_OFFSET + 1) {
ierr = KSPGMRESGetNewVectors(ksp,it+1);CHKERRQ(ierr);
}
/* VEC_VV(it-1) is orthogonal, it will be normalized once the VecNorm arrives. */
Zcur = VEC_VV(it); /* Zcur is not yet orthogonal, but the VecMDot to orthogonalize it has been started. */
Znext = VEC_VV(it+1); /* This iteration will compute Znext, update with a deferred correction once we know how
* Zcur relates to the previous vectors, and start the reduction to orthogonalize it. */
if (it < pgmres->max_k+1 && ksp->its+1 < PetscMax(2,ksp->max_it)) { /* We don't know whether what we have computed is enough, so apply the matrix. */
ierr = KSP_PCApplyBAorAB(ksp,Zcur,Znext,VEC_TEMP_MATOP);CHKERRQ(ierr);
}
if (it > 1) { /* Complete the pending reduction */
ierr = VecNormEnd(VEC_VV(it-1),NORM_2,&newnorm);CHKERRQ(ierr);
*HH(it-1,it-2) = newnorm;
}
if (it > 0) { /* Finish the reduction computing the latest column of H */
ierr = VecMDotEnd(Zcur,it,&(VEC_VV(0)),HH(0,it-1));CHKERRQ(ierr);
}
if (it > 1) {
/* normalize the base vector from two iterations ago, basis is complete up to here */
ierr = VecScale(VEC_VV(it-1),1./ *HH(it-1,it-2));CHKERRQ(ierr);
ierr = KSPPGMRESUpdateHessenberg(ksp,it-2,&hapend,&res);CHKERRQ(ierr);
pgmres->it = it-2;
ksp->its++;
ksp->rnorm = res;
ierr = (*ksp->converged)(ksp,ksp->its,res,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (it < pgmres->max_k+1 || ksp->reason || ksp->its == ksp->max_it) { /* Monitor if we are done or still iterating, but not before a restart. */
ierr = KSPLogResidualHistory(ksp,res);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,ksp->its,res);CHKERRQ(ierr);
}
if (ksp->reason) break;
/* Catch error in happy breakdown and signal convergence and break from loop */
if (hapend) {
if (ksp->errorifnotconverged) SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_NOT_CONVERGED,"You reached the happy break down, but convergence was not indicated. Residual norm = %G",res);
else {
ksp->reason = KSP_DIVERGED_BREAKDOWN;
break;
}
}
if (!(it < pgmres->max_k+1 && ksp->its < ksp->max_it)) break;
/* The it-2 column of H was not scaled when we computed Zcur, apply correction */
ierr = VecScale(Zcur,1./ *HH(it-1,it-2));CHKERRQ(ierr);
/* And Znext computed in this iteration was computed using the under-scaled Zcur */
ierr = VecScale(Znext,1./ *HH(it-1,it-2));CHKERRQ(ierr);
/* In the previous iteration, we projected an unnormalized Zcur against the Krylov basis, so we need to fix the column of H resulting from that projection. */
for (k=0; k<it; k++) *HH(k,it-1) /= *HH(it-1,it-2);
/* When Zcur was projected against the Krylov basis, VV(it-1) was still not normalized, so fix that too. This
* column is complete except for HH(it,it-1) which we won't know until the next iteration. */
*HH(it-1,it-1) /= *HH(it-1,it-2);
}
if (it > 0) {
PetscScalar *work;
if (!pgmres->orthogwork) {ierr = PetscMalloc((pgmres->max_k + 2)*sizeof(PetscScalar),&pgmres->orthogwork);CHKERRQ(ierr);}
work = pgmres->orthogwork;
/* Apply correction computed by the VecMDot in the last iteration to Znext. The original form is
*
* Znext -= sum_{j=0}^{i-1} Z[j+1] * H[j,i-1]
*
* where
*
* Z[j] = sum_{k=0}^j V[k] * H[k,j-1]
*
* substituting
*
* Znext -= sum_{j=0}^{i-1} sum_{k=0}^{j+1} V[k] * H[k,j] * H[j,i-1]
*
* rearranging the iteration space from row-column to column-row
*
* Znext -= sum_{k=0}^i sum_{j=k-1}^{i-1} V[k] * H[k,j] * H[j,i-1]
*
* Note that column it-1 of HH is correct. For all previous columns, we must look at HES because HH has already
* been transformed to upper triangular form.
*/
for (k=0; k<it+1; k++) {
work[k] = 0;
for (j=PetscMax(0,k-1); j<it-1; j++) work[k] -= *HES(k,j) * *HH(j,it-1);
}
ierr = VecMAXPY(Znext,it+1,work,&VEC_VV(0));CHKERRQ(ierr);
ierr = VecAXPY(Znext,-*HH(it-1,it-1),Zcur);CHKERRQ(ierr);
/* Orthogonalize Zcur against existing basis vectors. */
for (k=0; k<it; k++) work[k] = -*HH(k,it-1);
ierr = VecMAXPY(Zcur,it,work,&VEC_VV(0));CHKERRQ(ierr);
/* Zcur is now orthogonal, and will be referred to as VEC_VV(it) again, though it is still not normalized. */
/* Begin computing the norm of the new vector, will be normalized after the MatMult in the next iteration. */
ierr = VecNormBegin(VEC_VV(it),NORM_2,&newnorm);CHKERRQ(ierr);
}
/* Compute column of H (to the diagonal, but not the subdiagonal) to be able to orthogonalize the newest vector. */
ierr = VecMDotBegin(Znext,it+1,&VEC_VV(0),HH(0,it));CHKERRQ(ierr);
/* Start an asynchronous split-mode reduction, the result of the MDot and Norm will be collected on the next iteration. */
ierr = PetscCommSplitReductionBegin(PetscObjectComm((PetscObject)Znext));CHKERRQ(ierr);
}
if (itcount) *itcount = it-1; /* Number of iterations actually completed. */
/*
Down here we have to solve for the "best" coefficients of the Krylov
columns, add the solution values together, and possibly unwind the
preconditioning from the solution
*/
/* Form the solution (or the solution so far) */
ierr = KSPPGMRESBuildSoln(RS(0),ksp->vec_sol,ksp->vec_sol,ksp,it-2);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode petscNonlinearConverged(SNES snes, PetscInt it, PetscReal xnorm, PetscReal snorm, PetscReal fnorm, SNESConvergedReason * reason, void * ctx)
{
FEProblem & problem = *static_cast<FEProblem *>(ctx);
NonlinearSystem & system = problem.getNonlinearSystem();
// Let's be nice and always check PETSc error codes.
PetscErrorCode ierr = 0;
// Temporary variables to store SNES tolerances. Usual C-style would be to declare
// but not initialize these... but it bothers me to leave anything uninitialized.
PetscReal atol = 0.; // absolute convergence tolerance
PetscReal rtol = 0.; // relative convergence tolerance
PetscReal stol = 0.; // convergence (step) tolerance in terms of the norm of the change in the solution between steps
PetscInt maxit = 0; // maximum number of iterations
PetscInt maxf = 0; // maximum number of function evaluations
// Ask the SNES object about its tolerances.
ierr = SNESGetTolerances(snes,
&atol,
&rtol,
&stol,
&maxit,
&maxf);
CHKERRABORT(problem.comm().get(),ierr);
// Get current number of function evaluations done by SNES.
PetscInt nfuncs = 0;
ierr = SNESGetNumberFunctionEvals(snes, &nfuncs);
CHKERRABORT(problem.comm().get(),ierr);
// See if SNESSetFunctionDomainError() has been called. Note:
// SNESSetFunctionDomainError() and SNESGetFunctionDomainError()
// were added in different releases of PETSc.
#if !PETSC_VERSION_LESS_THAN(3,3,0)
PetscBool domainerror;
ierr = SNESGetFunctionDomainError(snes, &domainerror);
CHKERRABORT(problem.comm().get(),ierr);
if (domainerror)
{
*reason = SNES_DIVERGED_FUNCTION_DOMAIN;
return 0;
}
#endif
// Error message that will be set by the FEProblem.
std::string msg;
// xnorm: 2-norm of current iterate
// snorm: 2-norm of current step
// fnorm: 2-norm of function at current iterate
MooseNonlinearConvergenceReason moose_reason = problem.checkNonlinearConvergence(msg,
it,
xnorm,
snorm,
fnorm,
rtol,
stol,
atol,
nfuncs,
maxf,
system._initial_residual_before_preset_bcs,
/*div_threshold=*/(1.0/rtol)*system._initial_residual_before_preset_bcs);
if (msg.length() > 0)
PetscInfo(snes, msg.c_str());
switch (moose_reason)
{
case MOOSE_NONLINEAR_ITERATING:
*reason = SNES_CONVERGED_ITERATING;
break;
case MOOSE_CONVERGED_FNORM_ABS:
*reason = SNES_CONVERGED_FNORM_ABS;
break;
case MOOSE_CONVERGED_FNORM_RELATIVE:
*reason = SNES_CONVERGED_FNORM_RELATIVE;
break;
case MOOSE_CONVERGED_SNORM_RELATIVE:
#if PETSC_VERSION_LESS_THAN(3,3,0)
*reason = SNES_CONVERGED_PNORM_RELATIVE;
#else
*reason = SNES_CONVERGED_SNORM_RELATIVE;
#endif
break;
case MOOSE_DIVERGED_FUNCTION_COUNT:
*reason = SNES_DIVERGED_FUNCTION_COUNT;
break;
case MOOSE_DIVERGED_FNORM_NAN:
*reason = SNES_DIVERGED_FNORM_NAN;
break;
case MOOSE_DIVERGED_LINE_SEARCH:
#if PETSC_VERSION_LESS_THAN(3,2,0)
*reason = SNES_DIVERGED_LS_FAILURE;
#else
*reason = SNES_DIVERGED_LINE_SEARCH;
#endif
break;
}
return 0;
}
static PetscErrorCode TaoSolve_NM(Tao tao)
{
PetscErrorCode ierr;
TAO_NelderMead *nm = (TAO_NelderMead*)tao->data;
TaoConvergedReason reason;
PetscReal *x;
PetscInt i;
Vec Xmur=nm->Xmur, Xmue=nm->Xmue, Xmuc=nm->Xmuc, Xbar=nm->Xbar;
PetscReal fr,fe,fc;
PetscInt shrink;
PetscInt low,high;
PetscFunctionBegin;
nm->nshrink = 0;
nm->nreflect = 0;
nm->nincontract = 0;
nm->noutcontract = 0;
nm->nexpand = 0;
if (tao->XL || tao->XU || tao->ops->computebounds) {
ierr = PetscPrintf(((PetscObject)tao)->comm,"WARNING: Variable bounds have been set but will be ignored by NelderMead algorithm\n");CHKERRQ(ierr);
}
ierr = VecCopy(tao->solution,nm->simplex[0]);CHKERRQ(ierr);
ierr = TaoComputeObjective(tao,nm->simplex[0],&nm->f_values[0]);CHKERRQ(ierr);
nm->indices[0]=0;
for (i=1;i<nm->N+1;i++){
ierr = VecCopy(tao->solution,nm->simplex[i]);CHKERRQ(ierr);
ierr = VecGetOwnershipRange(nm->simplex[i],&low,&high);CHKERRQ(ierr);
if (i-1 >= low && i-1 < high) {
ierr = VecGetArray(nm->simplex[i],&x);CHKERRQ(ierr);
x[i-1-low] += nm->lamda;
ierr = VecRestoreArray(nm->simplex[i],&x);CHKERRQ(ierr);
}
ierr = TaoComputeObjective(tao,nm->simplex[i],&nm->f_values[i]);CHKERRQ(ierr);
nm->indices[i] = i;
}
/* Xbar = (Sum of all simplex vectors - worst vector)/N */
ierr = NelderMeadSort(nm);CHKERRQ(ierr);
ierr = VecSet(Xbar,0.0);CHKERRQ(ierr);
for (i=0;i<nm->N;i++) {
ierr = VecAXPY(Xbar,1.0,nm->simplex[nm->indices[i]]);CHKERRQ(ierr);
}
ierr = VecScale(Xbar,nm->oneOverN);CHKERRQ(ierr);
reason = TAO_CONTINUE_ITERATING;
while (1) {
shrink = 0;
ierr = VecCopy(nm->simplex[nm->indices[0]],tao->solution);CHKERRQ(ierr);
ierr = TaoMonitor(tao,tao->niter++,nm->f_values[nm->indices[0]],nm->f_values[nm->indices[nm->N]]-nm->f_values[nm->indices[0]],0.0,1.0,&reason);CHKERRQ(ierr);
if (reason != TAO_CONTINUE_ITERATING) break;
/* x(mu) = (1 + mu)Xbar - mu*X_N+1 */
ierr = VecAXPBYPCZ(Xmur,1+nm->mu_r,-nm->mu_r,0,Xbar,nm->simplex[nm->indices[nm->N]]);CHKERRQ(ierr);
ierr = TaoComputeObjective(tao,Xmur,&fr);CHKERRQ(ierr);
if (nm->f_values[nm->indices[0]] <= fr && fr < nm->f_values[nm->indices[nm->N-1]]) {
/* reflect */
nm->nreflect++;
ierr = PetscInfo(0,"Reflect\n");CHKERRQ(ierr);
ierr = NelderMeadReplace(nm,nm->indices[nm->N],Xmur,fr);CHKERRQ(ierr);
} else if (fr < nm->f_values[nm->indices[0]]) {
/* expand */
nm->nexpand++;
ierr = PetscInfo(0,"Expand\n");CHKERRQ(ierr);
ierr = VecAXPBYPCZ(Xmue,1+nm->mu_e,-nm->mu_e,0,Xbar,nm->simplex[nm->indices[nm->N]]);CHKERRQ(ierr);
ierr = TaoComputeObjective(tao,Xmue,&fe);CHKERRQ(ierr);
if (fe < fr) {
ierr = NelderMeadReplace(nm,nm->indices[nm->N],Xmue,fe);CHKERRQ(ierr);
} else {
ierr = NelderMeadReplace(nm,nm->indices[nm->N],Xmur,fr);CHKERRQ(ierr);
}
} else if (nm->f_values[nm->indices[nm->N-1]] <= fr && fr < nm->f_values[nm->indices[nm->N]]) {
/* outside contraction */
nm->noutcontract++;
ierr = PetscInfo(0,"Outside Contraction\n");CHKERRQ(ierr);
ierr = VecAXPBYPCZ(Xmuc,1+nm->mu_oc,-nm->mu_oc,0,Xbar,nm->simplex[nm->indices[nm->N]]);CHKERRQ(ierr);
ierr = TaoComputeObjective(tao,Xmuc,&fc);CHKERRQ(ierr);
if (fc <= fr) {
ierr = NelderMeadReplace(nm,nm->indices[nm->N],Xmuc,fc);CHKERRQ(ierr);
} else shrink=1;
} else {
/* inside contraction */
nm->nincontract++;
ierr = PetscInfo(0,"Inside Contraction\n");CHKERRQ(ierr);
ierr = VecAXPBYPCZ(Xmuc,1+nm->mu_ic,-nm->mu_ic,0,Xbar,nm->simplex[nm->indices[nm->N]]);CHKERRQ(ierr);
ierr = TaoComputeObjective(tao,Xmuc,&fc);CHKERRQ(ierr);
if (fc < nm->f_values[nm->indices[nm->N]]) {
ierr = NelderMeadReplace(nm,nm->indices[nm->N],Xmuc,fc);CHKERRQ(ierr);
} else shrink = 1;
}
if (shrink) {
nm->nshrink++;
ierr = PetscInfo(0,"Shrink\n");CHKERRQ(ierr);
for (i=1;i<nm->N+1;i++) {
ierr = VecAXPBY(nm->simplex[nm->indices[i]],1.5,-0.5,nm->simplex[nm->indices[0]]);CHKERRQ(ierr);
ierr = TaoComputeObjective(tao,nm->simplex[nm->indices[i]], &nm->f_values[nm->indices[i]]);CHKERRQ(ierr);
}
ierr = VecAXPBY(Xbar,1.5*nm->oneOverN,-0.5,nm->simplex[nm->indices[0]]);CHKERRQ(ierr);
/* Add last vector's fraction of average */
ierr = VecAXPY(Xbar,nm->oneOverN,nm->simplex[nm->indices[nm->N]]);CHKERRQ(ierr);
ierr = NelderMeadSort(nm);CHKERRQ(ierr);
/* Subtract new last vector from average */
ierr = VecAXPY(Xbar,-nm->oneOverN,nm->simplex[nm->indices[nm->N]]);CHKERRQ(ierr);
}
}
PetscFunctionReturn(0);
}
/*
SNESSolve_NEWTONTR - Implements Newton's Method with a very simple trust
region approach for solving systems of nonlinear equations.
*/
static PetscErrorCode SNESSolve_NEWTONTR(SNES snes)
{
SNES_NEWTONTR *neP = (SNES_NEWTONTR*)snes->data;
Vec X,F,Y,G,Ytmp;
PetscErrorCode ierr;
PetscInt maxits,i,lits;
PetscReal rho,fnorm,gnorm,gpnorm,xnorm=0,delta,nrm,ynorm,norm1;
PetscScalar cnorm;
KSP ksp;
SNESConvergedReason reason = SNES_CONVERGED_ITERATING;
PetscBool conv = PETSC_FALSE,breakout = PETSC_FALSE;
PetscFunctionBegin;
if (snes->xl || snes->xu || snes->ops->computevariablebounds) SETERRQ1(PetscObjectComm((PetscObject)snes),PETSC_ERR_ARG_WRONGSTATE, "SNES solver %s does not support bounds", ((PetscObject)snes)->type_name);
maxits = snes->max_its; /* maximum number of iterations */
X = snes->vec_sol; /* solution vector */
F = snes->vec_func; /* residual vector */
Y = snes->work[0]; /* work vectors */
G = snes->work[1];
Ytmp = snes->work[2];
ierr = PetscObjectSAWsTakeAccess((PetscObject)snes);CHKERRQ(ierr);
snes->iter = 0;
ierr = PetscObjectSAWsGrantAccess((PetscObject)snes);CHKERRQ(ierr);
if (!snes->vec_func_init_set) {
ierr = SNESComputeFunction(snes,X,F);CHKERRQ(ierr); /* F(X) */
} else snes->vec_func_init_set = PETSC_FALSE;
ierr = VecNorm(F,NORM_2,&fnorm);CHKERRQ(ierr); /* fnorm <- || F || */
SNESCheckFunctionNorm(snes,fnorm);
ierr = VecNorm(X,NORM_2,&xnorm);CHKERRQ(ierr); /* fnorm <- || F || */
ierr = PetscObjectSAWsTakeAccess((PetscObject)snes);CHKERRQ(ierr);
snes->norm = fnorm;
ierr = PetscObjectSAWsGrantAccess((PetscObject)snes);CHKERRQ(ierr);
delta = xnorm ? neP->delta0*xnorm : neP->delta0;
neP->delta = delta;
ierr = SNESLogConvergenceHistory(snes,fnorm,0);CHKERRQ(ierr);
ierr = SNESMonitor(snes,0,fnorm);CHKERRQ(ierr);
/* test convergence */
ierr = (*snes->ops->converged)(snes,snes->iter,0.0,0.0,fnorm,&snes->reason,snes->cnvP);CHKERRQ(ierr);
if (snes->reason) PetscFunctionReturn(0);
/* Set the stopping criteria to use the More' trick. */
ierr = PetscOptionsGetBool(((PetscObject)snes)->options,((PetscObject)snes)->prefix,"-snes_tr_ksp_regular_convergence_test",&conv,NULL);CHKERRQ(ierr);
if (!conv) {
SNES_TR_KSPConverged_Ctx *ctx;
ierr = SNESGetKSP(snes,&ksp);CHKERRQ(ierr);
ierr = PetscNew(&ctx);CHKERRQ(ierr);
ctx->snes = snes;
ierr = KSPConvergedDefaultCreate(&ctx->ctx);CHKERRQ(ierr);
ierr = KSPSetConvergenceTest(ksp,SNESTR_KSPConverged_Private,ctx,SNESTR_KSPConverged_Destroy);CHKERRQ(ierr);
ierr = PetscInfo(snes,"Using Krylov convergence test SNESTR_KSPConverged_Private\n");CHKERRQ(ierr);
}
for (i=0; i<maxits; i++) {
/* Call general purpose update function */
if (snes->ops->update) {
ierr = (*snes->ops->update)(snes, snes->iter);CHKERRQ(ierr);
}
/* Solve J Y = F, where J is Jacobian matrix */
ierr = SNESComputeJacobian(snes,X,snes->jacobian,snes->jacobian_pre);CHKERRQ(ierr);
SNESCheckJacobianDomainerror(snes);
ierr = KSPSetOperators(snes->ksp,snes->jacobian,snes->jacobian_pre);CHKERRQ(ierr);
ierr = KSPSolve(snes->ksp,F,Ytmp);CHKERRQ(ierr);
ierr = KSPGetIterationNumber(snes->ksp,&lits);CHKERRQ(ierr);
snes->linear_its += lits;
ierr = PetscInfo2(snes,"iter=%D, linear solve iterations=%D\n",snes->iter,lits);CHKERRQ(ierr);
ierr = VecNorm(Ytmp,NORM_2,&nrm);CHKERRQ(ierr);
norm1 = nrm;
while (1) {
ierr = VecCopy(Ytmp,Y);CHKERRQ(ierr);
nrm = norm1;
/* Scale Y if need be and predict new value of F norm */
if (nrm >= delta) {
nrm = delta/nrm;
gpnorm = (1.0 - nrm)*fnorm;
cnorm = nrm;
ierr = PetscInfo1(snes,"Scaling direction by %g\n",(double)nrm);CHKERRQ(ierr);
ierr = VecScale(Y,cnorm);CHKERRQ(ierr);
nrm = gpnorm;
ynorm = delta;
} else {
gpnorm = 0.0;
ierr = PetscInfo(snes,"Direction is in Trust Region\n");CHKERRQ(ierr);
ynorm = nrm;
}
ierr = VecAYPX(Y,-1.0,X);CHKERRQ(ierr); /* Y <- X - Y */
ierr = VecCopy(X,snes->vec_sol_update);CHKERRQ(ierr);
ierr = SNESComputeFunction(snes,Y,G);CHKERRQ(ierr); /* F(X) */
ierr = VecNorm(G,NORM_2,&gnorm);CHKERRQ(ierr); /* gnorm <- || g || */
if (fnorm == gpnorm) rho = 0.0;
else rho = (fnorm*fnorm - gnorm*gnorm)/(fnorm*fnorm - gpnorm*gpnorm);
/* Update size of trust region */
if (rho < neP->mu) delta *= neP->delta1;
else if (rho < neP->eta) delta *= neP->delta2;
else delta *= neP->delta3;
ierr = PetscInfo3(snes,"fnorm=%g, gnorm=%g, ynorm=%g\n",(double)fnorm,(double)gnorm,(double)ynorm);CHKERRQ(ierr);
ierr = PetscInfo3(snes,"gpred=%g, rho=%g, delta=%g\n",(double)gpnorm,(double)rho,(double)delta);CHKERRQ(ierr);
neP->delta = delta;
if (rho > neP->sigma) break;
ierr = PetscInfo(snes,"Trying again in smaller region\n");CHKERRQ(ierr);
/* check to see if progress is hopeless */
neP->itflag = PETSC_FALSE;
ierr = SNESTR_Converged_Private(snes,snes->iter,xnorm,ynorm,fnorm,&reason,snes->cnvP);CHKERRQ(ierr);
if (!reason) { ierr = (*snes->ops->converged)(snes,snes->iter,xnorm,ynorm,fnorm,&reason,snes->cnvP);CHKERRQ(ierr); }
if (reason) {
/* We're not progressing, so return with the current iterate */
ierr = SNESMonitor(snes,i+1,fnorm);CHKERRQ(ierr);
breakout = PETSC_TRUE;
break;
}
snes->numFailures++;
}
if (!breakout) {
/* Update function and solution vectors */
fnorm = gnorm;
ierr = VecCopy(G,F);CHKERRQ(ierr);
ierr = VecCopy(Y,X);CHKERRQ(ierr);
/* Monitor convergence */
ierr = PetscObjectSAWsTakeAccess((PetscObject)snes);CHKERRQ(ierr);
snes->iter = i+1;
snes->norm = fnorm;
snes->xnorm = xnorm;
snes->ynorm = ynorm;
ierr = PetscObjectSAWsGrantAccess((PetscObject)snes);CHKERRQ(ierr);
ierr = SNESLogConvergenceHistory(snes,snes->norm,lits);CHKERRQ(ierr);
ierr = SNESMonitor(snes,snes->iter,snes->norm);CHKERRQ(ierr);
/* Test for convergence, xnorm = || X || */
neP->itflag = PETSC_TRUE;
if (snes->ops->converged != SNESConvergedSkip) { ierr = VecNorm(X,NORM_2,&xnorm);CHKERRQ(ierr); }
ierr = (*snes->ops->converged)(snes,snes->iter,xnorm,ynorm,fnorm,&reason,snes->cnvP);CHKERRQ(ierr);
if (reason) break;
} else break;
}
if (i == maxits) {
ierr = PetscInfo1(snes,"Maximum number of iterations has been reached: %D\n",maxits);CHKERRQ(ierr);
if (!reason) reason = SNES_DIVERGED_MAX_IT;
}
ierr = PetscObjectSAWsTakeAccess((PetscObject)snes);CHKERRQ(ierr);
snes->reason = reason;
ierr = PetscObjectSAWsGrantAccess((PetscObject)snes);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode MatSeqBAIJSetNumericFactorization_inplace(Mat inA,PetscBool natural)
{
PetscFunctionBegin;
if (natural) {
switch (inA->rmap->bs) {
case 1:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_1_inplace;
break;
case 2:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_2_NaturalOrdering_inplace;
break;
case 3:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_3_NaturalOrdering_inplace;
break;
case 4:
#if defined(PETSC_USE_REAL_MAT_SINGLE)
{
PetscBool sse_enabled_local;
PetscErrorCode ierr;
ierr = PetscSSEIsEnabled(inA->comm,&sse_enabled_local,NULL);CHKERRQ(ierr);
if (sse_enabled_local) {
# if defined(PETSC_HAVE_SSE)
int i,*AJ=a->j,nz=a->nz,n=a->mbs;
if (n==(unsigned short)n) {
unsigned short *aj=(unsigned short*)AJ;
for (i=0; i<nz; i++) aj[i] = (unsigned short)AJ[i];
inA->ops->setunfactored = MatSetUnfactored_SeqBAIJ_4_NaturalOrdering_SSE_usj;
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_4_NaturalOrdering_SSE_usj;
ierr = PetscInfo(inA,"Using special SSE, in-place natural ordering, ushort j index factor BS=4\n");CHKERRQ(ierr);
} else {
/* Scale the column indices for easier indexing in MatSolve. */
/* for (i=0;i<nz;i++) { */
/* AJ[i] = AJ[i]*4; */
/* } */
inA->ops->setunfactored = MatSetUnfactored_SeqBAIJ_4_NaturalOrdering_SSE;
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_4_NaturalOrdering_SSE;
ierr = PetscInfo(inA,"Using special SSE, in-place natural ordering, int j index factor BS=4\n");CHKERRQ(ierr);
}
# else
/* This should never be reached. If so, problem in PetscSSEIsEnabled. */
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"SSE Hardware unavailable");
# endif
} else {
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_4_NaturalOrdering_inplace;
}
}
#else
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_4_NaturalOrdering_inplace;
#endif
break;
case 5:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_5_NaturalOrdering_inplace;
break;
case 6:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_6_NaturalOrdering_inplace;
break;
case 7:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_7_NaturalOrdering_inplace;
break;
default:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_N_inplace;
break;
}
} else {
switch (inA->rmap->bs) {
case 1:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_1_inplace;
break;
case 2:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_2_inplace;
break;
case 3:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_3_inplace;
break;
case 4:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_4_inplace;
break;
case 5:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_5_inplace;
break;
case 6:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_6_inplace;
break;
case 7:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_7_inplace;
break;
default:
inA->ops->lufactornumeric = MatLUFactorNumeric_SeqBAIJ_N_inplace;
break;
}
}
PetscFunctionReturn(0);
}
static PetscErrorCode PCSetUp_ILU(PC pc)
{
PetscErrorCode ierr;
PC_ILU *ilu = (PC_ILU*)pc->data;
MatInfo info;
PetscBool flg;
const MatSolverPackage stype;
MatFactorError err;
PetscFunctionBegin;
pc->failedreason = PC_NOERROR;
/* ugly hack to change default, since it is not support by some matrix types */
if (((PC_Factor*)ilu)->info.shifttype == (PetscReal)MAT_SHIFT_NONZERO) {
ierr = PetscObjectTypeCompare((PetscObject)pc->pmat,MATSEQAIJ,&flg);CHKERRQ(ierr);
if (!flg) {
ierr = PetscObjectTypeCompare((PetscObject)pc->pmat,MATMPIAIJ,&flg);CHKERRQ(ierr);
if (!flg) {
((PC_Factor*)ilu)->info.shifttype = (PetscReal)MAT_SHIFT_INBLOCKS;
PetscInfo(pc,"Changing shift type from NONZERO to INBLOCKS because block matrices do not support NONZERO\n");CHKERRQ(ierr);
}
}
}
ierr = MatSetErrorIfFailure(pc->pmat,pc->erroriffailure);CHKERRQ(ierr);
if (ilu->hdr.inplace) {
if (!pc->setupcalled) {
/* In-place factorization only makes sense with the natural ordering,
so we only need to get the ordering once, even if nonzero structure changes */
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)ilu)->ordering,&ilu->row,&ilu->col);CHKERRQ(ierr);
if (ilu->row) {ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)ilu->row);CHKERRQ(ierr);}
if (ilu->col) {ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)ilu->col);CHKERRQ(ierr);}
}
/* In place ILU only makes sense with fill factor of 1.0 because
cannot have levels of fill */
((PC_Factor*)ilu)->info.fill = 1.0;
((PC_Factor*)ilu)->info.diagonal_fill = 0.0;
ierr = MatILUFactor(pc->pmat,ilu->row,ilu->col,&((PC_Factor*)ilu)->info);CHKERRQ(ierr);CHKERRQ(ierr);
ierr = MatFactorGetError(pc->pmat,&err);CHKERRQ(ierr);
if (err) { /* Factor() fails */
pc->failedreason = (PCFailedReason)err;
PetscFunctionReturn(0);
}
((PC_Factor*)ilu)->fact = pc->pmat;
/* must update the pc record of the matrix state or the PC will attempt to run PCSetUp() yet again */
ierr = PetscObjectStateGet((PetscObject)pc->pmat,&pc->matstate);CHKERRQ(ierr);
} else {
if (!pc->setupcalled) {
/* first time in so compute reordering and symbolic factorization */
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)ilu)->ordering,&ilu->row,&ilu->col);CHKERRQ(ierr);
if (ilu->row) {ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)ilu->row);CHKERRQ(ierr);}
if (ilu->col) {ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)ilu->col);CHKERRQ(ierr);}
/* Remove zeros along diagonal? */
if (ilu->nonzerosalongdiagonal) {
ierr = MatReorderForNonzeroDiagonal(pc->pmat,ilu->nonzerosalongdiagonaltol,ilu->row,ilu->col);CHKERRQ(ierr);
}
if (!((PC_Factor*)ilu)->fact) {
ierr = MatGetFactor(pc->pmat,((PC_Factor*)ilu)->solvertype,MAT_FACTOR_ILU,&((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
}
ierr = MatILUFactorSymbolic(((PC_Factor*)ilu)->fact,pc->pmat,ilu->row,ilu->col,&((PC_Factor*)ilu)->info);CHKERRQ(ierr);
ierr = MatGetInfo(((PC_Factor*)ilu)->fact,MAT_LOCAL,&info);CHKERRQ(ierr);
ilu->hdr.actualfill = info.fill_ratio_needed;
ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
} else if (pc->flag != SAME_NONZERO_PATTERN) {
if (!ilu->hdr.reuseordering) {
/* compute a new ordering for the ILU */
ierr = ISDestroy(&ilu->row);CHKERRQ(ierr);
ierr = ISDestroy(&ilu->col);CHKERRQ(ierr);
ierr = MatGetOrdering(pc->pmat,((PC_Factor*)ilu)->ordering,&ilu->row,&ilu->col);CHKERRQ(ierr);
if (ilu->row) {ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)ilu->row);CHKERRQ(ierr);}
if (ilu->col) {ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)ilu->col);CHKERRQ(ierr);}
/* Remove zeros along diagonal? */
if (ilu->nonzerosalongdiagonal) {
ierr = MatReorderForNonzeroDiagonal(pc->pmat,ilu->nonzerosalongdiagonaltol,ilu->row,ilu->col);CHKERRQ(ierr);
}
}
ierr = MatDestroy(&((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
ierr = MatGetFactor(pc->pmat,((PC_Factor*)ilu)->solvertype,MAT_FACTOR_ILU,&((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
ierr = MatILUFactorSymbolic(((PC_Factor*)ilu)->fact,pc->pmat,ilu->row,ilu->col,&((PC_Factor*)ilu)->info);CHKERRQ(ierr);
ierr = MatGetInfo(((PC_Factor*)ilu)->fact,MAT_LOCAL,&info);CHKERRQ(ierr);
ilu->hdr.actualfill = info.fill_ratio_needed;
ierr = PetscLogObjectParent((PetscObject)pc,(PetscObject)((PC_Factor*)ilu)->fact);CHKERRQ(ierr);
}
ierr = MatFactorGetError(((PC_Factor*)ilu)->fact,&err);CHKERRQ(ierr);
if (err) { /* FactorSymbolic() fails */
pc->failedreason = (PCFailedReason)err;
PetscFunctionReturn(0);
}
ierr = MatLUFactorNumeric(((PC_Factor*)ilu)->fact,pc->pmat,&((PC_Factor*)ilu)->info);CHKERRQ(ierr);
ierr = MatFactorGetError(((PC_Factor*)ilu)->fact,&err);CHKERRQ(ierr);
if (err) { /* FactorNumeric() fails */
pc->failedreason = (PCFailedReason)err;
}
}
ierr = PCFactorGetMatSolverPackage(pc,&stype);CHKERRQ(ierr);
if (!stype) {
const MatSolverPackage solverpackage;
ierr = MatFactorGetSolverPackage(((PC_Factor*)ilu)->fact,&solverpackage);CHKERRQ(ierr);
ierr = PCFactorSetMatSolverPackage(pc,solverpackage);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/* @
TaoApply_BoundLineSearch - This routine performs a line search algorithm.
Input Parameters:
+ tao - TAO_SOLVER context
. X - current iterate (on output X contains new iterate, X + step*S)
. S - search direction
. f - objective function evaluated at X
. G - gradient evaluated at X
. W - work vector
- step - initial estimate of step length
Output parameters:
+ f - objective function evaluated at new iterate, X + step*S
. G - gradient evaluated at new iterate, X + step*S
. X - new iterate
. gnorm - 2-norm of G
- step - final step length
Info is set to one of:
+ 0 - the line search succeeds; the sufficient decrease
condition and the directional derivative condition hold
negative number if an input parameter is invalid
. -1 - step < 0
. -2 - ftol < 0
. -3 - rtol < 0
. -4 - gtol < 0
. -5 - stepmin < 0
. -6 - stepmax < stepmin
- -7 - maxfev < 0
positive number > 1 if the line search otherwise terminates
+ 2 - Relative width of the interval of uncertainty is
at most rtol.
. 3 - Maximum number of function evaluations (maxfev) has
been reached.
. 4 - Step is at the lower bound, stepmin.
. 5 - Step is at the upper bound, stepmax.
. 6 - Rounding errors may prevent further progress.
There may not be a step that satisfies the
sufficient decrease and curvature conditions.
Tolerances may be too small.
- 7 - Search direction is not a descent direction.
Notes:
This algorithm is is a modification of the algorithm by More' and
Thuente. The modifications concern bounds. This algorithm steps
in the direction passed into this routine. This point get
projected back into the feasible set. In the context of bound
constrained optimization, there may not be a point in the piecewise
linear path that satisfies the Wolfe conditions. When the active
set is changing, decrease in the objective function may be
sufficient to terminate this line search.
Note: Much of this coded is identical to the More' Thuente line search.
Variations to the code are commented.
Notes:
This routine is used within the following TAO bound constrained minimization
solvers: Newton linesearch (tao_tron) and limited memory variable metric
(tao_blmvm).
Level: advanced
.keywords: TAO_SOLVER, linesearch
@ */
static int TaoApply_BoundLineSearch(TAO_SOLVER tao,TaoVec* X,TaoVec* G,TaoVec* S,TaoVec* W,double *f, double *f_full,
double *step,TaoInt *info2,void*ctx)
{
TAO_LINESEARCH *neP = (TAO_LINESEARCH *) tao->linectx;
TaoVec *XL,*XU;
double xtrapf = 4.0;
double finit, width, width1, dginit, fm, fxm, fym, dgm, dgxm, dgym;
double dgx, dgy, dg, fx, fy, stx, sty, dgtest, ftest1=0.0, ftest2=0.0;
double bstepmin1, bstepmin2, bstepmax;
double dg1, dg2;
int info;
int need_gradient=0;
TaoInt i, stage1;
#if defined(PETSC_USE_COMPLEX)
PetscScalar cdginit, cdg, cstep = 0.0;
#endif
TaoFunctionBegin;
/* neP->stepmin - lower bound for step */
/* neP->stepmax - upper bound for step */
/* neP->rtol - relative tolerance for an acceptable step */
/* neP->ftol - tolerance for sufficient decrease condition */
/* neP->gtol - tolerance for curvature condition */
/* neP->nfev - number of function evaluations */
/* neP->maxfev - maximum number of function evaluations */
/* Check input parameters for errors */
if (*step < 0.0) {
info = PetscInfo1(tao,"TaoApply_BoundLineSearch:Line search error: step (%g) < 0\n",*step); CHKERRQ(info);
*info2 = -1; TaoFunctionReturn(0);
}
else if (neP->ftol < 0.0) {
info = PetscInfo1(tao,"TaoApply_BoundLineSearch:Line search error: ftol (%g) < 0\n",neP->ftol); CHKERRQ(info);
*info2 = -2; TaoFunctionReturn(0);
}
else if (neP->rtol < 0.0) {
info = PetscInfo1(tao,"TaoApply_BoundLineSearch:Line search error: rtol (%g) < 0\n",neP->rtol); CHKERRQ(info);
*info2 = -3; TaoFunctionReturn(0);
}
else if (neP->gtol < 0.0) {
info = PetscInfo1(tao,"TaoApply_BoundLineSearch:Line search error: gtol (%g) < 0\n",neP->gtol); CHKERRQ(info);
*info2 = -4; TaoFunctionReturn(0);
}
else if (neP->stepmin < 0.0) {
info = PetscInfo1(tao,"TaoApply_BoundLineSearch:Line search error: stepmin (%g) < 0\n",neP->stepmin); CHKERRQ(info);
*info2 = -5; TaoFunctionReturn(0);
}
else if (neP->stepmax < neP->stepmin) {
info = PetscInfo2(tao,"TaoApply_BoundLineSearch:Line search error: stepmax (%g) < stepmin (%g)\n", neP->stepmax,neP->stepmin); CHKERRQ(info);
*info2 = -6; TaoFunctionReturn(0);
}
else if (neP->maxfev < 0.0) {
info = PetscInfo1(tao,"TaoApply_BoundLineSearch:Line search error: maxfev (%d) < 0\n",neP->maxfev); CHKERRQ(info);
*info2 = -7; TaoFunctionReturn(0);
}
/* Compute step length needed to make all variables equal a bound */
/* Compute the smallest steplength that will make one nonbinding */
/* variable equal the bound */
double unBoundStepNorm, boundStepNorm;
info = TaoGetVariableBounds(tao,&XL,&XU); CHKERRQ(info);
info = S->Norm2(&unBoundStepNorm); CHKERRQ(info);
info = S->Negate(); CHKERRQ(info);
info = S->BoundGradientProjection(S,XL,X,XU); CHKERRQ(info);
info = S->Negate(); CHKERRQ(info);
info = S->Norm2(&boundStepNorm); CHKERRQ(info);
info = X->StepBoundInfo(XL,XU,S,&bstepmin1,&bstepmin2,&bstepmax); CHKERRQ(info);
neP->stepmax=TaoMin(bstepmax,1.0e+15);
info = PetscInfo2(tao,"TaoApply_BoundLineSearch:monitor: UnBoundNorm %22.12e, BoundNorm %22.12e \n",unBoundStepNorm,boundStepNorm); CHKERRQ(info);
/* Check that search direction is a descent direction */
#if defined(PETSC_USE_COMPLEX)
info = G->Dot(S,&cdginit);CHKERRQ(info); dginit = TaoReal(cdginit);
#else
info = G->Dot(S,&dginit);CHKERRQ(info);
#endif
if (dginit >= 0.0) {
info = PetscInfo1(tao,"TaoApply_BoundLineSearch:Search direction not a descent direction, dginit %22.12e \n",dginit); CHKERRQ(info);
*info2 = 7; TaoFunctionReturn(0);
}
/* Initialization */
neP->bracket = 0;
*info2 = 0;
stage1 = 1;
finit = *f;
dgtest = neP->ftol * dginit;
width = neP->stepmax - neP->stepmin;
width1 = width * 2.0;
info = W->CopyFrom(X);CHKERRQ(info);
/* Variable dictionary:
stx, fx, dgx - the step, function, and derivative at the best step
sty, fy, dgy - the step, function, and derivative at the other endpoint
of the interval of uncertainty
step, f, dg - the step, function, and derivative at the current step */
stx = 0.0;
fx = finit;
dgx = dginit;
sty = 0.0;
fy = finit;
dgy = dginit;
neP->nfev = 0;
tao->new_search=TAO_TRUE;
for (i=0; i< neP->maxfev; i++) {
/* Set min and max steps to correspond to the interval of uncertainty */
if (neP->bracket) {
neP->stepmin = TaoMin(stx,sty);
neP->stepmax = TaoMax(stx,sty);
} else {
neP->stepmin = stx;
neP->stepmax = *step + xtrapf * (*step - stx);
}
/* Force the step to be within the bounds */
*step = TaoMax(*step,neP->stepmin);
*step = TaoMin(*step,neP->stepmax);
/* If an unusual termination is to occur, then let step be the lowest
point obtained thus far */
if (((neP->bracket) && (*step <= neP->stepmin || *step >= neP->stepmax)) ||
((neP->bracket) && (neP->stepmax - neP->stepmin <= neP->rtol * neP->stepmax)) ||
(neP->nfev >= neP->maxfev - 1) || (neP->infoc == 0)) {
*step = stx;
}
#if defined(PETSC_USE_COMPLEX)
cstep = *step;
info = W->Waxpby(cstep,S,1.0,X);CHKERRQ(info);
#else
info = W->Waxpby(*step,S,1.0,X);CHKERRQ(info); /* W = X + step*S */
#endif
info=W->Median(XL,W,XU);CHKERRQ(info);
tao->current_step=*step;
if (tao->MeritFunctionGTSApply) {
info = TaoComputeMeritFunctionGTS(tao,W,S,f,&dg); CHKERRQ(info);
need_gradient = 1;
} else {
info = TaoComputeMeritFunctionGradient(tao,W,f,G);CHKERRQ(info);
tao->new_search=TAO_FALSE;
neP->nfev++;
#if defined(PETSC_USE_COMPLEX)
info = G->Dot(S,&cdg);CHKERRQ(info); dg = TaoReal(cdg);
#else
info = G->Dot(X,&dg1);CHKERRQ(info); /* dg = G^T S */
info = G->Dot(W,&dg2);CHKERRQ(info); /* dg = G^T S */
dg = (dg2-dg1) / (*step);
#endif
}
if (0 == i) {
*f_full = *f;
}
if ((*f != *f) || (dg1 != dg1) || (dg2 != dg2) || (dg != dg)) {
// User provided compute function generated Not-a-Number, assume
// domain violation and set function value and directional
// derivative to infinity.
*f = TAO_INFINITY;
dg = TAO_INFINITY;
dg1 = TAO_INFINITY;
dg2 = TAO_INFINITY;
}
ftest1 = finit + (*step) * dgtest;
ftest2 = finit + (*step) * dgtest * neP->ftol; // Armijo
info = PetscInfo7(tao, "TaoApply_BoundLineSearch:monitor: function %22.15e ftest1 %22.15e ftest2 %22.15e step %22.15e dg %22.15e gtol*dginit %22.15e bstepmin2 %22.15e \n",*f,ftest1,ftest2,*step,TaoAbsDouble(dg),neP->gtol*(-dginit),bstepmin2); CHKERRQ(info);
/* Convergence testing */
if ((*f <= ftest1) && (TaoAbsDouble(dg) <= neP->gtol*(-dginit))) {
info = PetscInfo(tao, "TaoApply_BoundLineSearch:Line search success: Sufficient decrease and directional deriv conditions hold\n"); CHKERRQ(info);
*info2 = 0;
break;
}
/* Check Armijo if beyond the first breakpoint */
if ((*f <= ftest2) && (*step >= bstepmin2)) {
info = PetscInfo(tao,"TaoApply_BoundLineSearch:Line search success: Sufficient decrease\n"); CHKERRQ(info);
*info2 = 0;
break;
}
/* Checks for bad cases */
if (((neP->bracket) && (*step <= neP->stepmin||*step >= neP->stepmax)) || (!neP->infoc)) {
info = PetscInfo(tao,"TaoApply_LineSearch:Rounding errors may prevent further progress. May not be a step satisfying\n"); CHKERRQ(info);
info = PetscInfo(tao,"TaoApply_BoundLineSearch:sufficient decrease and curvature conditions. Tolerances may be too small.\n"); CHKERRQ(info);
*info2 = 6; break;
}
if ((*step == neP->stepmax) && (*f <= ftest1) && (dg <= dgtest)) {
info = PetscInfo1(tao,"TaoApply_BoundLineSearch:Step is at the upper bound, stepmax (%g)\n",neP->stepmax); CHKERRQ(info);
*info2 = 5; break;
}
if ((*step == neP->stepmin) && (*f >= ftest1) && (dg >= dgtest)) {
info = PetscInfo1(tao,"TaoApply_BoundLineSearch:Step is at the lower bound, stepmin (%g)\n",neP->stepmin); CHKERRQ(info);
*info2 = 4; break;
}
if (neP->nfev >= neP->maxfev) {
info = PetscInfo2(tao,"TaoApply_BoundLineSearch:Number of line search function evals (%d) > maximum (%d)\n",neP->nfev,neP->maxfev); CHKERRQ(info);
*info2 = 3; break;
}
if ((neP->bracket) && (neP->stepmax - neP->stepmin <= neP->rtol*neP->stepmax)){
info = PetscInfo1(tao,"TaoApply_BoundLineSearch:Relative width of interval of uncertainty is at most rtol (%g)\n",neP->rtol); CHKERRQ(info);
*info2 = 2; break;
}
/* In the first stage, we seek a step for which the modified function
has a nonpositive value and nonnegative derivative */
if ((stage1) && (*f <= ftest1) && (dg >= dginit * TaoMin(neP->ftol, neP->gtol)))
stage1 = 0;
/* A modified function is used to predict the step only if we
have not obtained a step for which the modified function has a
nonpositive function value and nonnegative derivative, and if a
lower function value has been obtained but the decrease is not
sufficient */
if ((stage1) && (*f <= fx) && (*f > ftest1)) {
fm = *f - *step * dgtest; /* Define modified function */
fxm = fx - stx * dgtest; /* and derivatives */
fym = fy - sty * dgtest;
dgm = dg - dgtest;
dgxm = dgx - dgtest;
dgym = dgy - dgtest;
/* Update the interval of uncertainty and compute the new step */
info = TaoStep_LineSearch(tao,&stx,&fxm,&dgxm,&sty,&fym,&dgym,step,&fm,&dgm);CHKERRQ(info);
fx = fxm + stx * dgtest; /* Reset the function and */
fy = fym + sty * dgtest; /* gradient values */
dgx = dgxm + dgtest;
dgy = dgym + dgtest;
} else {
/* Update the interval of uncertainty and compute the new step */
info = TaoStep_LineSearch(tao,&stx,&fx,&dgx,&sty,&fy,&dgy,step,f,&dg);CHKERRQ(info);
}
/* Force a sufficient decrease in the interval of uncertainty */
if (neP->bracket) {
if (TaoAbsDouble(sty - stx) >= 0.66 * width1) *step = stx + 0.5*(sty - stx);
width1 = width;
width = TaoAbsDouble(sty - stx);
}
}
/* Finish computations */
info = X->CopyFrom(W); CHKERRQ(info);
if (need_gradient) {
info = TaoComputeMeritGradient(tao,X,G); CHKERRQ(info);
}
info = PetscInfo2(tao,"TaoApply_BoundLineSearch:%d function evals in line search, step = %10.4e\n",neP->nfev,*step); CHKERRQ(info);
TaoFunctionReturn(0);
}
PetscErrorCode MatLUFactorSymbolic_SeqBAIJ_inplace(Mat B,Mat A,IS isrow,IS iscol,const MatFactorInfo *info)
{
Mat_SeqBAIJ *a = (Mat_SeqBAIJ*)A->data,*b;
PetscInt n =a->mbs,bs = A->rmap->bs,bs2=a->bs2;
PetscBool row_identity,col_identity,both_identity;
IS isicol;
PetscErrorCode ierr;
const PetscInt *r,*ic;
PetscInt i,*ai=a->i,*aj=a->j;
PetscInt *bi,*bj,*ajtmp;
PetscInt *bdiag,row,nnz,nzi,reallocs=0,nzbd,*im;
PetscReal f;
PetscInt nlnk,*lnk,k,**bi_ptr;
PetscFreeSpaceList free_space=NULL,current_space=NULL;
PetscBT lnkbt;
PetscBool missing;
PetscFunctionBegin;
if (A->rmap->N != A->cmap->N) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"matrix must be square");
ierr = MatMissingDiagonal(A,&missing,&i);CHKERRQ(ierr);
if (missing) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"Matrix is missing diagonal entry %D",i);
ierr = ISInvertPermutation(iscol,PETSC_DECIDE,&isicol);CHKERRQ(ierr);
ierr = ISGetIndices(isrow,&r);CHKERRQ(ierr);
ierr = ISGetIndices(isicol,&ic);CHKERRQ(ierr);
/* get new row and diagonal pointers, must be allocated separately because they will be given to the Mat_SeqAIJ and freed separately */
ierr = PetscMalloc1(n+1,&bi);CHKERRQ(ierr);
ierr = PetscMalloc1(n+1,&bdiag);CHKERRQ(ierr);
bi[0] = bdiag[0] = 0;
/* linked list for storing column indices of the active row */
nlnk = n + 1;
ierr = PetscLLCreate(n,n,nlnk,lnk,lnkbt);CHKERRQ(ierr);
ierr = PetscMalloc2(n+1,&bi_ptr,n+1,&im);CHKERRQ(ierr);
/* initial FreeSpace size is f*(ai[n]+1) */
f = info->fill;
ierr = PetscFreeSpaceGet(PetscRealIntMultTruncate(f,ai[n]+1),&free_space);CHKERRQ(ierr);
current_space = free_space;
for (i=0; i<n; i++) {
/* copy previous fill into linked list */
nzi = 0;
nnz = ai[r[i]+1] - ai[r[i]];
ajtmp = aj + ai[r[i]];
ierr = PetscLLAddPerm(nnz,ajtmp,ic,n,nlnk,lnk,lnkbt);CHKERRQ(ierr);
nzi += nlnk;
/* add pivot rows into linked list */
row = lnk[n];
while (row < i) {
nzbd = bdiag[row] - bi[row] + 1; /* num of entries in the row with column index <= row */
ajtmp = bi_ptr[row] + nzbd; /* points to the entry next to the diagonal */
ierr = PetscLLAddSortedLU(ajtmp,row,nlnk,lnk,lnkbt,i,nzbd,im);CHKERRQ(ierr);
nzi += nlnk;
row = lnk[row];
}
bi[i+1] = bi[i] + nzi;
im[i] = nzi;
/* mark bdiag */
nzbd = 0;
nnz = nzi;
k = lnk[n];
while (nnz-- && k < i) {
nzbd++;
k = lnk[k];
}
bdiag[i] = bi[i] + nzbd;
/* if free space is not available, make more free space */
if (current_space->local_remaining<nzi) {
nnz = PetscIntMultTruncate(n - i,nzi); /* estimated and max additional space needed */
ierr = PetscFreeSpaceGet(nnz,¤t_space);CHKERRQ(ierr);
reallocs++;
}
/* copy data into free space, then initialize lnk */
ierr = PetscLLClean(n,n,nzi,lnk,current_space->array,lnkbt);CHKERRQ(ierr);
bi_ptr[i] = current_space->array;
current_space->array += nzi;
current_space->local_used += nzi;
current_space->local_remaining -= nzi;
}
#if defined(PETSC_USE_INFO)
if (ai[n] != 0) {
PetscReal af = ((PetscReal)bi[n])/((PetscReal)ai[n]);
ierr = PetscInfo3(A,"Reallocs %D Fill ratio:given %g needed %g\n",reallocs,(double)f,(double)af);CHKERRQ(ierr);
ierr = PetscInfo1(A,"Run with -pc_factor_fill %g or use \n",(double)af);CHKERRQ(ierr);
ierr = PetscInfo1(A,"PCFactorSetFill(pc,%g);\n",(double)af);CHKERRQ(ierr);
ierr = PetscInfo(A,"for best performance.\n");CHKERRQ(ierr);
} else {
ierr = PetscInfo(A,"Empty matrix\n");CHKERRQ(ierr);
}
#endif
ierr = ISRestoreIndices(isrow,&r);CHKERRQ(ierr);
ierr = ISRestoreIndices(isicol,&ic);CHKERRQ(ierr);
/* destroy list of free space and other temporary array(s) */
ierr = PetscMalloc1(bi[n]+1,&bj);CHKERRQ(ierr);
ierr = PetscFreeSpaceContiguous(&free_space,bj);CHKERRQ(ierr);
ierr = PetscLLDestroy(lnk,lnkbt);CHKERRQ(ierr);
ierr = PetscFree2(bi_ptr,im);CHKERRQ(ierr);
/* put together the new matrix */
ierr = MatSeqBAIJSetPreallocation_SeqBAIJ(B,bs,MAT_SKIP_ALLOCATION,NULL);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)B,(PetscObject)isicol);CHKERRQ(ierr);
b = (Mat_SeqBAIJ*)(B)->data;
b->free_a = PETSC_TRUE;
b->free_ij = PETSC_TRUE;
b->singlemalloc = PETSC_FALSE;
ierr = PetscMalloc1((bi[n]+1)*bs2,&b->a);CHKERRQ(ierr);
b->j = bj;
b->i = bi;
b->diag = bdiag;
b->free_diag = PETSC_TRUE;
b->ilen = 0;
b->imax = 0;
b->row = isrow;
b->col = iscol;
b->pivotinblocks = (info->pivotinblocks) ? PETSC_TRUE : PETSC_FALSE;
ierr = PetscObjectReference((PetscObject)isrow);CHKERRQ(ierr);
ierr = PetscObjectReference((PetscObject)iscol);CHKERRQ(ierr);
b->icol = isicol;
ierr = PetscMalloc1(bs*n+bs,&b->solve_work);CHKERRQ(ierr);
ierr = PetscLogObjectMemory((PetscObject)B,(bi[n]-n)*(sizeof(PetscInt)+sizeof(PetscScalar)*bs2));CHKERRQ(ierr);
b->maxnz = b->nz = bi[n];
(B)->factortype = MAT_FACTOR_LU;
(B)->info.factor_mallocs = reallocs;
(B)->info.fill_ratio_given = f;
if (ai[n] != 0) {
(B)->info.fill_ratio_needed = ((PetscReal)bi[n])/((PetscReal)ai[n]);
} else {
(B)->info.fill_ratio_needed = 0.0;
}
ierr = ISIdentity(isrow,&row_identity);CHKERRQ(ierr);
ierr = ISIdentity(iscol,&col_identity);CHKERRQ(ierr);
both_identity = (PetscBool) (row_identity && col_identity);
ierr = MatSeqBAIJSetNumericFactorization_inplace(B,both_identity);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode KSPSolve_CR(KSP ksp)
{
PetscErrorCode ierr;
PetscInt i = 0;
MatStructure pflag;
PetscReal dp;
PetscScalar ai, bi;
PetscScalar apq,btop, bbot;
Vec X,B,R,RT,P,AP,ART,Q;
Mat Amat, Pmat;
PetscFunctionBegin;
X = ksp->vec_sol;
B = ksp->vec_rhs;
R = ksp->work[0];
RT = ksp->work[1];
P = ksp->work[2];
AP = ksp->work[3];
ART = ksp->work[4];
Q = ksp->work[5];
/* R is the true residual norm, RT is the preconditioned residual norm */
ierr = PCGetOperators(ksp->pc,&Amat,&Pmat,&pflag);CHKERRQ(ierr);
if (!ksp->guess_zero) {
ierr = KSP_MatMult(ksp,Amat,X,R);CHKERRQ(ierr); /* R <- A*X */
ierr = VecAYPX(R,-1.0,B);CHKERRQ(ierr); /* R <- B-R == B-A*X */
} else {
ierr = VecCopy(B,R);CHKERRQ(ierr); /* R <- B (X is 0) */
}
ierr = KSP_PCApply(ksp,R,P);CHKERRQ(ierr); /* P <- B*R */
ierr = KSP_MatMult(ksp,Amat,P,AP);CHKERRQ(ierr); /* AP <- A*P */
ierr = VecCopy(P,RT);CHKERRQ(ierr); /* RT <- P */
ierr = VecCopy(AP,ART);CHKERRQ(ierr); /* ART <- AP */
ierr = VecDotBegin(RT,ART,&btop);CHKERRQ(ierr); /* (RT,ART) */
if (ksp->normtype == KSP_NORM_PRECONDITIONED) {
ierr = VecNormBegin(RT,NORM_2,&dp);CHKERRQ(ierr); /* dp <- RT'*RT */
ierr = VecDotEnd (RT,ART,&btop);CHKERRQ(ierr); /* (RT,ART) */
ierr = VecNormEnd (RT,NORM_2,&dp);CHKERRQ(ierr); /* dp <- RT'*RT */
} else if (ksp->normtype == KSP_NORM_UNPRECONDITIONED) {
ierr = VecNormBegin(R,NORM_2,&dp);CHKERRQ(ierr); /* dp <- R'*R */
ierr = VecDotEnd (RT,ART,&btop);CHKERRQ(ierr); /* (RT,ART) */
ierr = VecNormEnd (R,NORM_2,&dp);CHKERRQ(ierr); /* dp <- RT'*RT */
} else if (ksp->normtype == KSP_NORM_NATURAL) {
ierr = VecDotEnd (RT,ART,&btop);CHKERRQ(ierr); /* (RT,ART) */
dp = PetscSqrtReal(PetscAbsScalar(btop)); /* dp = sqrt(R,AR) */
}
if (PetscAbsScalar(btop) < 0.0) {
ksp->reason = KSP_DIVERGED_INDEFINITE_MAT;
ierr = PetscInfo(ksp,"diverging due to indefinite or negative definite matrix\n");CHKERRQ(ierr);
PetscFunctionReturn(0);
}
ksp->its = 0;
ierr = KSPMonitor(ksp,0,dp);CHKERRQ(ierr);
ierr = PetscObjectAMSTakeAccess((PetscObject)ksp);CHKERRQ(ierr);
ksp->rnorm = dp;
ierr = PetscObjectAMSGrantAccess((PetscObject)ksp);CHKERRQ(ierr);
ierr = KSPLogResidualHistory(ksp,dp);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,0,dp,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) PetscFunctionReturn(0);
i = 0;
do {
ierr = KSP_PCApply(ksp,AP,Q);CHKERRQ(ierr); /* Q <- B* AP */
ierr = VecDot(AP,Q,&apq);CHKERRQ(ierr);
if (PetscRealPart(apq) <= 0.0) {
ksp->reason = KSP_DIVERGED_INDEFINITE_PC;
ierr = PetscInfo(ksp,"KSPSolve_CR:diverging due to indefinite or negative definite PC\n");CHKERRQ(ierr);
break;
}
ai = btop/apq; /* ai = (RT,ART)/(AP,Q) */
ierr = VecAXPY(X,ai,P);CHKERRQ(ierr); /* X <- X + ai*P */
ierr = VecAXPY(RT,-ai,Q);CHKERRQ(ierr); /* RT <- RT - ai*Q */
ierr = KSP_MatMult(ksp,Amat,RT,ART);CHKERRQ(ierr); /* ART <- A*RT */
bbot = btop;
ierr = VecDotBegin(RT,ART,&btop);CHKERRQ(ierr);
if (ksp->normtype == KSP_NORM_PRECONDITIONED) {
ierr = VecNormBegin(RT,NORM_2,&dp);CHKERRQ(ierr); /* dp <- || RT || */
ierr = VecDotEnd (RT,ART,&btop);CHKERRQ(ierr);
ierr = VecNormEnd (RT,NORM_2,&dp);CHKERRQ(ierr); /* dp <- || RT || */
} else if (ksp->normtype == KSP_NORM_NATURAL) {
ierr = VecDotEnd(RT,ART,&btop);CHKERRQ(ierr);
dp = PetscSqrtReal(PetscAbsScalar(btop)); /* dp = sqrt(R,AR) */
} else if (ksp->normtype == KSP_NORM_NONE) {
ierr = VecDotEnd(RT,ART,&btop);CHKERRQ(ierr);
dp = 0.0;
} else if (ksp->normtype == KSP_NORM_UNPRECONDITIONED) {
ierr = VecAXPY(R,ai,AP);CHKERRQ(ierr); /* R <- R - ai*AP */
ierr = VecNormBegin(R,NORM_2,&dp);CHKERRQ(ierr); /* dp <- R'*R */
ierr = VecDotEnd (RT,ART,&btop);CHKERRQ(ierr);
ierr = VecNormEnd (R,NORM_2,&dp);CHKERRQ(ierr); /* dp <- R'*R */
} else SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"KSPNormType of %d not supported",(int)ksp->normtype);
if (PetscAbsScalar(btop) < 0.0) {
ksp->reason = KSP_DIVERGED_INDEFINITE_MAT;
ierr = PetscInfo(ksp,"diverging due to indefinite or negative definite PC\n");CHKERRQ(ierr);
break;
}
ierr = PetscObjectAMSTakeAccess((PetscObject)ksp);CHKERRQ(ierr);
ksp->its++;
ksp->rnorm = dp;
ierr = PetscObjectAMSGrantAccess((PetscObject)ksp);CHKERRQ(ierr);
ierr = KSPLogResidualHistory(ksp,dp);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,i+1,dp);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,i+1,dp,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) break;
bi = btop/bbot;
ierr = VecAYPX(P,bi,RT);CHKERRQ(ierr); /* P <- RT + Bi P */
ierr = VecAYPX(AP,bi,ART);CHKERRQ(ierr); /* AP <- ART + Bi AP */
i++;
} while (i<ksp->max_it);
if (i >= ksp->max_it) ksp->reason = KSP_DIVERGED_ITS;
PetscFunctionReturn(0);
}
/**************************************xyt.c***********************************/
static PetscErrorCode det_separators(xyt_ADT xyt_handle)
{
PetscInt i, ct, id;
PetscInt mask, edge, *iptr;
PetscInt *dir, *used;
PetscInt sum[4], w[4];
PetscScalar rsum[4], rw[4];
PetscInt op[] = {GL_ADD,0};
PetscScalar *lhs, *rhs;
PetscInt *nsep, *lnsep, *fo, nfo=0;
PCTFS_gs_ADT PCTFS_gs_handle=xyt_handle->mvi->PCTFS_gs_handle;
PetscInt *local2global =xyt_handle->mvi->local2global;
PetscInt n =xyt_handle->mvi->n;
PetscInt m =xyt_handle->mvi->m;
PetscInt level =xyt_handle->level;
PetscInt shared =0;
PetscErrorCode ierr;
PetscFunctionBegin;
dir = (PetscInt*)malloc(sizeof(PetscInt)*(level+1));
nsep = (PetscInt*)malloc(sizeof(PetscInt)*(level+1));
lnsep= (PetscInt*)malloc(sizeof(PetscInt)*(level+1));
fo = (PetscInt*)malloc(sizeof(PetscInt)*(n+1));
used = (PetscInt*)malloc(sizeof(PetscInt)*n);
PCTFS_ivec_zero(dir,level+1);
PCTFS_ivec_zero(nsep,level+1);
PCTFS_ivec_zero(lnsep,level+1);
PCTFS_ivec_set (fo,-1,n+1);
PCTFS_ivec_zero(used,n);
lhs = (PetscScalar*)malloc(sizeof(PetscScalar)*m);
rhs = (PetscScalar*)malloc(sizeof(PetscScalar)*m);
/* determine the # of unique dof */
PCTFS_rvec_zero(lhs,m);
PCTFS_rvec_set(lhs,1.0,n);
PCTFS_gs_gop_hc(PCTFS_gs_handle,lhs,"+\0",level);
ierr = PetscInfo(0,"done first PCTFS_gs_gop_hc\n");CHKERRQ(ierr);
PCTFS_rvec_zero(rsum,2);
for (ct=i=0; i<n; i++)
{
if (lhs[i]!=0.0) { rsum[0]+=1.0/lhs[i]; rsum[1]+=lhs[i]; }
if (lhs[i]!=1.0) shared=1;
}
PCTFS_grop_hc(rsum,rw,2,op,level);
rsum[0]+=0.1;
rsum[1]+=0.1;
xyt_handle->info->n_global=xyt_handle->info->m_global=(PetscInt) rsum[0];
xyt_handle->mvi->n_global =xyt_handle->mvi->m_global =(PetscInt) rsum[0];
/* determine separator sets top down */
if (shared) {
/* solution is to do as in the symmetric shared case but then */
/* pick the sub-hc with the most free dofs and do a mat-vec */
/* and pick up the responses on the other sub-hc from the */
/* initial separator set obtained from the symm. shared case */
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"shared dof separator determination not ready ... see hmt!!!\n");
for (iptr=fo+n,id=PCTFS_my_id,mask=PCTFS_num_nodes>>1,edge=level; edge>0; edge--,mask>>=1) {
/* set rsh of hc, fire, and collect lhs responses */
(id<mask) ? PCTFS_rvec_zero(lhs,m) : PCTFS_rvec_set(lhs,1.0,m);
PCTFS_gs_gop_hc(PCTFS_gs_handle,lhs,"+\0",edge);
/* set lsh of hc, fire, and collect rhs responses */
(id<mask) ? PCTFS_rvec_set(rhs,1.0,m) : PCTFS_rvec_zero(rhs,m);
PCTFS_gs_gop_hc(PCTFS_gs_handle,rhs,"+\0",edge);
for (i=0; i<n; i++) {
if (id< mask) {
if (lhs[i]!=0.0) lhs[i]=1.0;
}
if (id>=mask) {
if (rhs[i]!=0.0) rhs[i]=1.0;
}
}
if (id< mask) PCTFS_gs_gop_hc(PCTFS_gs_handle,lhs,"+\0",edge-1);
else PCTFS_gs_gop_hc(PCTFS_gs_handle,rhs,"+\0",edge-1);
/* count number of dofs I own that have signal and not in sep set */
PCTFS_rvec_zero(rsum,4);
for (PCTFS_ivec_zero(sum,4),ct=i=0;i<n;i++) {
if (!used[i]) {
/* number of unmarked dofs on node */
ct++;
/* number of dofs to be marked on lhs hc */
if (id< mask) {
if (lhs[i]!=0.0) { sum[0]++; rsum[0]+=1.0/lhs[i]; }
}
/* number of dofs to be marked on rhs hc */
if (id>=mask) {
if (rhs[i]!=0.0) { sum[1]++; rsum[1]+=1.0/rhs[i]; }
}
}
}
/* go for load balance - choose half with most unmarked dofs, bias LHS */
(id<mask) ? (sum[2]=ct) : (sum[3]=ct);
(id<mask) ? (rsum[2]=ct) : (rsum[3]=ct);
PCTFS_giop_hc(sum,w,4,op,edge);
PCTFS_grop_hc(rsum,rw,4,op,edge);
rsum[0]+=0.1; rsum[1]+=0.1; rsum[2]+=0.1; rsum[3]+=0.1;
if (id<mask) {
/* mark dofs I own that have signal and not in sep set */
for (ct=i=0;i<n;i++) {
if ((!used[i])&&(lhs[i]!=0.0)) {
ct++; nfo++;
if (nfo>n) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"nfo about to exceed n\n");
*--iptr = local2global[i];
used[i]=edge;
}
}
if (ct>1) PCTFS_ivec_sort(iptr,ct);
lnsep[edge]=ct;
nsep[edge] =(PetscInt) rsum[0];
dir [edge] =LEFT;
}
if (id>=mask) {
/* mark dofs I own that have signal and not in sep set */
for (ct=i=0;i<n;i++) {
if ((!used[i])&&(rhs[i]!=0.0)) {
ct++; nfo++;
if (nfo>n) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"nfo about to exceed n\n");
*--iptr = local2global[i];
used[i] =edge;
}
}
if (ct>1) PCTFS_ivec_sort(iptr,ct);
lnsep[edge] = ct;
nsep[edge] = (PetscInt) rsum[1];
dir [edge] = RIGHT;
}
/* LATER or we can recur on these to order seps at this level */
/* do we need full set of separators for this? */
/* fold rhs hc into lower */
if (id>=mask) id-=mask;
}
} else {
for (iptr=fo+n,id=PCTFS_my_id,mask=PCTFS_num_nodes>>1,edge=level;edge>0;edge--,mask>>=1) {
static PetscErrorCode TaoLineSearchApply_MT(TaoLineSearch ls, Vec x, PetscReal *f, Vec g, Vec s)
{
PetscErrorCode ierr;
TaoLineSearch_MT *mt;
PetscReal xtrapf = 4.0;
PetscReal finit, width, width1, dginit, fm, fxm, fym, dgm, dgxm, dgym;
PetscReal dgx, dgy, dg, dg2, fx, fy, stx, sty, dgtest;
PetscReal ftest1=0.0, ftest2=0.0;
PetscInt i, stage1,n1,n2,nn1,nn2;
PetscReal bstepmin1, bstepmin2, bstepmax;
PetscBool g_computed=PETSC_FALSE; /* to prevent extra gradient computation */
PetscFunctionBegin;
PetscValidHeaderSpecific(ls,TAOLINESEARCH_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,2);
PetscValidScalarPointer(f,3);
PetscValidHeaderSpecific(g,VEC_CLASSID,4);
PetscValidHeaderSpecific(s,VEC_CLASSID,5);
/* comm,type,size checks are done in interface TaoLineSearchApply */
mt = (TaoLineSearch_MT*)(ls->data);
ls->reason = TAOLINESEARCH_CONTINUE_ITERATING;
/* Check work vector */
if (!mt->work) {
ierr = VecDuplicate(x,&mt->work);CHKERRQ(ierr);
mt->x = x;
ierr = PetscObjectReference((PetscObject)mt->x);CHKERRQ(ierr);
} else if (x != mt->x) {
ierr = VecDestroy(&mt->work);CHKERRQ(ierr);
ierr = VecDuplicate(x,&mt->work);CHKERRQ(ierr);
ierr = PetscObjectDereference((PetscObject)mt->x);CHKERRQ(ierr);
mt->x = x;
ierr = PetscObjectReference((PetscObject)mt->x);CHKERRQ(ierr);
}
if (ls->bounded) {
/* Compute step length needed to make all variables equal a bound */
/* Compute the smallest steplength that will make one nonbinding variable
equal the bound */
ierr = VecGetLocalSize(ls->upper,&n1);CHKERRQ(ierr);
ierr = VecGetLocalSize(mt->x, &n2);CHKERRQ(ierr);
ierr = VecGetSize(ls->upper,&nn1);CHKERRQ(ierr);
ierr = VecGetSize(mt->x,&nn2);CHKERRQ(ierr);
if (n1 != n2 || nn1 != nn2) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_SIZ,"Variable vector not compatible with bounds vector");
ierr = VecScale(s,-1.0);CHKERRQ(ierr);
ierr = VecBoundGradientProjection(s,x,ls->lower,ls->upper,s);CHKERRQ(ierr);
ierr = VecScale(s,-1.0);CHKERRQ(ierr);
ierr = VecStepBoundInfo(x,s,ls->lower,ls->upper,&bstepmin1,&bstepmin2,&bstepmax);CHKERRQ(ierr);
ls->stepmax = PetscMin(bstepmax,1.0e15);
}
ierr = VecDot(g,s,&dginit);CHKERRQ(ierr);
if (PetscIsInfOrNanReal(dginit)) {
ierr = PetscInfo1(ls,"Initial Line Search step * g is Inf or Nan (%g)\n",(double)dginit);CHKERRQ(ierr);
ls->reason=TAOLINESEARCH_FAILED_INFORNAN;
PetscFunctionReturn(0);
}
if (dginit >= 0.0) {
ierr = PetscInfo1(ls,"Initial Line Search step * g is not descent direction (%g)\n",(double)dginit);CHKERRQ(ierr);
ls->reason = TAOLINESEARCH_FAILED_ASCENT;
PetscFunctionReturn(0);
}
/* Initialization */
mt->bracket = 0;
stage1 = 1;
finit = *f;
dgtest = ls->ftol * dginit;
width = ls->stepmax - ls->stepmin;
width1 = width * 2.0;
ierr = VecCopy(x,mt->work);CHKERRQ(ierr);
/* Variable dictionary:
stx, fx, dgx - the step, function, and derivative at the best step
sty, fy, dgy - the step, function, and derivative at the other endpoint
of the interval of uncertainty
step, f, dg - the step, function, and derivative at the current step */
stx = 0.0;
fx = finit;
dgx = dginit;
sty = 0.0;
fy = finit;
dgy = dginit;
ls->step=ls->initstep;
for (i=0; i< ls->max_funcs; i++) {
/* Set min and max steps to correspond to the interval of uncertainty */
if (mt->bracket) {
ls->stepmin = PetscMin(stx,sty);
ls->stepmax = PetscMax(stx,sty);
} else {
ls->stepmin = stx;
ls->stepmax = ls->step + xtrapf * (ls->step - stx);
}
/* Force the step to be within the bounds */
ls->step = PetscMax(ls->step,ls->stepmin);
ls->step = PetscMin(ls->step,ls->stepmax);
/* If an unusual termination is to occur, then let step be the lowest
point obtained thus far */
if ((stx!=0) && (((mt->bracket) && (ls->step <= ls->stepmin || ls->step >= ls->stepmax)) || ((mt->bracket) && (ls->stepmax - ls->stepmin <= ls->rtol * ls->stepmax)) ||
((ls->nfeval+ls->nfgeval) >= ls->max_funcs - 1) || (mt->infoc == 0))) {
ls->step = stx;
}
ierr = VecCopy(x,mt->work);CHKERRQ(ierr);
ierr = VecAXPY(mt->work,ls->step,s);CHKERRQ(ierr); /* W = X + step*S */
if (ls->bounded) {
ierr = VecMedian(ls->lower, mt->work, ls->upper, mt->work);CHKERRQ(ierr);
}
if (ls->usegts) {
ierr = TaoLineSearchComputeObjectiveAndGTS(ls,mt->work,f,&dg);CHKERRQ(ierr);
g_computed=PETSC_FALSE;
} else {
ierr = TaoLineSearchComputeObjectiveAndGradient(ls,mt->work,f,g);CHKERRQ(ierr);
g_computed=PETSC_TRUE;
if (ls->bounded) {
ierr = VecDot(g,x,&dg);CHKERRQ(ierr);
ierr = VecDot(g,mt->work,&dg2);CHKERRQ(ierr);
dg = (dg2 - dg)/ls->step;
} else {
ierr = VecDot(g,s,&dg);CHKERRQ(ierr);
}
}
if (0 == i) {
ls->f_fullstep=*f;
}
if (PetscIsInfOrNanReal(*f) || PetscIsInfOrNanReal(dg)) {
/* User provided compute function generated Not-a-Number, assume
domain violation and set function value and directional
derivative to infinity. */
*f = PETSC_INFINITY;
dg = PETSC_INFINITY;
}
ftest1 = finit + ls->step * dgtest;
if (ls->bounded) {
ftest2 = finit + ls->step * dgtest * ls->ftol;
}
/* Convergence testing */
if (((*f - ftest1 <= 1.0e-10 * PetscAbsReal(finit)) && (PetscAbsReal(dg) + ls->gtol*dginit <= 0.0))) {
ierr = PetscInfo(ls, "Line search success: Sufficient decrease and directional deriv conditions hold\n");CHKERRQ(ierr);
ls->reason = TAOLINESEARCH_SUCCESS;
break;
}
/* Check Armijo if beyond the first breakpoint */
if (ls->bounded && (*f <= ftest2) && (ls->step >= bstepmin2)) {
ierr = PetscInfo(ls,"Line search success: Sufficient decrease.\n");CHKERRQ(ierr);
ls->reason = TAOLINESEARCH_SUCCESS;
break;
}
/* Checks for bad cases */
if (((mt->bracket) && (ls->step <= ls->stepmin||ls->step >= ls->stepmax)) || (!mt->infoc)) {
ierr = PetscInfo(ls,"Rounding errors may prevent further progress. May not be a step satisfying\n");CHKERRQ(ierr);
ierr = PetscInfo(ls,"sufficient decrease and curvature conditions. Tolerances may be too small.\n");CHKERRQ(ierr);
ls->reason = TAOLINESEARCH_HALTED_OTHER;
break;
}
if ((ls->step == ls->stepmax) && (*f <= ftest1) && (dg <= dgtest)) {
ierr = PetscInfo1(ls,"Step is at the upper bound, stepmax (%g)\n",(double)ls->stepmax);CHKERRQ(ierr);
ls->reason = TAOLINESEARCH_HALTED_UPPERBOUND;
break;
}
if ((ls->step == ls->stepmin) && (*f >= ftest1) && (dg >= dgtest)) {
ierr = PetscInfo1(ls,"Step is at the lower bound, stepmin (%g)\n",(double)ls->stepmin);CHKERRQ(ierr);
ls->reason = TAOLINESEARCH_HALTED_LOWERBOUND;
break;
}
if ((mt->bracket) && (ls->stepmax - ls->stepmin <= ls->rtol*ls->stepmax)){
ierr = PetscInfo1(ls,"Relative width of interval of uncertainty is at most rtol (%g)\n",(double)ls->rtol);CHKERRQ(ierr);
ls->reason = TAOLINESEARCH_HALTED_RTOL;
break;
}
/* In the first stage, we seek a step for which the modified function
has a nonpositive value and nonnegative derivative */
if ((stage1) && (*f <= ftest1) && (dg >= dginit * PetscMin(ls->ftol, ls->gtol))) {
stage1 = 0;
}
/* A modified function is used to predict the step only if we
have not obtained a step for which the modified function has a
nonpositive function value and nonnegative derivative, and if a
lower function value has been obtained but the decrease is not
sufficient */
if ((stage1) && (*f <= fx) && (*f > ftest1)) {
fm = *f - ls->step * dgtest; /* Define modified function */
fxm = fx - stx * dgtest; /* and derivatives */
fym = fy - sty * dgtest;
dgm = dg - dgtest;
dgxm = dgx - dgtest;
dgym = dgy - dgtest;
/* if (dgxm * (ls->step - stx) >= 0.0) */
/* Update the interval of uncertainty and compute the new step */
ierr = Tao_mcstep(ls,&stx,&fxm,&dgxm,&sty,&fym,&dgym,&ls->step,&fm,&dgm);CHKERRQ(ierr);
fx = fxm + stx * dgtest; /* Reset the function and */
fy = fym + sty * dgtest; /* gradient values */
dgx = dgxm + dgtest;
dgy = dgym + dgtest;
} else {
/* Update the interval of uncertainty and compute the new step */
ierr = Tao_mcstep(ls,&stx,&fx,&dgx,&sty,&fy,&dgy,&ls->step,f,&dg);CHKERRQ(ierr);
}
/* Force a sufficient decrease in the interval of uncertainty */
if (mt->bracket) {
if (PetscAbsReal(sty - stx) >= 0.66 * width1) ls->step = stx + 0.5*(sty - stx);
width1 = width;
width = PetscAbsReal(sty - stx);
}
}
if ((ls->nfeval+ls->nfgeval) > ls->max_funcs) {
ierr = PetscInfo2(ls,"Number of line search function evals (%D) > maximum (%D)\n",(ls->nfeval+ls->nfgeval),ls->max_funcs);CHKERRQ(ierr);
ls->reason = TAOLINESEARCH_HALTED_MAXFCN;
}
/* Finish computations */
ierr = PetscInfo2(ls,"%D function evals in line search, step = %g\n",(ls->nfeval+ls->nfgeval),(double)ls->step);CHKERRQ(ierr);
/* Set new solution vector and compute gradient if needed */
ierr = VecCopy(mt->work,x);CHKERRQ(ierr);
if (!g_computed) {
ierr = TaoLineSearchComputeGradient(ls,mt->work,g);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
PetscErrorCode TaoPounders_solvequadratic(Tao tao,PetscReal *gnorm, PetscReal *qmin)
{
PetscErrorCode ierr;
#if defined(PETSC_USE_REAL_SINGLE)
PetscReal atol=1.0e-5;
#else
PetscReal atol=1.0e-10;
#endif
PetscInt info,its;
TAO_POUNDERS *mfqP = (TAO_POUNDERS*)tao->data;
PetscReal maxval;
PetscInt i,j;
PetscFunctionBegin;
ierr = VecCopy(mfqP->Gres, mfqP->subb);CHKERRQ(ierr);
ierr = VecSet(mfqP->subx,0.0);CHKERRQ(ierr);
ierr = VecSet(mfqP->subndel,-mfqP->delta);CHKERRQ(ierr);
ierr = VecSet(mfqP->subpdel,mfqP->delta);CHKERRQ(ierr);
ierr = MatCopy(mfqP->Hres,mfqP->subH,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = TaoResetStatistics(mfqP->subtao);CHKERRQ(ierr);
ierr = TaoSetTolerances(mfqP->subtao,NULL,NULL,*gnorm,*gnorm,NULL);CHKERRQ(ierr);
/* enforce bound constraints -- experimental */
if (tao->XU && tao->XL) {
ierr = VecCopy(tao->XU,mfqP->subxu);CHKERRQ(ierr);
ierr = VecAXPY(mfqP->subxu,-1.0,tao->solution);CHKERRQ(ierr);
ierr = VecScale(mfqP->subxu,1.0/mfqP->delta);CHKERRQ(ierr);
ierr = VecCopy(tao->XL,mfqP->subxl);CHKERRQ(ierr);
ierr = VecAXPY(mfqP->subxl,-1.0,tao->solution);CHKERRQ(ierr);
ierr = VecScale(mfqP->subxl,1.0/mfqP->delta);CHKERRQ(ierr);
ierr = VecPointwiseMin(mfqP->subxu,mfqP->subxu,mfqP->subpdel);CHKERRQ(ierr);
ierr = VecPointwiseMax(mfqP->subxl,mfqP->subxl,mfqP->subndel);CHKERRQ(ierr);
} else {
ierr = VecCopy(mfqP->subpdel,mfqP->subxu);CHKERRQ(ierr);
ierr = VecCopy(mfqP->subndel,mfqP->subxl);CHKERRQ(ierr);
}
/* Make sure xu > xl */
ierr = VecCopy(mfqP->subxl,mfqP->subpdel);CHKERRQ(ierr);
ierr = VecAXPY(mfqP->subpdel,-1.0,mfqP->subxu); CHKERRQ(ierr);
ierr = VecMax(mfqP->subpdel,NULL,&maxval);CHKERRQ(ierr);
if (maxval > 1e-10) {
SETERRQ(PETSC_COMM_WORLD,1,"upper bound < lower bound in subproblem");
}
/* Make sure xu > tao->solution > xl */
ierr = VecCopy(mfqP->subxl,mfqP->subpdel);CHKERRQ(ierr);
ierr = VecAXPY(mfqP->subpdel,-1.0,mfqP->subx); CHKERRQ(ierr);
ierr = VecMax(mfqP->subpdel,NULL,&maxval);CHKERRQ(ierr);
if (maxval > 1e-10) {
SETERRQ(PETSC_COMM_WORLD,1,"initial guess < lower bound in subproblem");
}
ierr = VecCopy(mfqP->subx,mfqP->subpdel);CHKERRQ(ierr);
ierr = VecAXPY(mfqP->subpdel,-1.0,mfqP->subxu); CHKERRQ(ierr);
ierr = VecMax(mfqP->subpdel,NULL,&maxval);CHKERRQ(ierr);
if (maxval > 1e-10) {
SETERRQ(PETSC_COMM_WORLD,1,"initial guess > upper bound in subproblem");
}
ierr = TaoSolve(mfqP->subtao);CHKERRQ(ierr);
ierr = TaoGetSolutionStatus(mfqP->subtao,NULL,qmin,NULL,NULL,NULL,NULL);CHKERRQ(ierr);
/* test bounds post-solution*/
ierr = VecCopy(mfqP->subxl,mfqP->subpdel);CHKERRQ(ierr);
ierr = VecAXPY(mfqP->subpdel,-1.0,mfqP->subx); CHKERRQ(ierr);
ierr = VecMax(mfqP->subpdel,NULL,&maxval);CHKERRQ(ierr);
if (maxval > 1e-5) {
ierr = PetscInfo(tao,"subproblem solution < lower bound");CHKERRQ(ierr);
tao->reason = TAO_DIVERGED_TR_REDUCTION;
}
ierr = VecCopy(mfqP->subx,mfqP->subpdel);CHKERRQ(ierr);
ierr = VecAXPY(mfqP->subpdel,-1.0,mfqP->subxu); CHKERRQ(ierr);
ierr = VecMax(mfqP->subpdel,NULL,&maxval);CHKERRQ(ierr);
if (maxval > 1e-5) {
ierr = PetscInfo(tao,"subproblem solution > upper bound");
tao->reason = TAO_DIVERGED_TR_REDUCTION;
}
*qmin *= -1;
PetscFunctionReturn(0);
}
PetscErrorCode EPSSolve_Lanczos(EPS eps)
{
EPS_LANCZOS *lanczos = (EPS_LANCZOS*)eps->data;
PetscErrorCode ierr;
PetscInt nconv,i,j,k,l,x,n,*perm,restart,ncv=eps->ncv,r,ld;
Vec vi,vj,w;
Mat U;
PetscScalar *Y,*ritz,stmp;
PetscReal *d,*e,*bnd,anorm,beta,norm,rtmp,resnorm;
PetscBool breakdown;
char *conv,ctmp;
PetscFunctionBegin;
ierr = DSGetLeadingDimension(eps->ds,&ld);CHKERRQ(ierr);
ierr = PetscMalloc4(ncv,&ritz,ncv,&bnd,ncv,&perm,ncv,&conv);CHKERRQ(ierr);
/* The first Lanczos vector is the normalized initial vector */
ierr = EPSGetStartVector(eps,0,NULL);CHKERRQ(ierr);
anorm = -1.0;
nconv = 0;
/* Restart loop */
while (eps->reason == EPS_CONVERGED_ITERATING) {
eps->its++;
/* Compute an ncv-step Lanczos factorization */
n = PetscMin(nconv+eps->mpd,ncv);
ierr = DSGetArrayReal(eps->ds,DS_MAT_T,&d);CHKERRQ(ierr);
e = d + ld;
ierr = EPSBasicLanczos(eps,d,e,nconv,&n,&breakdown,anorm);CHKERRQ(ierr);
beta = e[n-1];
ierr = DSRestoreArrayReal(eps->ds,DS_MAT_T,&d);CHKERRQ(ierr);
ierr = DSSetDimensions(eps->ds,n,0,nconv,0);CHKERRQ(ierr);
ierr = DSSetState(eps->ds,DS_STATE_INTERMEDIATE);CHKERRQ(ierr);
ierr = BVSetActiveColumns(eps->V,nconv,n);CHKERRQ(ierr);
/* Solve projected problem */
ierr = DSSolve(eps->ds,ritz,NULL);CHKERRQ(ierr);
ierr = DSSort(eps->ds,ritz,NULL,NULL,NULL,NULL);CHKERRQ(ierr);
/* Estimate ||A|| */
for (i=nconv;i<n;i++)
anorm = PetscMax(anorm,PetscAbsReal(PetscRealPart(ritz[i])));
/* Compute residual norm estimates as beta*abs(Y(m,:)) + eps*||A|| */
ierr = DSGetArray(eps->ds,DS_MAT_Q,&Y);CHKERRQ(ierr);
for (i=nconv;i<n;i++) {
resnorm = beta*PetscAbsScalar(Y[n-1+i*ld]) + PETSC_MACHINE_EPSILON*anorm;
ierr = (*eps->converged)(eps,ritz[i],eps->eigi[i],resnorm,&bnd[i],eps->convergedctx);CHKERRQ(ierr);
if (bnd[i]<eps->tol) conv[i] = 'C';
else conv[i] = 'N';
}
ierr = DSRestoreArray(eps->ds,DS_MAT_Q,&Y);CHKERRQ(ierr);
/* purge repeated ritz values */
if (lanczos->reorthog == EPS_LANCZOS_REORTHOG_LOCAL) {
for (i=nconv+1;i<n;i++) {
if (conv[i] == 'C' && PetscAbsScalar((ritz[i]-ritz[i-1])/ritz[i]) < eps->tol) conv[i] = 'R';
}
}
/* Compute restart vector */
if (breakdown) {
ierr = PetscInfo2(eps,"Breakdown in Lanczos method (it=%D norm=%g)\n",eps->its,(double)beta);CHKERRQ(ierr);
} else {
restart = nconv;
while (restart<n && conv[restart] != 'N') restart++;
if (restart >= n) {
breakdown = PETSC_TRUE;
} else {
for (i=restart+1;i<n;i++) {
if (conv[i] == 'N') {
ierr = SlepcSCCompare(eps->sc,ritz[restart],0.0,ritz[i],0.0,&r);CHKERRQ(ierr);
if (r>0) restart = i;
}
}
ierr = DSGetArray(eps->ds,DS_MAT_Q,&Y);CHKERRQ(ierr);
ierr = BVMultColumn(eps->V,1.0,0.0,n,Y+restart*ld+nconv);CHKERRQ(ierr);
ierr = DSRestoreArray(eps->ds,DS_MAT_Q,&Y);CHKERRQ(ierr);
}
}
/* Count and put converged eigenvalues first */
for (i=nconv;i<n;i++) perm[i] = i;
for (k=nconv;k<n;k++) {
if (conv[perm[k]] != 'C') {
j = k + 1;
while (j<n && conv[perm[j]] != 'C') j++;
if (j>=n) break;
l = perm[k]; perm[k] = perm[j]; perm[j] = l;
}
}
/* Sort eigenvectors according to permutation */
ierr = DSGetArray(eps->ds,DS_MAT_Q,&Y);CHKERRQ(ierr);
for (i=nconv;i<k;i++) {
x = perm[i];
if (x != i) {
j = i + 1;
while (perm[j] != i) j++;
/* swap eigenvalues i and j */
stmp = ritz[x]; ritz[x] = ritz[i]; ritz[i] = stmp;
rtmp = bnd[x]; bnd[x] = bnd[i]; bnd[i] = rtmp;
ctmp = conv[x]; conv[x] = conv[i]; conv[i] = ctmp;
perm[j] = x; perm[i] = i;
/* swap eigenvectors i and j */
for (l=0;l<n;l++) {
stmp = Y[l+x*ld]; Y[l+x*ld] = Y[l+i*ld]; Y[l+i*ld] = stmp;
}
}
}
ierr = DSRestoreArray(eps->ds,DS_MAT_Q,&Y);CHKERRQ(ierr);
/* compute converged eigenvectors */
ierr = DSGetMat(eps->ds,DS_MAT_Q,&U);CHKERRQ(ierr);
ierr = BVMultInPlace(eps->V,U,nconv,k);CHKERRQ(ierr);
ierr = MatDestroy(&U);CHKERRQ(ierr);
/* purge spurious ritz values */
if (lanczos->reorthog == EPS_LANCZOS_REORTHOG_LOCAL) {
for (i=nconv;i<k;i++) {
ierr = BVGetColumn(eps->V,i,&vi);CHKERRQ(ierr);
ierr = VecNorm(vi,NORM_2,&norm);CHKERRQ(ierr);
ierr = VecScale(vi,1.0/norm);CHKERRQ(ierr);
w = eps->work[0];
ierr = STApply(eps->st,vi,w);CHKERRQ(ierr);
ierr = VecAXPY(w,-ritz[i],vi);CHKERRQ(ierr);
ierr = BVRestoreColumn(eps->V,i,&vi);CHKERRQ(ierr);
ierr = VecNorm(w,NORM_2,&norm);CHKERRQ(ierr);
ierr = (*eps->converged)(eps,ritz[i],eps->eigi[i],norm,&bnd[i],eps->convergedctx);CHKERRQ(ierr);
if (bnd[i]>=eps->tol) conv[i] = 'S';
}
for (i=nconv;i<k;i++) {
if (conv[i] != 'C') {
j = i + 1;
while (j<k && conv[j] != 'C') j++;
if (j>=k) break;
/* swap eigenvalues i and j */
stmp = ritz[j]; ritz[j] = ritz[i]; ritz[i] = stmp;
rtmp = bnd[j]; bnd[j] = bnd[i]; bnd[i] = rtmp;
ctmp = conv[j]; conv[j] = conv[i]; conv[i] = ctmp;
/* swap eigenvectors i and j */
ierr = BVGetColumn(eps->V,i,&vi);CHKERRQ(ierr);
ierr = BVGetColumn(eps->V,j,&vj);CHKERRQ(ierr);
ierr = VecSwap(vi,vj);CHKERRQ(ierr);
ierr = BVRestoreColumn(eps->V,i,&vi);CHKERRQ(ierr);
ierr = BVRestoreColumn(eps->V,j,&vj);CHKERRQ(ierr);
}
}
k = i;
}
/* store ritz values and estimated errors */
for (i=nconv;i<n;i++) {
eps->eigr[i] = ritz[i];
eps->errest[i] = bnd[i];
}
ierr = EPSMonitor(eps,eps->its,nconv,eps->eigr,eps->eigi,eps->errest,n);CHKERRQ(ierr);
nconv = k;
if (eps->its >= eps->max_it) eps->reason = EPS_DIVERGED_ITS;
if (nconv >= eps->nev) eps->reason = EPS_CONVERGED_TOL;
if (eps->reason == EPS_CONVERGED_ITERATING) { /* copy restart vector */
ierr = BVCopyColumn(eps->V,n,nconv);CHKERRQ(ierr);
if (lanczos->reorthog == EPS_LANCZOS_REORTHOG_LOCAL && !breakdown) {
/* Reorthonormalize restart vector */
ierr = BVOrthogonalizeColumn(eps->V,nconv,NULL,&norm,&breakdown);CHKERRQ(ierr);
ierr = BVScaleColumn(eps->V,nconv,1.0/norm);CHKERRQ(ierr);
}
if (breakdown) {
/* Use random vector for restarting */
ierr = PetscInfo(eps,"Using random vector for restart\n");CHKERRQ(ierr);
ierr = EPSGetStartVector(eps,nconv,&breakdown);CHKERRQ(ierr);
}
if (breakdown) { /* give up */
eps->reason = EPS_DIVERGED_BREAKDOWN;
ierr = PetscInfo(eps,"Unable to generate more start vectors\n");CHKERRQ(ierr);
}
}
}
eps->nconv = nconv;
ierr = PetscFree4(ritz,bnd,perm,conv);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode EPSSolve_Arnoldi(EPS eps)
{
PetscErrorCode ierr;
PetscInt k,nv,ld;
Mat U;
PetscScalar *H,*X;
PetscReal beta,gamma=1.0;
PetscBool breakdown,harmonic,refined;
BVOrthogRefineType orthog_ref;
EPS_ARNOLDI *arnoldi = (EPS_ARNOLDI*)eps->data;
PetscFunctionBegin;
ierr = DSGetLeadingDimension(eps->ds,&ld);CHKERRQ(ierr);
ierr = DSGetRefined(eps->ds,&refined);CHKERRQ(ierr);
harmonic = (eps->extraction==EPS_HARMONIC || eps->extraction==EPS_REFINED_HARMONIC)?PETSC_TRUE:PETSC_FALSE;
ierr = BVGetOrthogonalization(eps->V,NULL,&orthog_ref,NULL);CHKERRQ(ierr);
/* Get the starting Arnoldi vector */
ierr = EPSGetStartVector(eps,0,NULL);CHKERRQ(ierr);
/* Restart loop */
while (eps->reason == EPS_CONVERGED_ITERATING) {
eps->its++;
/* Compute an nv-step Arnoldi factorization */
nv = PetscMin(eps->nconv+eps->mpd,eps->ncv);
ierr = DSSetDimensions(eps->ds,nv,0,eps->nconv,0);CHKERRQ(ierr);
ierr = DSGetArray(eps->ds,DS_MAT_A,&H);CHKERRQ(ierr);
if (!arnoldi->delayed) {
ierr = EPSBasicArnoldi(eps,PETSC_FALSE,H,ld,eps->nconv,&nv,&beta,&breakdown);CHKERRQ(ierr);
} else SETERRQ(PetscObjectComm((PetscObject)eps),1,"Not implemented");
/*if (orthog_ref == BV_ORTHOG_REFINE_NEVER) {
ierr = EPSDelayedArnoldi1(eps,H,ld,eps->V,eps->nconv,&nv,f,&beta,&breakdown);CHKERRQ(ierr);
} else {
ierr = EPSDelayedArnoldi(eps,H,ld,eps->V,eps->nconv,&nv,f,&beta,&breakdown);CHKERRQ(ierr);
}*/
ierr = DSRestoreArray(eps->ds,DS_MAT_A,&H);CHKERRQ(ierr);
ierr = DSSetState(eps->ds,DS_STATE_INTERMEDIATE);CHKERRQ(ierr);
ierr = BVSetActiveColumns(eps->V,eps->nconv,nv);CHKERRQ(ierr);
/* Compute translation of Krylov decomposition if harmonic extraction used */
if (harmonic) {
ierr = DSTranslateHarmonic(eps->ds,eps->target,beta,PETSC_FALSE,NULL,&gamma);CHKERRQ(ierr);
}
/* Solve projected problem */
ierr = DSSolve(eps->ds,eps->eigr,eps->eigi);CHKERRQ(ierr);
ierr = DSSort(eps->ds,eps->eigr,eps->eigi,NULL,NULL,NULL);CHKERRQ(ierr);
ierr = DSUpdateExtraRow(eps->ds);CHKERRQ(ierr);
/* Check convergence */
ierr = EPSKrylovConvergence(eps,PETSC_FALSE,eps->nconv,nv-eps->nconv,beta,gamma,&k);CHKERRQ(ierr);
if (refined) {
ierr = DSGetArray(eps->ds,DS_MAT_X,&X);CHKERRQ(ierr);
ierr = BVMultColumn(eps->V,1.0,0.0,k,X+k*ld);CHKERRQ(ierr);
ierr = DSRestoreArray(eps->ds,DS_MAT_X,&X);CHKERRQ(ierr);
ierr = DSGetMat(eps->ds,DS_MAT_Q,&U);CHKERRQ(ierr);
ierr = BVMultInPlace(eps->V,U,eps->nconv,nv);CHKERRQ(ierr);
ierr = MatDestroy(&U);CHKERRQ(ierr);
ierr = BVOrthogonalizeColumn(eps->V,k,NULL,NULL,NULL);CHKERRQ(ierr);
} else {
ierr = DSGetMat(eps->ds,DS_MAT_Q,&U);CHKERRQ(ierr);
ierr = BVMultInPlace(eps->V,U,eps->nconv,nv);CHKERRQ(ierr);
ierr = MatDestroy(&U);CHKERRQ(ierr);
}
eps->nconv = k;
ierr = EPSMonitor(eps,eps->its,eps->nconv,eps->eigr,eps->eigi,eps->errest,nv);CHKERRQ(ierr);
if (breakdown && k<eps->nev) {
ierr = PetscInfo2(eps,"Breakdown in Arnoldi method (it=%D norm=%g)\n",eps->its,(double)beta);CHKERRQ(ierr);
ierr = EPSGetStartVector(eps,k,&breakdown);CHKERRQ(ierr);
if (breakdown) {
eps->reason = EPS_DIVERGED_BREAKDOWN;
ierr = PetscInfo(eps,"Unable to generate more start vectors\n");CHKERRQ(ierr);
}
}
if (eps->its >= eps->max_it) eps->reason = EPS_DIVERGED_ITS;
if (eps->nconv >= eps->nev) eps->reason = EPS_CONVERGED_TOL;
}
/* truncate Schur decomposition and change the state to raw so that
PSVectors() computes eigenvectors from scratch */
ierr = DSSetDimensions(eps->ds,eps->nconv,0,0,0);CHKERRQ(ierr);
ierr = DSSetState(eps->ds,DS_STATE_RAW);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode TaoSolve_SSFLS(Tao tao)
{
TAO_SSLS *ssls = (TAO_SSLS *)tao->data;
PetscReal psi, ndpsi, normd, innerd, t=0;
PetscReal delta, rho;
PetscInt iter=0,kspits;
TaoConvergedReason reason;
TaoLineSearchConvergedReason ls_reason;
PetscErrorCode ierr;
PetscFunctionBegin;
/* Assume that Setup has been called!
Set the structure for the Jacobian and create a linear solver. */
delta = ssls->delta;
rho = ssls->rho;
ierr = TaoComputeVariableBounds(tao);CHKERRQ(ierr);
/* Project solution inside bounds */
ierr = VecMedian(tao->XL,tao->solution,tao->XU,tao->solution);CHKERRQ(ierr);
ierr = TaoLineSearchSetObjectiveAndGradientRoutine(tao->linesearch,Tao_SSLS_FunctionGradient,tao);CHKERRQ(ierr);
ierr = TaoLineSearchSetObjectiveRoutine(tao->linesearch,Tao_SSLS_Function,tao);CHKERRQ(ierr);
/* Calculate the function value and fischer function value at the
current iterate */
ierr = TaoLineSearchComputeObjectiveAndGradient(tao->linesearch,tao->solution,&psi,ssls->dpsi);CHKERRQ(ierr);
ierr = VecNorm(ssls->dpsi,NORM_2,&ndpsi);CHKERRQ(ierr);
while (1) {
ierr=PetscInfo3(tao, "iter: %D, merit: %g, ndpsi: %g\n",iter, (double)ssls->merit, (double)ndpsi);CHKERRQ(ierr);
/* Check the termination criteria */
ierr = TaoMonitor(tao,iter++,ssls->merit,ndpsi,0.0,t,&reason);CHKERRQ(ierr);
if (reason!=TAO_CONTINUE_ITERATING) break;
/* Calculate direction. (Really negative of newton direction. Therefore,
rest of the code uses -d.) */
ierr = KSPSetOperators(tao->ksp,tao->jacobian,tao->jacobian_pre);CHKERRQ(ierr);
ierr = KSPSolve(tao->ksp,ssls->ff,tao->stepdirection);CHKERRQ(ierr);
ierr = KSPGetIterationNumber(tao->ksp,&kspits);CHKERRQ(ierr);
tao->ksp_its+=kspits;
ierr = VecCopy(tao->stepdirection,ssls->w);CHKERRQ(ierr);
ierr = VecScale(ssls->w,-1.0);CHKERRQ(ierr);
ierr = VecBoundGradientProjection(ssls->w,tao->solution,tao->XL,tao->XU,ssls->w);CHKERRQ(ierr);
ierr = VecNorm(ssls->w,NORM_2,&normd);CHKERRQ(ierr);
ierr = VecDot(ssls->w,ssls->dpsi,&innerd);CHKERRQ(ierr);
/* Make sure that we have a descent direction */
if (innerd >= -delta*pow(normd, rho)) {
ierr = PetscInfo(tao, "newton direction not descent\n");CHKERRQ(ierr);
ierr = VecCopy(ssls->dpsi,tao->stepdirection);CHKERRQ(ierr);
ierr = VecDot(ssls->w,ssls->dpsi,&innerd);CHKERRQ(ierr);
}
ierr = VecScale(tao->stepdirection, -1.0);CHKERRQ(ierr);
innerd = -innerd;
ierr = TaoLineSearchSetInitialStepLength(tao->linesearch,1.0);
ierr = TaoLineSearchApply(tao->linesearch,tao->solution,&psi,ssls->dpsi,tao->stepdirection,&t,&ls_reason);CHKERRQ(ierr);
ierr = VecNorm(ssls->dpsi,NORM_2,&ndpsi);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
PetscErrorCode KSPSolve_CG(KSP ksp)
{
PetscErrorCode ierr;
PetscInt i,stored_max_it,eigs;
PetscScalar dpi = 0.0,a = 1.0,beta,betaold = 1.0,b = 0,*e = 0,*d = 0,delta,dpiold;
PetscReal dp = 0.0;
Vec X,B,Z,R,P,S,W;
KSP_CG *cg;
Mat Amat,Pmat;
PetscBool diagonalscale;
PetscFunctionBegin;
ierr = PCGetDiagonalScale(ksp->pc,&diagonalscale);CHKERRQ(ierr);
if (diagonalscale) SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"Krylov method %s does not support diagonal scaling",((PetscObject)ksp)->type_name);
cg = (KSP_CG*)ksp->data;
eigs = ksp->calc_sings;
stored_max_it = ksp->max_it;
X = ksp->vec_sol;
B = ksp->vec_rhs;
R = ksp->work[0];
Z = ksp->work[1];
P = ksp->work[2];
if (cg->singlereduction) {
S = ksp->work[3];
W = ksp->work[4];
} else {
S = 0; /* unused */
W = Z;
}
#define VecXDot(x,y,a) (((cg->type) == (KSP_CG_HERMITIAN)) ? VecDot(x,y,a) : VecTDot(x,y,a))
if (eigs) {e = cg->e; d = cg->d; e[0] = 0.0; }
ierr = PCGetOperators(ksp->pc,&Amat,&Pmat);CHKERRQ(ierr);
ksp->its = 0;
if (!ksp->guess_zero) {
ierr = KSP_MatMult(ksp,Amat,X,R);CHKERRQ(ierr); /* r <- b - Ax */
ierr = VecAYPX(R,-1.0,B);CHKERRQ(ierr);
} else {
ierr = VecCopy(B,R);CHKERRQ(ierr); /* r <- b (x is 0) */
}
switch (ksp->normtype) {
case KSP_NORM_PRECONDITIONED:
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
ierr = VecNorm(Z,NORM_2,&dp);CHKERRQ(ierr); /* dp <- z'*z = e'*A'*B'*B*A'*e' */
break;
case KSP_NORM_UNPRECONDITIONED:
ierr = VecNorm(R,NORM_2,&dp);CHKERRQ(ierr); /* dp <- r'*r = e'*A'*A*e */
break;
case KSP_NORM_NATURAL:
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
if (cg->singlereduction) {
ierr = KSP_MatMult(ksp,Amat,Z,S);CHKERRQ(ierr);
ierr = VecXDot(Z,S,&delta);CHKERRQ(ierr);
}
ierr = VecXDot(Z,R,&beta);CHKERRQ(ierr); /* beta <- z'*r */
if (PetscIsInfOrNanScalar(beta)) {
if (ksp->errorifnotconverged) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_NOT_CONVERGED,"KSPSolve has not converged due to Nan or Inf inner product");
else {
ksp->reason = KSP_DIVERGED_NANORINF;
PetscFunctionReturn(0);
}
}
dp = PetscSqrtReal(PetscAbsScalar(beta)); /* dp <- r'*z = r'*B*r = e'*A'*B*A*e */
break;
case KSP_NORM_NONE:
dp = 0.0;
break;
default: SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"%s",KSPNormTypes[ksp->normtype]);
}
ierr = KSPLogResidualHistory(ksp,dp);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,0,dp);CHKERRQ(ierr);
ksp->rnorm = dp;
ierr = (*ksp->converged)(ksp,0,dp,&ksp->reason,ksp->cnvP);CHKERRQ(ierr); /* test for convergence */
if (ksp->reason) PetscFunctionReturn(0);
if (ksp->normtype != KSP_NORM_PRECONDITIONED && (ksp->normtype != KSP_NORM_NATURAL)) {
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
}
if (ksp->normtype != KSP_NORM_NATURAL) {
if (cg->singlereduction) {
ierr = KSP_MatMult(ksp,Amat,Z,S);CHKERRQ(ierr);
ierr = VecXDot(Z,S,&delta);CHKERRQ(ierr);
}
ierr = VecXDot(Z,R,&beta);CHKERRQ(ierr); /* beta <- z'*r */
if (PetscIsInfOrNanScalar(beta)) {
if (ksp->errorifnotconverged) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_NOT_CONVERGED,"KSPSolve has not converged due to Nan or Inf inner product");
else {
ksp->reason = KSP_DIVERGED_NANORINF;
PetscFunctionReturn(0);
}
}
}
i = 0;
do {
ksp->its = i+1;
if (beta == 0.0) {
ksp->reason = KSP_CONVERGED_ATOL;
ierr = PetscInfo(ksp,"converged due to beta = 0\n");CHKERRQ(ierr);
break;
#if !defined(PETSC_USE_COMPLEX)
} else if ((i > 0) && (beta*betaold < 0.0)) {
ksp->reason = KSP_DIVERGED_INDEFINITE_PC;
ierr = PetscInfo(ksp,"diverging due to indefinite preconditioner\n");CHKERRQ(ierr);
break;
#endif
}
if (!i) {
ierr = VecCopy(Z,P);CHKERRQ(ierr); /* p <- z */
b = 0.0;
} else {
b = beta/betaold;
if (eigs) {
if (ksp->max_it != stored_max_it) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"Can not change maxit AND calculate eigenvalues");
e[i] = PetscSqrtReal(PetscAbsScalar(b))/a;
}
ierr = VecAYPX(P,b,Z);CHKERRQ(ierr); /* p <- z + b* p */
}
dpiold = dpi;
if (!cg->singlereduction || !i) {
ierr = KSP_MatMult(ksp,Amat,P,W);CHKERRQ(ierr); /* w <- Ap */
ierr = VecXDot(P,W,&dpi);CHKERRQ(ierr); /* dpi <- p'w */
} else {
ierr = VecAYPX(W,beta/betaold,S);CHKERRQ(ierr); /* w <- Ap */
dpi = delta - beta*beta*dpiold/(betaold*betaold); /* dpi <- p'w */
}
betaold = beta;
if (PetscIsInfOrNanScalar(dpi)) {
if (ksp->errorifnotconverged) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_NOT_CONVERGED,"KSPSolve has not converged due to Nan or Inf inner product");
else {
ksp->reason = KSP_DIVERGED_NANORINF;
PetscFunctionReturn(0);
}
}
if ((dpi == 0.0) || ((i > 0) && (PetscRealPart(dpi*dpiold) <= 0.0))) {
ksp->reason = KSP_DIVERGED_INDEFINITE_MAT;
ierr = PetscInfo(ksp,"diverging due to indefinite or negative definite matrix\n");CHKERRQ(ierr);
break;
}
a = beta/dpi; /* a = beta/p'w */
if (eigs) d[i] = PetscSqrtReal(PetscAbsScalar(b))*e[i] + 1.0/a;
ierr = VecAXPY(X,a,P);CHKERRQ(ierr); /* x <- x + ap */
ierr = VecAXPY(R,-a,W);CHKERRQ(ierr); /* r <- r - aw */
if (ksp->normtype == KSP_NORM_PRECONDITIONED && ksp->chknorm < i+2) {
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
if (cg->singlereduction) {
ierr = KSP_MatMult(ksp,Amat,Z,S);CHKERRQ(ierr);
}
ierr = VecNorm(Z,NORM_2,&dp);CHKERRQ(ierr); /* dp <- z'*z */
} else if (ksp->normtype == KSP_NORM_UNPRECONDITIONED && ksp->chknorm < i+2) {
ierr = VecNorm(R,NORM_2,&dp);CHKERRQ(ierr); /* dp <- r'*r */
} else if (ksp->normtype == KSP_NORM_NATURAL) {
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
if (cg->singlereduction) {
PetscScalar tmp[2];
Vec vecs[2];
vecs[0] = S; vecs[1] = R;
ierr = KSP_MatMult(ksp,Amat,Z,S);CHKERRQ(ierr);
ierr = VecMDot(Z,2,vecs,tmp);CHKERRQ(ierr);
delta = tmp[0]; beta = tmp[1];
} else {
ierr = VecXDot(Z,R,&beta);CHKERRQ(ierr); /* beta <- r'*z */
}
if (PetscIsInfOrNanScalar(beta)) {
if (ksp->errorifnotconverged) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_NOT_CONVERGED,"KSPSolve has not converged due to Nan or Inf inner product");
else {
ksp->reason = KSP_DIVERGED_NANORINF;
PetscFunctionReturn(0);
}
}
dp = PetscSqrtReal(PetscAbsScalar(beta));
} else {
dp = 0.0;
}
ksp->rnorm = dp;
CHKERRQ(ierr);KSPLogResidualHistory(ksp,dp);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,i+1,dp);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,i+1,dp,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) break;
if ((ksp->normtype != KSP_NORM_PRECONDITIONED && (ksp->normtype != KSP_NORM_NATURAL)) || (ksp->chknorm >= i+2)) {
ierr = KSP_PCApply(ksp,R,Z);CHKERRQ(ierr); /* z <- Br */
if (cg->singlereduction) {
ierr = KSP_MatMult(ksp,Amat,Z,S);CHKERRQ(ierr);
}
}
if ((ksp->normtype != KSP_NORM_NATURAL) || (ksp->chknorm >= i+2)) {
if (cg->singlereduction) {
PetscScalar tmp[2];
Vec vecs[2];
vecs[0] = S; vecs[1] = R;
ierr = VecMDot(Z,2,vecs,tmp);CHKERRQ(ierr);
delta = tmp[0]; beta = tmp[1];
} else {
ierr = VecXDot(Z,R,&beta);CHKERRQ(ierr); /* beta <- z'*r */
}
if (PetscIsInfOrNanScalar(beta)) {
if (ksp->errorifnotconverged) SETERRQ(PetscObjectComm((PetscObject)ksp),PETSC_ERR_NOT_CONVERGED,"KSPSolve has not converged due to Nan or Inf inner product");
else {
ksp->reason = KSP_DIVERGED_NANORINF;
PetscFunctionReturn(0);
}
}
}
i++;
} while (i<ksp->max_it);
if (i >= ksp->max_it) ksp->reason = KSP_DIVERGED_ITS;
PetscFunctionReturn(0);
}
static PetscErrorCode TaoLineSearchApply_GPCG(TaoLineSearch ls, Vec x, PetscReal *f, Vec g, Vec s)
{
TaoLineSearch_GPCG *neP = (TaoLineSearch_GPCG *)ls->data;
PetscErrorCode ierr;
PetscInt i;
PetscBool g_computed=PETSC_FALSE; /* to prevent extra gradient computation */
PetscReal d1,finit,actred,prered,rho, gdx;
PetscFunctionBegin;
/* ls->stepmin - lower bound for step */
/* ls->stepmax - upper bound for step */
/* ls->rtol - relative tolerance for an acceptable step */
/* ls->ftol - tolerance for sufficient decrease condition */
/* ls->gtol - tolerance for curvature condition */
/* ls->nfeval - number of function evaluations */
/* ls->nfeval - number of function/gradient evaluations */
/* ls->max_funcs - maximum number of function evaluations */
ls->reason = TAOLINESEARCH_CONTINUE_ITERATING;
ls->step = ls->initstep;
if (!neP->W2) {
ierr = VecDuplicate(x,&neP->W2);CHKERRQ(ierr);
ierr = VecDuplicate(x,&neP->W1);CHKERRQ(ierr);
ierr = VecDuplicate(x,&neP->Gold);CHKERRQ(ierr);
neP->x = x;
ierr = PetscObjectReference((PetscObject)neP->x);CHKERRQ(ierr);
} else if (x != neP->x) {
ierr = VecDestroy(&neP->x);CHKERRQ(ierr);
ierr = VecDestroy(&neP->W1);CHKERRQ(ierr);
ierr = VecDestroy(&neP->W2);CHKERRQ(ierr);
ierr = VecDestroy(&neP->Gold);CHKERRQ(ierr);
ierr = VecDuplicate(x,&neP->W1);CHKERRQ(ierr);
ierr = VecDuplicate(x,&neP->W2);CHKERRQ(ierr);
ierr = VecDuplicate(x,&neP->Gold);CHKERRQ(ierr);
ierr = PetscObjectDereference((PetscObject)neP->x);CHKERRQ(ierr);
neP->x = x;
ierr = PetscObjectReference((PetscObject)neP->x);CHKERRQ(ierr);
}
ierr = VecDot(g,s,&gdx);CHKERRQ(ierr);
if (gdx > 0) {
ierr = PetscInfo1(ls,"Line search error: search direction is not descent direction. dot(g,s) = %g\n",(double)gdx);CHKERRQ(ierr);
ls->reason = TAOLINESEARCH_FAILED_ASCENT;
PetscFunctionReturn(0);
}
ierr = VecCopy(x,neP->W2);CHKERRQ(ierr);
ierr = VecCopy(g,neP->Gold);CHKERRQ(ierr);
if (ls->bounded) {
/* Compute the smallest steplength that will make one nonbinding variable equal the bound */
ierr = VecStepBoundInfo(x,s,ls->lower,ls->upper,&rho,&actred,&d1);CHKERRQ(ierr);
ls->step = PetscMin(ls->step,d1);
}
rho=0; actred=0;
if (ls->step < 0) {
ierr = PetscInfo1(ls,"Line search error: initial step parameter %g< 0\n",(double)ls->step);CHKERRQ(ierr);
ls->reason = TAOLINESEARCH_HALTED_OTHER;
PetscFunctionReturn(0);
}
/* Initialization */
finit = *f;
for (i=0; i< ls->max_funcs; i++) {
/* Force the step to be within the bounds */
ls->step = PetscMax(ls->step,ls->stepmin);
ls->step = PetscMin(ls->step,ls->stepmax);
ierr = VecCopy(x,neP->W2);CHKERRQ(ierr);
ierr = VecAXPY(neP->W2,ls->step,s);CHKERRQ(ierr);
if (ls->bounded) {
/* Make sure new vector is numerically within bounds */
ierr = VecMedian(neP->W2,ls->lower,ls->upper,neP->W2);CHKERRQ(ierr);
}
/* Gradient is not needed here. Unless there is a separate
gradient routine, compute it here anyway to prevent recomputing at
the end of the line search */
if (ls->hasobjective) {
ierr = TaoLineSearchComputeObjective(ls,neP->W2,f);CHKERRQ(ierr);
g_computed=PETSC_FALSE;
} else if (ls->usegts){
ierr = TaoLineSearchComputeObjectiveAndGTS(ls,neP->W2,f,&gdx);CHKERRQ(ierr);
g_computed=PETSC_FALSE;
} else {
ierr = TaoLineSearchComputeObjectiveAndGradient(ls,neP->W2,f,g);CHKERRQ(ierr);
g_computed=PETSC_TRUE;
}
if (0 == i) {
ls->f_fullstep = *f;
}
actred = *f - finit;
ierr = VecCopy(neP->W2,neP->W1);CHKERRQ(ierr);
ierr = VecAXPY(neP->W1,-1.0,x);CHKERRQ(ierr); /* W1 = W2 - X */
ierr = VecDot(neP->W1,neP->Gold,&prered);CHKERRQ(ierr);
if (fabs(prered)<1.0e-100) prered=1.0e-12;
rho = actred/prered;
/*
If sufficient progress has been obtained, accept the
point. Otherwise, backtrack.
*/
if (actred > 0) {
ierr = PetscInfo(ls,"Step resulted in ascent, rejecting.\n");CHKERRQ(ierr);
ls->step = (ls->step)/2;
} else if (rho > ls->ftol){
break;
} else{
ls->step = (ls->step)/2;
}
/* Convergence testing */
if (ls->step <= ls->stepmin || ls->step >= ls->stepmax) {
ls->reason = TAOLINESEARCH_HALTED_OTHER;
ierr = PetscInfo(ls,"Rounding errors may prevent further progress. May not be a step satisfying\n");CHKERRQ(ierr);
ierr = PetscInfo(ls,"sufficient decrease and curvature conditions. Tolerances may be too small.\n");CHKERRQ(ierr);
break;
}
if (ls->step == ls->stepmax) {
ierr = PetscInfo1(ls,"Step is at the upper bound, stepmax (%g)\n",(double)ls->stepmax);CHKERRQ(ierr);
ls->reason = TAOLINESEARCH_HALTED_UPPERBOUND;
break;
}
if (ls->step == ls->stepmin) {
ierr = PetscInfo1(ls,"Step is at the lower bound, stepmin (%g)\n",(double)ls->stepmin);CHKERRQ(ierr);
ls->reason = TAOLINESEARCH_HALTED_LOWERBOUND;
break;
}
if ((ls->nfeval+ls->nfgeval) >= ls->max_funcs) {
ierr = PetscInfo2(ls,"Number of line search function evals (%D) > maximum (%D)\n",ls->nfeval+ls->nfgeval,ls->max_funcs);CHKERRQ(ierr);
ls->reason = TAOLINESEARCH_HALTED_MAXFCN;
break;
}
if ((neP->bracket) && (ls->stepmax - ls->stepmin <= ls->rtol*ls->stepmax)){
ierr = PetscInfo1(ls,"Relative width of interval of uncertainty is at most rtol (%g)\n",(double)ls->rtol);CHKERRQ(ierr);
ls->reason = TAOLINESEARCH_HALTED_RTOL;
break;
}
}
ierr = PetscInfo2(ls,"%D function evals in line search, step = %g\n",ls->nfeval+ls->nfgeval,(double)ls->step);CHKERRQ(ierr);
/* set new solution vector and compute gradient if necessary */
ierr = VecCopy(neP->W2, x);CHKERRQ(ierr);
if (ls->reason == TAOLINESEARCH_CONTINUE_ITERATING) {
ls->reason = TAOLINESEARCH_SUCCESS;
}
if (!g_computed) {
ierr = TaoLineSearchComputeGradient(ls,x,g);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
PetscErrorCode PCSetUp_MG(PC pc)
{
PC_MG *mg = (PC_MG*)pc->data;
PC_MG_Levels **mglevels = mg->levels;
PetscErrorCode ierr;
PetscInt i,n = mglevels[0]->levels;
PC cpc;
PetscBool dump = PETSC_FALSE,opsset,use_amat,missinginterpolate = PETSC_FALSE;
Mat dA,dB;
Vec tvec;
DM *dms;
PetscViewer viewer = 0;
PetscFunctionBegin;
/* FIX: Move this to PCSetFromOptions_MG? */
if (mg->usedmfornumberoflevels) {
PetscInt levels;
ierr = DMGetRefineLevel(pc->dm,&levels);CHKERRQ(ierr);
levels++;
if (levels > n) { /* the problem is now being solved on a finer grid */
ierr = PCMGSetLevels(pc,levels,NULL);CHKERRQ(ierr);
n = levels;
ierr = PCSetFromOptions(pc);CHKERRQ(ierr); /* it is bad to call this here, but otherwise will never be called for the new hierarchy */
mglevels = mg->levels;
}
}
ierr = KSPGetPC(mglevels[0]->smoothd,&cpc);CHKERRQ(ierr);
/* If user did not provide fine grid operators OR operator was not updated since last global KSPSetOperators() */
/* so use those from global PC */
/* Is this what we always want? What if user wants to keep old one? */
ierr = KSPGetOperatorsSet(mglevels[n-1]->smoothd,NULL,&opsset);CHKERRQ(ierr);
if (opsset) {
Mat mmat;
ierr = KSPGetOperators(mglevels[n-1]->smoothd,NULL,&mmat);CHKERRQ(ierr);
if (mmat == pc->pmat) opsset = PETSC_FALSE;
}
if (!opsset) {
ierr = PCGetUseAmat(pc,&use_amat);CHKERRQ(ierr);
if(use_amat){
ierr = PetscInfo(pc,"Using outer operators to define finest grid operator \n because PCMGGetSmoother(pc,nlevels-1,&ksp);KSPSetOperators(ksp,...); was not called.\n");CHKERRQ(ierr);
ierr = KSPSetOperators(mglevels[n-1]->smoothd,pc->mat,pc->pmat);CHKERRQ(ierr);
}
else {
ierr = PetscInfo(pc,"Using matrix (pmat) operators to define finest grid operator \n because PCMGGetSmoother(pc,nlevels-1,&ksp);KSPSetOperators(ksp,...); was not called.\n");CHKERRQ(ierr);
ierr = KSPSetOperators(mglevels[n-1]->smoothd,pc->pmat,pc->pmat);CHKERRQ(ierr);
}
}
for (i=n-1; i>0; i--) {
if (!(mglevels[i]->interpolate || mglevels[i]->restrct)) {
missinginterpolate = PETSC_TRUE;
continue;
}
}
/*
Skipping if user has provided all interpolation/restriction needed (since DM might not be able to produce them (when coming from SNES/TS)
Skipping for galerkin==2 (externally managed hierarchy such as ML and GAMG). Cleaner logic here would be great. Wrap ML/GAMG as DMs?
*/
if (missinginterpolate && pc->dm && mg->galerkin != 2 && !pc->setupcalled) {
/* construct the interpolation from the DMs */
Mat p;
Vec rscale;
ierr = PetscMalloc1(n,&dms);CHKERRQ(ierr);
dms[n-1] = pc->dm;
/* Separately create them so we do not get DMKSP interference between levels */
for (i=n-2; i>-1; i--) {ierr = DMCoarsen(dms[i+1],MPI_COMM_NULL,&dms[i]);CHKERRQ(ierr);}
for (i=n-2; i>-1; i--) {
DMKSP kdm;
PetscBool dmhasrestrict;
ierr = KSPSetDM(mglevels[i]->smoothd,dms[i]);CHKERRQ(ierr);
if (mg->galerkin) {ierr = KSPSetDMActive(mglevels[i]->smoothd,PETSC_FALSE);CHKERRQ(ierr);}
ierr = DMGetDMKSPWrite(dms[i],&kdm);CHKERRQ(ierr);
/* Ugly hack so that the next KSPSetUp() will use the RHS that we set. A better fix is to change dmActive to take
* a bitwise OR of computing the matrix, RHS, and initial iterate. */
kdm->ops->computerhs = NULL;
kdm->rhsctx = NULL;
if (!mglevels[i+1]->interpolate) {
ierr = DMCreateInterpolation(dms[i],dms[i+1],&p,&rscale);CHKERRQ(ierr);
ierr = PCMGSetInterpolation(pc,i+1,p);CHKERRQ(ierr);
if (rscale) {ierr = PCMGSetRScale(pc,i+1,rscale);CHKERRQ(ierr);}
ierr = VecDestroy(&rscale);CHKERRQ(ierr);
ierr = MatDestroy(&p);CHKERRQ(ierr);
}
ierr = DMHasCreateRestriction(dms[i],&dmhasrestrict);CHKERRQ(ierr);
if (dmhasrestrict && !mglevels[i+1]->restrct){
ierr = DMCreateRestriction(dms[i],dms[i+1],&p);CHKERRQ(ierr);
ierr = PCMGSetRestriction(pc,i+1,p);CHKERRQ(ierr);
ierr = MatDestroy(&p);CHKERRQ(ierr);
}
}
for (i=n-2; i>-1; i--) {ierr = DMDestroy(&dms[i]);CHKERRQ(ierr);}
ierr = PetscFree(dms);CHKERRQ(ierr);
}
if (pc->dm && !pc->setupcalled) {
/* finest smoother also gets DM but it is not active, independent of whether galerkin==2 */
ierr = KSPSetDM(mglevels[n-1]->smoothd,pc->dm);CHKERRQ(ierr);
ierr = KSPSetDMActive(mglevels[n-1]->smoothd,PETSC_FALSE);CHKERRQ(ierr);
}
if (mg->galerkin == 1) {
Mat B;
/* currently only handle case where mat and pmat are the same on coarser levels */
ierr = KSPGetOperators(mglevels[n-1]->smoothd,&dA,&dB);CHKERRQ(ierr);
if (!pc->setupcalled) {
for (i=n-2; i>-1; i--) {
if (!mglevels[i+1]->restrct && !mglevels[i+1]->interpolate) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"Must provide interpolation or restriction for each MG level except level 0");
if (!mglevels[i+1]->interpolate) {
ierr = PCMGSetInterpolation(pc,i+1,mglevels[i+1]->restrct);CHKERRQ(ierr);
}
if (!mglevels[i+1]->restrct) {
ierr = PCMGSetRestriction(pc,i+1,mglevels[i+1]->interpolate);CHKERRQ(ierr);
}
if (mglevels[i+1]->interpolate == mglevels[i+1]->restrct) {
ierr = MatPtAP(dB,mglevels[i+1]->interpolate,MAT_INITIAL_MATRIX,1.0,&B);CHKERRQ(ierr);
} else {
ierr = MatMatMatMult(mglevels[i+1]->restrct,dB,mglevels[i+1]->interpolate,MAT_INITIAL_MATRIX,1.0,&B);CHKERRQ(ierr);
}
ierr = KSPSetOperators(mglevels[i]->smoothd,B,B);CHKERRQ(ierr);
if (i != n-2) {ierr = PetscObjectDereference((PetscObject)dB);CHKERRQ(ierr);}
dB = B;
}
if (n > 1) {ierr = PetscObjectDereference((PetscObject)dB);CHKERRQ(ierr);}
} else {
for (i=n-2; i>-1; i--) {
if (!mglevels[i+1]->restrct && !mglevels[i+1]->interpolate) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"Must provide interpolation or restriction for each MG level except level 0");
if (!mglevels[i+1]->interpolate) {
ierr = PCMGSetInterpolation(pc,i+1,mglevels[i+1]->restrct);CHKERRQ(ierr);
}
if (!mglevels[i+1]->restrct) {
ierr = PCMGSetRestriction(pc,i+1,mglevels[i+1]->interpolate);CHKERRQ(ierr);
}
ierr = KSPGetOperators(mglevels[i]->smoothd,NULL,&B);CHKERRQ(ierr);
if (mglevels[i+1]->interpolate == mglevels[i+1]->restrct) {
ierr = MatPtAP(dB,mglevels[i+1]->interpolate,MAT_REUSE_MATRIX,1.0,&B);CHKERRQ(ierr);
} else {
ierr = MatMatMatMult(mglevels[i+1]->restrct,dB,mglevels[i+1]->interpolate,MAT_REUSE_MATRIX,1.0,&B);CHKERRQ(ierr);
}
ierr = KSPSetOperators(mglevels[i]->smoothd,B,B);CHKERRQ(ierr);
dB = B;
}
}
} else if (!mg->galerkin && pc->dm && pc->dm->x) {
/* need to restrict Jacobian location to coarser meshes for evaluation */
for (i=n-2; i>-1; i--) {
Mat R;
Vec rscale;
if (!mglevels[i]->smoothd->dm->x) {
Vec *vecs;
ierr = KSPCreateVecs(mglevels[i]->smoothd,1,&vecs,0,NULL);CHKERRQ(ierr);
mglevels[i]->smoothd->dm->x = vecs[0];
ierr = PetscFree(vecs);CHKERRQ(ierr);
}
ierr = PCMGGetRestriction(pc,i+1,&R);CHKERRQ(ierr);
ierr = PCMGGetRScale(pc,i+1,&rscale);CHKERRQ(ierr);
ierr = MatRestrict(R,mglevels[i+1]->smoothd->dm->x,mglevels[i]->smoothd->dm->x);CHKERRQ(ierr);
ierr = VecPointwiseMult(mglevels[i]->smoothd->dm->x,mglevels[i]->smoothd->dm->x,rscale);CHKERRQ(ierr);
}
}
if (!mg->galerkin && pc->dm) {
for (i=n-2; i>=0; i--) {
DM dmfine,dmcoarse;
Mat Restrict,Inject;
Vec rscale;
ierr = KSPGetDM(mglevels[i+1]->smoothd,&dmfine);CHKERRQ(ierr);
ierr = KSPGetDM(mglevels[i]->smoothd,&dmcoarse);CHKERRQ(ierr);
ierr = PCMGGetRestriction(pc,i+1,&Restrict);CHKERRQ(ierr);
ierr = PCMGGetRScale(pc,i+1,&rscale);CHKERRQ(ierr);
Inject = NULL; /* Callback should create it if it needs Injection */
ierr = DMRestrict(dmfine,Restrict,rscale,Inject,dmcoarse);CHKERRQ(ierr);
}
}
if (!pc->setupcalled) {
for (i=0; i<n; i++) {
ierr = KSPSetFromOptions(mglevels[i]->smoothd);CHKERRQ(ierr);
}
for (i=1; i<n; i++) {
if (mglevels[i]->smoothu && (mglevels[i]->smoothu != mglevels[i]->smoothd)) {
ierr = KSPSetFromOptions(mglevels[i]->smoothu);CHKERRQ(ierr);
}
}
/* insure that if either interpolation or restriction is set the other other one is set */
for (i=1; i<n; i++) {
ierr = PCMGGetInterpolation(pc,i,NULL);CHKERRQ(ierr);
ierr = PCMGGetRestriction(pc,i,NULL);CHKERRQ(ierr);
}
for (i=0; i<n-1; i++) {
if (!mglevels[i]->b) {
Vec *vec;
ierr = KSPCreateVecs(mglevels[i]->smoothd,1,&vec,0,NULL);CHKERRQ(ierr);
ierr = PCMGSetRhs(pc,i,*vec);CHKERRQ(ierr);
ierr = VecDestroy(vec);CHKERRQ(ierr);
ierr = PetscFree(vec);CHKERRQ(ierr);
}
if (!mglevels[i]->r && i) {
ierr = VecDuplicate(mglevels[i]->b,&tvec);CHKERRQ(ierr);
ierr = PCMGSetR(pc,i,tvec);CHKERRQ(ierr);
ierr = VecDestroy(&tvec);CHKERRQ(ierr);
}
if (!mglevels[i]->x) {
ierr = VecDuplicate(mglevels[i]->b,&tvec);CHKERRQ(ierr);
ierr = PCMGSetX(pc,i,tvec);CHKERRQ(ierr);
ierr = VecDestroy(&tvec);CHKERRQ(ierr);
}
}
if (n != 1 && !mglevels[n-1]->r) {
/* PCMGSetR() on the finest level if user did not supply it */
Vec *vec;
ierr = KSPCreateVecs(mglevels[n-1]->smoothd,1,&vec,0,NULL);CHKERRQ(ierr);
ierr = PCMGSetR(pc,n-1,*vec);CHKERRQ(ierr);
ierr = VecDestroy(vec);CHKERRQ(ierr);
ierr = PetscFree(vec);CHKERRQ(ierr);
}
}
if (pc->dm) {
/* need to tell all the coarser levels to rebuild the matrix using the DM for that level */
for (i=0; i<n-1; i++) {
if (mglevels[i]->smoothd->setupstage != KSP_SETUP_NEW) mglevels[i]->smoothd->setupstage = KSP_SETUP_NEWMATRIX;
}
}
for (i=1; i<n; i++) {
if (mglevels[i]->smoothu == mglevels[i]->smoothd || mg->am == PC_MG_FULL || mg->am == PC_MG_KASKADE || mg->cyclesperpcapply > 1){
/* if doing only down then initial guess is zero */
ierr = KSPSetInitialGuessNonzero(mglevels[i]->smoothd,PETSC_TRUE);CHKERRQ(ierr);
}
if (mglevels[i]->eventsmoothsetup) {ierr = PetscLogEventBegin(mglevels[i]->eventsmoothsetup,0,0,0,0);CHKERRQ(ierr);}
ierr = KSPSetUp(mglevels[i]->smoothd);CHKERRQ(ierr);
if (mglevels[i]->smoothd->reason == KSP_DIVERGED_PCSETUP_FAILED) {
pc->failedreason = PC_SUBPC_ERROR;
}
if (mglevels[i]->eventsmoothsetup) {ierr = PetscLogEventEnd(mglevels[i]->eventsmoothsetup,0,0,0,0);CHKERRQ(ierr);}
if (!mglevels[i]->residual) {
Mat mat;
ierr = KSPGetOperators(mglevels[i]->smoothd,NULL,&mat);CHKERRQ(ierr);
ierr = PCMGSetResidual(pc,i,PCMGResidualDefault,mat);CHKERRQ(ierr);
}
}
for (i=1; i<n; i++) {
if (mglevels[i]->smoothu && mglevels[i]->smoothu != mglevels[i]->smoothd) {
Mat downmat,downpmat;
/* check if operators have been set for up, if not use down operators to set them */
ierr = KSPGetOperatorsSet(mglevels[i]->smoothu,&opsset,NULL);CHKERRQ(ierr);
if (!opsset) {
ierr = KSPGetOperators(mglevels[i]->smoothd,&downmat,&downpmat);CHKERRQ(ierr);
ierr = KSPSetOperators(mglevels[i]->smoothu,downmat,downpmat);CHKERRQ(ierr);
}
ierr = KSPSetInitialGuessNonzero(mglevels[i]->smoothu,PETSC_TRUE);CHKERRQ(ierr);
if (mglevels[i]->eventsmoothsetup) {ierr = PetscLogEventBegin(mglevels[i]->eventsmoothsetup,0,0,0,0);CHKERRQ(ierr);}
ierr = KSPSetUp(mglevels[i]->smoothu);CHKERRQ(ierr);
if (mglevels[i]->smoothu->reason == KSP_DIVERGED_PCSETUP_FAILED) {
pc->failedreason = PC_SUBPC_ERROR;
}
if (mglevels[i]->eventsmoothsetup) {ierr = PetscLogEventEnd(mglevels[i]->eventsmoothsetup,0,0,0,0);CHKERRQ(ierr);}
}
}
if (mglevels[0]->eventsmoothsetup) {ierr = PetscLogEventBegin(mglevels[0]->eventsmoothsetup,0,0,0,0);CHKERRQ(ierr);}
ierr = KSPSetUp(mglevels[0]->smoothd);CHKERRQ(ierr);
if (mglevels[0]->smoothd->reason == KSP_DIVERGED_PCSETUP_FAILED) {
pc->failedreason = PC_SUBPC_ERROR;
}
if (mglevels[0]->eventsmoothsetup) {ierr = PetscLogEventEnd(mglevels[0]->eventsmoothsetup,0,0,0,0);CHKERRQ(ierr);}
/*
Dump the interpolation/restriction matrices plus the
Jacobian/stiffness on each level. This allows MATLAB users to
easily check if the Galerkin condition A_c = R A_f R^T is satisfied.
Only support one or the other at the same time.
*/
#if defined(PETSC_USE_SOCKET_VIEWER)
ierr = PetscOptionsGetBool(((PetscObject)pc)->options,((PetscObject)pc)->prefix,"-pc_mg_dump_matlab",&dump,NULL);CHKERRQ(ierr);
if (dump) viewer = PETSC_VIEWER_SOCKET_(PetscObjectComm((PetscObject)pc));
dump = PETSC_FALSE;
#endif
ierr = PetscOptionsGetBool(((PetscObject)pc)->options,((PetscObject)pc)->prefix,"-pc_mg_dump_binary",&dump,NULL);CHKERRQ(ierr);
if (dump) viewer = PETSC_VIEWER_BINARY_(PetscObjectComm((PetscObject)pc));
if (viewer) {
for (i=1; i<n; i++) {
ierr = MatView(mglevels[i]->restrct,viewer);CHKERRQ(ierr);
}
for (i=0; i<n; i++) {
ierr = KSPGetPC(mglevels[i]->smoothd,&pc);CHKERRQ(ierr);
ierr = MatView(pc->mat,viewer);CHKERRQ(ierr);
}
}
PetscFunctionReturn(0);
}
static int TaoSolve_BNLS(TAO_SOLVER tao, void*solver){
TAO_BNLS *bnls = (TAO_BNLS *)solver;
int info;
TaoInt lsflag,iter=0;
TaoTerminateReason reason=TAO_CONTINUE_ITERATING;
double f,f_full,gnorm,gdx,stepsize=1.0;
TaoTruth success;
TaoVec *XU, *XL;
TaoVec *X, *G=bnls->G, *PG=bnls->PG;
TaoVec *R=bnls->R, *DXFree=bnls->DXFree;
TaoVec *DX=bnls->DX, *Work=bnls->Work;
TaoMat *H, *Hsub=bnls->Hsub;
TaoIndexSet *FreeVariables = bnls->FreeVariables;
TaoFunctionBegin;
/* Check if upper bound greater than lower bound. */
info = TaoGetSolution(tao,&X);CHKERRQ(info); bnls->X=X;
info = TaoGetVariableBounds(tao,&XL,&XU);CHKERRQ(info);
info = TaoEvaluateVariableBounds(tao,XL,XU); CHKERRQ(info);
info = TaoGetHessian(tao,&H);CHKERRQ(info); bnls->H=H;
/* Project the current point onto the feasible set */
info = X->Median(XL,X,XU); CHKERRQ(info);
TaoLinearSolver *tls;
// Modify the linear solver to a conjugate gradient method
info = TaoGetLinearSolver(tao, &tls); CHKERRQ(info);
TaoLinearSolverPetsc *pls;
pls = dynamic_cast <TaoLinearSolverPetsc *> (tls);
// set trust radius to zero
// PETSc ignores this case and should return the negative curvature direction
// at its current default length
pls->SetTrustRadius(0.0);
if(!bnls->M) bnls->M = new TaoLMVMMat(X);
TaoLMVMMat *M = bnls->M;
KSP pksp = pls->GetKSP();
// we will want to provide an initial guess in case neg curvature on the first iteration
info = KSPSetInitialGuessNonzero(pksp,PETSC_TRUE); CHKERRQ(info);
PC ppc;
// Modify the preconditioner to use the bfgs approximation
info = KSPGetPC(pksp, &ppc); CHKERRQ(info);
PetscTruth BFGSPreconditioner=PETSC_FALSE;// debug flag
info = PetscOptionsGetTruth(PETSC_NULL,"-bnls_pc_bfgs",
&BFGSPreconditioner,PETSC_NULL); CHKERRQ(info);
if( BFGSPreconditioner)
{
info=PetscInfo(tao,"TaoSolve_BNLS: using bfgs preconditioner\n");
info = KSPSetNormType(pksp, KSP_NORM_PRECONDITIONED); CHKERRQ(info);
info = PCSetType(ppc, PCSHELL); CHKERRQ(info);
info = PCShellSetName(ppc, "bfgs"); CHKERRQ(info);
info = PCShellSetContext(ppc, M); CHKERRQ(info);
info = PCShellSetApply(ppc, bfgs_apply); CHKERRQ(info);
}
else
{// default to none
info=PetscInfo(tao,"TaoSolve_BNLS: using no preconditioner\n");
info = PCSetType(ppc, PCNONE); CHKERRQ(info);
}
info = TaoComputeMeritFunctionGradient(tao,X,&f,G);CHKERRQ(info);
info = PG->BoundGradientProjection(G,XL,X,XU);CHKERRQ(info);
info = PG->Norm2(&gnorm); CHKERRQ(info);
// Set initial scaling for the function
if (f != 0.0) {
info = M->SetDelta(2.0 * TaoAbsDouble(f) / (gnorm*gnorm)); CHKERRQ(info);
}
else {
info = M->SetDelta(2.0 / (gnorm*gnorm)); CHKERRQ(info);
}
while (reason==TAO_CONTINUE_ITERATING){
/* Project the gradient and calculate the norm */
info = PG->BoundGradientProjection(G,XL,X,XU);CHKERRQ(info);
info = PG->Norm2(&gnorm); CHKERRQ(info);
info = M->Update(X, PG); CHKERRQ(info);
PetscScalar ewAtol = PetscMin(0.5,gnorm)*gnorm;
info = KSPSetTolerances(pksp,PETSC_DEFAULT,ewAtol,
PETSC_DEFAULT, PETSC_DEFAULT); CHKERRQ(info);
info=PetscInfo1(tao,"TaoSolve_BNLS: gnorm =%g\n",gnorm);
pksp->printreason = PETSC_TRUE;
info = KSPView(pksp,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(info);
M->View();
info = TaoMonitor(tao,iter++,f,gnorm,0.0,stepsize,&reason);
CHKERRQ(info);
if (reason!=TAO_CONTINUE_ITERATING) break;
info = FreeVariables->WhichEqual(PG,G); CHKERRQ(info);
info = TaoComputeHessian(tao,X,H);CHKERRQ(info);
/* Create a reduced linear system */
info = R->SetReducedVec(G,FreeVariables);CHKERRQ(info);
info = R->Negate();CHKERRQ(info);
/* Use gradient as initial guess */
PetscTruth UseGradientIG=PETSC_FALSE;// debug flag
info = PetscOptionsGetTruth(PETSC_NULL,"-bnls_use_gradient_ig",
&UseGradientIG,PETSC_NULL); CHKERRQ(info);
if(UseGradientIG)
info = DX->CopyFrom(G);
else
{
info=PetscInfo(tao,"TaoSolve_BNLS: use bfgs init guess \n");
info = M->Solve(G, DX, &success);
}
CHKERRQ(info);
info = DXFree->SetReducedVec(DX,FreeVariables);CHKERRQ(info);
info = DXFree->Negate(); CHKERRQ(info);
info = Hsub->SetReducedMatrix(H,FreeVariables,FreeVariables);CHKERRQ(info);
bnls->gamma_factor /= 2;
success = TAO_FALSE;
while (success==TAO_FALSE) {
/* Approximately solve the reduced linear system */
info = TaoPreLinearSolve(tao,Hsub);CHKERRQ(info);
info = TaoLinearSolve(tao,Hsub,R,DXFree,&success);CHKERRQ(info);
info = DX->SetToZero(); CHKERRQ(info);
info = DX->ReducedXPY(DXFree,FreeVariables);CHKERRQ(info);
info = DX->Dot(G,&gdx); CHKERRQ(info);
if (gdx>=0 || success==TAO_FALSE) { /* use bfgs direction */
info = M->Solve(G, DX, &success); CHKERRQ(info);
info = DX->BoundGradientProjection(DX,XL,X,XU); CHKERRQ(info);
info = DX->Negate(); CHKERRQ(info);
// Check for success (descent direction)
info = DX->Dot(G,&gdx); CHKERRQ(info);
if (gdx >= 0) {
// Step is not descent or solve was not successful
// Use steepest descent direction (scaled)
if (f != 0.0) {
info = M->SetDelta(2.0 * TaoAbsDouble(f) / (gnorm*gnorm)); CHKERRQ(info);
}
else {
info = M->SetDelta(2.0 / (gnorm*gnorm)); CHKERRQ(info);
}
info = M->Reset(); CHKERRQ(info);
info = M->Update(X, G); CHKERRQ(info);
info = DX->CopyFrom(G);
info = DX->Negate(); CHKERRQ(info);
info = DX->Dot(G,&gdx); CHKERRQ(info);
info=PetscInfo1(tao,"LMVM Solve Fail use steepest descent, gdx %22.12e \n",gdx);
}
else {
info=PetscInfo1(tao,"Newton Solve Fail use BFGS direction, gdx %22.12e \n",gdx);
}
success = TAO_TRUE;
// bnls->gamma_factor *= 2;
// bnls->gamma = bnls->gamma_factor*(gnorm);
//#if !defined(PETSC_USE_COMPLEX)
// info=PetscInfo2(tao,"TaoSolve_NLS: modify diagonal (assume same nonzero structure), gamma_factor=%g, gamma=%g\n",bnls->gamma_factor,bnls->gamma);
// CHKERRQ(info);
//#else
// info=PetscInfo3(tao,"TaoSolve_NLS: modify diagonal (asuume same nonzero structure), gamma_factor=%g, gamma=%g, gdx %22.12e \n",
// bnls->gamma_factor,PetscReal(bnls->gamma),gdx);CHKERRQ(info);
//#endif
// info = Hsub->ShiftDiagonal(bnls->gamma);CHKERRQ(info);
// if (f != 0.0) {
// info = M->SetDelta(2.0 * TaoAbsDouble(f) / (gnorm*gnorm)); CHKERRQ(info);
// }
// else {
// info = M->SetDelta(2.0 / (gnorm*gnorm)); CHKERRQ(info);
// }
// info = M->Reset(); CHKERRQ(info);
// info = M->Update(X, G); CHKERRQ(info);
// success = TAO_FALSE;
} else {
info=PetscInfo1(tao,"Newton Solve is descent direction, gdx %22.12e \n",gdx);
success = TAO_TRUE;
}
}
stepsize=1.0;
info = TaoLineSearchApply(tao,X,G,DX,Work,
&f,&f_full,&stepsize,&lsflag);
CHKERRQ(info);
} /* END MAIN LOOP */
TaoFunctionReturn(0);
}
