Actual source code: oldroutines.c

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


  4: class TaoPetscApplication;
  5: int TaoAppGetTaoPetscApp(TAO_APPLICATION, TaoPetscApplication**);

  7: typedef struct {
  8:   /* Function Gradient Evaluation over single element  */
  9:   int  (*computef)(TAO_SOLVER, Vec, double*, void*); 
 10:   int  (*computeg)(TAO_SOLVER, Vec, Vec, void*); 
 11:   int  (*computefg)(TAO_SOLVER, Vec, double*, Vec, void*); 
 12:   int  (*computeh)(TAO_SOLVER, Vec, Mat*, Mat*, MatStructure*, void*); 
 13:   int  (*computer)(TAO_SOLVER, Vec, Vec, void*); 
 14:   int  (*computej)(TAO_SOLVER, Vec, Mat*, void*); 
 15:   TAO_SOLVER tao;
 16:   void *fctx;
 17:   void *fgctx;
 18:   void *gctx;
 19:   void *hctx;
 20:   void *rctx;
 21:   void *jctx;
 22: } TaoPETScOLD;


 27: static int TaoPetscAppF(TAO_APPLICATION taoapp , Vec X , double *f, void*ctx){
 28:   int info;
 29:   TaoPETScOLD* mctx= (TaoPETScOLD*)ctx;
 31:   info=(*mctx->computef)(mctx->tao,X,f,mctx->fctx); CHKERRQ(info);
 32:   return(0);  
 33: }

 37: static int TaoPetscAppG(TAO_APPLICATION taoapp , Vec X , Vec G, void*ctx){
 38:   int info;
 39:   TaoPETScOLD* mctx= (TaoPETScOLD*)ctx;
 41:   info=(*mctx->computeg)(mctx->tao,X,G,mctx->gctx); CHKERRQ(info);
 42:   return(0);  
 43: }

 47: static int TaoPetscAppFG(TAO_APPLICATION taoapp , Vec X , double *f, Vec G, void* ctx){
 48:   int info;
 49:   TaoPETScOLD* mctx= (TaoPETScOLD*)ctx;
 51:   info=(*mctx->computefg)(mctx->tao,X,f,G,mctx->fgctx); CHKERRQ(info);
 52:   return(0);  
 53: }

 57: static int TaoPetscAppH(TAO_APPLICATION taoapp , Vec X , Mat *H, Mat *HP, MatStructure *flag, void* ctx){
 58:   int info;
 59:   TaoPETScOLD* mctx= (TaoPETScOLD*)ctx;
 61:   info=(*mctx->computeh)(mctx->tao,X,H,HP,flag,mctx->hctx); CHKERRQ(info);
 62:   return(0);  
 63: }

 67: static int TaoPetscAppR(TAO_APPLICATION taoapp , Vec X , Vec R, void*ctx){
 68:   int info;
 69:   TaoPETScOLD* mctx= (TaoPETScOLD*)ctx;
 71:   info=(*mctx->computer)(mctx->tao,X,R,mctx->rctx); CHKERRQ(info);
 72:   return(0);  
 73: }

 77: static int TaoPetscAppJ(TAO_APPLICATION taoapp , Vec X , Mat *J, Mat *JP, MatStructure *flag, void* ctx){
 78:   int info;
 79:   TaoPETScOLD* mctx= (TaoPETScOLD*)ctx;
 81:   info=(*mctx->computej)(mctx->tao,X,J,mctx->jctx); CHKERRQ(info);
 82:   return(0);  
 83: }


 88: /* @C
 89:    TaoSetPetscFunction - Sets a routine that evaluates the function at
 90: the specified point.

 92:    Collective on TAO_SOLVER

 94:    Input Parameters:
 95: +  taoapp - the TAO_APPLICATION context
 96: .  x - variable vector that stores the solution
 97: .  func - function evaluation routine
 98: -  ctx - [optional] user-defined context for private data for the 
 99:          function and gradient evaluation routine (may be TAO_NULL)

101:    Note: This function is no longer supported. Use TaoSetObjectiveFunction() and TaoSetVariableVec() instead.

103:    Level: intermediate

105: .seealso:  TaoAppSetObjectiveRoutine(), TaoAppSetInitialSolutionVec()
106: @ */
107: int TaoSetPetscFunction(TAO_APPLICATION taoapp, Vec X, int (*func)(TAO_SOLVER,Vec,double*,void*),void *ctx){
108:   int info;
109:   TaoPETScOLD* fgctx= (TaoPETScOLD*)ctx;
111:   PetscNew(TaoPETScOLD,&fgctx);
112:   fgctx->computef = func;
113:   fgctx->fctx=ctx;
114:   fgctx->tao = 0;
115:   info = TaoAppSetInitialSolutionVec(taoapp,X); CHKERRQ(info);
116:   info = TaoAppSetObjectiveRoutine(taoapp,TaoPetscAppF,(void*)fgctx); CHKERRQ(info);
117:   info = TaoAppSetDestroyRoutine(taoapp,TaoApplicationFreeMemory, (void*)fgctx); CHKERRQ(info);
118:   return(0);
119: }


