Actual source code: taopetsc.c

  1: #include "src/fortran/custom/zpetsc.h"
  2: #include "petscksp.h"
 3:  #include tao.h
  4: /*
  5: #include "src/externaltao/petsctao/vector/taovec_petsc.h"
  6: #include "src/externaltao/petsctao/matrix/taomat_petsc.h"
  7: #include "src/externaltao/petsctao/indexset/taois_petsc.h"
  8: #include "src/externaltao/petsctao/linearsolver/taolinearsolver_petsc.h"
  9: #include "src/externaltao/petsctao/application/taoapp_petsc.h"
 10: */


 13: #ifdef PETSC_HAVE_FORTRAN_CAPS

 15: #define taowrappetscvec_       TAOWRAPPETSCVEC
 16: #define taowrappetscmat_       TAOWRAPPETSCMAT
 17: #define taovecgetpetscvec_     TAOVECGETPETSCVEC
 18: #define taomatgetpetscmat_     TAOMATGETPETSCMAT

 20: #define taowrapis_       TAOWRAPIS
 21: #define taowrapksp_     TAOWRAPKSP

 23: #define taoindexsetgetis_         TAOINDEXSETGETIS
 24: #define taolinearsolvergetpetscksp_   TAOLINEARSOLVERGETPETSCKSP

 26: #define taopetscapplicationcreate_     TAOPETSCAPPLICATIONCREATE
 27: #define taoapplicationcreate_          TAOAPPLICATIONCREATE
 28: #define taoapplicationdestroy_          TAOAPPLICATIONDESTROY
 29: #define taosetapplication_          TAOSETAPPLICATION
 30: /* #define taosetfromoptions_          TAOSETFROMOPTIONS */

 32: /*
 33: #define taosetobjectivefunctionroutine_          TAOSETOBJECTIVEFUNCTIONROUTINE
 34: #define taosetobjectivefunctiongradientroutine_  TAOSETOBJECTIVEFUNCTIONGRADIENTROUTINE
 35: #define taosetgradientroutine_                   TAOSETGRADIENTROUTINE
 36: #define taosethessianroutine_                    TAOSETHESSIANROUTINE
 37: #define taosetvariableboundsroutine_             TAOSETVARIABLEBOUNDSROUTINE
 38: */

 40: #define taoappsetobjectiveandgradientroutine_    TAOAPPSETOBJECTIVEANDGRADIENTROUTINE
 41: #define taoappsetobjectiveandgradientro_         TAOAPPSETOBJECTIVEANDGRADIENTRO
 42: #define taoappsetobjectiveroutine_               TAOAPPSETOBJECTIVEROUTINE
 43: #define taoappsetgradientroutine_                TAOAPPSETGRADIENTROUTINE
 44: #define taoappsethessianroutine_                 TAOAPPSETHESSIANROUTINE
 45: #define taoappsetvariableboundsroutine_          TAOAPPSETVARIABLEBOUNDSROUTINE
 46: #define taoappsetjacobianroutine_                TAOAPPSETJACOBIANROUTINE
 47: #define taoappsetconstraintroutine_              TAOAPPSETCONSTRAINTROUTINE

 49: /* Grid application */
 50: #define daappsethessianroutine_                         DAAPPSETHESSIANROUTINE
 51: #define daappsetobjectiveandgradientroutine_            DAAPPSETOBJECTIVEANDGRADIENTROUTINE
 52: #define daappsetobjectiveandgradientrou_                DAAPPSETOBJECTIVEANDGRADIENTROU
 53: #define daappsetgradientroutine_                        DAAPPSETGRADIENTROUTINE
 54: #define daappsetobjectiveroutine_                       DAAPPSETOBJECTIVEROUTINE
 55: #define daappsetvariableboundsroutine_                  DAAPPSETVARIABLEBOUNDSROUTINE
 56: #define daappsetconstraintroutine_                      DAAPPSETCONSTRAINTROUTINE
 57: #define daappsetjacobianroutine_                        DAAPPSETJACOBIANROUTINE
 58: #define daappsetbeforemonitor_                          DAAPPSETBEFOREMONITOR
 59: #define daappsetaftermonitor_                           DAAPPSETAFTERMONITOR
 60: #define daappsetelementobjectiveandgradientroutine_     DAAPPSETELEMENTOBJECTIVEANDGRADIENTROUTINE
 61: #define daappsetelementobjectiveandgrad_                DAAPPSETELEMENTOBJECTIVEANDGRAD
 62: #define daappsetelementhessianroutine_                  DAAPPSETELEMENTHESSIANROUTINE


 65: /* deprecated */
 66: #define taosetpetscfunction_             TAOSETPETSCFUNCTION
 67: #define taosetpetscfunctiongradient_     TAOSETPETSCFUNCTIONGRADIENT
 68: #define taosetpetscgradient_             TAOSETPETSCGRADIENT
 69: #define taosetpetschessian_              TAOSETPETSCHESSIAN


 72: #define taodefaultcomputehessian_   TAODEFAULTCOMPUTEHESSIAN
 73: #define taodefaultcomputehessiancolor_ TAODEFAULTCOMPUTEHESSIANCOLOR
 74: #define taosetpetscjacobian_             TAOSETPETSCJACOBIAN
 75: #define taosetjacobianroutine_             TAOSETJACOBIANROUTINE
 76: #define taosetconstraintroutine_           TAOSETCONSTRAINTROUTINE
 77: #define taosetjacobianmat_                 TAOSETJACOBIANMAT
 78: #define taosetconstraintvec_               TAOSETCONSTRAINTVEC

 80: #define taosetpetscvariablebounds_       TAOSETPETSCVARIABLEBOUNDS
 81: #define taosetpetscinitialvector_        TAOSETPETSCINITIALVECTOR
 82: #define taogetksp_                      TAOGETKSP

 84: #elif !defined(PETSC_HAVE_FORTRAN_UNDERSCORE)

 86: #define taowrappetscvec_       taowrappetscvec
 87: #define taowrappetscmat_       taowrappetscmat
 88: #define taovecgetpetscvec_     taovecgetpetscvec
 89: #define taomatgetpetscmat_     taomatgetpetscmat

 91: #define taowrapis_       taowrapis
 92: #define taowrapksp_     taowrapksp

 94: #define taoindexsetgetpetscis_         taoindexsetgetpetscis
 95: #define taolinearsolvergetksp_   taolinearsolvergetksp

 97: #define taopetscapplicationcreate_     taopetscapplicationcreate 
 98: #define taoapplicationcreate_                taoapplicationcreate 
 99: #define taoapplicationdestroy_                taoapplicationdestroy 
