static PetscErrorCode QPComputeStepDirection(TAO_BQPIP *qp, Tao tao)
{
PetscErrorCode ierr;
PetscFunctionBegin;
/* Calculate DG */
ierr = VecCopy(tao->stepdirection, qp->DG);CHKERRQ(ierr);
ierr = VecAXPY(qp->DG, 1.0, qp->R3);CHKERRQ(ierr);
/* Calculate DT */
ierr = VecCopy(tao->stepdirection, qp->DT);CHKERRQ(ierr);
ierr = VecScale(qp->DT, -1.0);CHKERRQ(ierr);
ierr = VecAXPY(qp->DT, -1.0, qp->R5);CHKERRQ(ierr);
/* Calculate DZ */
ierr = VecAXPY(qp->DZ, -1.0, qp->Z);CHKERRQ(ierr);
ierr = VecPointwiseDivide(qp->GZwork, qp->DG, qp->G);CHKERRQ(ierr);
ierr = VecPointwiseMult(qp->GZwork, qp->GZwork, qp->Z);CHKERRQ(ierr);
ierr = VecAXPY(qp->DZ, -1.0, qp->GZwork);CHKERRQ(ierr);
/* Calculate DS */
ierr = VecAXPY(qp->DS, -1.0, qp->S);CHKERRQ(ierr);
ierr = VecPointwiseDivide(qp->TSwork, qp->DT, qp->T);CHKERRQ(ierr);
ierr = VecPointwiseMult(qp->TSwork, qp->TSwork, qp->S);CHKERRQ(ierr);
ierr = VecAXPY(qp->DS, -1.0, qp->TSwork);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode KSPBuildPressure_CB_Nullspace_BSSCR(KSP ksp)
{
KSP_BSSCR *bsscr = (KSP_BSSCR *)ksp->data;
FeEquationNumber *eq_num = bsscr->solver->st_sle->pSolnVec->feVariable->eqNum;
FeMesh *feMesh = bsscr->solver->st_sle->pSolnVec->feVariable->feMesh; /* is the pressure mesh */
unsigned ijk[3];
Vec t, v;
int numLocalNodes, globalNodeNumber, i, j, eq;
MatStokesBlockScaling BA = bsscr->BA;
PetscErrorCode ierr;
Mat Amat,Pmat, G;
MatStructure pflag;
PetscFunctionBegin;
/* get G matrix from Amat matrix operator on ksp */
ierr=Stg_PCGetOperators(ksp->pc,&Amat,&Pmat,&pflag);CHKERRQ(ierr);
MatNestGetSubMat( Amat, 0,1, &G );/* G should always exist */
/* now create Vecs t and v to match size of G: i.e. pressure */ /* NOTE: not using "h" vector from ksp->vec_rhs because this part of the block vector doesn't always exist */
MatGetVecs( G, &t, PETSC_NULL );/* t and v are destroyed in KSPDestroy_BSSCR */
MatGetVecs( G, &v, PETSC_NULL );/* t and v such that can do G*t */
numLocalNodes = Mesh_GetLocalSize( feMesh, MT_VERTEX); /* number of nodes on current proc not counting any shadow nodes */
for(j=0;j<numLocalNodes;j++){
i = globalNodeNumber = Mesh_DomainToGlobal( feMesh, MT_VERTEX, j);
RegularMeshUtils_Element_1DTo3D(feMesh, i, ijk);
eq = eq_num->destinationArray[j][0];/* get global equation number -- 2nd arg is always 0 because pressure has only one dof */
if(eq != -1){
if( (ijk[0]+ijk[1]+ijk[2])%2 ==0 ){
VecSetValue(t,eq,1.0,INSERT_VALUES);
}
else{
VecSetValue(v,eq,1.0,INSERT_VALUES); }}}
VecAssemblyBegin( t );
VecAssemblyEnd( t );
VecAssemblyBegin( v );
VecAssemblyEnd( v );
/* Scaling the null vectors here because it easier at the moment *//* maybe should do this in the original scaling function */
if( BA->scaling_exists == PETSC_TRUE ){
Vec R2;
/* Get the scalings out the block mat data */
VecNestGetSubVec( BA->Rz, 1, &R2 );
VecPointwiseDivide( t, t, R2); /* x <- x * 1/R2 */
VecPointwiseDivide( v, v, R2);
}
bsscr_writeVec( t, "t", "Writing t vector");
bsscr_writeVec( v, "v", "Writing v vector");
bsscr->t=t;
bsscr->v=v;
PetscFunctionReturn(0);
}
void PkStruct::finalize() {
VecAssemblyBegin(pkvec); VecAssemblyEnd(pkvec);
VecAssemblyBegin(nmodes); VecAssemblyEnd(nmodes);
VecAssemblyBegin(kvec); VecAssemblyEnd(kvec);
//Normalize and return
VecShift(nmodes, 1.e-20);
VecPointwiseDivide(pkvec, nmodes);
VecPointwiseDivide(kvec, nmodes);
VecGetArray(kvec, &_kvec);
VecGetArray(pkvec, &_pkvec);
VecGetArray(nmodes, &_nmodes);
}
PetscErrorCode VecPointwiseDivide_MultiVec(Vec w, Vec x, Vec y)
{
#if !defined(NDEBUG)
TBOX_ASSERT(w);
TBOX_ASSERT(x);
TBOX_ASSERT(y);
#endif
Vec_MultiVec* mw = static_cast<Vec_MultiVec*>(w->data);
Vec_MultiVec* mx = static_cast<Vec_MultiVec*>(x->data);
Vec_MultiVec* my = static_cast<Vec_MultiVec*>(y->data);
#if !defined(NDEBUG)
TBOX_ASSERT(mw);
TBOX_ASSERT(mx);
TBOX_ASSERT(my);
TBOX_ASSERT(mw->n == mx->n);
TBOX_ASSERT(mw->n == my->n);
#endif
PetscErrorCode ierr;
for (PetscInt k = 0; k < mw->n; ++k)
{
ierr = VecPointwiseDivide(mw->array[k], mx->array[k], my->array[k]);
CHKERRQ(ierr);
}
ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(w));
CHKERRQ(ierr);
PetscFunctionReturn(0);
} // VecPointwiseDivide_MultiVec
/*@
STApplyTranspose - Applies the transpose of the operator to a vector, for
instance B^T(A - sB)^-T in the case of the shift-and-invert tranformation
and generalized eigenproblem.
Collective on ST and Vec
Input Parameters:
+ st - the spectral transformation context
- x - input vector
Output Parameter:
. y - output vector
Level: developer
.seealso: STApply()
@*/
PetscErrorCode STApplyTranspose(ST st,Vec x,Vec y)
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,2);
PetscValidHeaderSpecific(y,VEC_CLASSID,3);
PetscValidType(st,1);
STCheckMatrices(st,1);
if (x == y) SETERRQ(PetscObjectComm((PetscObject)st),PETSC_ERR_ARG_IDN,"x and y must be different vectors");
if (!st->setupcalled) { ierr = STSetUp(st);CHKERRQ(ierr); }
if (!st->ops->applytrans) SETERRQ(PetscObjectComm((PetscObject)st),PETSC_ERR_SUP,"ST does not have applytrans");
ierr = PetscLogEventBegin(ST_ApplyTranspose,st,x,y,0);CHKERRQ(ierr);
st->applys++;
if (st->D) { /* with balancing */
ierr = VecPointwiseMult(st->wb,x,st->D);CHKERRQ(ierr);
ierr = (*st->ops->applytrans)(st,st->wb,y);CHKERRQ(ierr);
ierr = VecPointwiseDivide(y,y,st->D);CHKERRQ(ierr);
} else {
ierr = (*st->ops->applytrans)(st,x,y);CHKERRQ(ierr);
}
ierr = PetscLogEventEnd(ST_ApplyTranspose,st,x,y,0);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
// updated
PetscErrorCode BSSCR_MatStokesMVBlock_ApplyScaling( MatStokesBlockScaling BA, Mat A, Vec b, Vec x, Mat S, PetscTruth sym )
{
Mat K,G,D,C;
Vec L1,L2, R1,R2;
Vec f,h, u,p;
/* Get the scalings out the block mat data */
VecNestGetSubVec( BA->Lz, 0, &L1 );
VecNestGetSubVec( BA->Lz, 1, &L2 );
VecNestGetSubVec( BA->Rz, 0, &R1 );
VecNestGetSubVec( BA->Rz, 1, &R2 );
/* get the subblock solution and rhs */
if( x != PETSC_NULL ) {
VecNestGetSubVec( x, 0, &u );
VecNestGetSubVec( x, 1, &p );
VecPointwiseDivide( u, u,R1); /* x <- x * 1/R1 */
VecPointwiseDivide( p, p,R2);
}
if( b != PETSC_NULL ) {
VecNestGetSubVec( b, 0, &f );
VecNestGetSubVec( b, 1, &h );
VecPointwiseMult( f, f,L1); /* f <- f * L1 */
VecPointwiseMult( h, h,L2);
}
/* Scale matrices */
MatNestGetSubMat( A, 0,0, &K );
MatNestGetSubMat( A, 0,1, &G );
MatNestGetSubMat( A, 1,0, &D );
MatNestGetSubMat( A, 1,1, &C );
if( K != PETSC_NULL ) { MatDiagonalScale( K, L1,R1 ); }
if( G != PETSC_NULL ) { MatDiagonalScale( G, L1,R2 ); }
if( D != PETSC_NULL && !sym ) { MatDiagonalScale( D, L2,R1 ); }
if( C != PETSC_NULL ) { MatDiagonalScale( C, L2,R2 ); }
if( S != PETSC_NULL ) { MatDiagonalScale( S, L2,R2 ); }
PetscFunctionReturn(0);
}
PetscErrorCode MatShift_Shell(Mat Y,PetscScalar a)
{
Mat_Shell *shell = (Mat_Shell*)Y->data;
PetscErrorCode ierr;
PetscFunctionBegin;
if (shell->left || shell->right || shell->dshift) {
if (!shell->dshift) {
if (!shell->dshift_owned) {ierr = VecDuplicate(shell->left ? shell->left : shell->right, &shell->dshift_owned);CHKERRQ(ierr);}
shell->dshift = shell->dshift_owned;
ierr = VecSet(shell->dshift,shell->vshift+a);CHKERRQ(ierr);
} else {ierr = VecScale(shell->dshift,a);CHKERRQ(ierr);}
if (shell->left) {ierr = VecPointwiseDivide(shell->dshift,shell->dshift,shell->left);CHKERRQ(ierr);}
if (shell->right) {ierr = VecPointwiseDivide(shell->dshift,shell->dshift,shell->right);CHKERRQ(ierr);}
} else shell->vshift += a;
ierr = MatShellUseScaledMethods(Y);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/** Get coordinates for every node in closure (every subelement vertex)
*
* @note This function cannot be implemented for all \a dFS types. For most purposes, users should
* \a dFSGetGeometryVectorExpanded and evaluate (element by element) on the nodes of their choice
* (with a self-quadrature).
*
* @param fs Function space
* @param inx the new vector with block size 3 and the same number of blocks as the closure vector
**/
dErr dFSGetNodalCoordinatesGlobal(dFS fs,Vec *inx)
{
dErr err;
Vec Expanded,Ones,X,Count,Xclosure,Countclosure;
dFS fs3;
dFunctionBegin;
dValidHeader(fs,DM_CLASSID,1);
dValidPointer(inx,2);
*inx = 0;
err = dFSGetNodalCoordinateFS(fs,&fs3);
dCHK(err);
err = dFSGetNodalCoordinatesExpanded(fs,&Expanded);
dCHK(err);
if (!fs->nodalcoord.global) {
err = dFSCreateGlobalVector(fs3,&fs->nodalcoord.global);
dCHK(err);
}
X = fs->nodalcoord.global;
/* Count the number of occurances of each node in the closure. */
err = VecDuplicate(Expanded,&Ones);
dCHK(err);
err = VecDuplicate(X,&Count);
dCHK(err);
err = VecDohpZeroEntries(Count);
dCHK(err);
err = VecSet(Ones,1.);
dCHK(err);
err = dFSExpandedToGlobal(fs3,Ones,Count,dFS_INHOMOGENEOUS,ADD_VALUES);
dCHK(err);
err = VecDestroy(&Ones);
dCHK(err);
err = VecDohpZeroEntries(X);
dCHK(err);
err = dFSExpandedToGlobal(fs3,Expanded,X,dFS_INHOMOGENEOUS,ADD_VALUES);
dCHK(err);
err = VecDohpGetClosure(X,&Xclosure);
dCHK(err);
err = VecDohpGetClosure(Count,&Countclosure);
dCHK(err);
err = VecPointwiseDivide(Xclosure,Xclosure,Countclosure);
dCHK(err);
err = VecDohpRestoreClosure(X,&Xclosure);
dCHK(err);
err = VecDohpRestoreClosure(Count,&Countclosure);
dCHK(err);
err = VecDestroy(&Count);
dCHK(err);
*inx = X;
dFunctionReturn(0);
}
void N_VDiv_Petsc(N_Vector x, N_Vector y, N_Vector z)
{
Vec *xv = NV_PVEC_PTC(x);
Vec *yv = NV_PVEC_PTC(y);
Vec *zv = NV_PVEC_PTC(z);
VecPointwiseDivide(*zv, *xv, *yv); /* z = x/y */
return;
}
static PetscErrorCode VecPointwiseDivide_Nest(Vec w,Vec x,Vec y)
{
Vec_Nest *bx = (Vec_Nest*)x->data;
Vec_Nest *by = (Vec_Nest*)y->data;
Vec_Nest *bw = (Vec_Nest*)w->data;
PetscInt i,nr;
PetscErrorCode ierr;
PetscFunctionBegin;
VecNestCheckCompatible3(w,1,x,2,y,3);
nr = bx->nb;
for (i=0; i<nr; i++) {
ierr = VecPointwiseDivide(bw->v[i],bx->v[i],by->v[i]);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
PetscErrorCode monitorRelerr(const VerboseLevel vl, const Vec x, const Vec right_precond, const PetscInt num_iter, const PetscReal rel_res, const Mat CF, const Vec conjParam, const Vec conjSrc, GridInfo *gi)
{
PetscFunctionBegin;
PetscErrorCode ierr;
if (gi->verbose_level >= vl && gi->has_xref) {
Vec dx = gi->vecTemp;
ierr = VecPointwiseDivide(dx, x, right_precond); CHKERRQ(ierr);
ierr = VecAXPY(dx, -1.0, gi->xref); CHKERRQ(ierr);
PetscReal norm_dx;
ierr = VecNorm(dx, NORM_INFINITY, &norm_dx); CHKERRQ(ierr);
PetscReal rel_err = norm_dx / gi->norm_xref;
ierr = PetscFPrintf(PETSC_COMM_WORLD, stdout, "\t%d\t\trelres: %e, \trelerr: %e\n", num_iter, rel_res, rel_err); CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/*@
EPSGetInvariantSubspace - Gets an orthonormal basis of the computed invariant
subspace.
Not Collective, but vectors are shared by all processors that share the EPS
Input Parameter:
. eps - the eigensolver context
Output Parameter:
. v - an array of vectors
Notes:
This function should be called after EPSSolve() has finished.
The user should provide in v an array of nconv vectors, where nconv is
the value returned by EPSGetConverged().
The first k vectors returned in v span an invariant subspace associated
with the first k computed eigenvalues (note that this is not true if the
k-th eigenvalue is complex and matrix A is real; in this case the first
k+1 vectors should be used). An invariant subspace X of A satisfies Ax
in X for all x in X (a similar definition applies for generalized
eigenproblems).
Level: intermediate
.seealso: EPSGetEigenpair(), EPSGetConverged(), EPSSolve()
@*/
PetscErrorCode EPSGetInvariantSubspace(EPS eps,Vec *v)
{
PetscErrorCode ierr;
PetscInt i;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(v,2);
PetscValidHeaderSpecific(*v,VEC_CLASSID,2);
EPSCheckSolved(eps,1);
if (!eps->ishermitian && eps->state==EPS_STATE_EIGENVECTORS) SETERRQ(PetscObjectComm((PetscObject)eps),PETSC_ERR_ARG_WRONGSTATE,"EPSGetInvariantSubspace must be called before EPSGetEigenpair,EPSGetEigenvector,EPSComputeRelativeError or EPSComputeResidualNorm");
for (i=0;i<eps->nconv;i++) {
ierr = BVCopyVec(eps->V,i,v[i]);CHKERRQ(ierr);
if (eps->balance!=EPS_BALANCE_NONE && eps->D) {
ierr = VecPointwiseDivide(v[i],v[i],eps->D);CHKERRQ(ierr);
ierr = VecNormalize(v[i],NULL);CHKERRQ(ierr);
}
}
PetscFunctionReturn(0);
}
/*
Matrix free operation of 1d Laplacian and Grad for GLL spectral elements
*/
PetscErrorCode MatMult_Laplacian(Mat A,Vec x,Vec y)
{
AppCtx *appctx;
PetscErrorCode ierr;
PetscReal **temp,vv;
PetscInt i,j,xs,xn;
Vec xlocal,ylocal;
const PetscScalar *xl;
PetscScalar *yl;
PetscBLASInt _One = 1,n;
PetscScalar _DOne = 1;
ierr = MatShellGetContext(A,&appctx);CHKERRQ(ierr);
ierr = DMGetLocalVector(appctx->da,&xlocal);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(appctx->da,x,INSERT_VALUES,xlocal);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(appctx->da,x,INSERT_VALUES,xlocal);CHKERRQ(ierr);
ierr = DMGetLocalVector(appctx->da,&ylocal);CHKERRQ(ierr);
ierr = VecSet(ylocal,0.0);CHKERRQ(ierr);
ierr = PetscGLLElementLaplacianCreate(&appctx->SEMop.gll,&temp);CHKERRQ(ierr);
for (i=0; i<appctx->param.N; i++) {
vv =-appctx->param.mu*2.0/appctx->param.Le;
for (j=0; j<appctx->param.N; j++) temp[i][j]=temp[i][j]*vv;
}
ierr = DMDAVecGetArrayRead(appctx->da,xlocal,(void*)&xl);CHKERRQ(ierr);
ierr = DMDAVecGetArray(appctx->da,ylocal,&yl);CHKERRQ(ierr);
ierr = DMDAGetCorners(appctx->da,&xs,NULL,NULL,&xn,NULL,NULL);CHKERRQ(ierr);
ierr = PetscBLASIntCast(appctx->param.N,&n);CHKERRQ(ierr);
for (j=xs; j<xs+xn; j += appctx->param.N-1) {
PetscStackCallBLAS("BLASgemv",BLASgemv_("N",&n,&n,&_DOne,&temp[0][0],&n,&xl[j],&_One,&_DOne,&yl[j],&_One));
}
ierr = DMDAVecRestoreArrayRead(appctx->da,xlocal,(void*)&xl);CHKERRQ(ierr);
ierr = DMDAVecRestoreArray(appctx->da,ylocal,&yl);CHKERRQ(ierr);
ierr = PetscGLLElementLaplacianDestroy(&appctx->SEMop.gll,&temp);CHKERRQ(ierr);
ierr = VecSet(y,0.0);CHKERRQ(ierr);
ierr = DMLocalToGlobalBegin(appctx->da,ylocal,ADD_VALUES,y);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(appctx->da,ylocal,ADD_VALUES,y);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(appctx->da,&xlocal);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(appctx->da,&ylocal);CHKERRQ(ierr);
ierr = VecPointwiseDivide(y,y,appctx->SEMop.mass);CHKERRQ(ierr);
return 0;
}
PetscErrorCode monitorSnapshot(const VerboseLevel vl, const Vec x, const Vec right_precond, const PetscInt num_iter, const PetscReal rel_res, const Mat CF, const Vec conjParam, const Vec conjSrc, GridInfo *gi)
{
PetscFunctionBegin;
PetscErrorCode ierr;
char snapshot_name[PETSC_MAX_PATH_LEN];
char num_iter_str[PETSC_MAX_PATH_LEN];
Vec x_snapshot = gi->vecTemp;
if (gi->verbose_level >= vl && gi->snapshot_interval > 0 && num_iter >= 0 && num_iter % gi->snapshot_interval == 0) {
ierr = PetscStrcpy(snapshot_name, gi->output_name); CHKERRQ(ierr);
ierr = PetscStrcat(snapshot_name, "."); CHKERRQ(ierr);
//sprintf(num_iter_str, "%d", num_iter);
ierr = PetscFPrintf(PETSC_COMM_WORLD, stdout, "%d", num_iter); CHKERRQ(ierr);
ierr = PetscStrcat(snapshot_name, num_iter_str); CHKERRQ(ierr);
ierr = VecCopy(x, x_snapshot); CHKERRQ(ierr);
ierr = VecPointwiseDivide(x_snapshot, x_snapshot, right_precond); CHKERRQ(ierr);
ierr = output(snapshot_name, x_snapshot, CF, conjParam, conjSrc, *gi); CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
PetscErrorCode KSPBuildPressure_Const_Nullspace_BSSCR(KSP ksp)
{
KSP_BSSCR *bsscr = (KSP_BSSCR *)ksp->data;
FeEquationNumber *eq_num = bsscr->solver->st_sle->pSolnVec->feVariable->eqNum;
FeMesh *feMesh = bsscr->solver->st_sle->pSolnVec->feVariable->feMesh; /* is the pressure mesh */
unsigned ijk[3];
Vec t;
int numLocalNodes, globalNodeNumber, i, eq;
MatStokesBlockScaling BA = bsscr->BA;
PetscErrorCode ierr;
Mat Amat,Pmat, G;
MatStructure pflag;
PetscFunctionBegin;
/* get G matrix from Amat matrix operator on ksp */
ierr=Stg_PCGetOperators(ksp->pc,&Amat,&Pmat,&pflag);CHKERRQ(ierr);
MatNestGetSubMat( Amat, 0,1, &G );/* G should always exist */
/* now create Vec t to match size of G: i.e. pressure */ /* NOTE: not using "h" vector from ksp->vec_rhs because this part of the block vector doesn't always exist */
MatGetVecs( G, &t, PETSC_NULL );/* t is destroyed in KSPDestroy_BSSCR */
VecSet(t, 1.0);
VecAssemblyBegin( t );
VecAssemblyEnd( t );
/* Scaling the null vectors here because it easier at the moment */
if( BA->scaling_exists == PETSC_TRUE ){
Vec R2;
/* Get the scalings out the block mat data */
VecNestGetSubVec( BA->Rz, 1, &R2 );
VecPointwiseDivide( t, t, R2); /* x <- x * 1/R2 */
}
bsscr_writeVec( t, "t", "Writing t vector");
bsscr->t=t;
PetscFunctionReturn(0);
}
PetscErrorCode PCBDDCScalingSetUp(PC pc)
{
PC_IS* pcis=(PC_IS*)pc->data;
PC_BDDC* pcbddc=(PC_BDDC*)pc->data;
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(pc,PC_CLASSID,1);
ierr = PetscLogEventBegin(PC_BDDC_Scaling[pcbddc->current_level],pc,0,0,0);CHKERRQ(ierr);
/* create work vector for the operator */
ierr = VecDestroy(&pcbddc->work_scaling);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_B,&pcbddc->work_scaling);CHKERRQ(ierr);
/* always rebuild pcis->D */
if (pcis->use_stiffness_scaling) {
PetscScalar *a;
PetscInt i,n;
ierr = MatGetDiagonal(pcbddc->local_mat,pcis->vec1_N);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->N_to_B,pcis->vec1_N,pcis->D,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->N_to_B,pcis->vec1_N,pcis->D,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecAbs(pcis->D);CHKERRQ(ierr);
ierr = VecGetLocalSize(pcis->D,&n);CHKERRQ(ierr);
ierr = VecGetArray(pcis->D,&a);CHKERRQ(ierr);
for (i=0;i<n;i++) if (PetscAbsScalar(a[i])<PETSC_SMALL) a[i] = 1.0;
ierr = VecRestoreArray(pcis->D,&a);CHKERRQ(ierr);
}
ierr = VecSet(pcis->vec1_global,0.0);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,pcis->D,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->global_to_B,pcis->D,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,pcis->vec1_global,pcis->vec1_B,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->global_to_B,pcis->vec1_global,pcis->vec1_B,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecPointwiseDivide(pcis->D,pcis->D,pcis->vec1_B);CHKERRQ(ierr);
/* now setup */
if (pcbddc->use_deluxe_scaling) {
if (!pcbddc->deluxe_ctx) {
ierr = PCBDDCScalingCreate_Deluxe(pc);CHKERRQ(ierr);
}
ierr = PCBDDCScalingSetUp_Deluxe(pc);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)pc,"PCBDDCScalingRestriction_C",PCBDDCScalingRestriction_Deluxe);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)pc,"PCBDDCScalingExtension_C",PCBDDCScalingExtension_Deluxe);CHKERRQ(ierr);
} else {
ierr = PetscObjectComposeFunction((PetscObject)pc,"PCBDDCScalingRestriction_C",PCBDDCScalingRestriction_Basic);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)pc,"PCBDDCScalingExtension_C",PCBDDCScalingExtension_Basic);CHKERRQ(ierr);
}
/* test */
if (pcbddc->dbg_flag) {
Mat B0_B = NULL;
Vec B0_Bv = NULL, B0_Bv2 = NULL;
Vec vec2_global;
PetscViewer viewer = pcbddc->dbg_viewer;
PetscReal error;
/* extension -> from local to parallel */
ierr = VecSet(pcis->vec1_global,0.0);CHKERRQ(ierr);
ierr = VecSetRandom(pcis->vec1_B,NULL);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,pcis->vec1_B,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->global_to_B,pcis->vec1_B,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_global,&vec2_global);CHKERRQ(ierr);
ierr = VecCopy(pcis->vec1_global,vec2_global);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,pcis->vec1_global,pcis->vec1_B,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->global_to_B,pcis->vec1_global,pcis->vec1_B,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
if (pcbddc->benign_n) {
IS is_dummy;
ierr = ISCreateStride(PETSC_COMM_SELF,pcbddc->benign_n,0,1,&is_dummy);CHKERRQ(ierr);
ierr = MatCreateSubMatrix(pcbddc->benign_B0,is_dummy,pcis->is_B_local,MAT_INITIAL_MATRIX,&B0_B);CHKERRQ(ierr);
ierr = ISDestroy(&is_dummy);CHKERRQ(ierr);
ierr = MatCreateVecs(B0_B,NULL,&B0_Bv);CHKERRQ(ierr);
ierr = VecDuplicate(B0_Bv,&B0_Bv2);CHKERRQ(ierr);
ierr = MatMult(B0_B,pcis->vec1_B,B0_Bv);CHKERRQ(ierr);
}
ierr = PCBDDCScalingExtension(pc,pcis->vec1_B,pcis->vec1_global);CHKERRQ(ierr);
if (pcbddc->benign_saddle_point) {
PetscReal errorl = 0.;
ierr = VecScatterBegin(pcis->global_to_B,pcis->vec1_global,pcis->vec1_B,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->global_to_B,pcis->vec1_global,pcis->vec1_B,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
if (pcbddc->benign_n) {
ierr = MatMult(B0_B,pcis->vec1_B,B0_Bv2);CHKERRQ(ierr);
ierr = VecAXPY(B0_Bv,-1.0,B0_Bv2);CHKERRQ(ierr);
ierr = VecNorm(B0_Bv,NORM_INFINITY,&errorl);CHKERRQ(ierr);
}
ierr = MPI_Allreduce(&errorl,&error,1,MPIU_REAL,MPI_SUM,PetscObjectComm((PetscObject)pc));CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Error benign extension %1.14e\n",error);CHKERRQ(ierr);
}
ierr = VecAXPY(pcis->vec1_global,-1.0,vec2_global);CHKERRQ(ierr);
ierr = VecNorm(pcis->vec1_global,NORM_INFINITY,&error);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Error scaling extension %1.14e\n",error);CHKERRQ(ierr);
ierr = VecDestroy(&vec2_global);CHKERRQ(ierr);
/* restriction -> from parallel to local */
ierr = VecSet(pcis->vec1_global,0.0);CHKERRQ(ierr);
ierr = VecSetRandom(pcis->vec1_B,NULL);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,pcis->vec1_B,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->global_to_B,pcis->vec1_B,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = PCBDDCScalingRestriction(pc,pcis->vec1_global,pcis->vec1_B);CHKERRQ(ierr);
ierr = VecScale(pcis->vec1_B,-1.0);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,pcis->vec1_B,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->global_to_B,pcis->vec1_B,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecNorm(pcis->vec1_global,NORM_INFINITY,&error);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Error scaling restriction %1.14e\n",error);CHKERRQ(ierr);
ierr = MatDestroy(&B0_B);CHKERRQ(ierr);
ierr = VecDestroy(&B0_Bv);CHKERRQ(ierr);
ierr = VecDestroy(&B0_Bv2);CHKERRQ(ierr);
}
ierr = PetscLogEventEnd(PC_BDDC_Scaling[pcbddc->current_level],pc,0,0,0);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
void PETSC_STDCALL vecpointwisedivide_(Vec w,Vec x,Vec y, int *__ierr ){
*__ierr = VecPointwiseDivide(
(Vec)PetscToPointer((w) ),
(Vec)PetscToPointer((x) ),
(Vec)PetscToPointer((y) ));
}
int main(int argc, char **argv)
{
DM dm; /* Problem specification */
SNES snes; /* Nonlinear solver */
Vec u; /* Solutions */
AppCtx user; /* User-defined work context */
PetscErrorCode ierr;
ierr = PetscInitialize(&argc, &argv, NULL,help);if (ierr) return ierr;
ierr = ProcessOptions(PETSC_COMM_WORLD, &user);CHKERRQ(ierr);
/* Primal system */
ierr = SNESCreate(PETSC_COMM_WORLD, &snes);CHKERRQ(ierr);
ierr = CreateMesh(PETSC_COMM_WORLD, &user, &dm);CHKERRQ(ierr);
ierr = SNESSetDM(snes, dm);CHKERRQ(ierr);
ierr = SetupDiscretization(dm, "potential", SetupPrimalProblem, &user);CHKERRQ(ierr);
ierr = DMCreateGlobalVector(dm, &u);CHKERRQ(ierr);
ierr = VecSet(u, 0.0);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) u, "potential");CHKERRQ(ierr);
ierr = DMPlexSetSNESLocalFEM(dm, &user, &user, &user);CHKERRQ(ierr);
ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);
ierr = SNESSolve(snes, NULL, u);CHKERRQ(ierr);
ierr = SNESGetSolution(snes, &u);CHKERRQ(ierr);
ierr = VecViewFromOptions(u, NULL, "-potential_view");CHKERRQ(ierr);
if (user.spectral) {
PetscInt planeDir[2] = {0, 1};
PetscReal planeCoord[2] = {0., 1.};
ierr = ComputeSpectral(dm, u, 2, planeDir, planeCoord, &user);CHKERRQ(ierr);
}
/* Adjoint system */
if (user.adjoint) {
DM dmAdj;
SNES snesAdj;
Vec uAdj;
ierr = SNESCreate(PETSC_COMM_WORLD, &snesAdj);CHKERRQ(ierr);
ierr = PetscObjectSetOptionsPrefix((PetscObject) snesAdj, "adjoint_");CHKERRQ(ierr);
ierr = DMClone(dm, &dmAdj);CHKERRQ(ierr);
ierr = SNESSetDM(snesAdj, dmAdj);CHKERRQ(ierr);
ierr = SetupDiscretization(dmAdj, "adjoint", SetupAdjointProblem, &user);CHKERRQ(ierr);
ierr = DMCreateGlobalVector(dmAdj, &uAdj);CHKERRQ(ierr);
ierr = VecSet(uAdj, 0.0);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) uAdj, "adjoint");CHKERRQ(ierr);
ierr = DMPlexSetSNESLocalFEM(dmAdj, &user, &user, &user);CHKERRQ(ierr);
ierr = SNESSetFromOptions(snesAdj);CHKERRQ(ierr);
ierr = SNESSolve(snesAdj, NULL, uAdj);CHKERRQ(ierr);
ierr = SNESGetSolution(snesAdj, &uAdj);CHKERRQ(ierr);
ierr = VecViewFromOptions(uAdj, NULL, "-adjoint_view");CHKERRQ(ierr);
/* Error representation */
{
DM dmErr, dmErrAux, dms[2];
Vec errorEst, errorL2, uErr, uErrLoc, uAdjLoc, uAdjProj;
IS *subis;
PetscReal errorEstTot, errorL2Norm, errorL2Tot;
PetscInt N, i;
PetscErrorCode (*funcs[1])(PetscInt, PetscReal, const PetscReal [], PetscInt, PetscScalar *, void *) = {trig_u};
void (*identity[1])(PetscInt, PetscInt, PetscInt,
const PetscInt[], const PetscInt[], const PetscScalar[], const PetscScalar[], const PetscScalar[],
const PetscInt[], const PetscInt[], const PetscScalar[], const PetscScalar[], const PetscScalar[],
PetscReal, const PetscReal[], PetscInt, const PetscScalar[], PetscScalar[]) = {f0_identityaux_u};
void *ctxs[1] = {0};
ctxs[0] = &user;
ierr = DMClone(dm, &dmErr);CHKERRQ(ierr);
ierr = SetupDiscretization(dmErr, "error", SetupErrorProblem, &user);CHKERRQ(ierr);
ierr = DMGetGlobalVector(dmErr, &errorEst);CHKERRQ(ierr);
ierr = DMGetGlobalVector(dmErr, &errorL2);CHKERRQ(ierr);
/* Compute auxiliary data (solution and projection of adjoint solution) */
ierr = DMGetLocalVector(dmAdj, &uAdjLoc);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(dmAdj, uAdj, INSERT_VALUES, uAdjLoc);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(dmAdj, uAdj, INSERT_VALUES, uAdjLoc);CHKERRQ(ierr);
ierr = DMGetGlobalVector(dm, &uAdjProj);CHKERRQ(ierr);
ierr = PetscObjectCompose((PetscObject) dm, "dmAux", (PetscObject) dmAdj);CHKERRQ(ierr);
ierr = PetscObjectCompose((PetscObject) dm, "A", (PetscObject) uAdjLoc);CHKERRQ(ierr);
ierr = DMProjectField(dm, 0.0, u, identity, INSERT_VALUES, uAdjProj);CHKERRQ(ierr);
ierr = PetscObjectCompose((PetscObject) dm, "dmAux", NULL);CHKERRQ(ierr);
ierr = PetscObjectCompose((PetscObject) dm, "A", NULL);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(dmAdj, &uAdjLoc);CHKERRQ(ierr);
/* Attach auxiliary data */
dms[0] = dm; dms[1] = dm;
ierr = DMCreateSuperDM(dms, 2, &subis, &dmErrAux);CHKERRQ(ierr);
if (0) {
PetscSection sec;
ierr = DMGetSection(dms[0], &sec);CHKERRQ(ierr);
ierr = PetscSectionView(sec, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = DMGetSection(dms[1], &sec);CHKERRQ(ierr);
ierr = PetscSectionView(sec, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = DMGetSection(dmErrAux, &sec);CHKERRQ(ierr);
ierr = PetscSectionView(sec, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
ierr = DMViewFromOptions(dmErrAux, NULL, "-dm_err_view");CHKERRQ(ierr);
ierr = ISViewFromOptions(subis[0], NULL, "-super_is_view");CHKERRQ(ierr);
ierr = ISViewFromOptions(subis[1], NULL, "-super_is_view");CHKERRQ(ierr);
ierr = DMGetGlobalVector(dmErrAux, &uErr);CHKERRQ(ierr);
ierr = VecViewFromOptions(u, NULL, "-map_vec_view");CHKERRQ(ierr);
ierr = VecViewFromOptions(uAdjProj, NULL, "-map_vec_view");CHKERRQ(ierr);
ierr = VecViewFromOptions(uErr, NULL, "-map_vec_view");CHKERRQ(ierr);
ierr = VecISCopy(uErr, subis[0], SCATTER_FORWARD, u);CHKERRQ(ierr);
ierr = VecISCopy(uErr, subis[1], SCATTER_FORWARD, uAdjProj);CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(dm, &uAdjProj);CHKERRQ(ierr);
for (i = 0; i < 2; ++i) {ierr = ISDestroy(&subis[i]);CHKERRQ(ierr);}
ierr = PetscFree(subis);CHKERRQ(ierr);
ierr = DMGetLocalVector(dmErrAux, &uErrLoc);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(dm, uErr, INSERT_VALUES, uErrLoc);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(dm, uErr, INSERT_VALUES, uErrLoc);CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(dmErrAux, &uErr);CHKERRQ(ierr);
ierr = PetscObjectCompose((PetscObject) dmAdj, "dmAux", (PetscObject) dmErrAux);CHKERRQ(ierr);
ierr = PetscObjectCompose((PetscObject) dmAdj, "A", (PetscObject) uErrLoc);CHKERRQ(ierr);
/* Compute cellwise error estimate */
ierr = VecSet(errorEst, 0.0);CHKERRQ(ierr);
ierr = DMPlexComputeCellwiseIntegralFEM(dmAdj, uAdj, errorEst, &user);CHKERRQ(ierr);
ierr = PetscObjectCompose((PetscObject) dmAdj, "dmAux", NULL);CHKERRQ(ierr);
ierr = PetscObjectCompose((PetscObject) dmAdj, "A", NULL);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(dmErrAux, &uErrLoc);CHKERRQ(ierr);
ierr = DMDestroy(&dmErrAux);CHKERRQ(ierr);
/* Plot cellwise error vector */
ierr = VecViewFromOptions(errorEst, NULL, "-error_view");CHKERRQ(ierr);
/* Compute ratio of estimate (sum over cells) with actual L_2 error */
ierr = DMComputeL2Diff(dm, 0.0, funcs, ctxs, u, &errorL2Norm);CHKERRQ(ierr);
ierr = DMPlexComputeL2DiffVec(dm, 0.0, funcs, ctxs, u, errorL2);CHKERRQ(ierr);
ierr = VecViewFromOptions(errorL2, NULL, "-l2_error_view");CHKERRQ(ierr);
ierr = VecNorm(errorL2, NORM_INFINITY, &errorL2Tot);CHKERRQ(ierr);
ierr = VecNorm(errorEst, NORM_INFINITY, &errorEstTot);CHKERRQ(ierr);
ierr = VecGetSize(errorEst, &N);CHKERRQ(ierr);
ierr = VecPointwiseDivide(errorEst, errorEst, errorL2);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) errorEst, "Error ratio");CHKERRQ(ierr);
ierr = VecViewFromOptions(errorEst, NULL, "-error_ratio_view");CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "N: %D L2 error: %g Error Ratio: %g/%g = %g\n", N, (double) errorL2Norm, (double) errorEstTot, (double) PetscSqrtReal(errorL2Tot), (double) errorEstTot/PetscSqrtReal(errorL2Tot));CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(dmErr, &errorEst);CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(dmErr, &errorL2);CHKERRQ(ierr);
ierr = DMDestroy(&dmErr);CHKERRQ(ierr);
}
ierr = DMDestroy(&dmAdj);CHKERRQ(ierr);
ierr = VecDestroy(&uAdj);CHKERRQ(ierr);
ierr = SNESDestroy(&snesAdj);CHKERRQ(ierr);
}
/* Cleanup */
ierr = VecDestroy(&u);CHKERRQ(ierr);
ierr = SNESDestroy(&snes);CHKERRQ(ierr);
ierr = DMDestroy(&dm);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
static dErr dFSCreateGeometryFromMesh_Private(dFS fs)
{
dErr err;
dMesh mesh;
dJacobi jacobi;
dMeshEH *ents;
dEntTopology *topo;
const dInt *offset;
const dReal *rcoords;
dScalar *x;
dInt nents,n;
dFS cfs;
Vec Expanded,Global,Count;
dFunctionBegin;
err = dFSGetMesh(fs,&mesh);
dCHK(err);
err = dFSGetJacobi(fs,&jacobi);
dCHK(err);
err = dFSGetCoordinateFS(fs,&cfs);
dCHK(err);
err = dFSCreateExpandedVector(cfs,&Expanded);
dCHK(err);
err = dFSCreateGlobalVector(cfs,&Global);
dCHK(err);
err = VecDuplicate(Global,&Count);
dCHK(err);
/* Count the number of elements in which each node appears */
err = VecSet(Expanded,1.);
dCHK(err);
err = VecZeroEntries(Count);
dCHK(err);
err = dFSExpandedToGlobal(cfs,Expanded,Count,dFS_HOMOGENEOUS,ADD_VALUES);
dCHK(err);
/* Populate \a Expanded with local coordinates from mesh */
err = dMeshGetNumEnts(mesh,fs->set.active,dTYPE_REGION,dTOPO_ALL,&nents);
dCHK(err);
err = dMallocA2(nents,&ents,nents,&topo);
dCHK(err);
err = dMeshGetEnts(mesh,fs->set.active,dTYPE_REGION,dTOPO_ALL,ents,nents,NULL);
dCHK(err);
err = dMeshGetTopo(mesh,nents,ents,topo);
dCHK(err);
err = dMeshGetAdjVertexCoords(mesh,nents,ents,&offset,&rcoords);
dCHK(err);
err = VecGetLocalSize(Expanded,&n);
dCHK(err);
if (n != 3*offset[nents]) dERROR(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Size of Expanded %D does not match offset %D",n,3*offset[nents]);
err = VecGetArray(Expanded,&x);
dCHK(err);
for (dInt e=0,k=0; e<nents; e++) {
switch (topo[e]) {
case dTOPO_HEX:
for (dInt i=0; i<8; i++) {
static const dInt connidx[8] = {0,4,3,7,1,5,2,6}; /* FIXME: generalize this */
for (dInt j=0; j<3; j++) x[k++] = rcoords[(offset[e]+connidx[i])*3+j];
}
break;
default:
dERROR(PETSC_COMM_SELF,PETSC_ERR_SUP,"No support for topology %s",dMeshEntTopologyName(topo[e]));
}
}
err = VecRestoreArray(Expanded,&x);
dCHK(err);
err = dMeshRestoreAdjVertexCoords(mesh,nents,ents,&offset,&rcoords);
dCHK(err);
err = dFree2(ents,topo);
dCHK(err);
/* Populate \a Global with the average coordinates from all the elements whose closure contains the node */
err = dFSExpandedToGlobal(cfs,Expanded,Global,dFS_INHOMOGENEOUS,ADD_VALUES);
dCHK(err);
err = VecPointwiseDivide(Global,Global,Count);
dCHK(err);
err = VecDestroy(&Count);
dCHK(err);
fs->geometry.expanded = Expanded;
fs->geometry.global = Global;
dFunctionReturn(0);
}
extern PetscErrorCode MatLMVMUpdate(Mat M, Vec x, Vec g)
{
MatLMVMCtx *ctx;
PetscReal rhotemp, rhotol;
PetscReal y0temp, s0temp;
PetscReal yDy, yDs, sDs;
PetscReal sigmanew, denom;
PetscErrorCode ierr;
PetscInt i;
PetscBool same;
PetscReal yy_sum=0.0, ys_sum=0.0, ss_sum=0.0;
PetscFunctionBegin;
PetscValidHeaderSpecific(x,VEC_CLASSID,2);
PetscValidHeaderSpecific(g,VEC_CLASSID,3);
ierr = PetscObjectTypeCompare((PetscObject)M,MATSHELL,&same);CHKERRQ(ierr);
if (!same) SETERRQ(PETSC_COMM_SELF,1,"Matrix M is not type MatLMVM");
ierr = MatShellGetContext(M,(void**)&ctx);CHKERRQ(ierr);
if (!ctx->allocated) {
ierr = MatLMVMAllocateVectors(M, x); CHKERRQ(ierr);
}
if (0 == ctx->iter) {
ierr = MatLMVMReset(M);CHKERRQ(ierr);
} else {
ierr = VecAYPX(ctx->Gprev,-1.0,g);CHKERRQ(ierr);
ierr = VecAYPX(ctx->Xprev,-1.0,x);CHKERRQ(ierr);
ierr = VecDot(ctx->Gprev,ctx->Xprev,&rhotemp);CHKERRQ(ierr);
ierr = VecDot(ctx->Gprev,ctx->Gprev,&y0temp);CHKERRQ(ierr);
rhotol = ctx->eps * y0temp;
if (rhotemp > rhotol) {
++ctx->nupdates;
ctx->lmnow = PetscMin(ctx->lmnow+1, ctx->lm);
ierr=PetscObjectDereference((PetscObject)ctx->S[ctx->lm]);CHKERRQ(ierr);
ierr=PetscObjectDereference((PetscObject)ctx->Y[ctx->lm]);CHKERRQ(ierr);
for (i = ctx->lm-1; i >= 0; --i) {
ctx->S[i+1] = ctx->S[i];
ctx->Y[i+1] = ctx->Y[i];
ctx->rho[i+1] = ctx->rho[i];
}
ctx->S[0] = ctx->Xprev;
ctx->Y[0] = ctx->Gprev;
PetscObjectReference((PetscObject)ctx->S[0]);
PetscObjectReference((PetscObject)ctx->Y[0]);
ctx->rho[0] = 1.0 / rhotemp;
/* Compute the scaling */
switch(ctx->scaleType) {
case MatLMVM_Scale_None:
break;
case MatLMVM_Scale_Scalar:
/* Compute s^T s */
ierr = VecDot(ctx->Xprev,ctx->Xprev,&s0temp);CHKERRQ(ierr);
/* Scalar is positive; safeguards are not required. */
/* Save information for scalar scaling */
ctx->yy_history[(ctx->nupdates - 1) % ctx->scalar_history] = y0temp;
ctx->ys_history[(ctx->nupdates - 1) % ctx->scalar_history] = rhotemp;
ctx->ss_history[(ctx->nupdates - 1) % ctx->scalar_history] = s0temp;
/* Compute summations for scalar scaling */
yy_sum = 0; /* No safeguard required; y^T y > 0 */
ys_sum = 0; /* No safeguard required; y^T s > 0 */
ss_sum = 0; /* No safeguard required; s^T s > 0 */
for (i = 0; i < PetscMin(ctx->nupdates, ctx->scalar_history); ++i) {
yy_sum += ctx->yy_history[i];
ys_sum += ctx->ys_history[i];
ss_sum += ctx->ss_history[i];
}
if (0.0 == ctx->s_alpha) {
/* Safeguard ys_sum */
if (0.0 == ys_sum) {
ys_sum = TAO_ZERO_SAFEGUARD;
}
sigmanew = ss_sum / ys_sum;
} else if (1.0 == ctx->s_alpha) {
/* Safeguard yy_sum */
if (0.0 == yy_sum) {
yy_sum = TAO_ZERO_SAFEGUARD;
}
sigmanew = ys_sum / yy_sum;
} else {
denom = 2*ctx->s_alpha*yy_sum;
/* Safeguard denom */
if (0.0 == denom) {
denom = TAO_ZERO_SAFEGUARD;
}
sigmanew = ((2*ctx->s_alpha-1)*ys_sum + PetscSqrtScalar((2*ctx->s_alpha-1)*(2*ctx->s_alpha-1)*ys_sum*ys_sum - 4*(ctx->s_alpha)*(ctx->s_alpha-1)*yy_sum*ss_sum)) / denom;
}
switch(ctx->limitType) {
case MatLMVM_Limit_Average:
if (1.0 == ctx->mu) {
ctx->sigma = sigmanew;
} else if (ctx->mu) {
ctx->sigma = ctx->mu * sigmanew + (1.0 - ctx->mu) * ctx->sigma;
}
break;
case MatLMVM_Limit_Relative:
if (ctx->mu) {
ctx->sigma = TaoMid((1.0 - ctx->mu) * ctx->sigma, sigmanew, (1.0 + ctx->mu) * ctx->sigma);
}
break;
case MatLMVM_Limit_Absolute:
if (ctx->nu) {
ctx->sigma = TaoMid(ctx->sigma - ctx->nu, sigmanew, ctx->sigma + ctx->nu);
}
break;
default:
ctx->sigma = sigmanew;
break;
}
break;
case MatLMVM_Scale_Broyden:
/* Original version */
/* Combine DFP and BFGS */
/* This code appears to be numerically unstable. We use the */
/* original version because this was used to generate all of */
/* the data and because it may be the least unstable of the */
/* bunch. */
/* P = Q = inv(D); */
ierr = VecCopy(ctx->D,ctx->P);CHKERRQ(ierr);
ierr = VecReciprocal(ctx->P);CHKERRQ(ierr);
ierr = VecCopy(ctx->P,ctx->Q);CHKERRQ(ierr);
/* V = y*y */
ierr = VecPointwiseMult(ctx->V,ctx->Gprev,ctx->Gprev);CHKERRQ(ierr);
/* W = inv(D)*s */
ierr = VecPointwiseMult(ctx->W,ctx->Xprev,ctx->P);CHKERRQ(ierr);
ierr = VecDot(ctx->W,ctx->Xprev,&sDs);CHKERRQ(ierr);
/* Safeguard rhotemp and sDs */
if (0.0 == rhotemp) {
rhotemp = TAO_ZERO_SAFEGUARD;
}
if (0.0 == sDs) {
sDs = TAO_ZERO_SAFEGUARD;
}
if (1.0 != ctx->phi) {
/* BFGS portion of the update */
/* U = (inv(D)*s)*(inv(D)*s) */
ierr = VecPointwiseMult(ctx->U,ctx->W,ctx->W);CHKERRQ(ierr);
/* Assemble */
ierr = VecAXPY(ctx->P,1.0/rhotemp,ctx->V);CHKERRQ(ierr);
ierr = VecAXPY(ctx->P,-1.0/sDs,ctx->U);CHKERRQ(ierr);
}
if (0.0 != ctx->phi) {
/* DFP portion of the update */
/* U = inv(D)*s*y */
ierr = VecPointwiseMult(ctx->U, ctx->W, ctx->Gprev);CHKERRQ(ierr);
/* Assemble */
ierr = VecAXPY(ctx->Q,1.0/rhotemp + sDs/(rhotemp*rhotemp), ctx->V);CHKERRQ(ierr);
ierr = VecAXPY(ctx->Q,-2.0/rhotemp,ctx->U);CHKERRQ(ierr);
}
if (0.0 == ctx->phi) {
ierr = VecCopy(ctx->P,ctx->U);CHKERRQ(ierr);
} else if (1.0 == ctx->phi) {
ierr = VecCopy(ctx->Q,ctx->U);CHKERRQ(ierr);
} else {
/* Broyden update U=(1-phi)*P + phi*Q */
ierr = VecCopy(ctx->Q,ctx->U);CHKERRQ(ierr);
ierr = VecAXPBY(ctx->U,1.0-ctx->phi, ctx->phi, ctx->P);CHKERRQ(ierr);
}
/* Obtain inverse and ensure positive definite */
ierr = VecReciprocal(ctx->U);CHKERRQ(ierr);
ierr = VecAbs(ctx->U);CHKERRQ(ierr);
switch(ctx->rScaleType) {
case MatLMVM_Rescale_None:
break;
case MatLMVM_Rescale_Scalar:
case MatLMVM_Rescale_GL:
if (ctx->rScaleType == MatLMVM_Rescale_GL) {
/* Gilbert and Lemarachal use the old diagonal */
ierr = VecCopy(ctx->D,ctx->P);CHKERRQ(ierr);
} else {
/* The default version uses the current diagonal */
ierr = VecCopy(ctx->U,ctx->P);CHKERRQ(ierr);
}
/* Compute s^T s */
ierr = VecDot(ctx->Xprev,ctx->Xprev,&s0temp);CHKERRQ(ierr);
/* Save information for special cases of scalar rescaling */
ctx->yy_rhistory[(ctx->nupdates - 1) % ctx->rescale_history] = y0temp;
ctx->ys_rhistory[(ctx->nupdates - 1) % ctx->rescale_history] = rhotemp;
ctx->ss_rhistory[(ctx->nupdates - 1) % ctx->rescale_history] = s0temp;
if (0.5 == ctx->r_beta) {
if (1 == PetscMin(ctx->nupdates, ctx->rescale_history)) {
ierr = VecPointwiseMult(ctx->V,ctx->Y[0],ctx->P);CHKERRQ(ierr);
ierr = VecDot(ctx->V,ctx->Y[0],&yy_sum);CHKERRQ(ierr);
ierr = VecPointwiseDivide(ctx->W,ctx->S[0],ctx->P);CHKERRQ(ierr);
ierr = VecDot(ctx->W,ctx->S[0],&ss_sum);CHKERRQ(ierr);
ys_sum = ctx->ys_rhistory[0];
} else {
ierr = VecCopy(ctx->P,ctx->Q);CHKERRQ(ierr);
ierr = VecReciprocal(ctx->Q);CHKERRQ(ierr);
/* Compute summations for scalar scaling */
yy_sum = 0; /* No safeguard required */
ys_sum = 0; /* No safeguard required */
ss_sum = 0; /* No safeguard required */
for (i = 0; i < PetscMin(ctx->nupdates, ctx->rescale_history); ++i) {
ierr = VecPointwiseMult(ctx->V,ctx->Y[i],ctx->P);CHKERRQ(ierr);
ierr = VecDot(ctx->V,ctx->Y[i],&yDy);CHKERRQ(ierr);
yy_sum += yDy;
ierr = VecPointwiseMult(ctx->W,ctx->S[i],ctx->Q);CHKERRQ(ierr);
ierr = VecDot(ctx->W,ctx->S[i],&sDs);CHKERRQ(ierr);
ss_sum += sDs;
ys_sum += ctx->ys_rhistory[i];
}
}
} else if (0.0 == ctx->r_beta) {
if (1 == PetscMin(ctx->nupdates, ctx->rescale_history)) {
/* Compute summations for scalar scaling */
ierr = VecPointwiseDivide(ctx->W,ctx->S[0],ctx->P);CHKERRQ(ierr);
ierr = VecDot(ctx->W, ctx->Y[0], &ys_sum);CHKERRQ(ierr);
ierr = VecDot(ctx->W, ctx->W, &ss_sum);CHKERRQ(ierr);
yy_sum += ctx->yy_rhistory[0];
} else {
ierr = VecCopy(ctx->Q, ctx->P);CHKERRQ(ierr);
ierr = VecReciprocal(ctx->Q);CHKERRQ(ierr);
/* Compute summations for scalar scaling */
yy_sum = 0; /* No safeguard required */
ys_sum = 0; /* No safeguard required */
ss_sum = 0; /* No safeguard required */
for (i = 0; i < PetscMin(ctx->nupdates, ctx->rescale_history); ++i) {
ierr = VecPointwiseMult(ctx->W, ctx->S[i], ctx->Q);CHKERRQ(ierr);
ierr = VecDot(ctx->W, ctx->Y[i], &yDs);CHKERRQ(ierr);
ys_sum += yDs;
ierr = VecDot(ctx->W, ctx->W, &sDs);CHKERRQ(ierr);
ss_sum += sDs;
yy_sum += ctx->yy_rhistory[i];
}
}
} else if (1.0 == ctx->r_beta) {
/* Compute summations for scalar scaling */
yy_sum = 0; /* No safeguard required */
ys_sum = 0; /* No safeguard required */
ss_sum = 0; /* No safeguard required */
for (i = 0; i < PetscMin(ctx->nupdates, ctx->rescale_history); ++i) {
ierr = VecPointwiseMult(ctx->V, ctx->Y[i], ctx->P);CHKERRQ(ierr);
ierr = VecDot(ctx->V, ctx->S[i], &yDs);CHKERRQ(ierr);
ys_sum += yDs;
ierr = VecDot(ctx->V, ctx->V, &yDy);CHKERRQ(ierr);
yy_sum += yDy;
ss_sum += ctx->ss_rhistory[i];
}
} else {
ierr = VecCopy(ctx->Q, ctx->P);CHKERRQ(ierr);
ierr = VecPow(ctx->P, ctx->r_beta);CHKERRQ(ierr);
ierr = VecPointwiseDivide(ctx->Q, ctx->P, ctx->Q);CHKERRQ(ierr);
/* Compute summations for scalar scaling */
yy_sum = 0; /* No safeguard required */
ys_sum = 0; /* No safeguard required */
ss_sum = 0; /* No safeguard required */
for (i = 0; i < PetscMin(ctx->nupdates, ctx->rescale_history); ++i) {
ierr = VecPointwiseMult(ctx->V, ctx->P, ctx->Y[i]);CHKERRQ(ierr);
ierr = VecPointwiseMult(ctx->W, ctx->Q, ctx->S[i]);CHKERRQ(ierr);
ierr = VecDot(ctx->V, ctx->V, &yDy);CHKERRQ(ierr);
ierr = VecDot(ctx->V, ctx->W, &yDs);CHKERRQ(ierr);
ierr = VecDot(ctx->W, ctx->W, &sDs);CHKERRQ(ierr);
yy_sum += yDy;
ys_sum += yDs;
ss_sum += sDs;
}
}
if (0.0 == ctx->r_alpha) {
/* Safeguard ys_sum */
if (0.0 == ys_sum) {
ys_sum = TAO_ZERO_SAFEGUARD;
}
sigmanew = ss_sum / ys_sum;
} else if (1.0 == ctx->r_alpha) {
/* Safeguard yy_sum */
if (0.0 == yy_sum) {
ys_sum = TAO_ZERO_SAFEGUARD;
}
sigmanew = ys_sum / yy_sum;
} else {
denom = 2*ctx->r_alpha*yy_sum;
/* Safeguard denom */
if (0.0 == denom) {
denom = TAO_ZERO_SAFEGUARD;
}
sigmanew = ((2*ctx->r_alpha-1)*ys_sum + PetscSqrtScalar((2*ctx->r_alpha-1)*(2*ctx->r_alpha-1)*ys_sum*ys_sum - 4*ctx->r_alpha*(ctx->r_alpha-1)*yy_sum*ss_sum)) / denom;
}
/* If Q has small values, then Q^(r_beta - 1) */
/* can have very large values. Hence, ys_sum */
/* and ss_sum can be infinity. In this case, */
/* sigmanew can either be not-a-number or infinity. */
if (PetscIsInfOrNanReal(sigmanew)) {
/* sigmanew is not-a-number; skip rescaling */
} else if (!sigmanew) {
/* sigmanew is zero; this is a bad case; skip rescaling */
} else {
/* sigmanew is positive */
ierr = VecScale(ctx->U, sigmanew);CHKERRQ(ierr);
}
break;
}
/* Modify for previous information */
switch(ctx->limitType) {
case MatLMVM_Limit_Average:
if (1.0 == ctx->mu) {
ierr = VecCopy(ctx->D, ctx->U);CHKERRQ(ierr);
} else if (ctx->mu) {
ierr = VecAXPBY(ctx->D,ctx->mu, 1.0-ctx->mu,ctx->U);CHKERRQ(ierr);
}
break;
case MatLMVM_Limit_Relative:
if (ctx->mu) {
/* P = (1-mu) * D */
ierr = VecAXPBY(ctx->P, 1.0-ctx->mu, 0.0, ctx->D);CHKERRQ(ierr);
/* Q = (1+mu) * D */
ierr = VecAXPBY(ctx->Q, 1.0+ctx->mu, 0.0, ctx->D);CHKERRQ(ierr);
ierr = VecMedian(ctx->P, ctx->U, ctx->Q, ctx->D);CHKERRQ(ierr);
}
break;
case MatLMVM_Limit_Absolute:
if (ctx->nu) {
ierr = VecCopy(ctx->P, ctx->D);CHKERRQ(ierr);
ierr = VecShift(ctx->P, -ctx->nu);CHKERRQ(ierr);
ierr = VecCopy(ctx->D, ctx->Q);CHKERRQ(ierr);
ierr = VecShift(ctx->Q, ctx->nu);CHKERRQ(ierr);
ierr = VecMedian(ctx->P, ctx->U, ctx->Q, ctx->P);CHKERRQ(ierr);
}
break;
default:
ierr = VecCopy(ctx->U, ctx->D);CHKERRQ(ierr);
break;
}
break;
}
ierr = PetscObjectDereference((PetscObject)ctx->Xprev);CHKERRQ(ierr);
ierr = PetscObjectDereference((PetscObject)ctx->Gprev);CHKERRQ(ierr);
ctx->Xprev = ctx->S[ctx->lm];
ctx->Gprev = ctx->Y[ctx->lm];
ierr = PetscObjectReference((PetscObject)ctx->S[ctx->lm]);CHKERRQ(ierr);
ierr = PetscObjectReference((PetscObject)ctx->Y[ctx->lm]);CHKERRQ(ierr);
} else {
++ctx->nrejects;
}
}
++ctx->iter;
ierr = VecCopy(x, ctx->Xprev);CHKERRQ(ierr);
ierr = VecCopy(g, ctx->Gprev);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode PCBDDCScalingSetUp(PC pc)
{
PC_IS* pcis=(PC_IS*)pc->data;
PC_BDDC* pcbddc=(PC_BDDC*)pc->data;
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(pc,PC_CLASSID,1);
/* create work vector for the operator */
ierr = VecDestroy(&pcbddc->work_scaling);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_B,&pcbddc->work_scaling);CHKERRQ(ierr);
/* always rebuild pcis->D */
if (pcis->use_stiffness_scaling) {
ierr = MatGetDiagonal(pcbddc->local_mat,pcis->vec1_N);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->N_to_B,pcis->vec1_N,pcis->D,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->N_to_B,pcis->vec1_N,pcis->D,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
}
ierr = VecCopy(pcis->D,pcis->vec1_B);CHKERRQ(ierr);
ierr = VecSet(pcis->vec1_global,0.0);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,pcis->vec1_B,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->global_to_B,pcis->vec1_B,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,pcis->vec1_global,pcis->vec1_B,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->global_to_B,pcis->vec1_global,pcis->vec1_B,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecPointwiseDivide(pcis->D,pcis->D,pcis->vec1_B);CHKERRQ(ierr);
/* now setup */
if (pcbddc->use_deluxe_scaling) {
if (!pcbddc->deluxe_ctx) {
ierr = PCBDDCScalingCreate_Deluxe(pc);CHKERRQ(ierr);
}
ierr = PCBDDCScalingSetUp_Deluxe(pc);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)pc,"PCBDDCScalingRestriction_C",PCBDDCScalingRestriction_Deluxe);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)pc,"PCBDDCScalingExtension_C",PCBDDCScalingExtension_Deluxe);CHKERRQ(ierr);
} else {
ierr = PetscObjectComposeFunction((PetscObject)pc,"PCBDDCScalingRestriction_C",PCBDDCScalingRestriction_Basic);CHKERRQ(ierr);
ierr = PetscObjectComposeFunction((PetscObject)pc,"PCBDDCScalingExtension_C",PCBDDCScalingExtension_Basic);CHKERRQ(ierr);
}
/* test */
if (pcbddc->dbg_flag) {
Vec vec2_global;
PetscViewer viewer=pcbddc->dbg_viewer;
PetscReal error;
/* extension -> from local to parallel */
ierr = VecSet(pcis->vec1_global,0.0);CHKERRQ(ierr);
ierr = VecSetRandom(pcis->vec1_B,NULL);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,pcis->vec1_B,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->global_to_B,pcis->vec1_B,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_global,&vec2_global);CHKERRQ(ierr);
ierr = VecCopy(pcis->vec1_global,vec2_global);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,pcis->vec1_global,pcis->vec1_B,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->global_to_B,pcis->vec1_global,pcis->vec1_B,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = PCBDDCScalingExtension(pc,pcis->vec1_B,pcis->vec1_global);CHKERRQ(ierr);
ierr = VecAXPY(pcis->vec1_global,-1.0,vec2_global);CHKERRQ(ierr);
ierr = VecNorm(pcis->vec1_global,NORM_INFINITY,&error);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Error scaling extension %1.14e\n",error);CHKERRQ(ierr);
if (error>1.e-8 && pcbddc->dbg_flag>1) {
ierr = VecView(pcis->vec1_global,viewer);CHKERRQ(ierr);
}
ierr = VecDestroy(&vec2_global);CHKERRQ(ierr);
/* restriction -> from parallel to local */
ierr = VecSet(pcis->vec1_global,0.0);CHKERRQ(ierr);
ierr = VecSetRandom(pcis->vec1_B,NULL);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,pcis->vec1_B,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->global_to_B,pcis->vec1_B,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = PCBDDCScalingRestriction(pc,pcis->vec1_global,pcis->vec1_B);CHKERRQ(ierr);
ierr = VecScale(pcis->vec1_B,-1.0);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,pcis->vec1_B,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterEnd(pcis->global_to_B,pcis->vec1_B,pcis->vec1_global,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecNorm(pcis->vec1_global,NORM_INFINITY,&error);CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"Error scaling restriction %1.14e\n",error);CHKERRQ(ierr);
if (error>1.e-8 && pcbddc->dbg_flag>1) {
ierr = VecView(pcis->vec1_global,viewer);CHKERRQ(ierr);
}
}
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
Vec x,y,w; /* vectors */
Vec *z; /* array of vectors */
PetscReal norm,v,v1,v2,maxval;
PetscInt n = 20,maxind;
PetscErrorCode ierr;
PetscScalar one = 1.0,two = 2.0,three = 3.0,dots[3],dot;
ierr = PetscInitialize(&argc,&argv,(char*)0,help);if (ierr) return ierr;
ierr = PetscOptionsGetInt(NULL,NULL,"-n",&n,NULL);CHKERRQ(ierr);
/*
Create a vector, specifying only its global dimension.
When using VecCreate(), VecSetSizes() and VecSetFromOptions(), the vector format
(currently parallel, shared, or sequential) is determined at runtime. Also, the
parallel partitioning of the vector is determined by PETSc at runtime.
Routines for creating particular vector types directly are:
VecCreateSeq() - uniprocessor vector
VecCreateMPI() - distributed vector, where the user can
determine the parallel partitioning
VecCreateShared() - parallel vector that uses shared memory
(available only on the SGI); otherwise,
is the same as VecCreateMPI()
With VecCreate(), VecSetSizes() and VecSetFromOptions() the option -vec_type mpi or
-vec_type shared causes the particular type of vector to be formed.
*/
ierr = VecCreate(PETSC_COMM_WORLD,&x);CHKERRQ(ierr);
ierr = VecSetSizes(x,PETSC_DECIDE,n);CHKERRQ(ierr);
ierr = VecSetFromOptions(x);CHKERRQ(ierr);
/*
Duplicate some work vectors (of the same format and
partitioning as the initial vector).
*/
ierr = VecDuplicate(x,&y);CHKERRQ(ierr);
ierr = VecDuplicate(x,&w);CHKERRQ(ierr);
/*
Duplicate more work vectors (of the same format and
partitioning as the initial vector). Here we duplicate
an array of vectors, which is often more convenient than
duplicating individual ones.
*/
ierr = VecDuplicateVecs(x,3,&z);CHKERRQ(ierr);
/*
Set the vectors to entries to a constant value.
*/
ierr = VecSet(x,one);CHKERRQ(ierr);
ierr = VecSet(y,two);CHKERRQ(ierr);
ierr = VecSet(z[0],one);CHKERRQ(ierr);
ierr = VecSet(z[1],two);CHKERRQ(ierr);
ierr = VecSet(z[2],three);CHKERRQ(ierr);
/*
Demonstrate various basic vector routines.
*/
ierr = VecDot(x,y,&dot);CHKERRQ(ierr);
ierr = VecMDot(x,3,z,dots);CHKERRQ(ierr);
/*
Note: If using a complex numbers version of PETSc, then
PETSC_USE_COMPLEX is defined in the makefiles; otherwise,
(when using real numbers) it is undefined.
*/
ierr = PetscPrintf(PETSC_COMM_WORLD,"Vector length %D\n",n);CHKERRQ(ierr);
ierr = VecMax(x,&maxind,&maxval);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"VecMax %g, VecInd %D\n",(double)maxval,maxind);CHKERRQ(ierr);
ierr = VecMin(x,&maxind,&maxval);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"VecMin %g, VecInd %D\n",(double)maxval,maxind);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"All other values should be near zero\n");CHKERRQ(ierr);
ierr = VecScale(x,two);CHKERRQ(ierr);
ierr = VecNorm(x,NORM_2,&norm);CHKERRQ(ierr);
v = norm-2.0*PetscSqrtReal((PetscReal)n); if (v > -PETSC_SMALL && v < PETSC_SMALL) v = 0.0;
ierr = PetscPrintf(PETSC_COMM_WORLD,"VecScale %g\n",(double)v);CHKERRQ(ierr);
ierr = VecCopy(x,w);CHKERRQ(ierr);
ierr = VecNorm(w,NORM_2,&norm);CHKERRQ(ierr);
v = norm-2.0*PetscSqrtReal((PetscReal)n); if (v > -PETSC_SMALL && v < PETSC_SMALL) v = 0.0;
ierr = PetscPrintf(PETSC_COMM_WORLD,"VecCopy %g\n",(double)v);CHKERRQ(ierr);
ierr = VecAXPY(y,three,x);CHKERRQ(ierr);
ierr = VecNorm(y,NORM_2,&norm);CHKERRQ(ierr);
v = norm-8.0*PetscSqrtReal((PetscReal)n); if (v > -PETSC_SMALL && v < PETSC_SMALL) v = 0.0;
ierr = PetscPrintf(PETSC_COMM_WORLD,"VecAXPY %g\n",(double)v);CHKERRQ(ierr);
ierr = VecAYPX(y,two,x);CHKERRQ(ierr);
ierr = VecNorm(y,NORM_2,&norm);CHKERRQ(ierr);
v = norm-18.0*PetscSqrtReal((PetscReal)n); if (v > -PETSC_SMALL && v < PETSC_SMALL) v = 0.0;
ierr = PetscPrintf(PETSC_COMM_WORLD,"VecAYPX %g\n",(double)v);CHKERRQ(ierr);
ierr = VecSwap(x,y);CHKERRQ(ierr);
ierr = VecNorm(y,NORM_2,&norm);CHKERRQ(ierr);
v = norm-2.0*PetscSqrtReal((PetscReal)n); if (v > -PETSC_SMALL && v < PETSC_SMALL) v = 0.0;
ierr = PetscPrintf(PETSC_COMM_WORLD,"VecSwap %g\n",(double)v);CHKERRQ(ierr);
ierr = VecNorm(x,NORM_2,&norm);CHKERRQ(ierr);
v = norm-18.0*PetscSqrtReal((PetscReal)n); if (v > -PETSC_SMALL && v < PETSC_SMALL) v = 0.0;
ierr = PetscPrintf(PETSC_COMM_WORLD,"VecSwap %g\n",(double)v);CHKERRQ(ierr);
ierr = VecWAXPY(w,two,x,y);CHKERRQ(ierr);
ierr = VecNorm(w,NORM_2,&norm);CHKERRQ(ierr);
v = norm-38.0*PetscSqrtReal((PetscReal)n); if (v > -PETSC_SMALL && v < PETSC_SMALL) v = 0.0;
ierr = PetscPrintf(PETSC_COMM_WORLD,"VecWAXPY %g\n",(double)v);CHKERRQ(ierr);
ierr = VecPointwiseMult(w,y,x);CHKERRQ(ierr);
ierr = VecNorm(w,NORM_2,&norm);CHKERRQ(ierr);
v = norm-36.0*PetscSqrtReal((PetscReal)n); if (v > -PETSC_SMALL && v < PETSC_SMALL) v = 0.0;
ierr = PetscPrintf(PETSC_COMM_WORLD,"VecPointwiseMult %g\n",(double)v);CHKERRQ(ierr);
ierr = VecPointwiseDivide(w,x,y);CHKERRQ(ierr);
ierr = VecNorm(w,NORM_2,&norm);CHKERRQ(ierr);
v = norm-9.0*PetscSqrtReal((PetscReal)n); if (v > -PETSC_SMALL && v < PETSC_SMALL) v = 0.0;
ierr = PetscPrintf(PETSC_COMM_WORLD,"VecPointwiseDivide %g\n",(double)v);CHKERRQ(ierr);
dots[0] = one;
dots[1] = three;
dots[2] = two;
ierr = VecSet(x,one);CHKERRQ(ierr);
ierr = VecMAXPY(x,3,dots,z);CHKERRQ(ierr);
ierr = VecNorm(z[0],NORM_2,&norm);CHKERRQ(ierr);
v = norm-PetscSqrtReal((PetscReal)n); if (v > -PETSC_SMALL && v < PETSC_SMALL) v = 0.0;
ierr = VecNorm(z[1],NORM_2,&norm);CHKERRQ(ierr);
v1 = norm-2.0*PetscSqrtReal((PetscReal)n); if (v1 > -PETSC_SMALL && v1 < PETSC_SMALL) v1 = 0.0;
ierr = VecNorm(z[2],NORM_2,&norm);CHKERRQ(ierr);
v2 = norm-3.0*PetscSqrtReal((PetscReal)n); if (v2 > -PETSC_SMALL && v2 < PETSC_SMALL) v2 = 0.0;
ierr = PetscPrintf(PETSC_COMM_WORLD,"VecMAXPY %g %g %g \n",(double)v,(double)v1,(double)v2);CHKERRQ(ierr);
/*
Free work space. All PETSc objects should be destroyed when they
are no longer needed.
*/
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = VecDestroy(&w);CHKERRQ(ierr);
ierr = VecDestroyVecs(3,&z);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
static PetscErrorCode TaoSolve_ASILS(Tao tao)
{
TAO_SSLS *asls = (TAO_SSLS *)tao->data;
PetscReal psi,ndpsi, normd, innerd, t=0;
PetscInt iter=0, nf;
PetscErrorCode ierr;
TaoConvergedReason reason;
TaoLineSearchConvergedReason ls_reason;
PetscFunctionBegin;
/* Assume that Setup has been called!
Set the structure for the Jacobian and create a linear solver. */
ierr = TaoComputeVariableBounds(tao);CHKERRQ(ierr);
ierr = TaoLineSearchSetObjectiveAndGradientRoutine(tao->linesearch,Tao_ASLS_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,asls->dpsi);CHKERRQ(ierr);
ierr = VecNorm(asls->dpsi,NORM_2,&ndpsi);CHKERRQ(ierr);
while (1) {
/* Check the termination criteria */
ierr = PetscInfo3(tao,"iter %D, merit: %g, ||dpsi||: %g\n",iter, (double)asls->merit, (double)ndpsi);CHKERRQ(ierr);
ierr = TaoMonitor(tao, iter++, asls->merit, ndpsi, 0.0, t, &reason);CHKERRQ(ierr);
if (TAO_CONTINUE_ITERATING != reason) break;
/* We are going to solve a linear system of equations. We need to
set the tolerances for the solve so that we maintain an asymptotic
rate of convergence that is superlinear.
Note: these tolerances are for the reduced system. We really need
to make sure that the full system satisfies the full-space conditions.
This rule gives superlinear asymptotic convergence
asls->atol = min(0.5, asls->merit*sqrt(asls->merit));
asls->rtol = 0.0;
This rule gives quadratic asymptotic convergence
asls->atol = min(0.5, asls->merit*asls->merit);
asls->rtol = 0.0;
Calculate a free and fixed set of variables. The fixed set of
variables are those for the d_b is approximately equal to zero.
The definition of approximately changes as we approach the solution
to the problem.
No one rule is guaranteed to work in all cases. The following
definition is based on the norm of the Jacobian matrix. If the
norm is large, the tolerance becomes smaller. */
ierr = MatNorm(tao->jacobian,NORM_1,&asls->identifier);CHKERRQ(ierr);
asls->identifier = PetscMin(asls->merit, 1e-2) / (1 + asls->identifier);
ierr = VecSet(asls->t1,-asls->identifier);CHKERRQ(ierr);
ierr = VecSet(asls->t2, asls->identifier);CHKERRQ(ierr);
ierr = ISDestroy(&asls->fixed);CHKERRQ(ierr);
ierr = ISDestroy(&asls->free);CHKERRQ(ierr);
ierr = VecWhichBetweenOrEqual(asls->t1, asls->db, asls->t2, &asls->fixed);CHKERRQ(ierr);
ierr = ISComplementVec(asls->fixed,asls->t1, &asls->free);CHKERRQ(ierr);
ierr = ISGetSize(asls->fixed,&nf);CHKERRQ(ierr);
ierr = PetscInfo1(tao,"Number of fixed variables: %D\n", nf);CHKERRQ(ierr);
/* We now have our partition. Now calculate the direction in the
fixed variable space. */
ierr = TaoVecGetSubVec(asls->ff, asls->fixed, tao->subset_type, 0.0, &asls->r1);
ierr = TaoVecGetSubVec(asls->da, asls->fixed, tao->subset_type, 1.0, &asls->r2);
ierr = VecPointwiseDivide(asls->r1,asls->r1,asls->r2);CHKERRQ(ierr);
ierr = VecSet(tao->stepdirection,0.0);CHKERRQ(ierr);
ierr = VecISAXPY(tao->stepdirection, asls->fixed,1.0,asls->r1);CHKERRQ(ierr);
/* Our direction in the Fixed Variable Set is fixed. Calculate the
information needed for the step in the Free Variable Set. To
do this, we need to know the diagonal perturbation and the
right hand side. */
ierr = TaoVecGetSubVec(asls->da, asls->free, tao->subset_type, 0.0, &asls->r1);CHKERRQ(ierr);
ierr = TaoVecGetSubVec(asls->ff, asls->free, tao->subset_type, 0.0, &asls->r2);CHKERRQ(ierr);
ierr = TaoVecGetSubVec(asls->db, asls->free, tao->subset_type, 1.0, &asls->r3);CHKERRQ(ierr);
ierr = VecPointwiseDivide(asls->r1,asls->r1, asls->r3);CHKERRQ(ierr);
ierr = VecPointwiseDivide(asls->r2,asls->r2, asls->r3);CHKERRQ(ierr);
/* r1 is the diagonal perturbation
r2 is the right hand side
r3 is no longer needed
Now need to modify r2 for our direction choice in the fixed
variable set: calculate t1 = J*d, take the reduced vector
of t1 and modify r2. */
ierr = MatMult(tao->jacobian, tao->stepdirection, asls->t1);CHKERRQ(ierr);
ierr = TaoVecGetSubVec(asls->t1,asls->free,tao->subset_type,0.0,&asls->r3);CHKERRQ(ierr);
ierr = VecAXPY(asls->r2, -1.0, asls->r3);CHKERRQ(ierr);
/* Calculate the reduced problem matrix and the direction */
if (!asls->w && (tao->subset_type == TAO_SUBSET_MASK || tao->subset_type == TAO_SUBSET_MATRIXFREE)) {
ierr = VecDuplicate(tao->solution, &asls->w);CHKERRQ(ierr);
}
ierr = TaoMatGetSubMat(tao->jacobian, asls->free, asls->w, tao->subset_type,&asls->J_sub);CHKERRQ(ierr);
if (tao->jacobian != tao->jacobian_pre) {
ierr = TaoMatGetSubMat(tao->jacobian_pre, asls->free, asls->w, tao->subset_type, &asls->Jpre_sub);CHKERRQ(ierr);
} else {
ierr = MatDestroy(&asls->Jpre_sub);CHKERRQ(ierr);
asls->Jpre_sub = asls->J_sub;
ierr = PetscObjectReference((PetscObject)(asls->Jpre_sub));CHKERRQ(ierr);
}
ierr = MatDiagonalSet(asls->J_sub, asls->r1,ADD_VALUES);CHKERRQ(ierr);
ierr = TaoVecGetSubVec(tao->stepdirection, asls->free, tao->subset_type, 0.0, &asls->dxfree);CHKERRQ(ierr);
ierr = VecSet(asls->dxfree, 0.0);CHKERRQ(ierr);
/* Calculate the reduced direction. (Really negative of Newton
direction. Therefore, rest of the code uses -d.) */
ierr = KSPReset(tao->ksp);
ierr = KSPSetOperators(tao->ksp, asls->J_sub, asls->Jpre_sub);CHKERRQ(ierr);
ierr = KSPSolve(tao->ksp, asls->r2, asls->dxfree);CHKERRQ(ierr);
/* Add the direction in the free variables back into the real direction. */
ierr = VecISAXPY(tao->stepdirection, asls->free, 1.0,asls->dxfree);CHKERRQ(ierr);
/* Check the real direction for descent and if not, use the negative
gradient direction. */
ierr = VecNorm(tao->stepdirection, NORM_2, &normd);CHKERRQ(ierr);
ierr = VecDot(tao->stepdirection, asls->dpsi, &innerd);CHKERRQ(ierr);
if (innerd <= asls->delta*pow(normd, asls->rho)) {
ierr = PetscInfo1(tao,"Gradient direction: %5.4e.\n", (double)innerd);CHKERRQ(ierr);
ierr = PetscInfo1(tao, "Iteration %D: newton direction not descent\n", iter);CHKERRQ(ierr);
ierr = VecCopy(asls->dpsi, tao->stepdirection);CHKERRQ(ierr);
ierr = VecDot(asls->dpsi, tao->stepdirection, &innerd);CHKERRQ(ierr);
}
ierr = VecScale(tao->stepdirection, -1.0);CHKERRQ(ierr);
innerd = -innerd;
/* We now have a correct descent direction. Apply a linesearch to
find the new iterate. */
ierr = TaoLineSearchSetInitialStepLength(tao->linesearch, 1.0);CHKERRQ(ierr);
ierr = TaoLineSearchApply(tao->linesearch, tao->solution, &psi,asls->dpsi, tao->stepdirection, &t, &ls_reason);CHKERRQ(ierr);
ierr = VecNorm(asls->dpsi, NORM_2, &ndpsi);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
static PetscErrorCode QPIPSetInitialPoint(TAO_BQPIP *qp, Tao tao)
{
PetscErrorCode ierr;
PetscReal two=2.0,p01=1;
PetscReal gap1,gap2,fff,mu;
PetscFunctionBegin;
/* Compute function, Gradient R=Hx+b, and Hessian */
ierr = TaoComputeVariableBounds(tao);CHKERRQ(ierr);
ierr = VecMedian(qp->XL, tao->solution, qp->XU, tao->solution);CHKERRQ(ierr);
ierr = MatMult(tao->hessian, tao->solution, tao->gradient);CHKERRQ(ierr);
ierr = VecCopy(qp->C0, qp->Work);CHKERRQ(ierr);
ierr = VecAXPY(qp->Work, 0.5, tao->gradient);CHKERRQ(ierr);
ierr = VecAXPY(tao->gradient, 1.0, qp->C0);CHKERRQ(ierr);
ierr = VecDot(tao->solution, qp->Work, &fff);CHKERRQ(ierr);
qp->pobj = fff + qp->c;
/* Initialize Primal Vectors */
/* T = XU - X; G = X - XL */
ierr = VecCopy(qp->XU, qp->T);CHKERRQ(ierr);
ierr = VecAXPY(qp->T, -1.0, tao->solution);CHKERRQ(ierr);
ierr = VecCopy(tao->solution, qp->G);CHKERRQ(ierr);
ierr = VecAXPY(qp->G, -1.0, qp->XL);CHKERRQ(ierr);
ierr = VecSet(qp->GZwork, p01);CHKERRQ(ierr);
ierr = VecSet(qp->TSwork, p01);CHKERRQ(ierr);
ierr = VecPointwiseMax(qp->G, qp->G, qp->GZwork);CHKERRQ(ierr);
ierr = VecPointwiseMax(qp->T, qp->T, qp->TSwork);CHKERRQ(ierr);
/* Initialize Dual Variable Vectors */
ierr = VecCopy(qp->G, qp->Z);CHKERRQ(ierr);
ierr = VecReciprocal(qp->Z);CHKERRQ(ierr);
ierr = VecCopy(qp->T, qp->S);CHKERRQ(ierr);
ierr = VecReciprocal(qp->S);CHKERRQ(ierr);
ierr = MatMult(tao->hessian, qp->Work, qp->RHS);CHKERRQ(ierr);
ierr = VecAbs(qp->RHS);CHKERRQ(ierr);
ierr = VecSet(qp->Work, p01);CHKERRQ(ierr);
ierr = VecPointwiseMax(qp->RHS, qp->RHS, qp->Work);CHKERRQ(ierr);
ierr = VecPointwiseDivide(qp->RHS, tao->gradient, qp->RHS);CHKERRQ(ierr);
ierr = VecNorm(qp->RHS, NORM_1, &gap1);CHKERRQ(ierr);
mu = PetscMin(10.0,(gap1+10.0)/qp->m);
ierr = VecScale(qp->S, mu);CHKERRQ(ierr);
ierr = VecScale(qp->Z, mu);CHKERRQ(ierr);
ierr = VecSet(qp->TSwork, p01);CHKERRQ(ierr);
ierr = VecSet(qp->GZwork, p01);CHKERRQ(ierr);
ierr = VecPointwiseMax(qp->S, qp->S, qp->TSwork);CHKERRQ(ierr);
ierr = VecPointwiseMax(qp->Z, qp->Z, qp->GZwork);CHKERRQ(ierr);
qp->mu=0;qp->dinfeas=1.0;qp->pinfeas=1.0;
while ( (qp->dinfeas+qp->pinfeas)/(qp->m+qp->n) >= qp->mu ){
ierr = VecScale(qp->G, two);CHKERRQ(ierr);
ierr = VecScale(qp->Z, two);CHKERRQ(ierr);
ierr = VecScale(qp->S, two);CHKERRQ(ierr);
ierr = VecScale(qp->T, two);CHKERRQ(ierr);
ierr = QPIPComputeResidual(qp,tao);CHKERRQ(ierr);
ierr = VecCopy(tao->solution, qp->R3);CHKERRQ(ierr);
ierr = VecAXPY(qp->R3, -1.0, qp->G);CHKERRQ(ierr);
ierr = VecAXPY(qp->R3, -1.0, qp->XL);CHKERRQ(ierr);
ierr = VecCopy(tao->solution, qp->R5);CHKERRQ(ierr);
ierr = VecAXPY(qp->R5, 1.0, qp->T);CHKERRQ(ierr);
ierr = VecAXPY(qp->R5, -1.0, qp->XU);CHKERRQ(ierr);
ierr = VecNorm(qp->R3, NORM_INFINITY, &gap1);CHKERRQ(ierr);
ierr = VecNorm(qp->R5, NORM_INFINITY, &gap2);CHKERRQ(ierr);
qp->pinfeas=PetscMax(gap1,gap2);
/* Compute the duality gap */
ierr = VecDot(qp->G, qp->Z, &gap1);CHKERRQ(ierr);
ierr = VecDot(qp->T, qp->S, &gap2);CHKERRQ(ierr);
qp->gap = (gap1+gap2);
qp->dobj = qp->pobj - qp->gap;
if (qp->m>0) qp->mu=qp->gap/(qp->m); else qp->mu=0.0;
qp->rgap=qp->gap/( PetscAbsReal(qp->dobj) + PetscAbsReal(qp->pobj) + 1.0 );
}
PetscFunctionReturn(0);
}
PetscErrorCode PCISSetUp(PC pc)
{
PC_IS *pcis = (PC_IS*)(pc->data);
Mat_IS *matis;
PetscErrorCode ierr;
PetscBool flg,issbaij;
Vec counter;
PetscFunctionBegin;
ierr = PetscObjectTypeCompare((PetscObject)pc->pmat,MATIS,&flg);CHKERRQ(ierr);
if (!flg) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONG,"Preconditioner type of Neumann Neumman requires matrix of type MATIS");
matis = (Mat_IS*)pc->pmat->data;
pcis->pure_neumann = matis->pure_neumann;
/* get info on mapping */
ierr = PetscObjectReference((PetscObject)matis->mapping);CHKERRQ(ierr);
ierr = ISLocalToGlobalMappingDestroy(&pcis->mapping);CHKERRQ(ierr);
pcis->mapping = matis->mapping;
ierr = ISLocalToGlobalMappingGetSize(pcis->mapping,&pcis->n);CHKERRQ(ierr);
ierr = ISLocalToGlobalMappingGetInfo(pcis->mapping,&(pcis->n_neigh),&(pcis->neigh),&(pcis->n_shared),&(pcis->shared));CHKERRQ(ierr);
/* Creating local and global index sets for interior and inteface nodes. */
{
PetscInt n_I;
PetscInt *idx_I_local,*idx_B_local,*idx_I_global,*idx_B_global;
PetscInt *array;
PetscInt i,j;
/* Identifying interior and interface nodes, in local numbering */
ierr = PetscMalloc1(pcis->n,&array);CHKERRQ(ierr);
ierr = PetscMemzero(array,pcis->n*sizeof(PetscInt));CHKERRQ(ierr);
for (i=0;i<pcis->n_neigh;i++)
for (j=0;j<pcis->n_shared[i];j++)
array[pcis->shared[i][j]] += 1;
ierr = PetscMalloc1(pcis->n,&idx_I_local);CHKERRQ(ierr);
ierr = PetscMalloc1(pcis->n,&idx_B_local);CHKERRQ(ierr);
for (i=0, pcis->n_B=0, n_I=0; i<pcis->n; i++) {
if (!array[i]) {
idx_I_local[n_I] = i;
n_I++;
} else {
idx_B_local[pcis->n_B] = i;
pcis->n_B++;
}
}
/* Getting the global numbering */
idx_B_global = idx_I_local + n_I; /* Just avoiding allocating extra memory, since we have vacant space */
idx_I_global = idx_B_local + pcis->n_B;
ierr = ISLocalToGlobalMappingApply(pcis->mapping,pcis->n_B,idx_B_local,idx_B_global);CHKERRQ(ierr);
ierr = ISLocalToGlobalMappingApply(pcis->mapping,n_I, idx_I_local,idx_I_global);CHKERRQ(ierr);
/* Creating the index sets. */
ierr = ISCreateGeneral(PETSC_COMM_SELF,pcis->n_B,idx_B_local,PETSC_COPY_VALUES, &pcis->is_B_local);CHKERRQ(ierr);
ierr = ISCreateGeneral(PETSC_COMM_SELF,pcis->n_B,idx_B_global,PETSC_COPY_VALUES,&pcis->is_B_global);CHKERRQ(ierr);
ierr = ISCreateGeneral(PETSC_COMM_SELF,n_I,idx_I_local,PETSC_COPY_VALUES, &pcis->is_I_local);CHKERRQ(ierr);
ierr = ISCreateGeneral(PETSC_COMM_SELF,n_I,idx_I_global,PETSC_COPY_VALUES,&pcis->is_I_global);CHKERRQ(ierr);
/* Freeing memory and restoring arrays */
ierr = PetscFree(idx_B_local);CHKERRQ(ierr);
ierr = PetscFree(idx_I_local);CHKERRQ(ierr);
ierr = PetscFree(array);CHKERRQ(ierr);
}
/*
Extracting the blocks A_II, A_BI, A_IB and A_BB from A. If the numbering
is such that interior nodes come first than the interface ones, we have
[ | ]
[ A_II | A_IB ]
A = [ | ]
[-----------+------]
[ A_BI | A_BB ]
*/
ierr = MatGetSubMatrix(matis->A,pcis->is_I_local,pcis->is_I_local,MAT_INITIAL_MATRIX,&pcis->A_II);CHKERRQ(ierr);
ierr = MatGetSubMatrix(matis->A,pcis->is_B_local,pcis->is_B_local,MAT_INITIAL_MATRIX,&pcis->A_BB);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)matis->A,MATSEQSBAIJ,&issbaij);CHKERRQ(ierr);
if (!issbaij) {
ierr = MatGetSubMatrix(matis->A,pcis->is_I_local,pcis->is_B_local,MAT_INITIAL_MATRIX,&pcis->A_IB);CHKERRQ(ierr);
ierr = MatGetSubMatrix(matis->A,pcis->is_B_local,pcis->is_I_local,MAT_INITIAL_MATRIX,&pcis->A_BI);CHKERRQ(ierr);
} else {
Mat newmat;
ierr = MatConvert(matis->A,MATSEQBAIJ,MAT_INITIAL_MATRIX,&newmat);CHKERRQ(ierr);
ierr = MatGetSubMatrix(newmat,pcis->is_I_local,pcis->is_B_local,MAT_INITIAL_MATRIX,&pcis->A_IB);CHKERRQ(ierr);
ierr = MatGetSubMatrix(newmat,pcis->is_B_local,pcis->is_I_local,MAT_INITIAL_MATRIX,&pcis->A_BI);CHKERRQ(ierr);
ierr = MatDestroy(&newmat);CHKERRQ(ierr);
}
/*
Creating work vectors and arrays
*/
ierr = VecDuplicate(matis->x,&pcis->vec1_N);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_N,&pcis->vec2_N);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,pcis->n-pcis->n_B,&pcis->vec1_D);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_D,&pcis->vec2_D);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_D,&pcis->vec3_D);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_D,&pcis->vec4_D);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,pcis->n_B,&pcis->vec1_B);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_B,&pcis->vec2_B);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_B,&pcis->vec3_B);CHKERRQ(ierr);
ierr = MatCreateVecs(pc->pmat,&pcis->vec1_global,0);CHKERRQ(ierr);
ierr = PetscMalloc1(pcis->n,&pcis->work_N);CHKERRQ(ierr);
/* Creating the scatter contexts */
ierr = VecScatterCreate(pcis->vec1_global,pcis->is_I_global,pcis->vec1_D,(IS)0,&pcis->global_to_D);CHKERRQ(ierr);
ierr = VecScatterCreate(pcis->vec1_N,pcis->is_B_local,pcis->vec1_B,(IS)0,&pcis->N_to_B);CHKERRQ(ierr);
ierr = VecScatterCreate(pcis->vec1_global,pcis->is_B_global,pcis->vec1_B,(IS)0,&pcis->global_to_B);CHKERRQ(ierr);
/* Creating scaling "matrix" D */
ierr = PetscOptionsGetBool(((PetscObject)pc)->prefix,"-pc_is_use_stiffness_scaling",&pcis->use_stiffness_scaling,NULL);CHKERRQ(ierr);
if (!pcis->D) {
ierr = VecDuplicate(pcis->vec1_B,&pcis->D);CHKERRQ(ierr);
if (!pcis->use_stiffness_scaling) {
ierr = VecSet(pcis->D,pcis->scaling_factor);CHKERRQ(ierr);
} else {
ierr = MatGetDiagonal(matis->A,pcis->vec1_N);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->N_to_B,pcis->vec1_N,pcis->D,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd (pcis->N_to_B,pcis->vec1_N,pcis->D,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
}
}
ierr = VecCopy(pcis->D,pcis->vec1_B);CHKERRQ(ierr);
ierr = MatCreateVecs(pc->pmat,&counter,0);CHKERRQ(ierr); /* temporary auxiliar vector */
ierr = VecSet(counter,0.0);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,pcis->vec1_B,counter,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterEnd (pcis->global_to_B,pcis->vec1_B,counter,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,counter,pcis->vec1_B,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd (pcis->global_to_B,counter,pcis->vec1_B,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecPointwiseDivide(pcis->D,pcis->D,pcis->vec1_B);CHKERRQ(ierr);
ierr = VecDestroy(&counter);CHKERRQ(ierr);
/* See historical note 01, at the bottom of this file. */
/*
Creating the KSP contexts for the local Dirichlet and Neumann problems.
*/
if (pcis->computesolvers) {
PC pc_ctx;
/* Dirichlet */
ierr = KSPCreate(PETSC_COMM_SELF,&pcis->ksp_D);CHKERRQ(ierr);
ierr = PetscObjectIncrementTabLevel((PetscObject)pcis->ksp_D,(PetscObject)pc,1);CHKERRQ(ierr);
ierr = KSPSetOperators(pcis->ksp_D,pcis->A_II,pcis->A_II);CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix(pcis->ksp_D,"is_localD_");CHKERRQ(ierr);
ierr = KSPGetPC(pcis->ksp_D,&pc_ctx);CHKERRQ(ierr);
ierr = PCSetType(pc_ctx,PCLU);CHKERRQ(ierr);
ierr = KSPSetType(pcis->ksp_D,KSPPREONLY);CHKERRQ(ierr);
ierr = KSPSetFromOptions(pcis->ksp_D);CHKERRQ(ierr);
/* the vectors in the following line are dummy arguments, just telling the KSP the vector size. Values are not used */
ierr = KSPSetUp(pcis->ksp_D);CHKERRQ(ierr);
/* Neumann */
ierr = KSPCreate(PETSC_COMM_SELF,&pcis->ksp_N);CHKERRQ(ierr);
ierr = PetscObjectIncrementTabLevel((PetscObject)pcis->ksp_N,(PetscObject)pc,1);CHKERRQ(ierr);
ierr = KSPSetOperators(pcis->ksp_N,matis->A,matis->A);CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix(pcis->ksp_N,"is_localN_");CHKERRQ(ierr);
ierr = KSPGetPC(pcis->ksp_N,&pc_ctx);CHKERRQ(ierr);
ierr = PCSetType(pc_ctx,PCLU);CHKERRQ(ierr);
ierr = KSPSetType(pcis->ksp_N,KSPPREONLY);CHKERRQ(ierr);
ierr = KSPSetFromOptions(pcis->ksp_N);CHKERRQ(ierr);
{
PetscBool damp_fixed = PETSC_FALSE,
remove_nullspace_fixed = PETSC_FALSE,
set_damping_factor_floating = PETSC_FALSE,
not_damp_floating = PETSC_FALSE,
not_remove_nullspace_floating = PETSC_FALSE;
PetscReal fixed_factor,
floating_factor;
ierr = PetscOptionsGetReal(((PetscObject)pc_ctx)->prefix,"-pc_is_damp_fixed",&fixed_factor,&damp_fixed);CHKERRQ(ierr);
if (!damp_fixed) fixed_factor = 0.0;
ierr = PetscOptionsGetBool(((PetscObject)pc_ctx)->prefix,"-pc_is_damp_fixed",&damp_fixed,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(((PetscObject)pc_ctx)->prefix,"-pc_is_remove_nullspace_fixed",&remove_nullspace_fixed,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(((PetscObject)pc_ctx)->prefix,"-pc_is_set_damping_factor_floating",
&floating_factor,&set_damping_factor_floating);CHKERRQ(ierr);
if (!set_damping_factor_floating) floating_factor = 0.0;
ierr = PetscOptionsGetBool(((PetscObject)pc_ctx)->prefix,"-pc_is_set_damping_factor_floating",&set_damping_factor_floating,NULL);CHKERRQ(ierr);
if (!set_damping_factor_floating) floating_factor = 1.e-12;
ierr = PetscOptionsGetBool(((PetscObject)pc_ctx)->prefix,"-pc_is_not_damp_floating",¬_damp_floating,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(((PetscObject)pc_ctx)->prefix,"-pc_is_not_remove_nullspace_floating",¬_remove_nullspace_floating,NULL);CHKERRQ(ierr);
if (pcis->pure_neumann) { /* floating subdomain */
if (!(not_damp_floating)) {
ierr = PCFactorSetShiftType(pc_ctx,MAT_SHIFT_NONZERO);CHKERRQ(ierr);
ierr = PCFactorSetShiftAmount(pc_ctx,floating_factor);CHKERRQ(ierr);
}
if (!(not_remove_nullspace_floating)) {
MatNullSpace nullsp;
ierr = MatNullSpaceCreate(PETSC_COMM_SELF,PETSC_TRUE,0,NULL,&nullsp);CHKERRQ(ierr);
ierr = KSPSetNullSpace(pcis->ksp_N,nullsp);CHKERRQ(ierr);
ierr = MatNullSpaceDestroy(&nullsp);CHKERRQ(ierr);
}
} else { /* fixed subdomain */
if (damp_fixed) {
ierr = PCFactorSetShiftType(pc_ctx,MAT_SHIFT_NONZERO);CHKERRQ(ierr);
ierr = PCFactorSetShiftAmount(pc_ctx,floating_factor);CHKERRQ(ierr);
}
if (remove_nullspace_fixed) {
MatNullSpace nullsp;
ierr = MatNullSpaceCreate(PETSC_COMM_SELF,PETSC_TRUE,0,NULL,&nullsp);CHKERRQ(ierr);
ierr = KSPSetNullSpace(pcis->ksp_N,nullsp);CHKERRQ(ierr);
ierr = MatNullSpaceDestroy(&nullsp);CHKERRQ(ierr);
}
}
}
/* the vectors in the following line are dummy arguments, just telling the KSP the vector size. Values are not used */
ierr = KSPSetUp(pcis->ksp_N);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/**
* output
* ------
* Output the E and H fields.
*/
PetscErrorCode output(char *output_name, const Vec x, const Mat CF, const Vec conjParam, const Vec conjSrc, const GridInfo gi)
{
PetscFunctionBegin;
PetscErrorCode ierr;
char output_name_prefixed[PETSC_MAX_PATH_LEN];
//const char *prefix = "/out/";
const char *h_extension = ".H.h5";
const char *e_extension = ".E.h5";
//ierr = PetscStrcpy(output_name_prefixed, getenv("FD3D_ROOT")); CHKERRQ(ierr);
//ierr = PetscStrcat(output_name_prefixed, prefix); CHKERRQ(ierr);
//ierr = PetscStrcat(output_name_prefixed, output_name); CHKERRQ(ierr);
ierr = PetscStrcpy(output_name_prefixed, output_name); CHKERRQ(ierr);
char h_file[PETSC_MAX_PATH_LEN];
char e_file[PETSC_MAX_PATH_LEN];
ierr = PetscStrcpy(h_file, output_name_prefixed); CHKERRQ(ierr);
ierr = PetscStrcat(h_file, h_extension); CHKERRQ(ierr);
ierr = PetscStrcpy(e_file, output_name_prefixed); CHKERRQ(ierr);
ierr = PetscStrcat(e_file, e_extension); CHKERRQ(ierr);
Vec y; // H field vector if x_type == Etype
ierr = VecDuplicate(gi.vecTemp, &y); CHKERRQ(ierr);
ierr = VecCopy(conjSrc, y); CHKERRQ(ierr);
if (gi.x_type==Etype) {
ierr = MatMultAdd(CF, x, y, y); CHKERRQ(ierr);
ierr = VecScale(y, -1.0/PETSC_i/gi.omega); CHKERRQ(ierr);
} else {
ierr = VecScale(y, -1.0); CHKERRQ(ierr);
ierr = MatMultAdd(CF, x, y, y); CHKERRQ(ierr);
ierr = VecScale(y, 1.0/PETSC_i/gi.omega); CHKERRQ(ierr);
}
ierr = VecPointwiseDivide(y, y, conjParam);
PetscViewer viewer;
//viewer = PETSC_VIEWER_STDOUT_WORLD;
//ierr = PetscViewerHDF5Open(PETSC_COMM_WORLD, h_file, FILE_MODE_WRITE, &viewer); CHKERRQ(ierr);
/** Write the E-field file. */
ierr = PetscViewerHDF5Open(PETSC_COMM_WORLD, e_file, FILE_MODE_WRITE, &viewer); CHKERRQ(ierr);
ierr = PetscViewerHDF5PushGroup(viewer, "/");
if (gi.x_type==Etype) {
ierr = PetscObjectSetName((PetscObject) x, "E"); CHKERRQ(ierr);
ierr = VecView(x, viewer); CHKERRQ(ierr);
} else {
assert(gi.x_type==Htype);
ierr = PetscObjectSetName((PetscObject) y, "E"); CHKERRQ(ierr);
ierr = VecView(y, viewer); CHKERRQ(ierr);
}
ierr = PetscViewerDestroy(&viewer); CHKERRQ(ierr);
/** Write the H-field file. */
ierr = PetscViewerHDF5Open(PETSC_COMM_WORLD, h_file, FILE_MODE_WRITE, &viewer); CHKERRQ(ierr);
ierr = PetscViewerHDF5PushGroup(viewer, "/");
if (gi.x_type==Etype) {
ierr = PetscObjectSetName((PetscObject) y, "H"); CHKERRQ(ierr);
ierr = VecView(y, viewer); CHKERRQ(ierr);
} else {
assert(gi.x_type==Htype);
ierr = PetscObjectSetName((PetscObject) x, "H"); CHKERRQ(ierr);
ierr = VecView(x, viewer); CHKERRQ(ierr);
}
ierr = PetscViewerDestroy(&viewer); CHKERRQ(ierr);
ierr = VecDestroy(&y); CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode TaoSolve_BQPIP(Tao tao)
{
TAO_BQPIP *qp = (TAO_BQPIP*)tao->data;
PetscErrorCode ierr;
PetscInt iter=0,its;
PetscReal d1,d2,ksptol,sigma;
PetscReal sigmamu;
PetscReal dstep,pstep,step=0;
PetscReal gap[4];
TaoConvergedReason reason;
PetscFunctionBegin;
qp->dobj = 0.0;
qp->pobj = 1.0;
qp->gap = 10.0;
qp->rgap = 1.0;
qp->mu = 1.0;
qp->sigma = 1.0;
qp->dinfeas = 1.0;
qp->psteplength = 0.0;
qp->dsteplength = 0.0;
/* Tighten infinite bounds, things break when we don't do this
-- see test_bqpip.c
*/
ierr = VecSet(qp->XU,1.0e20);CHKERRQ(ierr);
ierr = VecSet(qp->XL,-1.0e20);CHKERRQ(ierr);
ierr = VecPointwiseMax(qp->XL,qp->XL,tao->XL);CHKERRQ(ierr);
ierr = VecPointwiseMin(qp->XU,qp->XU,tao->XU);CHKERRQ(ierr);
ierr = TaoComputeObjectiveAndGradient(tao,tao->solution,&qp->c,qp->C0);CHKERRQ(ierr);
ierr = TaoComputeHessian(tao,tao->solution,tao->hessian,tao->hessian_pre);CHKERRQ(ierr);
ierr = MatMult(tao->hessian, tao->solution, qp->Work);CHKERRQ(ierr);
ierr = VecDot(tao->solution, qp->Work, &d1);CHKERRQ(ierr);
ierr = VecAXPY(qp->C0, -1.0, qp->Work);CHKERRQ(ierr);
ierr = VecDot(qp->C0, tao->solution, &d2);CHKERRQ(ierr);
qp->c -= (d1/2.0+d2);
ierr = MatGetDiagonal(tao->hessian, qp->HDiag);CHKERRQ(ierr);
ierr = QPIPSetInitialPoint(qp,tao);CHKERRQ(ierr);
ierr = QPIPComputeResidual(qp,tao);CHKERRQ(ierr);
/* Enter main loop */
while (1){
/* Check Stopping Condition */
ierr = TaoMonitor(tao,iter++,qp->pobj,PetscSqrtScalar(qp->gap + qp->dinfeas),
qp->pinfeas, step, &reason);CHKERRQ(ierr);
if (reason != TAO_CONTINUE_ITERATING) break;
/*
Dual Infeasibility Direction should already be in the right
hand side from computing the residuals
*/
ierr = QPIPComputeNormFromCentralPath(qp,&d1);CHKERRQ(ierr);
if (iter > 0 && (qp->rnorm>5*qp->mu || d1*d1>qp->m*qp->mu*qp->mu) ) {
sigma=1.0;sigmamu=qp->mu;
sigma=0.0;sigmamu=0;
} else {
sigma=0.0;sigmamu=0;
}
ierr = VecSet(qp->DZ, sigmamu);CHKERRQ(ierr);
ierr = VecSet(qp->DS, sigmamu);CHKERRQ(ierr);
if (sigmamu !=0){
ierr = VecPointwiseDivide(qp->DZ, qp->DZ, qp->G);CHKERRQ(ierr);
ierr = VecPointwiseDivide(qp->DS, qp->DS, qp->T);CHKERRQ(ierr);
ierr = VecCopy(qp->DZ,qp->RHS2);CHKERRQ(ierr);
ierr = VecAXPY(qp->RHS2, 1.0, qp->DS);CHKERRQ(ierr);
} else {
ierr = VecZeroEntries(qp->RHS2);CHKERRQ(ierr);
}
/*
Compute the Primal Infeasiblitiy RHS and the
Diagonal Matrix to be added to H and store in Work
*/
ierr = VecPointwiseDivide(qp->DiagAxpy, qp->Z, qp->G);CHKERRQ(ierr);
ierr = VecPointwiseMult(qp->GZwork, qp->DiagAxpy, qp->R3);CHKERRQ(ierr);
ierr = VecAXPY(qp->RHS, -1.0, qp->GZwork);CHKERRQ(ierr);
ierr = VecPointwiseDivide(qp->TSwork, qp->S, qp->T);CHKERRQ(ierr);
ierr = VecAXPY(qp->DiagAxpy, 1.0, qp->TSwork);CHKERRQ(ierr);
ierr = VecPointwiseMult(qp->TSwork, qp->TSwork, qp->R5);CHKERRQ(ierr);
ierr = VecAXPY(qp->RHS, -1.0, qp->TSwork);CHKERRQ(ierr);
ierr = VecAXPY(qp->RHS2, 1.0, qp->RHS);CHKERRQ(ierr);
/* Determine the solving tolerance */
ksptol = qp->mu/10.0;
ksptol = PetscMin(ksptol,0.001);
ierr = MatDiagonalSet(tao->hessian, qp->DiagAxpy, ADD_VALUES);CHKERRQ(ierr);
ierr = MatAssemblyBegin(tao->hessian,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(tao->hessian,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = KSPSetOperators(tao->ksp, tao->hessian, tao->hessian_pre);CHKERRQ(ierr);
ierr = KSPSolve(tao->ksp, qp->RHS, tao->stepdirection);CHKERRQ(ierr);
ierr = KSPGetIterationNumber(tao->ksp,&its);CHKERRQ(ierr);
tao->ksp_its+=its;
ierr = VecScale(qp->DiagAxpy, -1.0);CHKERRQ(ierr);
ierr = MatDiagonalSet(tao->hessian, qp->DiagAxpy, ADD_VALUES);CHKERRQ(ierr);
ierr = MatAssemblyBegin(tao->hessian,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(tao->hessian,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = VecScale(qp->DiagAxpy, -1.0);CHKERRQ(ierr);
ierr = QPComputeStepDirection(qp,tao);CHKERRQ(ierr);
ierr = QPStepLength(qp); CHKERRQ(ierr);
/* Calculate New Residual R1 in Work vector */
ierr = MatMult(tao->hessian, tao->stepdirection, qp->RHS2);CHKERRQ(ierr);
ierr = VecAXPY(qp->RHS2, 1.0, qp->DS);CHKERRQ(ierr);
ierr = VecAXPY(qp->RHS2, -1.0, qp->DZ);CHKERRQ(ierr);
ierr = VecAYPX(qp->RHS2, qp->dsteplength, tao->gradient);CHKERRQ(ierr);
ierr = VecNorm(qp->RHS2, NORM_2, &qp->dinfeas);CHKERRQ(ierr);
ierr = VecDot(qp->DZ, qp->DG, gap);CHKERRQ(ierr);
ierr = VecDot(qp->DS, qp->DT, gap+1);CHKERRQ(ierr);
qp->rnorm=(qp->dinfeas+qp->psteplength*qp->pinfeas)/(qp->m+qp->n);
pstep = qp->psteplength; dstep = qp->dsteplength;
step = PetscMin(qp->psteplength,qp->dsteplength);
sigmamu= ( pstep*pstep*(gap[0]+gap[1]) +
(1 - pstep + pstep*sigma)*qp->gap )/qp->m;
if (qp->predcorr && step < 0.9){
if (sigmamu < qp->mu){
sigmamu=sigmamu/qp->mu;
sigmamu=sigmamu*sigmamu*sigmamu;
} else {sigmamu = 1.0;}
sigmamu = sigmamu*qp->mu;
/* Compute Corrector Step */
ierr = VecPointwiseMult(qp->DZ, qp->DG, qp->DZ);CHKERRQ(ierr);
ierr = VecScale(qp->DZ, -1.0);CHKERRQ(ierr);
ierr = VecShift(qp->DZ, sigmamu);CHKERRQ(ierr);
ierr = VecPointwiseDivide(qp->DZ, qp->DZ, qp->G);CHKERRQ(ierr);
ierr = VecPointwiseMult(qp->DS, qp->DS, qp->DT);CHKERRQ(ierr);
ierr = VecScale(qp->DS, -1.0);CHKERRQ(ierr);
ierr = VecShift(qp->DS, sigmamu);CHKERRQ(ierr);
ierr = VecPointwiseDivide(qp->DS, qp->DS, qp->T);CHKERRQ(ierr);
ierr = VecCopy(qp->DZ, qp->RHS2);CHKERRQ(ierr);
ierr = VecAXPY(qp->RHS2, -1.0, qp->DS);CHKERRQ(ierr);
ierr = VecAXPY(qp->RHS2, 1.0, qp->RHS);CHKERRQ(ierr);
/* Approximately solve the linear system */
ierr = MatDiagonalSet(tao->hessian, qp->DiagAxpy, ADD_VALUES);CHKERRQ(ierr);
ierr = MatAssemblyBegin(tao->hessian,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(tao->hessian,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = KSPSolve(tao->ksp, qp->RHS2, tao->stepdirection);CHKERRQ(ierr);
ierr = KSPGetIterationNumber(tao->ksp,&its);CHKERRQ(ierr);
tao->ksp_its+=its;
ierr = MatDiagonalSet(tao->hessian, qp->HDiag, INSERT_VALUES);CHKERRQ(ierr);
ierr = MatAssemblyBegin(tao->hessian,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(tao->hessian,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = QPComputeStepDirection(qp,tao);CHKERRQ(ierr);
ierr = QPStepLength(qp);CHKERRQ(ierr);
} /* End Corrector step */
/* Take the step */
pstep = qp->psteplength; dstep = qp->dsteplength;
ierr = VecAXPY(qp->Z, dstep, qp->DZ);CHKERRQ(ierr);
ierr = VecAXPY(qp->S, dstep, qp->DS);CHKERRQ(ierr);
ierr = VecAXPY(tao->solution, dstep, tao->stepdirection);CHKERRQ(ierr);
ierr = VecAXPY(qp->G, dstep, qp->DG);CHKERRQ(ierr);
ierr = VecAXPY(qp->T, dstep, qp->DT);CHKERRQ(ierr);
/* Compute Residuals */
ierr = QPIPComputeResidual(qp,tao);CHKERRQ(ierr);
/* Evaluate quadratic function */
ierr = MatMult(tao->hessian, tao->solution, qp->Work);CHKERRQ(ierr);
ierr = VecDot(tao->solution, qp->Work, &d1);CHKERRQ(ierr);
ierr = VecDot(tao->solution, qp->C0, &d2);CHKERRQ(ierr);
ierr = VecDot(qp->G, qp->Z, gap);CHKERRQ(ierr);
ierr = VecDot(qp->T, qp->S, gap+1);CHKERRQ(ierr);
qp->pobj=d1/2.0 + d2+qp->c;
/* Compute the duality gap */
qp->gap = (gap[0]+gap[1]);
qp->dobj = qp->pobj - qp->gap;
if (qp->m>0) qp->mu=qp->gap/(qp->m);
qp->rgap=qp->gap/( PetscAbsReal(qp->dobj) + PetscAbsReal(qp->pobj) + 1.0 );
} /* END MAIN LOOP */
PetscFunctionReturn(0);
}