124: /* @C
125:    TaoSetPetscGradient - Sets the gradient evaluation routine and gradient
126:    vector for use by the TAO_SOLVER routines.

128:    Collective on TAO_SOLVER

130:    Input Parameters:
131: +  taoapp - the TAO_APPLICATION context
132: .  g - vector to store gradient
133: .  grad - gradient evaluation routine
134: -  ctx - [optional] user-defined function context 

136:    Note:
137:    This routine is no longer supported.

139: .seealso: TaoAppSetGradientRoutine()

141: @ */
142: int TaoSetPetscGradient(TAO_APPLICATION taoapp, Vec g, int (*grad)(TAO_SOLVER,Vec,Vec,void*),void *ctx){
143:   int info;
144:   TaoPETScOLD* fgctx= (TaoPETScOLD*)ctx;
146:   PetscNew(TaoPETScOLD,&fgctx);
147:   fgctx->computeg = grad;
148:   fgctx->gctx=ctx;
149:   fgctx->tao = 0;
150:   info = TaoAppSetGradientRoutine(taoapp,TaoPetscAppG,(void*)fgctx); CHKERRQ(info);
151:   info = TaoAppSetDestroyRoutine(taoapp,TaoApplicationFreeMemory, (void*)fgctx); CHKERRQ(info);
152:   return(0);
153: }

157: /* @C
158:    TaoSetPetscFunctionGradient - Sets a routine for function and gradient evaluation.

160:    Collective on TAO_SOLVER

162:    Input Parameters:
163: +  taoapp - the TAO_APPLICATION context
164: .  x - vector to store solution
165: .  g - vector to store gradient
166: .  funcgrad - routine for evaluating the function and gradient
167: -  ctx - optional user-defined context for private data for the 
168:          function and gradient evaluation routine (may be TAO_NULL)

170:    Level: intermediate

172:    Note: 
173:    This routine is no longer supported.

175: .seealso: TaoAppSetObjectiveAndGradientRoutine(), TaoSetVariableVec()

177: @ */
178: int TaoSetPetscFunctionGradient(TAO_APPLICATION taoapp, Vec x, Vec g, int (*funcgrad)(TAO_SOLVER,Vec,double*,Vec, void*),void *ctx){
179:   int info;
180:   TaoPETScOLD* fgctx= (TaoPETScOLD*)ctx;
182:   PetscNew(TaoPETScOLD,&fgctx);
183:   fgctx->computefg = funcgrad;
184:   fgctx->fgctx=ctx;
185:   fgctx->tao = 0;
186:   info = TaoAppSetObjectiveAndGradientRoutine(taoapp,TaoPetscAppFG,(void*)fgctx); CHKERRQ(info);
187:   info = TaoAppSetDestroyRoutine(taoapp,TaoApplicationFreeMemory, (void*)fgctx); CHKERRQ(info);
188:   info = TaoAppSetInitialSolutionVec(taoapp,x); CHKERRQ(info);
189:   return(0);
190: }

194: /* @C
195:    TaoSetPetscHessian - Sets the function to compute the Hessian as well as the
196:    location to store the matrix.

198:    Collective on TAO_SOLVER and Mat

200:    Input Parameters:
201: +  taoapp - the TAO_APPLICATION context
202: .  H - Hessian matrix
203: .  Hpre - preconditioner matrix (usually same as the Hessian)
204: .  hess - Hessian evaluation routine
205: -  ctx - [optional] user-defined context for private data for the 
206:          Hessian evaluation routine (may be TAO_NULL)

208:    Level: intermediate

210:    Note: This routine is no longer supported.

212: .seealso: TaoAppSetHessianRoutine(), TaoAppSetHessianMat()
213: @ */
214: int TaoSetPetscHessian(TAO_APPLICATION taoapp, Mat H, Mat Hpre, int (*hess)(TAO_SOLVER,Vec,Mat*,Mat*,MatStructure*,void*),void *ctx){
215:   int info;
216:   TaoPETScOLD* fgctx= (TaoPETScOLD*)ctx;
218:   PetscNew(TaoPETScOLD,&fgctx);
219:   fgctx->computeh = hess;
220:   fgctx->hctx=ctx;
221:   fgctx->tao = 0;
222:   info = TaoAppSetHessianRoutine(taoapp,TaoPetscAppH,(void*)fgctx);CHKERRQ(info);
223:   info = TaoAppSetHessianMat(taoapp,H,Hpre);CHKERRQ(info);
224:   info = TaoAppSetDestroyRoutine(taoapp,TaoApplicationFreeMemory, (void*)fgctx); CHKERRQ(info);
225:   return(0);
226: }