100: #define taosetapplication_                taosetapplication 
101: /* #define taosetfromoptions_          taosetfromoptions */

103: /*
104: #define taosetobjectivefunctionroutine_          taosetobjectivefunctionroutine
105: #define taosetobjectivefunctiongradientroutine_  taosetobjectivefunctiongradientroutine
106: #define taosetgradientroutine_                   taosetgradientroutine
107: #define taosethessianroutine_                    taosethessianroutine
108: #define taosetvariableboundsroutine_             taosetvariableboundsroutine
109: */

111: #define taoappsetobjectiveandgradientroutine_    taoappsetobjectiveandgradientroutine
112: #define taoappsetobjectiveandgradientro_         taoappsetobjectiveandgradientro
113: #define taoappsetobjectiveroutine_               taoappsetobjectiveroutine
114: #define taoappsetgradientroutine_                taoappsetgradientroutine
115: #define taoappsethessianroutine_                 taoappsethessianroutine
116: #define taoappsetvariableboundsroutine_          taoappsetvariableboundsroutine
117: #define taoappsetjacobianroutine_                taoappsetjacobianroutine
118: #define taoappsetconstraintroutine_              taoappsetconstraintroutine


121: /* Grid application */
122: #define daappsethessianroutine_                         daappsethessianroutine
123: #define daappsetobjectiveandgradientroutine_            daappsetobjectiveandgradientroutine
124: #define daappsetobjectiveandgradientrou_                daappsetobjectiveandgradientrou
125: #define daappsetgradientroutine_                        daappsetgradientroutine
126: #define daappsetobjectiveroutine_                       daappsetobjectiveroutine
127: #define daappsetvariableboundsroutine_                  daappsetvariableboundsroutine
128: #define daappsetconstraintroutine_                      daappsetconstraintroutine
129: #define daappsetjacobianroutine_                        daappsetjacobianroutine
130: #define daappsetbeforemonitor_                          daappsetbeforemonitor
131: #define daappsetaftermonitor_                           daappsetaftermonitor
132: #define daappsetelementobjectiveandgradientroutine_     daappsetelementobjectiveandgradientroutine
133: #define daappsetelementobjectiveandgrad_                daappsetelementobjectiveandgrad
134: #define daappsetelementhessianroutine_                  daappsetelementhessianroutine

