Actual source code: tao_app_j.c

      1: #include "tao_app_impl.h"       /*I  "tao.h"  I*/

      9: /*@C
     10:    TaoAppComputeGradient - Compute the gradient of the objective function using the
     11:    routine set by TaoApplicationSetGradientRoutine().

     13:    Collective on TAO_APPLICATION

     15:    Input Parameters:
     16: +  taopp - the TAO_APPLICATION context
     17: -  X - the point where the objective should be evaluated

     19:    Output Parameter:
     20: .  f - function value

     22:    Level: developer

     24: .keywords: TAO_APPLICATION, objective

     26: .seealso: TaoAppComputeGradient(), TaoAppComputeObjectiveAndGradient()
     27: @*/
     28: int TaoAppComputeVariableBounds(TAO_APPLICATION taoapp, Vec XL, Vec XU){
     29:   int info;
     34:   info = PetscLogInfo((XL,"TAO:  Compute variable bounds of TAO_APPLICATION object.\n")); CHKERRQ(info);
     35:   if (taoapp->computebounds){
     36:     info = (*taoapp->computebounds)(taoapp,XL,XU,taoapp->boundctx); CHKERRQ(info);
     37:   }
     38:   return(0);
     39: }

     43: /*@C
     44:    TaoAppSetVariableBoundsRoutine - Sets a routine that evaluates the function at
     45: the specified point.

     47:    Collective on TAO_APPLICATION

     49:    Input Parameters:
     50: +  taoapp - the TAO_APPLICATION context
     51: .  func - bound evaluation routine
     52: -  ctx - [optional] user-defined context for private data for the
     53:          bounds evaluation routine (may be TAO_NULL)

     55:    Calling sequence of func:
     56: $     func (Vec xl,Vec xu, void *ctx);

     58: +  tao - the TAO_APPLICATION context
     59: .  xl - lower bound vector
     60: .  xu - upper bound vector
     61: -  ctx - [optional] user-defined function context

     63:    Level: beginner

     65: .seealso: TaoGetVariableBoundVecs()

     67: .keywords: TAO_APPLICATION, set, bounds
     68: @*/
     69: int TaoAppSetVariableBoundsRoutine(TAO_APPLICATION taoapp, int (*func)(TAO_APPLICATION,Vec,Vec,void*),void *ctx){
     72:   taoapp->computebounds=func;
     73:   taoapp->boundctx=ctx;
     74:   return(0);
     75: }

     80: /*@
     81:    TaoAppSetFunctionVec - Set the Vec that will be used to store the constraint function.

     83:    Collective on TAO_APPLICATION

     85:    Input Parameters:
     86: +  taoapp - the TAO_APPLICATION context
     87: -  r - vector to constrainf function values

     89:    Level: intermediate

     91: .keywords: TAO_APPLICATION, set, function

     93: .seealso: TaoAppSetJacobianMat(), TaoAppSetConstraintRoutine()

     95: @*/
     96: int TaoAppSetFunctionVec(TAO_APPLICATION taoapp, Vec r){
     97:   int info;
    100:   if (r){
    102:     PetscObjectReference((PetscObject)r);
    103:   }
    104:   if (taoapp->R){
    105:     info=VecDestroy(taoapp->R); CHKERRQ(info);
    106:   }
    107:   taoapp->R=r;
    108:   return(0);
    109: }

    114: /*@C
    115:    TaoAppGetFunctionVec - Get the Vec that used to store the constraint function.

    117:    Collective on TAO_APPLICATION

    119:    Input Parameters:
    120: +  taoapp - the TAO_APPLICATION context
    121: -  r - vector to constrainf function values

    123:    Level: intermediate

    125: .keywords: TAO_APPLICATION, set, function

    127: .seealso: TaoAppSetJacobianMat(), TaoAppSetConstraintRoutine()

    129: @*/
    130: int TaoAppGetFunctionVec(TAO_APPLICATION taoapp, Vec *r){
    133:   if (r){
    134:     *r=taoapp->R;
    135:   }
    136:   return(0);
    137: }

    143: /*@C
    144:    TaoAppSetConstraintRoutine - Sets the routine that evaluates
    145:    equality constraint functions.

    147:    Collective on TAO_APPLICATION

    149:    Input Parameters:
    150: +  taoapp - the TAO_APPLICATION context
    151: .  func - the constraint function evaluation routine
    152: -  ctx - [optional] user-defined function context

    154:    Calling sequence of func:
    155: $     func (TAO_APPLICATION taoapp,Vec x,Vec r,void *ctx);

    157: +  taoapp - the TAO_APPLICATION  context
    158: .  x - input vector
    159: .  r - constraint vector
    160: -  ctx - user-defined function gradient context set from TaoAppSetConstraintRoutine()

    162:    Level: intermediate

    164: .keywords: TAO_APPLICATION, set, function

    166: .seealso: TaoAppSetFunctionVec(), TaoAppSetJacobianRoutine()

    168: @*/
    169: int TaoAppSetConstraintRoutine(TAO_APPLICATION taoapp, int (*func)(TAO_APPLICATION,Vec,Vec,void*),void *ctx){
    172:   taoapp->usrfvctx = ctx;
    173:   taoapp->computevfunc = func;
    174:   return(0);
    175: }

    179: /*@C
    180:    TaoAppComputeFunction - Compute the constraint vector using the
    181:    routine set by TaoApplicationSetConstraintsRoutine().

    183:    Collective on TAO_APPLICATION

    185:    Input Parameters:
    186: +  taopp - the TAO_APPLICATION context
    187: -  X - the point where the objective should be evaluated

    189:    Output Parameter:
    190: .  R - constraint vector

    192:    Level: developer

    194: .keywords: TAO_APPLICATION, objective

    196: .seealso: TaoAppComputeJacobian() TaoAppSetConstraintRoutine()
    197: @*/
    198: int TaoAppComputeFunction(TAO_APPLICATION taoapp, Vec X, Vec R){
    199:   int     info;

    205:   if (taoapp->computevfunc){
    206:     info = PetscLogEventBegin(Tao_FunctionEval,taoapp,X,R,0);CHKERRQ(info);
    207:     PetscStackPush("Tao user ConstraintsFunction");
    208:     info = (*taoapp->computevfunc)(taoapp,X,R,taoapp->usrfvctx);
    209:     CHKERRQ(info);
    210:     PetscStackPop;
    211:     info = PetscLogEventEnd(Tao_FunctionEval,taoapp,X,R,0);
    212:   } else {
    213:     SETERRQ(1,"TAO ERROR: Must set Constraint function");
    214:   }
    215:   return(0);
    216: }

    221: /*@
    222:    TaoAppSetJacobianMat - Sets the matrix to be used for the Jacobian.

    224:    Collective on TAO_APPLICATION and Mat

    226:    Input Parameters:
    227: +  taoapp - the TAO_APPLICATION context
    228: .  J - Jacobian matrix
    229: -  JP - Preconditioner for Jacobian

    231:    Level: intermediate

    233: .keywords: TAO_APPLICATION, Jacobian

    235: .seealso: TaoAppSetJacobianRoutine(), TaoAppSetFunctionVec()
    236: @*/
    237: int TaoAppSetJacobianMat(TAO_APPLICATION taoapp,Mat J, Mat JP){
    238:   int info;
    241:   if (J || JP){
    244:     PetscObjectReference((PetscObject)J);
    245:     PetscObjectReference((PetscObject)JP);
    246:   }

    248:   if (taoapp->J || taoapp->JP){
    249:     info=MatDestroy(taoapp->J);CHKERRQ(info);
    250:     info=MatDestroy(taoapp->JP);CHKERRQ(info);
    251:   }
    252:   taoapp->J=J;
    253:   taoapp->JP=JP;
    254:   return(0);
    255: }

    259: /*@
    260:    TaoAppGetJacobianMat - Get the matrix to be used for the Jacobian.

    262:    Collective on TAO_APPLICATION and Mat

    264:    Input Parameters:
    265: +  taoapp - the TAO_APPLICATION context
    266: -  J - Jacobian matrix

    268:    Level: intermediate

    270: .keywords: TAO_APPLICATION, Jacobian

    272: .seealso: TaoAppSetJacobianMat()
    273: @*/
    274: int TaoAppGetJacobianMat(TAO_APPLICATION taoapp,Mat *J, Mat *JP){
    277:   if (J) { *J=taoapp->J;}
    278:   if (JP){ *JP=taoapp->JP; }
    279:   return(0);
    280: }

    284: /*@C
    285:    TaoAppSetJacobianRoutine - Sets the function to compute the Jacobian of
    286: the equality constraint function as well as the
    287:    location to store the matrix.

    289:    Collective on TAO_APPLICATION and Mat

    291:    Input Parameters:
    292: +  taoapp - the TAO_APPLICATION context
    293: .  jac - Jacobian evaluation routine
    294: -  ctx - [optional] user-defined context for private data for the
    295:          Hessian evaluation routine (may be TAO_NULL)

    297:    Calling sequence of func:
    298: $    jac (TAO_APPLICATION taoapp,Vec x,Mat *J,Mat *JPre, void *ctx);

    300: +  taoapp - the TAO_APPLICATION  context
    301: .  x - input vector
    302: .  J - Jacobian matrix
    303: .  JPre - matrix to precondition J
    304: -  ctx - [optional] user-defined Hessian context

    306:    Notes:

    308:    The function jac() takes Mat * as the matrix arguments rather than Mat.
    309:    This allows the Jacobian evaluation routine to replace J with a
    310:    completely new new matrix structure (not just different matrix elements)
    311:    when appropriate, for instance, if the nonzero structure is changing
    312:    throughout the global iterations.

    314:    Level: intermediate

    316: .keywords: TAO_APPLICATION, Jacobian

    318: .seealso: TaoAppSetJacobianMat(), TaoAppSetConstraintRoutine()
    319: @*/
    320: int TaoAppSetJacobianRoutine(TAO_APPLICATION taoapp,int (*jac)(TAO_APPLICATION,Vec,Mat*,Mat*,MatStructure*,void*),void *ctx){
    323:   taoapp->computejacobian=jac;
    324:   taoapp->usrjctx=ctx;
    325:   return(0);
    326: }

    331: /*@C
    332:    TaoAppComputeJacobian - Compute the Jacobian of the nonlinear equations using the
    333:    routine set by TaoApplicationSetJacobianRoutine().

    335:    Collective on TAO_APPLICATION

    337:    Input Parameters:
    338: +  taopp - the TAO_APPLICATION context
    339: .  X - the variable vector
    340: .  H - the Jacobian matrix
    341: .  HP - the preconditioner for the Jacobian matrix.
    342: -  flag - flag used in KSPSetOperators()

    344:    Output Parameter:
    345: +  H - the Jacobian matrix
    346: .  HP - the preconditioner for the Jacobian matrix.
    347: -  flag - flag used in KSPSetOperators()

    349:    Level: developer

    351: .keywords: TAO_APPLICATION, objective

    353: .seealso: TaoAppComputeFunction(), TaoAppSetJacobianRoutine()
    354: @*/
    355: int TaoAppComputeJacobian(TAO_APPLICATION taoapp, Vec X, Mat *JJ, Mat *JJPre, MatStructure*flag){

    357:   int     info;
    358:   Mat J=*JJ,JPre=*JJPre;
    359:   MatStructure pflag=*flag;

    365:   if (taoapp->computejacobian){
    366:     PetscStackPush("TAO User Jacobian Evaluation");
    367:     info = PetscLogEventBegin(Tao_JacobianEval,taoapp,X,J,0);CHKERRQ(info);
    368:     info = (*taoapp->computejacobian)(taoapp,X,&J,&JPre, &pflag, taoapp->usrjctx);
    369:     CHKERRQ(info);
    370:     info = PetscLogEventEnd(Tao_JacobianEval,taoapp,X,J,0);CHKERRQ(info);
    371:     PetscStackPop;
    372:   } else {
    373:     SETERRQ(1,"TAO Error:  No Jacobian Routine Available.");
    374:   }
    375:   *JJ=J;*JJPre=JPre; *flag=pflag;
    376:   return(0);
    377: }