231: /* @C
232:    TaoSetPetscConstraintsFunction - Sets the routine that evaluates
233: equality constraint functions.

235:    Collective on TAO_APPLICATION

237:    Input Parameters:
238: +  taoapp - the TAO_APPLICATION context
239: .  r - vector to constrainf function values
240: .  func - the constraint function evaluation routine
241: -  ctx - [optional] user-defined function context 

243:    Calling sequence of func:
244: $     func (TAO_SOLVER solver,Vec x,Vec r,void *ctx);

246: +  solver - the TAO_SOLVER solver context
247: .  x - input vector
248: .  r - constraint vector
249: -  ctx - user-defined function gradient context set from TaoSetPetscFunction()

251:    Level: intermediate

253: .keywords: TAO_SOLVER, set, function

255: .seealso: TaoGetGradient(), TaoSetPetscHessian()

257: @ */
258: int TaoSetPetscConstraintsFunction(TAO_APPLICATION taoapp, Vec r, int (*func)(TAO_SOLVER,Vec,Vec,void*),void 
259:                                    *ctx){
260:   int info;
261:   TaoPETScOLD* fgctx= (TaoPETScOLD*)ctx;
263:   PetscNew(TaoPETScOLD,&fgctx);
264:   fgctx->computer = func;
265:   fgctx->rctx=ctx;
266:   fgctx->tao = 0;
267:   info = TaoAppSetConstraintRoutine(taoapp,TaoPetscAppR,(void*)fgctx); CHKERRQ(info);
268:   info = TaoAppSetDestroyRoutine(taoapp,TaoApplicationFreeMemory, (void*)fgctx); CHKERRQ(info);
269:   info = TaoAppSetFunctionVec(taoapp,r); CHKERRQ(info);
270:   return(0);
271: }


276: /* @C
277:    TaoSetPetscJacobian - Sets the function to compute the Jacobian of
278: the equality constraint function as well as the
279:    location to store the matrix.

281:    Collective on TAO_APPLICATION and Mat

283:    Input Parameters:
284: +  solver - the TAO_APPLICATION context
285: .  J - Jacobian matrix
286: .  jac - Jacobian evaluation routine
287: -  ctx - [optional] user-defined context for private data for the 
288:          Hessian evaluation routine (may be TAO_NULL)

290:    Calling sequence of func:
291: $    jac (TAO_SOLVER solver,Vec x,Mat *J,void *ctx);

293: +  solver - the TAO_SOLVER solver context
294: .  x - input vector
295: .  J - Jacobian matrix
296: -  ctx - [optional] user-defined Hessian context

298:    Notes: 

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

306:    Level: intermediate

308: .keywords: TAO_SOLVER, Jacobian

310: .seealso: TaoSetPetscFunction(), TaoSetPetscConstraintsFunction()
311: @ */
312: int TaoSetPetscJacobian(TAO_APPLICATION taoapp,Mat J,int (*jac)(TAO_SOLVER,Vec,Mat*,void*),void *ctx){
313:   int info;
314:   TaoPETScOLD* fgctx= (TaoPETScOLD*)ctx;
316:   PetscNew(TaoPETScOLD,&fgctx);
317:   fgctx->computej = jac;
318:   fgctx->jctx=ctx;
319:   fgctx->tao = 0;
320:   info = TaoAppSetJacobianRoutine(taoapp,TaoPetscAppJ,(void*)fgctx);CHKERRQ(info);
321:   info = TaoAppSetDestroyRoutine(taoapp,TaoApplicationFreeMemory, (void*)fgctx); CHKERRQ(info);
322:   info = TaoAppSetJacobianMat(taoapp,J,J); CHKERRQ(info);
323:   return(0);
324: }




331: int TaoSetFromOptions(TAO_APPLICATION taoapp){
332:   int info;
334:   info=TaoAppSetFromOptions(taoapp); CHKERRQ(info);
335:   return(0);
336: }

338: class TaoApplication;

343: int TaoSetApplication(TAO_SOLVER tao, TAO_APPLICATION taoapp){
344:   int info;
345:   TaoPetscApplication* tpapp;
347:   info=TaoAppGetTaoPetscApp(taoapp, &tpapp); CHKERRQ(info);
348:   info=TaoSetApplication(tao,(TaoApplication*)(tpapp)); CHKERRQ(info);
349:   return(0);
350: }


355: int TaoApplicationDestroy(TAO_APPLICATION taoapp){
356:   int info;
358:   info=TaoAppDestroy(taoapp); CHKERRQ(info);
359:   return(0);
360: }