136: /* deprecated */
137: #define taosetpetscfunction_             taosetpetscfunction
138: #define taosetpetscfunctiongradient_     taosetpetscfunctiongradient
139: #define taosetpetscgradient_             taosetpetscgradient
140: #define taosetpetschessian_              taosetpetschessian
141: #define taodefaultcomputehessian_   taodefaultcomputehessian
142: #define taodefaultcomputehessiancolor_ taodefaultcomputehessiancolor

144: #define taosetpetscjacobian_             taosetpetscjacobian
145: #define taosetconstraintsfunction_  taosetconstraintsfunction

147: #define taosetjacobianroutine_             taosetjacobianroutine
148: #define taosetconstraintroutine_           taosetconstraintroutine
149: #define taosetjacobianmat_                 taosetjacobianmat
150: #define taosetconstraintvec_               taosetconstraintvec

152: #define taosetpetscvariablebounds_       taosetpetscvariablebounds
153: #define taosetpetscinitialvector_        taosetpetscinitialvector
154: #define taogetksp_                      taogetksp

156: #endif

159: void PETSC_STDCALL taowrappetscvec_(Vec *V, TaoVecPetsc **TV,  int *ierr)
160: {
161:   *TaoWrapPetscVec(*V,TV);
162: }

164: void PETSC_STDCALL taovecgetpetscvec_(TaoVec* *TV, Vec *V,  int *ierr)
165: {
166:   *ierr=TaoVecGetPetscVec(*TV,V);
167: }


170: void PETSC_STDCALL taowrappetscmat_(Mat *M, TaoMatPetsc **TM,  int *ierr)
171: {
172:   *TaoWrapPetscMat(*M,TM);
173: }


176: void PETSC_STDCALL taomatgetpetscmat_(TaoMat* *TM, Mat *M,  int *ierr)
177: {
178:   *ierr=TaoMatGetPetscMat(*TM,M);
179: }


182: void PETSC_STDCALL taowrappetscis_(IS *M, int *imax,TaoIndexSetPetsc **TM,  int *ierr)
183: {
184:   *TaoWrapPetscIS(*M,*imax,TM);
185: }


188: void PETSC_STDCALL taoindexsetgetpetscis_(TaoIndexSet* *TM, IS *M,  int *ierr)
189: {
190:   *ierr=TaoIndexSetGetPetscIS(*TM,M);
191: }


194: void PETSC_STDCALL taowrapksp_( KSP *M, TaoLinearSolverPetsc **TM,  int *ierr)
195: {
196:   *TaoWrapKSP(*M,TM);
197: }

199: void PETSC_STDCALL taolinearsolvergetksp_(TaoLinearSolver **TM, KSP *M,  int *ierr)
200: {
201:   *ierr=TaoLinearSolverGetKSP(*TM,M);
202: }

204: void PETSC_STDCALL taopetscapplicationcreate_(MPI_Comm *comm,TAO_APPLICATION  *outtao,int *ierr){

206:   *TaoPetscApplicationCreate((MPI_Comm)PetscToPointerComm(*comm),outtao);

208: }

210: void PETSC_STDCALL taoapplicationcreate_(MPI_Comm *comm,TAO_APPLICATION  *outtao,int *ierr){

212:   *TaoApplicationCreate((MPI_Comm)PetscToPointerComm(*comm),outtao);

214: }

216: void PETSC_STDCALL taoapplicationdestroy_(TAO_APPLICATION  *outtao,int *ierr){

218:   *TaoApplicationDestroy(*outtao);

220: }

222: /* Very Old routine  must get rid of it .  Here only for backward compatibility */
223: void PETSC_STDCALL taosetapplication_(TAO_SOLVER *tao, TAO_APPLICATION  *outtao, int *ierr){

225:   *TaoSetupApplicationSolver(*outtao, *tao);

227: }

229: /* Very Old routine  must get rid of it .  Here only for backward compatibility */
230: /*
231: void PETSC_STDCALL taosetfromoptions_(TAO_SOLVER *tao, int *ierr){

233:   *TaoSetOptions(*tao);

235: }
236: */
237: /* -------------- Setting call-back routines ---------------- */

239: static void (PETSC_STDCALL *f1a)(TAO_SOLVER*,Vec*,double*,Vec*,void*,int*);
240: static void (PETSC_STDCALL *f1)(TAO_APPLICATION*,Vec*,double*,Vec*,void*,int*);


244: static int ourtaominfunctiongradientroutine(TAO_SOLVER tao,Vec x,double *f,Vec r,void *ctx)
245: {
246:   int info = 0;
247:   (*f1a)(&tao,&x,f,&r,ctx,&info);CHKERRQ(info);
248:   return 0;
249: }

