Date: 2013-07-02T14:49:26+00:00

Actual source code: vi.c
petsc-3.4.2 2013-07-02

      1: #include <petsc-private/snesimpl.h>  /*I "petscsnes.h" I*/
      2: #include <petscdm.h>

      6: /*@C
      7:    SNESVISetComputeVariableBounds - Sets a function  that is called to compute the variable bounds

      9:    Input parameter
     10: +  snes - the SNES context
     11: -  compute - computes the bounds

     13:    Level: advanced

     15: .seealso:   SNESVISetVariableBounds()

     17: @*/
     18: PetscErrorCode SNESVISetComputeVariableBounds(SNES snes, PetscErrorCode (*compute)(SNES,Vec,Vec))
     19: {
     20:   PetscErrorCode ierr,(*f)(SNES,PetscErrorCode (*)(SNES,Vec,Vec));

     24:   PetscObjectQueryFunction((PetscObject)snes,"SNESVISetComputeVariableBounds_C",&f);
     25:   if (!f) {SNESSetType(snes,SNESVINEWTONRSLS);}
     26:   PetscUseMethod(snes,"SNESVISetComputeVariableBounds_C",(SNES,PetscErrorCode (*)(SNES,Vec,Vec)),(snes,compute));
     27:   return(0);
     28: }

     32: PetscErrorCode SNESVISetComputeVariableBounds_VI(SNES snes,SNESVIComputeVariableBoundsFunction compute)
     33: {
     35:   snes->ops->computevariablebounds = compute;
     36:   return(0);
     37: }

     41: /*
     42:    SNESVIComputeInactiveSetIS - Gets the global indices for the bogus inactive set variables

     44:    Input parameter
     45: .  snes - the SNES context
     46: .  X    - the snes solution vector

     48:    Output parameter
     49: .  ISact - active set index set

     51:  */
     52: PetscErrorCode SNESVIComputeInactiveSetIS(Vec upper,Vec lower,Vec X,Vec F,IS *inact)
     53: {
     54:   PetscErrorCode    ierr;
     55:   const PetscScalar *x,*xl,*xu,*f;
     56:   PetscInt          *idx_act,i,nlocal,nloc_isact=0,ilow,ihigh,i1=0;

     59:   VecGetLocalSize(X,&nlocal);
     60:   VecGetOwnershipRange(X,&ilow,&ihigh);
     61:   VecGetArrayRead(X,&x);
     62:   VecGetArrayRead(lower,&xl);
     63:   VecGetArrayRead(upper,&xu);
     64:   VecGetArrayRead(F,&f);
     65:   /* Compute inactive set size */
     66:   for (i=0; i < nlocal; i++) {
     67:     if (((PetscRealPart(x[i]) > PetscRealPart(xl[i]) + 1.e-8 || (PetscRealPart(f[i]) < 0.0)) && ((PetscRealPart(x[i]) < PetscRealPart(xu[i]) - 1.e-8) || PetscRealPart(f[i]) > 0.0))) nloc_isact++;
     68:   }

     70:   PetscMalloc(nloc_isact*sizeof(PetscInt),&idx_act);

     72:   /* Set inactive set indices */
     73:   for (i=0; i < nlocal; i++) {
     74:     if (((PetscRealPart(x[i]) > PetscRealPart(xl[i]) + 1.e-8 || (PetscRealPart(f[i]) < 0.0)) && ((PetscRealPart(x[i]) < PetscRealPart(xu[i]) - 1.e-8) || PetscRealPart(f[i]) > 0.0))) idx_act[i1++] = ilow+i;
     75:   }

     77:   /* Create inactive set IS */
     78:   ISCreateGeneral(PetscObjectComm((PetscObject)upper),nloc_isact,idx_act,PETSC_OWN_POINTER,inact);

     80:   VecRestoreArrayRead(X,&x);
     81:   VecRestoreArrayRead(lower,&xl);
     82:   VecRestoreArrayRead(upper,&xu);
     83:   VecRestoreArrayRead(F,&f);
     84:   return(0);
     85: }

     87: /* --------------------------------------------------------------------------------------------------------*/

     91: PetscErrorCode  SNESMonitorVI(SNES snes,PetscInt its,PetscReal fgnorm,void *dummy)
     92: {
     93:   PetscErrorCode    ierr;
     94:   PetscViewer       viewer = dummy ? (PetscViewer) dummy : PETSC_VIEWER_STDOUT_(PetscObjectComm((PetscObject)snes));
     95:   const PetscScalar *x,*xl,*xu,*f;
     96:   PetscInt          i,n,act[2] = {0,0},fact[2],N;
     97:   /* Number of components that actually hit the bounds (c.f. active variables) */
     98:   PetscInt  act_bound[2] = {0,0},fact_bound[2];
     99:   PetscReal rnorm,fnorm;
    100:   double    tmp;

    103:   VecGetLocalSize(snes->vec_sol,&n);
    104:   VecGetSize(snes->vec_sol,&N);
    105:   VecGetArrayRead(snes->xl,&xl);
    106:   VecGetArrayRead(snes->xu,&xu);
    107:   VecGetArrayRead(snes->vec_sol,&x);
    108:   VecGetArrayRead(snes->vec_func,&f);

    110:   rnorm = 0.0;
    111:   for (i=0; i<n; i++) {
    112:     if (((PetscRealPart(x[i]) > PetscRealPart(xl[i]) + 1.e-8 || (PetscRealPart(f[i]) < 0.0)) && ((PetscRealPart(x[i]) < PetscRealPart(xu[i]) - 1.e-8) || PetscRealPart(f[i]) > 0.0))) rnorm += PetscRealPart(PetscConj(f[i])*f[i]);
    113:     else if (PetscRealPart(x[i]) <= PetscRealPart(xl[i]) + 1.e-8 && PetscRealPart(f[i]) >= 0.0) act[0]++;
    114:     else if (PetscRealPart(x[i]) >= PetscRealPart(xu[i]) - 1.e-8 && PetscRealPart(f[i]) <= 0.0) act[1]++;
    115:     else SETERRQ(PetscObjectComm((PetscObject)snes),PETSC_ERR_PLIB,"Can never get here");
    116:   }

    118:   for (i=0; i<n; i++) {
    119:     if (PetscRealPart(x[i]) <= PetscRealPart(xl[i]) + 1.e-8) act_bound[0]++;
    120:     else if (PetscRealPart(x[i]) >= PetscRealPart(xu[i]) - 1.e-8) act_bound[1]++;
    121:   }
    122:   VecRestoreArrayRead(snes->vec_func,&f);
    123:   VecRestoreArrayRead(snes->xl,&xl);
    124:   VecRestoreArrayRead(snes->xu,&xu);
    125:   VecRestoreArrayRead(snes->vec_sol,&x);
    126:   MPI_Allreduce(&rnorm,&fnorm,1,MPIU_REAL,MPIU_SUM,PetscObjectComm((PetscObject)snes));
    127:   MPI_Allreduce(act,fact,2,MPIU_INT,MPI_SUM,PetscObjectComm((PetscObject)snes));
    128:   MPI_Allreduce(act_bound,fact_bound,2,MPIU_INT,MPI_SUM,PetscObjectComm((PetscObject)snes));
    129:   fnorm = PetscSqrtReal(fnorm);

    131:   PetscViewerASCIIAddTab(viewer,((PetscObject)snes)->tablevel);
    132:   if (snes->ntruebounds) tmp = ((double)(fact[0]+fact[1]))/((double)snes->ntruebounds);
    133:   else tmp = 0.0;
    134:   PetscViewerASCIIPrintf(viewer,"%3D SNES VI Function norm %14.12e Active lower constraints %D/%D upper constraints %D/%D Percent of total %g Percent of bounded %g\n",its,(double)fnorm,fact[0],fact_bound[0],fact[1],fact_bound[1],((double)(fact[0]+fact[1]))/((double)N),tmp);

    136:   PetscViewerASCIISubtractTab(viewer,((PetscObject)snes)->tablevel);
    137:   return(0);
    138: }

    140: /*
    141:      Checks if J^T F = 0 which implies we've found a local minimum of the norm of the function,
    142:     || F(u) ||_2 but not a zero, F(u) = 0. In the case when one cannot compute J^T F we use the fact that
    143:     0 = (J^T F)^T W = F^T J W iff W not in the null space of J. Thanks for Jorge More
    144:     for this trick. One assumes that the probability that W is in the null space of J is very, very small.
    145: */
    148: PetscErrorCode SNESVICheckLocalMin_Private(SNES snes,Mat A,Vec F,Vec W,PetscReal fnorm,PetscBool *ismin)
    149: {
    150:   PetscReal      a1;
    152:   PetscBool      hastranspose;

    155:   *ismin = PETSC_FALSE;
    156:   MatHasOperation(A,MATOP_MULT_TRANSPOSE,&hastranspose);
    157:   if (hastranspose) {
    158:     /* Compute || J^T F|| */
    159:     MatMultTranspose(A,F,W);
    160:     VecNorm(W,NORM_2,&a1);
    161:     PetscInfo1(snes,"|| J^T F|| %g near zero implies found a local minimum\n",(double)(a1/fnorm));
    162:     if (a1/fnorm < 1.e-4) *ismin = PETSC_TRUE;
    163:   } else {
    164:     Vec         work;
    165:     PetscScalar result;
    166:     PetscReal   wnorm;

    168:     VecSetRandom(W,NULL);
    169:     VecNorm(W,NORM_2,&wnorm);
    170:     VecDuplicate(W,&work);
    171:     MatMult(A,W,work);
    172:     VecDot(F,work,&result);
    173:     VecDestroy(&work);
    174:     a1   = PetscAbsScalar(result)/(fnorm*wnorm);
    175:     PetscInfo1(snes,"(F^T J random)/(|| F ||*||random|| %g near zero implies found a local minimum\n",(double)a1);
    176:     if (a1 < 1.e-4) *ismin = PETSC_TRUE;
    177:   }
    178:   return(0);
    179: }

    181: /*
    182:      Checks if J^T(F - J*X) = 0
    183: */
    186: PetscErrorCode SNESVICheckResidual_Private(SNES snes,Mat A,Vec F,Vec X,Vec W1,Vec W2)
    187: {
    188:   PetscReal      a1,a2;
    190:   PetscBool      hastranspose;

    193:   MatHasOperation(A,MATOP_MULT_TRANSPOSE,&hastranspose);
    194:   if (hastranspose) {
    195:     MatMult(A,X,W1);
    196:     VecAXPY(W1,-1.0,F);

    198:     /* Compute || J^T W|| */
    199:     MatMultTranspose(A,W1,W2);
    200:     VecNorm(W1,NORM_2,&a1);
    201:     VecNorm(W2,NORM_2,&a2);
    202:     if (a1 != 0.0) {
    203:       PetscInfo1(snes,"||J^T(F-Ax)||/||F-AX|| %g near zero implies inconsistent rhs\n",(double)(a2/a1));
    204:     }
    205:   }
    206:   return(0);
    207: }

    209: /*
    210:   SNESConvergedDefault_VI - Checks the convergence of the semismooth newton algorithm.

    212:   Notes:
    213:   The convergence criterion currently implemented is
    214:   merit < abstol
    215:   merit < rtol*merit_initial
    216: */
    219: PetscErrorCode SNESConvergedDefault_VI(SNES snes,PetscInt it,PetscReal xnorm,PetscReal gradnorm,PetscReal fnorm,SNESConvergedReason *reason,void *dummy)
    220: {

    227:   *reason = SNES_CONVERGED_ITERATING;

    229:   if (!it) {
    230:     /* set parameter for default relative tolerance convergence test */
    231:     snes->ttol = fnorm*snes->rtol;
    232:   }
    233:   if (fnorm != fnorm) {
    234:     PetscInfo(snes,"Failed to converged, function norm is NaN\n");
    235:     *reason = SNES_DIVERGED_FNORM_NAN;
    236:   } else if (fnorm < snes->abstol) {
    237:     PetscInfo2(snes,"Converged due to function norm %g < %g\n",(double)fnorm,(double)snes->abstol);
    238:     *reason = SNES_CONVERGED_FNORM_ABS;
    239:   } else if (snes->nfuncs >= snes->max_funcs) {
    240:     PetscInfo2(snes,"Exceeded maximum number of function evaluations: %D > %D\n",snes->nfuncs,snes->max_funcs);
    241:     *reason = SNES_DIVERGED_FUNCTION_COUNT;
    242:   }

    244:   if (it && !*reason) {
    245:     if (fnorm < snes->ttol) {
    246:       PetscInfo2(snes,"Converged due to function norm %g < %g (relative tolerance)\n",(double)fnorm,(double)snes->ttol);
    247:       *reason = SNES_CONVERGED_FNORM_RELATIVE;
    248:     }
    249:   }
    250:   return(0);
    251: }

    254: /* -------------------------------------------------------------------------- */
    255: /*
    256:    SNESVIProjectOntoBounds - Projects X onto the feasible region so that Xl[i] <= X[i] <= Xu[i] for i = 1...n.

    258:    Input Parameters:
    259: .  SNES - nonlinear solver context

    261:    Output Parameters:
    262: .  X - Bound projected X

    264: */

    268: PetscErrorCode SNESVIProjectOntoBounds(SNES snes,Vec X)
    269: {
    270:   PetscErrorCode    ierr;
    271:   const PetscScalar *xl,*xu;
    272:   PetscScalar       *x;
    273:   PetscInt          i,n;

    276:   VecGetLocalSize(X,&n);
    277:   VecGetArray(X,&x);
    278:   VecGetArrayRead(snes->xl,&xl);
    279:   VecGetArrayRead(snes->xu,&xu);

    281:   for (i = 0; i<n; i++) {
    282:     if (PetscRealPart(x[i]) < PetscRealPart(xl[i])) x[i] = xl[i];
    283:     else if (PetscRealPart(x[i]) > PetscRealPart(xu[i])) x[i] = xu[i];
    284:   }
    285:   VecRestoreArray(X,&x);
    286:   VecRestoreArrayRead(snes->xl,&xl);
    287:   VecRestoreArrayRead(snes->xu,&xu);
    288:   return(0);
    289: }

    294: /*
    295:    SNESVIGetActiveSetIndices - Gets the global indices for the active set variables

    297:    Input parameter
    298: .  snes - the SNES context
    299: .  X    - the snes solution vector
    300: .  F    - the nonlinear function vector

    302:    Output parameter
    303: .  ISact - active set index set
    304:  */
    305: PetscErrorCode SNESVIGetActiveSetIS(SNES snes,Vec X,Vec F,IS *ISact)
    306: {
    307:   PetscErrorCode    ierr;
    308:   Vec               Xl=snes->xl,Xu=snes->xu;
    309:   const PetscScalar *x,*f,*xl,*xu;
    310:   PetscInt          *idx_act,i,nlocal,nloc_isact=0,ilow,ihigh,i1=0;

    313:   VecGetLocalSize(X,&nlocal);
    314:   VecGetOwnershipRange(X,&ilow,&ihigh);
    315:   VecGetArrayRead(X,&x);
    316:   VecGetArrayRead(Xl,&xl);
    317:   VecGetArrayRead(Xu,&xu);
    318:   VecGetArrayRead(F,&f);
    319:   /* Compute active set size */
    320:   for (i=0; i < nlocal;i++) {
    321:     if (!((PetscRealPart(x[i]) > PetscRealPart(xl[i]) + 1.e-8 || (PetscRealPart(f[i]) < 0.0)) && ((PetscRealPart(x[i]) < PetscRealPart(xu[i]) - 1.e-8) || PetscRealPart(f[i]) > 0.0))) nloc_isact++;
    322:   }

    324:   PetscMalloc(nloc_isact*sizeof(PetscInt),&idx_act);

    326:   /* Set active set indices */
    327:   for (i=0; i < nlocal; i++) {
    328:     if (!((PetscRealPart(x[i]) > PetscRealPart(xl[i]) + 1.e-8 || (PetscRealPart(f[i]) < 0.0)) && ((PetscRealPart(x[i]) < PetscRealPart(xu[i]) - 1.e-8) || PetscRealPart(f[i]) > 0.0))) idx_act[i1++] = ilow+i;
    329:   }

    331:   /* Create active set IS */
    332:   ISCreateGeneral(PetscObjectComm((PetscObject)snes),nloc_isact,idx_act,PETSC_OWN_POINTER,ISact);

    334:   VecRestoreArrayRead(X,&x);
    335:   VecRestoreArrayRead(Xl,&xl);
    336:   VecRestoreArrayRead(Xu,&xu);
    337:   VecRestoreArrayRead(F,&f);
    338:   return(0);
    339: }

    343: PetscErrorCode SNESVICreateIndexSets_RS(SNES snes,Vec X,Vec F,IS *ISact,IS *ISinact)
    344: {
    346:   PetscInt       rstart,rend;

    349:   SNESVIGetActiveSetIS(snes,X,F,ISact);
    350:   VecGetOwnershipRange(X,&rstart,&rend);
    351:   ISComplement(*ISact,rstart,rend,ISinact);
    352:   return(0);
    353: }

    357: PetscErrorCode SNESVIComputeInactiveSetFnorm(SNES snes,Vec F,Vec X, PetscReal *fnorm)
    358: {
    359:   PetscErrorCode    ierr;
    360:   const PetscScalar *x,*xl,*xu,*f;
    361:   PetscInt          i,n;
    362:   PetscReal         rnorm;

    365:   VecGetLocalSize(X,&n);
    366:   VecGetArrayRead(snes->xl,&xl);
    367:   VecGetArrayRead(snes->xu,&xu);
    368:   VecGetArrayRead(X,&x);
    369:   VecGetArrayRead(F,&f);
    370:   rnorm = 0.0;
    371:   for (i=0; i<n; i++) {
    372:     if (((PetscRealPart(x[i]) > PetscRealPart(xl[i]) + 1.e-8 || (PetscRealPart(f[i]) < 0.0)) && ((PetscRealPart(x[i]) < PetscRealPart(xu[i]) - 1.e-8) || PetscRealPart(f[i]) > 0.0))) rnorm += PetscRealPart(PetscConj(f[i])*f[i]);
    373:   }
    374:   VecRestoreArrayRead(F,&f);
    375:   VecRestoreArrayRead(snes->xl,&xl);
    376:   VecRestoreArrayRead(snes->xu,&xu);
    377:   VecRestoreArrayRead(X,&x);
    378:   MPI_Allreduce(&rnorm,fnorm,1,MPIU_REAL,MPIU_SUM,PetscObjectComm((PetscObject)snes));
    379:   *fnorm = PetscSqrtReal(*fnorm);
    380:   return(0);
    381: }

    385: PetscErrorCode SNESVIDMComputeVariableBounds(SNES snes,Vec xl, Vec xu)
    386: {

    390:   DMComputeVariableBounds(snes->dm, xl, xu);
    391:   return(0);
    392: }

    395: /* -------------------------------------------------------------------------- */
    396: /*
    397:    SNESSetUp_VI - Does setup common to all VI solvers -- basically makes sure bounds have been properly set up
    398:    of the SNESVI nonlinear solver.

    400:    Input Parameter:
    401: .  snes - the SNES context
    402: .  x - the solution vector

    404:    Application Interface Routine: SNESSetUp()

    406:    Notes:
    407:    For basic use of the SNES solvers, the user need not explicitly call
    408:    SNESSetUp(), since these actions will automatically occur during
    409:    the call to SNESSolve().
    410:  */
    413: PetscErrorCode SNESSetUp_VI(SNES snes)
    414: {
    416:   PetscInt       i_start[3],i_end[3];

    419:   SNESSetWorkVecs(snes,1);
    420:   SNESSetUpMatrices(snes);

    422:   if (!snes->ops->computevariablebounds && snes->dm) {
    423:     PetscBool flag;
    424:     DMHasVariableBounds(snes->dm, &flag);

    426:     snes->ops->computevariablebounds = SNESVIDMComputeVariableBounds;
    427:   }
    428:   if (!snes->usersetbounds) {
    429:     if (snes->ops->computevariablebounds) {
    430:       if (!snes->xl) {VecDuplicate(snes->vec_sol,&snes->xl);}
    431:       if (!snes->xu) {VecDuplicate(snes->vec_sol,&snes->xu);}
    432:       (*snes->ops->computevariablebounds)(snes,snes->xl,snes->xu);
    433:     } else if (!snes->xl && !snes->xu) {
    434:       /* If the lower and upper bound on variables are not set, set it to -Inf and Inf */
    435:       VecDuplicate(snes->vec_sol, &snes->xl);
    436:       VecSet(snes->xl,SNES_VI_NINF);
    437:       VecDuplicate(snes->vec_sol, &snes->xu);
    438:       VecSet(snes->xu,SNES_VI_INF);
    439:     } else {
    440:       /* Check if lower bound, upper bound and solution vector distribution across the processors is identical */
    441:       VecGetOwnershipRange(snes->vec_sol,i_start,i_end);
    442:       VecGetOwnershipRange(snes->xl,i_start+1,i_end+1);
    443:       VecGetOwnershipRange(snes->xu,i_start+2,i_end+2);
    444:       if ((i_start[0] != i_start[1]) || (i_start[0] != i_start[2]) || (i_end[0] != i_end[1]) || (i_end[0] != i_end[2]))
    445:         SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_SIZ,"Distribution of lower bound, upper bound and the solution vector should be identical across all the processors.");
    446:     }
    447:   }
    448:   return(0);
    449: }
    450: /* -------------------------------------------------------------------------- */
    453: PetscErrorCode SNESReset_VI(SNES snes)
    454: {

    458:   VecDestroy(&snes->xl);
    459:   VecDestroy(&snes->xu);
    460:   snes->usersetbounds = PETSC_FALSE;
    461:   return(0);
    462: }

    464: /*
    465:    SNESDestroy_VI - Destroys the private SNES_VI context that was created
    466:    with SNESCreate_VI().

    468:    Input Parameter:
    469: .  snes - the SNES context

    471:    Application Interface Routine: SNESDestroy()
    472:  */
    475: PetscErrorCode SNESDestroy_VI(SNES snes)
    476: {

    480:   PetscFree(snes->data);

    482:   /* clear composed functions */
    483:   PetscObjectComposeFunction((PetscObject)snes,"SNESLineSearchSet_C",NULL);
    484:   PetscObjectComposeFunction((PetscObject)snes,"SNESLineSearchSetMonitor_C",NULL);
    485:   return(0);
    486: }

    490: /*@
    491:    SNESVISetVariableBounds - Sets the lower and upper bounds for the solution vector. xl <= x <= xu.

    493:    Input Parameters:
    494: .  snes - the SNES context.
    495: .  xl   - lower bound.
    496: .  xu   - upper bound.

    498:    Notes:
    499:    If this routine is not called then the lower and upper bounds are set to
    500:    SNES_VI_INF and SNES_VI_NINF respectively during SNESSetUp().

    502:    Level: advanced

    504: @*/
    505: PetscErrorCode SNESVISetVariableBounds(SNES snes, Vec xl, Vec xu)
    506: {
    507:   PetscErrorCode ierr,(*f)(SNES,Vec,Vec);

    513:   PetscObjectQueryFunction((PetscObject)snes,"SNESVISetVariableBounds_C",&f);
    514:   if (!f) {SNESSetType(snes,SNESVINEWTONRSLS);}
    515:   PetscUseMethod(snes,"SNESVISetVariableBounds_C",(SNES,Vec,Vec),(snes,xl,xu));
    516:   snes->usersetbounds = PETSC_TRUE;
    517:   return(0);
    518: }

    522: PetscErrorCode SNESVISetVariableBounds_VI(SNES snes,Vec xl,Vec xu)
    523: {
    524:   PetscErrorCode    ierr;
    525:   const PetscScalar *xxl,*xxu;
    526:   PetscInt          i,n, cnt = 0;

    529:   SNESGetFunction(snes,&snes->vec_func,NULL,NULL);
    530:   if (!snes->vec_func) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"Must call SNESSetFunction() or SNESSetDM() first");
    531:   {
    532:     PetscInt xlN,xuN,N;
    533:     VecGetSize(xl,&xlN);
    534:     VecGetSize(xu,&xuN);
    535:     VecGetSize(snes->vec_func,&N);
    536:     if (xlN != N) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_INCOMP,"Incompatible vector lengths lower bound = %D solution vector = %D",xlN,N);
    537:     if (xuN != N) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_INCOMP,"Incompatible vector lengths: upper bound = %D solution vector = %D",xuN,N);
    538:   }
    539:   SNESSetType(snes,SNESVINEWTONRSLS);
    540:   PetscObjectReference((PetscObject)xl);
    541:   PetscObjectReference((PetscObject)xu);
    542:   VecDestroy(&snes->xl);
    543:   VecDestroy(&snes->xu);
    544:   snes->xl = xl;
    545:   snes->xu = xu;
    546:   VecGetLocalSize(xl,&n);
    547:   VecGetArrayRead(xl,&xxl);
    548:   VecGetArrayRead(xu,&xxu);
    549:   for (i=0; i<n; i++) cnt += ((xxl[i] != SNES_VI_NINF) || (xxu[i] != SNES_VI_INF));

    551:   MPI_Allreduce(&cnt,&snes->ntruebounds,1,MPIU_INT,MPI_SUM,PetscObjectComm((PetscObject)snes));
    552:   VecRestoreArrayRead(xl,&xxl);
    553:   VecRestoreArrayRead(xu,&xxu);
    554:   return(0);
    555: }

    559: PetscErrorCode SNESSetFromOptions_VI(SNES snes)
    560: {
    562:   PetscBool      flg;
    563:   SNESLineSearch linesearch;

    566:   PetscOptionsHead("SNES VI options");
    567:   PetscOptionsBool("-snes_vi_monitor","Monitor all non-active variables","None",PETSC_FALSE,&flg,0);
    568:   if (flg) {
    569:     SNESMonitorSet(snes,SNESMonitorVI,0,0);
    570:   }
    571:   if (!snes->linesearch) {
    572:     SNESGetLineSearch(snes, &linesearch);
    573:     SNESLineSearchSetType(linesearch, SNESLINESEARCHBT);
    574:     SNESLineSearchBTSetAlpha(linesearch, 0.0);
    575:   }
    576:   PetscOptionsTail();
    577:   return(0);
    578: }