Actual source code: taoappobject.c

  1: #include "taoappobject.h"     /*I "tao_solver.h"  I*/
  2: #include "tao_general.h"
 3:  #include taovec.h


  8: /*@C
  9:    EvaluateObjectiveFunction - Evaluate the objective function
 10:    at the point x.

 12:    Collective on TAO_SOLVER

 14:    Input Parameters:
 15: .  xx - the point at which to evaluate the obective function

 17:    Output Parameters:
 18: .  ff - objective function value

 20: .seealso TaoSetPetscGradient(), EvaluateObjectiveFunction(), EvaluateObjectiveAndGradientFunction()

 22:    Level: intermediate

 24: .keywords: application, context

 26: @*/
 27: int TaoApplication::EvaluateObjectiveFunction(TaoVec *xx, double *ff){
 28:   TaoFunctionBegin;
 29:   SETERRQ(56,"Operation not defined");
 30:   //  TaoFunctionReturn(0);
 31: }

 35: /*@C
 36:    EvaluateGradient - Evaluate the gradient of the
 37:    objective function at the point x.

 39:    Collective on TAO_SOLVER

 41:    Input Parameters:
 42: .  xx - the point at which to evaluate the gradient

 44:    Output Parameters:
 45: .  gg - the gradient vector

 47: .seealso TaoSetPetscGradient(), EvaluateObjectiveFunction(), EvaluateObjectiveAndGradientFunction()

 49:    Level: intermediate

 51: .keywords: application, context

 53: @*/
 54: int TaoApplication::EvaluateGradient(TaoVec *xx, TaoVec *gg){
 55:   TaoFunctionBegin;
 56:   SETERRQ(56,"Operation not defined");
 57:   //  TaoFunctionReturn(0);
 58: }


 63: /*@C
 64:    EvaluateObjectiveAndGradient - Evaluate the objective function
 65:    and its gradient at the point x.

 67:    Collective on TAO_SOLVER

 69:    Input Parameters:
 70: .  xx - the point at which to evaluate the gradient

 72:    Output Parameters:
 73: +  ff - the objective value
 74: -  gg - the gradient vector

 76: .seealso TaoSetPetscFunctionGradient(), EvaluateGradient(), EvaluateObjectiveFunction()

 78:    Level: intermediate

 80: .keywords: application, gradient

 82: @*/
 83: int TaoApplication::EvaluateObjectiveAndGradient(TaoVec *xx, double *ff, TaoVec *gg){
 84:   int info;
 85:   TaoFunctionBegin;
 86:   info=this->EvaluateObjectiveFunction(xx,ff);CHKERRQ(info);
 87:   info=this->EvaluateGradient(xx,gg);CHKERRQ(info);
 88:   TaoFunctionReturn(0);
 89: }

 93: /*@C
 94:    EvaluateHessian - Evaluate the Hessian of the objective function
 95:    at the point x.

 97:    Collective on TAO_SOLVER

 99:    Input Parameters:
100: .  xx - the point at which to evaluate the gradient

102:    Output Parameters:
103: .  HH - the Hessian matrix

105: .seealso TaoSetPetscHessian()
106:    Level: intermediate

108: .keywords: application, hessian

110: @*/
111: int TaoApplication::EvaluateHessian(TaoVec *xx, TaoMat *HH){
112:   TaoFunctionBegin;
113:   SETERRQ(56,"Operation not defined");
114:   //  TaoFunctionReturn(0);
115: }

119: /*@C
120:    HessianSolve - Solve a linear system involving the Hessian
121: matrix, or apply an inverse Hessian operator to a vector.

123:    Collective on TAO_SOLVER

125:    Input Parameters:
126: .  rhs - the right-hand side

128:    Output Parameters:
129: +  vv - the solution
130: -  success - flag states whether solution was found.

132: .seealso TaoSetMethod(), TaoLMVMSetSize(), EvaluateHessian()

134:    Level: intermediate

136: .keywords: application, Hessian, LMVM

138: @*/
139: int TaoApplication::HessianSolve(TaoVec *rhs, TaoVec*vv, TaoTruth *success){
140:   int info;
141:   TaoFunctionBegin;
142:   info=vv->CopyFrom(rhs);CHKERRQ(info);
143:   *success=TAO_TRUE;
144:   TaoFunctionReturn(0);
145: }