251: static int ourtaominfunctiongradientroutine2(TAO_APPLICATION taoapp,Vec x,double *f,Vec r,void *ctx)
252: {
253:   int info = 0;
254:   (*f1)(&taoapp,&x,f,&r,ctx,&info);CHKERRQ(info);
255:   return 0;
256: }



261: void PETSC_STDCALL taosetpetscfunctiongradient_(TAO_APPLICATION  *taoapp,Vec *x,Vec *r,void (PETSC_STDCALL *func)(TAO_SOLVER*,Vec*,double*,Vec*,void*,int*),void *ctx,int *info){
262:   f1a = func;
263:   *info = TaoSetPetscFunctionGradient(*taoapp,*x,*r,ourtaominfunctiongradientroutine,ctx);
264: }

266: void PETSC_STDCALL taoappsetobjectiveandgradientroutine_(TAO_APPLICATION  *taoapp,void (PETSC_STDCALL *func)(TAO_APPLICATION*,Vec*,double*,Vec*,void*,int*),void *ctx,int *info){
267:   f1 = func;
268:   *info = TaoAppSetObjectiveAndGradientRoutine(*taoapp,ourtaominfunctiongradientroutine2,ctx);
269: }
270: void PETSC_STDCALL taoappsetobjectiveandgradientro_(TAO_APPLICATION  *taoapp,void (PETSC_STDCALL *func)(TAO_APPLICATION*,Vec*,double*,Vec*,void*,int*),void *ctx,int *info){
271:   f1 = func;
272:   *info = TaoAppSetObjectiveAndGradientRoutine(*taoapp,ourtaominfunctiongradientroutine2,ctx);
273: }


276: static void (PETSC_STDCALL *f2a)(TAO_SOLVER*,Vec*,double*,void*,int*);
277: static void (PETSC_STDCALL *f2)(TAO_APPLICATION*,Vec*,double*,void*,int*);
279: static int ourtaominfunction(TAO_SOLVER tao,Vec x,double* d,void *ctx)
280: {
281:   int info = 0;
282:   (*f2a)(&tao,&x,d,ctx,&info);CHKERRQ(info);
283:   return 0;
284: }
285: static int ourtaominfunction2(TAO_APPLICATION taoapp,Vec x,double* d,void *ctx)
286: {
287:   int info = 0;
288:   (*f2)(&taoapp,&x,d,ctx,&info);CHKERRQ(info);
289:   return 0;
290: }

293: void PETSC_STDCALL taosetpetscfunction_(TAO_APPLICATION  *taoapp,Vec *x,
294:           void (PETSC_STDCALL *func)(TAO_SOLVER*,Vec*,double*,void*,int*),void *ctx,int *info){
295:   f2a = func;
296:   *info = TaoSetPetscFunction(*taoapp,*x,ourtaominfunction,ctx);
297: }

299: void PETSC_STDCALL taoappsetobjectiveroutine(TAO_APPLICATION  *taoapp,
300:           void (PETSC_STDCALL *func)(TAO_APPLICATION*,Vec*,double*,void*,int*),void *ctx,int *info){
301:   f2 = func;
302:   *info = TaoAppSetObjectiveRoutine(*taoapp,ourtaominfunction2,ctx);
303: }



307: static void (PETSC_STDCALL *f3a)(TAO_SOLVER*,Vec*,Vec *,void*,int*);
308: static void (PETSC_STDCALL *f3)(TAO_APPLICATION*,Vec*,Vec *,void*,int*);

311: static int ourtaogradientfunction(TAO_SOLVER tao,Vec x,Vec d,void *ctx)
312: {
313:   int info = 0;
314:   (*f3a)(&tao,&x,&d,ctx,&info);CHKERRQ(info);
315:   return 0;
316: }
317: static int ourtaogradientfunction2(TAO_APPLICATION taoapp,Vec x,Vec d,void *ctx)
318: {
319:   int info = 0;
320:   (*f3)(&taoapp,&x,&d,ctx,&info);CHKERRQ(info);
321:   return 0;
322: }

325: void PETSC_STDCALL taosetpetscgradient_(TAO_APPLICATION *taoapp,Vec *r,void (PETSC_STDCALL *func)(TAO_SOLVER*,Vec*,Vec*,void*,int*),void *ctx,int *info){
326:   f3a = func;
327:   *info = TaoSetPetscGradient(*taoapp,*r,ourtaogradientfunction,ctx);
328: }

