Actual source code: taosolver_bounds.c
petsc-3.7.1 2016-05-15
Report Typos and Errors

      1: #include <petsc/private/taoimpl.h> /*I "petsctao.h" I*/

      5: /*@
      6:   TaoSetVariableBounds - Sets the upper and lower bounds

      8:   Logically collective on Tao

     10:   Input Parameters:
     11: + tao - the Tao context
     12: . XL  - vector of lower bounds
     13: - XU  - vector of upper bounds

     15:   Level: beginner

     17: .seealso: TaoSetObjectiveRoutine(), TaoSetHessianRoutine() TaoSetObjectiveAndGradientRoutine()
     18: @*/

     20: PetscErrorCode TaoSetVariableBounds(Tao tao, Vec XL, Vec XU)
     21: {

     26:   if (XL) {
     28:     PetscObjectReference((PetscObject)XL);
     29:   }
     30:   if (XU) {
     32:     PetscObjectReference((PetscObject)XU);
     33:   }
     34:   VecDestroy(&tao->XL);
     35:   VecDestroy(&tao->XU);
     36:   tao->XL = XL;
     37:   tao->XU = XU;
     38:   return(0);
     39: }

     43: /*@C
     44:   TaoSetVariableBoundsRoutine - Sets a function to be used to compute variable bounds

     46:   Logically collective on Tao

     48:   Input Parameters:
     49: + tao - the Tao context
     50: . func - the bounds computation routine
     51: - ctx - [optional] user-defined context for private data for the bounds computation (may be NULL)

     53:   Calling sequence of func:
     54: $      func (Tao tao, Vec xl, Vec xu);

     56: + tao - the Tao
     57: . xl  - vector of lower bounds
     58: . xu  - vector of upper bounds
     59: - ctx - the (optional) user-defined function context

     61:   Level: beginner

     63: .seealso: TaoSetObjectiveRoutine(), TaoSetHessianRoutine() TaoSetObjectiveAndGradientRoutine(), TaoSetVariableBounds()

     65: Note: The func passed in to TaoSetVariableBoundsRoutine() takes
     66: precedence over any values set in TaoSetVariableBounds().

     68: @*/
     69: PetscErrorCode TaoSetVariableBoundsRoutine(Tao tao, PetscErrorCode (*func)(Tao, Vec, Vec, void*), void *ctx)
     70: {
     73:   tao->user_boundsP = ctx;
     74:   tao->ops->computebounds = func;
     75:   return(0);
     76: }

     80: PetscErrorCode TaoGetVariableBounds(Tao tao, Vec *XL, Vec *XU)
     81: {
     84:   if (XL) {
     85:     *XL=tao->XL;
     86:   }
     87:   if (XU) {
     88:     *XU=tao->XU;
     89:   }
     90:   return(0);
     91: }

     95: /*@C
     96:    TaoComputeVariableBounds - Compute the variable bounds using the
     97:    routine set by TaoSetVariableBoundsRoutine().

     99:    Collective on Tao

    101:    Input Parameters:
    102: .  tao - the Tao context

    104:    Level: developer

    106: .seealso: TaoSetVariableBoundsRoutine(), TaoSetVariableBounds()
    107: @*/

    109: PetscErrorCode TaoComputeVariableBounds(Tao tao)
    110: {

    115:   if (!tao->ops->computebounds) return(0);
    116:   if (!tao->XL || !tao->XU) {
    117:     if (!tao->solution) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"TaoSetInitialVector must be called before TaoComputeVariableBounds");
    118:     VecDuplicate(tao->solution, &tao->XL);
    119:     VecSet(tao->XL, PETSC_NINFINITY);
    120:     VecDuplicate(tao->solution, &tao->XU);
    121:     VecSet(tao->XU, PETSC_INFINITY);
    122:   }
    123:   PetscStackPush("Tao compute variable bounds");
    124:   (*tao->ops->computebounds)(tao,tao->XL,tao->XU,tao->user_boundsP);
    125:   PetscStackPop;
    126:   return(0);
    127: }

    131: /*@
    132:   TaoSetInequalityBounds - Sets the upper and lower bounds

    134:   Logically collective on Tao

    136:   Input Parameters:
    137: + tao - the Tao context
    138: . IL  - vector of lower bounds
    139: - IU  - vector of upper bounds

    141:   Level: beginner

    143: .seealso: TaoSetObjectiveRoutine(), TaoSetHessianRoutine() TaoSetObjectiveAndGradientRoutine()
    144: @*/

    146: PetscErrorCode TaoSetInequalityBounds(Tao tao, Vec IL, Vec IU)
    147: {

    152:   if (IL) {
    154:     PetscObjectReference((PetscObject)IL);
    155:   }
    156:   if (IU) {
    158:     PetscObjectReference((PetscObject)IU);
    159:   }
    160:   VecDestroy(&tao->IL);
    161:   VecDestroy(&tao->IU);
    162:   tao->IL = IL;
    163:   tao->IU = IU;
    164:   return(0);
    165: }

    170: PetscErrorCode TaoGetInequalityBounds(Tao tao, Vec *IL, Vec *IU)
    171: {
    174:   if (IL) {
    175:     *IL=tao->IL;
    176:   }
    177:   if (IU) {
    178:     *IU=tao->IU;
    179:   }
    180:   return(0);
    181: }

    185: /*@C
    186:    TaoComputeConstraints - Compute the variable bounds using the
    187:    routine set by TaoSetConstraintsRoutine().

    189:    Collective on Tao

    191:    Input Parameters:
    192: .  tao - the Tao context

    194:    Level: developer

    196: .seealso: TaoSetConstraintsRoutine(), TaoComputeJacobian()
    197: @*/

    199: PetscErrorCode TaoComputeConstraints(Tao tao, Vec X, Vec C)
    200: {

    210:   if (!tao->ops->computeconstraints) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"TaoSetConstraintsRoutine() has not been called");
    211:   if (!tao->solution) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"TaoSetInitialVector must be called before TaoComputeConstraints");
    212:   PetscLogEventBegin(Tao_ConstraintsEval,tao,X,C,NULL);
    213:   PetscStackPush("Tao constraints evaluation routine");
    214:   (*tao->ops->computeconstraints)(tao,X,C,tao->user_conP);
    215:   PetscStackPop;
    216:   PetscLogEventEnd(Tao_ConstraintsEval,tao,X,C,NULL);
    217:   tao->nconstraints++;
    218:   return(0);
    219: }

    223: /*@C
    224:   TaoSetConstraintsRoutine - Sets a function to be used to compute constraints.  TAO only handles constraints under certain conditions, see manual for details

    226:   Logically collective on Tao

    228:   Input Parameters:
    229: + tao - the Tao context
    230: . c   - A vector that will be used to store constraint evaluation
    231: . func - the bounds computation routine
    232: - ctx - [optional] user-defined context for private data for the constraints computation (may be NULL)

    234:   Calling sequence of func:
    235: $      func (Tao tao, Vec x, Vec c, void *ctx);

    237: + tao - the Tao
    238: . x   - point to evaluate constraints
    239: . c   - vector constraints evaluated at x
    240: - ctx - the (optional) user-defined function context

    242:   Level: intermediate

    244: .seealso: TaoSetObjectiveRoutine(), TaoSetHessianRoutine() TaoSetObjectiveAndGradientRoutine(), TaoSetVariablevBounds()

    246: @*/
    247: PetscErrorCode TaoSetConstraintsRoutine(Tao tao, Vec c, PetscErrorCode (*func)(Tao, Vec, Vec, void*), void *ctx)
    248: {
    251:     tao->constraints = c;
    252:     tao->user_conP = ctx;
    253:     tao->ops->computeconstraints = func;
    254:     return(0);
    255: }

    259: /*@
    260:   TaoComputeDualVariables - Computes the dual vectors corresponding to the bounds
    261:   of the variables

    263:   Collective on Tao

    265:   Input Parameters:
    266: . tao - the Tao context

    268:   Output Parameter:
    269: + DL - dual variable vector for the lower bounds
    270: - DU - dual variable vector for the upper bounds

    272:   Level: advanced

    274:   Note:
    275:   DL and DU should be created before calling this routine.  If calling
    276:   this routine after using an unconstrained solver, DL and DU are set to all
    277:   zeros.

    279:   Level: advanced

    281: .seealso: TaoComputeObjective(), TaoSetVariableBounds()
    282: @*/
    283: PetscErrorCode TaoComputeDualVariables(Tao tao, Vec DL, Vec DU)
    284: {
    292:   if (tao->ops->computedual) {
    293:     (*tao->ops->computedual)(tao,DL,DU);
    294:   }  else {
    295:     VecSet(DL,0.0);
    296:     VecSet(DU,0.0);
    297:   }
    298:   return(0);
    299: }

    303: /*@
    304:   TaoGetDualVariables - Gets pointers to the dual vectors

    306:   Collective on Tao

    308:   Input Parameters:
    309: . tao - the Tao context

    311:   Output Parameter:
    312: + DE - dual variable vector for the lower bounds
    313: - DI - dual variable vector for the upper bounds

    315:   Level: advanced

    317: .seealso: TaoComputeDualVariables()
    318: @*/
    319: PetscErrorCode TaoGetDualVariables(Tao tao, Vec *DE, Vec *DI)
    320: {
    323:   if (DE) {
    324:     *DE = tao->DE;
    325:   }
    326:   if (DI) {
    327:     *DI = tao->DI;
    328:   }
    329:   return(0);
    330: }

    334: /*@C
    335:   TaoSetEqualityConstraintsRoutine - Sets a function to be used to compute constraints.  TAO only handles constraints under certain conditions, see manual for details

    337:   Logically collective on Tao

    339:   Input Parameters:
    340: + tao - the Tao context
    341: . ce   - A vector that will be used to store equality constraint evaluation
    342: . func - the bounds computation routine
    343: - ctx - [optional] user-defined context for private data for the equality constraints computation (may be NULL)

    345:   Calling sequence of func:
    346: $      func (Tao tao, Vec x, Vec ce, void *ctx);

    348: + tao - the Tao
    349: . x   - point to evaluate equality constraints
    350: . ce   - vector of equality constraints evaluated at x
    351: - ctx - the (optional) user-defined function context

    353:   Level: intermediate

    355: .seealso: TaoSetObjectiveRoutine(), TaoSetHessianRoutine() TaoSetObjectiveAndGradientRoutine(), TaoSetVariableBounds()

    357: @*/
    358: PetscErrorCode TaoSetEqualityConstraintsRoutine(Tao tao, Vec ce, PetscErrorCode (*func)(Tao, Vec, Vec, void*), void *ctx)
    359: {

    364:   if (ce) {
    366:     PetscObjectReference((PetscObject)ce);
    367:   }
    368:   VecDestroy(&tao->constraints_equality);

    370:   tao->constraints_equality = ce;
    371:   tao->user_con_equalityP = ctx;
    372:   tao->ops->computeequalityconstraints = func;
    373:   return(0);
    374: }

    379: /*@C
    380:   TaoSetInequalityConstraintsRoutine - Sets a function to be used to compute constraints.  TAO only handles constraints under certain conditions, see manual for details

    382:   Logically collective on Tao

    384:   Input Parameters:
    385: + tao - the Tao context
    386: . ci   - A vector that will be used to store inequality constraint evaluation
    387: . func - the bounds computation routine
    388: - ctx - [optional] user-defined context for private data for the inequality constraints computation (may be NULL)

    390:   Calling sequence of func:
    391: $      func (Tao tao, Vec x, Vec ci, void *ctx);

    393: + tao - the Tao
    394: . x   - point to evaluate inequality constraints
    395: . ci   - vector of inequality constraints evaluated at x
    396: - ctx - the (optional) user-defined function context

    398:   Level: intermediate

    400: .seealso: TaoSetObjectiveRoutine(), TaoSetHessianRoutine() TaoSetObjectiveAndGradientRoutine(), TaoSetVariableBounds()

    402: @*/
    403: PetscErrorCode TaoSetInequalityConstraintsRoutine(Tao tao, Vec ci, PetscErrorCode (*func)(Tao, Vec, Vec, void*), void *ctx)
    404: {

    409:   if (ci) {
    411:     PetscObjectReference((PetscObject)ci);
    412:   }
    413:   VecDestroy(&tao->constraints_inequality);
    414:   tao->constraints_inequality = ci;

    416:   tao->user_con_inequalityP = ctx;
    417:   tao->ops->computeinequalityconstraints = func;
    418:   return(0);
    419: }

    424: /*@C
    425:    TaoComputeEqualityConstraints - Compute the variable bounds using the
    426:    routine set by TaoSetEqualityConstraintsRoutine().

    428:    Collective on Tao

    430:    Input Parameters:
    431: .  tao - the Tao context

    433:    Level: developer

    435: .seealso: TaoSetEqualityConstraintsRoutine(), TaoComputeJacobianEquality()
    436: @*/

    438: PetscErrorCode TaoComputeEqualityConstraints(Tao tao, Vec X, Vec CE)
    439: {

    449:   if (!tao->ops->computeequalityconstraints) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"TaoSetEqualityConstraintsRoutine() has not been called");
    450:   if (!tao->solution) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"TaoSetInitialVector must be called before TaoComputeEqualityConstraints");
    451:   PetscLogEventBegin(Tao_ConstraintsEval,tao,X,CE,NULL);
    452:   PetscStackPush("Tao equality constraints evaluation routine");
    453:   (*tao->ops->computeequalityconstraints)(tao,X,CE,tao->user_con_equalityP);
    454:   PetscStackPop;
    455:   PetscLogEventEnd(Tao_ConstraintsEval,tao,X,CE,NULL);
    456:   tao->nconstraints++;
    457:   return(0);
    458: }

    463: /*@C
    464:    TaoComputeInequalityConstraints - Compute the variable bounds using the
    465:    routine set by TaoSetInequalityConstraintsRoutine().

    467:    Collective on Tao

    469:    Input Parameters:
    470: .  tao - the Tao context

    472:    Level: developer

    474: .seealso: TaoSetInequalityConstraintsRoutine(), TaoComputeJacobianInequality()
    475: @*/

    477: PetscErrorCode TaoComputeInequalityConstraints(Tao tao, Vec X, Vec CI)
    478: {

    488:   if (!tao->ops->computeinequalityconstraints) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"TaoSetInequalityConstraintsRoutine() has not been called");
    489:   if (!tao->solution) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"TaoSetInitialVector must be called before TaoComputeInequalityConstraints");
    490:   PetscLogEventBegin(Tao_ConstraintsEval,tao,X,CI,NULL);
    491:   PetscStackPush("Tao inequality constraints evaluation routine");
    492:   (*tao->ops->computeinequalityconstraints)(tao,X,CI,tao->user_con_inequalityP);
    493:   PetscStackPop;
    494:   PetscLogEventEnd(Tao_ConstraintsEval,tao,X,CI,NULL);
    495:   tao->nconstraints++;
    496:   return(0);
    497: }