150: /*@C
151:    EvaluateConstraints - Evaluate the constraint functions
152:    at the point x.

154:    Collective on TAO_SOLVER

156:    Input Parameters:
157: .  xx - the point at which to evaluate the gradient

159:    Output Parameters:
160: .  RR - the constraint vector

162: .seealso TaoSetPetscConstraintsFunction()
163:    Level: intermediate

165: .keywords: application, constraints

167: @*/
168: int TaoApplication::EvaluateConstraints(TaoVec *xx, TaoVec *RR){
169:   TaoFunctionBegin;
170:   SETERRQ(56,"Operation not defined");
171:   //  TaoFunctionReturn(0);
172: }

176: /*@C
177:    EvaluateJacobian - Evaluate the Jacobian of the constraint functions
178:    at the point x.

180:    Collective on TAO_SOLVER

182:    Input Parameters:
183: .  xx - the point at which to evaluate the gradient

185:    Output Parameters:
186: .  JJ - the Jacobian matrix

188: .seealso TaoSetPetscJacobian()

190:    Level: intermediate

192: .keywords: application, constraints

194: @*/
195: int TaoApplication::EvaluateJacobian(TaoVec *xx, TaoMat *JJ){
196:   TaoFunctionBegin;
197:   SETERRQ(56,"Operation not defined");
198:   //  TaoFunctionReturn(0);
199: }

203: /*@C
204:    InitializeVariables - Initialize the variables for the optimization
205:    solver.  Set an initial point.


208:    Collective on TAO_SOLVER

210:    Input Parameters:
211: .  xx - the variable vector

213:    Level: intermediate

215: .keywords: application, constraints

217: @*/
218: int TaoApplication::InitializeVariables(TaoVec *xx){
219:   int info;
220:   TaoFunctionBegin;
221:   info=xx->SetToZero();CHKERRQ(info);
222:   TaoFunctionReturn(0);
223: }

227: /*@C
228:    GetVariableVector - Sets the pointer to a vector that will
229:    be used to store the variables.

231:    Collective on TAO_SOLVER

233:    Output Parameters:
234: .  xx - vector to the variable vector

236:    Level: intermediate

238: .keywords: application, variables

240: @*/
241: int TaoApplication::GetVariableVector(TaoVec **xx){
242:   TaoFunctionBegin;
243:   *xx=0;
244:   TaoFunctionReturn(0);
245: }


250: /*@C
251:    EvaluateVariableBounds - Set these vectors equal to the lower
252:    and upper bounds on the variables.

254:    Collective on TAO_SOLVER

256:    Input Parameters:
257: +  xxll - vector vector of lower bounds
258: -  xxuu - vector vector of upper bounds

260:    Level: intermediate

262: .keywords: application, bounds

264: @*/
265: int TaoApplication::EvaluateVariableBounds(TaoVec *xxll, TaoVec *xxuu){
266:   int info;
267:   double dd;
268:   TaoFunctionBegin;
269:   if (xxll){
270:     dd=-TAO_INFINITY;
271:     info=xxll->SetToConstant(dd); CHKERRQ(info);
272:   }
273:   if (xxuu){
274:     dd=TAO_INFINITY;
275:     info=xxuu->SetToConstant(dd); CHKERRQ(info);
276:   }
277:   TaoFunctionReturn(0);
278: }


283: /*@C
284:    GetHessianMatrix - Sets the pointer to a matrix that will
285:    be used to store the Hessian of the objective function.

287:    Collective on TAO_SOLVER

289:    Output Parameters:
290: .  HH - vector to the Hessian

292:    Level: intermediate

294: .keywords: application, gradient

296: @*/
297: int TaoApplication::GetHessianMatrix(TaoMat **HH){
298:   TaoFunctionBegin;
299:   *HH=0;
300:   TaoFunctionReturn(0);
301: }