330: void PETSC_STDCALL taoappsetgradientroutine_(TAO_APPLICATION *taoapp,void (PETSC_STDCALL *func)(TAO_APPLICATION*,Vec*,Vec*,void*,int*),void *ctx,int *info){
331:   f3 = func;
332:   *info = TaoAppSetGradientRoutine(*taoapp,ourtaogradientfunction2,ctx);
333: }


336: /* ---------------------------------------------------------*/
337: /*
338:   taodefaultcomputehessian() and taodefaultcomputehessiancolor().
339:   These routines can be used directly from Fortran, but the following is done
340:   primarily so that a Fortran call to TaoSetPetscHessian() will properly handle the
341:   defaults being passed in.

343:   functions, hence no STDCALL
344: */
345: void taodefaultcomputehessian_(TAO_APPLICATION *tao,Vec *x,Mat *m,Mat *p,MatStructure* type,
346:                                void *ctx,int *info)
347: {
348:   *info = TaoAppDefaultComputeHessian(*tao,*x,m,p,type,ctx);
349: }

351: void  taodefaultcomputehessiancolor_(TAO_APPLICATION *tao,Vec *x,Mat *m,Mat *p,
352:                                      MatStructure* type,void *ctx,int *info)
353: {
354:   *info = TaoAppDefaultComputeHessianColor(*tao,*x,m,p,type,*(MatFDColoring*)ctx);
355: }

357: static void (PETSC_STDCALL *f4a)(TAO_SOLVER*,Vec*,Mat*,Mat*,MatStructure*,void*,int*);
358: static void (PETSC_STDCALL *f4)(TAO_APPLICATION*,Vec*,Mat*,Mat*,MatStructure*,void*,int*);

361: static int ourtaohessian(TAO_SOLVER tao,Vec x,Mat* m,Mat* p,MatStructure* type,void*ctx)
362: {
363:   int info = 0;
364:   (*f4a)(&tao,&x,m,p,type,ctx,&info);CHKERRQ(info);
365:   return 0;
366: }
367: static int ourtaohessian2(TAO_APPLICATION taoapp,Vec x,Mat* m,Mat* p,MatStructure* type,void*ctx)
368: {
369:   int info = 0;
370:   (*f4)(&taoapp,&x,m,p,type,ctx,&info);CHKERRQ(info);
371:   return 0;
372: }


376: void PETSC_STDCALL taosetpetschessian_(TAO_APPLICATION  *taoapp,Mat *A,Mat *B,void (PETSC_STDCALL *func)(TAO_SOLVER*,Vec*,Mat*,Mat*,
377:                                   MatStructure*,void*,int*),void *ctx,int *info)
378: {
379:   f4a = func;
380:   *info = TaoSetPetscHessian(*taoapp,*A,*B,ourtaohessian,ctx);
381: }

383: void PETSC_STDCALL taoappsethessianroutine_(TAO_APPLICATION  *taoapp,void (PETSC_STDCALL *func)(TAO_APPLICATION*,Vec*,Mat*,Mat*,
384:                                   MatStructure*,void*,int*),void *ctx,int *info)
385: {
386:   if ((void(*)())func == (void(*)()) taodefaultcomputehessian_) {
387:     *info = TaoAppSetHessianRoutine(*taoapp,TaoAppDefaultComputeHessian,ctx);
388:   } else if ( (void(*)()) func == (void(*)()) taodefaultcomputehessiancolor_) {
389:     *info = TaoAppSetHessianRoutine(*taoapp,TaoAppDefaultComputeHessianColor,*(MatFDColoring*)ctx);
390:   } else {
391:     f4 = func;
392:     *info = TaoAppSetHessianRoutine(*taoapp,ourtaohessian2,ctx);
393:   }
394: }


397: static void (PETSC_STDCALL *fb)(TAO_APPLICATION*, Vec*,Vec *,void*,int*);


401: static int ourtaovariableboundsroutine(TAO_APPLICATION tao, Vec x,Vec d,void *ctx)
402: {
403:   int info = 0;
404:   (*fb)(&tao,&x,&d,ctx,&info);CHKERRQ(info);
405:   return 0;
406: }



411: void PETSC_STDCALL taoappsetvariableboundsroutine_(TAO_APPLICATION *taoapp,void (PETSC_STDCALL *func)(TAO_APPLICATION*,Vec*,Vec*,void*,int*),void *ctx,int *info){
412:   fb = func;
413:   *info = TaoAppSetVariableBoundsRoutine(*taoapp,ourtaovariableboundsroutine,ctx);
414: }


417: static void (PETSC_STDCALL *f6a)(TAO_SOLVER*,Vec*,Vec *,void*,int*);
418: static void (PETSC_STDCALL *f6)(TAO_APPLICATION*,Vec*,Vec *,void*,int*);
420: static int ourtaoconstraintsfunction(TAO_SOLVER tao,Vec x,Vec d,void *ctx)
421: {
422:   int info = 0;
423:   (*f6a)(&tao,&x,&d,ctx,&info);CHKERRQ(info);
424:   return 0;
425: }
426: static int ourtaoconstraintsfunction2(TAO_APPLICATION taoapp,Vec x,Vec d,void *ctx)
427: {
428:   int info = 0;
429:   (*f6)(&taoapp,&x,&d,ctx,&info);CHKERRQ(info);
430:   return 0;
431: }

434: void PETSC_STDCALL taosetpetscconstraintsfunction_(TAO_APPLICATION  *taoapp,Vec *r,void (PETSC_STDCALL *func)(TAO_SOLVER*,Vec*,Vec*,void*,int*),void *ctx,int *info){
435:   f6a = func;
436:   *info = TaoSetPetscConstraintsFunction(*taoapp,*r,ourtaoconstraintsfunction,ctx);
437: }

439: void PETSC_STDCALL taoappsetconstraintroutine_(TAO_APPLICATION  *taoapp,void (PETSC_STDCALL *func)(TAO_APPLICATION*,Vec*,Vec*,void*,int*),void *ctx,int *info){
440:   f6 = func;
441:   *info = TaoAppSetConstraintRoutine(*taoapp,ourtaoconstraintsfunction2,ctx);
442: }

444: void PETSC_STDCALL taosetconstraintvec_(TAO_APPLICATION  *taoapp, Vec *r, int *info){
445:   *info = TaoAppSetFunctionVec(*taoapp,*r);
446: }

448: static void (PETSC_STDCALL *f7a)(TAO_SOLVER*,Vec*,Mat *,void*,int*);
449: static void (PETSC_STDCALL *f7)(TAO_APPLICATION*,Vec*,Mat *,Mat*, MatStructure*,void*,int*);
451: static int ourtaojacobianfunction(TAO_SOLVER tao,Vec x,Mat *J,void *ctx)
452: {
453:   int info = 0;
454:   (*f7a)(&tao,&x,J,ctx,&info);CHKERRQ(info);
455:   return 0;
456: }
457: static int ourtaojacobianfunction2(TAO_APPLICATION tao,Vec x,Mat *J,Mat *JP, MatStructure *flag,void *ctx)
458: {
459:   int info = 0;
460:   (*f7)(&tao,&x,J,JP,flag,ctx,&info);CHKERRQ(info);
461:   return 0;
462: }

465: void PETSC_STDCALL taosetpetscjacobian_(TAO_APPLICATION  *taoapp, Mat*J, void (PETSC_STDCALL *func)(TAO_SOLVER*,Vec*,Mat*,void*,int*),void *ctx,int *info){
466:   f7a = func;
467:   *info = TaoSetPetscJacobian(*taoapp,*J,ourtaojacobianfunction,ctx);
468: }

470: void PETSC_STDCALL taoappsetjacobianroutine_(TAO_APPLICATION  *taoapp,void (PETSC_STDCALL *func)(TAO_APPLICATION*,Vec*,Mat*,Mat*,MatStructure*,void*,int*),void *ctx,int *info){
471:   f7 = func;
472:   *info = TaoAppSetJacobianRoutine(*taoapp,ourtaojacobianfunction2,ctx);
473: }

475: void PETSC_STDCALL taosetjacobianmat_(TAO_APPLICATION  *taoapp,Mat *J, Mat *JP,int *info){
476:   *info = TaoAppSetJacobianMat(*taoapp,*J,*JP);
477: }


480: void PETSC_STDCALL taogetksp_(TAO_SOLVER  *tao,KSP *tksp, int *info ){
481:   *info = TaoGetKSP(*tao,tksp);
482: }


486:  #include taodaapplication.h