305: /*@C
306:    GetJacobianMatrix - Sets the pointer to a matrix that will
307:    be used to store the Jacobian

309:    Collective on TAO_SOLVER

311:    Output Parameters:
312: .  JJ - matrix to the Jacobian

314:    Level: intermediate

316: .keywords: application, gradient

318: @*/
319: int TaoApplication::GetJacobianMatrix(TaoMat **JJ){
320:   TaoFunctionBegin;
321:   *JJ=0;
322:   TaoFunctionReturn(0);
323: }

325: int TaoApplication::GetConstraintVector(TaoVec **rr){
326:   TaoFunctionBegin;
327:   *rr=0;
328:   TaoFunctionReturn(0);
329: }


334: int TaoApplication::GetInequalityConstraints(TaoVec**ll, TaoMat **AA, TaoVec **uu){
335:   TaoFunctionBegin;
336:   *ll=0;
337:   *AA=0;
338:   *uu=0;
339:   TaoFunctionReturn(0);
340: }


345: /*@C
346:   CreateATDAMatrix - Creates a new matrix of the for A^T D A, where A=this.

348:    Input Parameter:
349: +  A - matrix A
350: .  D -  a TaoVec in the column space of this matrix that will represent a diagonal matrix
351: -  X -  a vector in the rowspace of this matrix

353:    Output Parameter:
354: .  M - the new matrix

356:    Note:
357:    The operation M->Multiply(X,D) must be well defined

359: .seealso TaoMat::SetReducedMatrix()

361:    Level: intermediate
362: @*/
363: int TaoApplication::CreateATDAMatrix(TaoMat*A, TaoVec* D,TaoVec* X, TaoMat** M){
364:   TaoFunctionBegin;
365:   SETERRQ(56,"Operation not defined");
366:   /* TaoFunctionReturn(1); */
367: }



373: /*@C
374:    Monitor - Monitor the current solution

376:    Collective on TAO_SOLVER

378:    Level: intermediate

380:    Note: This routine is called after each iteration

382: .keywords: application, monitor

384: @*/
385: int TaoApplication::Monitor(){
386:   TaoFunctionBegin;
387:   TaoFunctionReturn(0);
388: }

392: /*@C
393:    Monitor2 - 

395:    Collective on TAO_SOLVER

397:    Input Parameters:
398: .  xx - the current solution
399: .  gl - the gradient of the Lagrangian function
400: .  dx - the step direction

402:    Output Parameters:
403: .  *term - TAO_TRUE if the solver should stop iterating and TAO_FALSE if the solver should continue;

405: .seealso TaoSetPetscGradient(),

407:    Level: intermediate

409: .keywords: application, context

411: @*/
412: int TaoApplication::Monitor2(TaoVec *xx, TaoVec *gg, TaoVec *ff, TaoTruth *term){
413:   TaoFunctionBegin;
414:   *term=TAO_FALSE;
415:   TaoFunctionReturn(0);
416: }



422: /*@C
423:    GetLinearSolver - Create and a linear solver used to solve this matrix

425:    Collective on TAO_SOLVER

427:    input Parameters:
428: +  H - the operator to be used to solve
429: -  flag - indicates properties solver must have

431:    Output Parameters:
432: .  tksp - the linear solver

434:    Types of linear solvers are:
435: +  100 - Solver for any square matrix
436: .  110 - GMRES
437: .  200 - Any symmetric matrix
438: .  210 - MINRES
439: .  220 - CG with Trust  Region
440: .  300 - Any symmetric positive definite
441: -  310 - Conjugate Gradient

443:    Level: intermediate

445: .keywords: application, linear solver

447: @*/
448: int TaoApplication::GetLinearSolver(TaoMat *H, int flag, TaoLinearSolver **tksp){
449:   TaoFunctionBegin;
450:   SETERRQ(56,"Operation not defined");
451: }

455: /*@
456:    TaoDestroyApplication - Destroys the TAO application

458:    Collective on TAO_APPLICATION

460:    Input Parameters:
461: .  myapp - pointer to the TaoApplication object (TaoApplication*),


464:    Level: developer

466: .keywords: application

468: @*/
469: int TaoDestroyApplication(TaoApplication *myapp){
470:   TaoFunctionBegin;
471:   delete myapp;
472:   TaoFunctionReturn(0);
473: }