488: /* Grid Application routines */
490: static void (PETSC_STDCALL *grid1)(TAO_APPLICATION*, DA*, Vec*, Mat*, void*, int*);
491: static void (PETSC_STDCALL *grid2)(TAO_APPLICATION*, DA*, Vec*, double*, Vec*, void*, int*);
492: static void (PETSC_STDCALL *grid3)(TAO_APPLICATION*, DA*, Vec*, Vec*, void*, int*);
493: static void (PETSC_STDCALL *grid4)(TAO_APPLICATION*, DA*, Vec*, double*, void*, int*);
494: static void (PETSC_STDCALL *grid5)(TAO_APPLICATION*, DA*, Vec*, Vec*, void*, int*);
495: static void (PETSC_STDCALL *grid6)(TAO_APPLICATION*, DA*, Vec*, Vec*, void*, int*);
496: static void (PETSC_STDCALL *grid7)(TAO_APPLICATION*, DA*, Vec*, Mat*, void*, int*);
497: static void (PETSC_STDCALL *grid8)(TAO_APPLICATION*, DA*, int*, void*, int*);
498: static void (PETSC_STDCALL *grid9)(TAO_APPLICATION*, DA*, int*, void*, int*);
499: /* Grid Application Element routines */
500: static void (PETSC_STDCALL *grid10)(int[2], double[4], double*, double[4], void*, int*);
501: static void (PETSC_STDCALL *grid11)(int[2], double[4], double[4][4], void*, int*);
503: static int ourdaappsethessianroutine(TAO_APPLICATION daapp, DA da, Vec x, Mat H, void *ctx) {
504:   int info = 0;
505:   (*grid1)(&daapp, &da, &x, &H, ctx, &info);
506:   return info;
507: }
508: static int ourdaappsetobjectiveandgradientroutine(TAO_APPLICATION daapp, DA da, Vec x, double *f, Vec G, void *ctx) {
509:   int info = 0;
510:   (*grid2)(&daapp, &da, &x, f, &G, ctx, &info);
511:   return info;
512: }
513: static int ourdaappsetgradientroutine(TAO_APPLICATION daapp, DA da, Vec x, Vec g, void *ctx) {
514:   int info = 0;
515:   (*grid3)(&daapp, &da, &x, &g, ctx, &info);
516:   return info;
517: }
518: static int ourdaappsetobjectiveroutine(TAO_APPLICATION daapp, DA da, Vec x, double *f, void *ctx) {
519:   int info = 0;
520:   (*grid4)(&daapp, &da, &x, f, ctx, &info);
521:   return info;
522: }
523: static int ourdaappsetvariableboundsroutine(TAO_APPLICATION daapp, DA da, Vec L, Vec U, void *ctx) {
524:   int info = 0;
525:   (*grid5)(&daapp, &da, &L, &U, ctx, &info);
526:   return info;
527: }
528: static int ourdaappsetconstraintroutine(TAO_APPLICATION daapp, DA da, Vec X, Vec R, void *ctx) {
529:   int info = 0;
530:   (*grid6)(&daapp, &da, &X, &R, ctx, &info);
531:   return info;
532: }
533: static int ourdaappsetjacobianroutine(TAO_APPLICATION daapp, DA da, Vec X, Mat J, void *ctx) {
534:   int info = 0;
535:   (*grid7)(&daapp, &da, &X, &J, ctx, &info);
536:   return info;
537: }
538: static int ourdaappsetbeforemonitor(TAO_APPLICATION daapp, DA da, int levels, void *ctx) {
539:   int info = 0;
540:   (*grid8)(&daapp, &da, &levels, ctx, &info);
541:   return info;
542: }
543: static int ourdaappsetaftermonitor(TAO_APPLICATION daapp, DA da, int levels, void *ctx) {
544:   int info = 0;
545:   (*grid9)(&daapp, &da, &levels, ctx, &info);
546:   return info;
547: }
548: static int ourdaappsetelementobjectiveandgradientroutine(int coord[2], double x[4], double *f, double g[4], void *ctx) {
549:   int info = 0;
550:   (*grid10)(coord, x, f, g, ctx, &info);
551:   return info;
552: }
553: static int ourdaappsetelementhessianroutine(int coord[2], double x[4], double H[4][4], void *ctx) {
554:   int info = 0;
555:   (*grid11)(coord, x, H, ctx, &info);
556:   return info;
557: }
559: void PETSC_STDCALL daappsethessianroutine_(TAO_APPLICATION *daapp, void (PETSC_STDCALL *func)(TAO_APPLICATION*,DA*,Vec*, Mat*, void*, int*),void *ctx, int *info) {
560:   grid1 = func;
561:   *info = DAAppSetHessianRoutine(*daapp, ourdaappsethessianroutine, ctx);
562: }
563: void PETSC_STDCALL daappsetobjectiveandgradientroutine_(TAO_APPLICATION *daapp, void (PETSC_STDCALL *func)(TAO_APPLICATION*, DA*, Vec*, double*, Vec*, void*, int*), void *ctx, int *info) {
564:   grid2 = func;
565:   *info = DAAppSetObjectiveAndGradientRoutine(*daapp, ourdaappsetobjectiveandgradientroutine, ctx);
566: }
567: void PETSC_STDCALL daappsetobjectiveandgradientrou_(TAO_APPLICATION *daapp, void (PETSC_STDCALL *func)(TAO_APPLICATION*, DA*, Vec*, double*, Vec*, void*, int*), void *ctx, int *info) {
568:   grid2 = func;
569:   *info = DAAppSetObjectiveAndGradientRoutine(*daapp, ourdaappsetobjectiveandgradientroutine, ctx);
570: }

572: void PETSC_STDCALL daappsetgradientroutine_(TAO_APPLICATION *daapp, void (PETSC_STDCALL *func)(TAO_APPLICATION*, DA*, Vec*, Vec*, void*, int*), void *ctx, int *info) {
573:   grid3 = func;
574:   *info = DAAppSetGradientRoutine(*daapp, ourdaappsetgradientroutine, ctx);
575: }
576: void PETSC_STDCALL daappsetobjectiveroutine_(TAO_APPLICATION *daapp, void (PETSC_STDCALL *func)(TAO_APPLICATION*, DA*, Vec*, double*, void*, int*), void *ctx, int *info) {
577:   grid4 = func;
578:   *info = DAAppSetObjectiveRoutine(*daapp, ourdaappsetobjectiveroutine, ctx);
579: }
580: void PETSC_STDCALL daappsetvariableboundsroutine_(TAO_APPLICATION *daapp, void (PETSC_STDCALL *func)(TAO_APPLICATION*, DA*, Vec*, Vec*, void*, int*), void *ctx, int *info) {
581:   grid5 = func;
582:   *info = DAAppSetVariableBoundsRoutine(*daapp, ourdaappsetvariableboundsroutine, ctx);
583: }
584: void PETSC_STDCALL daappsetconstraintroutine_(TAO_APPLICATION *daapp, void (PETSC_STDCALL *func)(TAO_APPLICATION*, DA*, Vec*, Vec*, void*, int*), void *ctx, int *info) {
585:   grid6 = func;
586:   *info = DAAppSetConstraintRoutine(*daapp, ourdaappsetconstraintroutine, ctx);
587: }
588: void PETSC_STDCALL daappsetjacobianroutine_(TAO_APPLICATION *daapp, void (PETSC_STDCALL *func)(TAO_APPLICATION*, DA*, Vec*, Mat*, void*, int*), void *ctx, int *info) {
589:   grid7 = func;
590:   *info = DAAppSetJacobianRoutine(*daapp, ourdaappsetjacobianroutine, ctx);
591: }
592: void PETSC_STDCALL daappsetbeforemonitor_(TAO_APPLICATION *daapp, void (PETSC_STDCALL *func)(TAO_APPLICATION*, DA*, int*, void*, int*), void *ctx, int *info) {
593:   grid8 = func;
594:   *info = DAAppSetBeforeMonitor(*daapp, ourdaappsetbeforemonitor, ctx);
595: }
596: void PETSC_STDCALL daappsetaftermonitor_(TAO_APPLICATION *daapp, void (PETSC_STDCALL *func)(TAO_APPLICATION*, DA*, int*, void*, int*), void *ctx, int *info) {
597:   grid9 = func;
598:   *info = DAAppSetAfterMonitor(*daapp, ourdaappsetaftermonitor, ctx);
599: }
600: void PETSC_STDCALL daappsetelementobjectiveandgradientroutine_(TAO_APPLICATION *daapp, void (PETSC_STDCALL *func)(int[2], double[4], double*, double[4], void*, int*), int *flops, void *ctx, int *info) {
601:   grid10 = func;
602:   *info = DAAppSetElementObjectiveAndGradientRoutine(*daapp, ourdaappsetelementobjectiveandgradientroutine, *flops, ctx);
603: }
604: void PETSC_STDCALL daappsetelementobjectiveandgrad_(TAO_APPLICATION *daapp, void (PETSC_STDCALL *func)(int[2], double[4], double*, double[4], void*, int*), int *flops, void *ctx, int *info) {
605:   grid10 = func;
606:   *info = DAAppSetElementObjectiveAndGradientRoutine(*daapp, ourdaappsetelementobjectiveandgradientroutine, *flops, ctx);
607: }
608: void PETSC_STDCALL daappsetelementhessianroutine_(TAO_APPLICATION *daapp, void (PETSC_STDCALL *func)(int[2], double[4], double[4][4], void*, int*), int *flops, void *ctx, int *info) {
609:   grid11 = func;
610:   *info = DAAppSetElementHessianRoutine(*daapp, ourdaappsetelementhessianroutine, *flops, ctx);
611: }