Actual source code: kt.c

  1: #include "src/bound/impls/kt/kt.h"
  2: #include "src/tao_impl.h"

  4: static int TaoSetDown_KT(TAO_SOLVER, void *);
  5: static int TaoMonitor_KT(TAO_SOLVER my_tao, void *solver);

  7: /* ---------------------------------------------------------- */
 10: int TaoSetUp_KT(TAO_SOLVER tao,void *solver)
 11: {
 12:   TAO_KT *kt = (TAO_KT *)solver;
 13:   TaoVec *xx;
 14:   TaoTruth flg;
 15:   int info;

 17:   TaoFunctionBegin;
 18:   info = TaoGetSolution(tao,&xx); CHKERRQ(info);

 20:   // Create new complementarity solver
 21:   info = TaoOptionString("-tao_kt_method",0,0,kt->comp_method,
 22:                          kt->comp_method,256,&flg);
 23:   CHKERRQ(info);
 24:   if (kt->csolver==0){
 25:       info = TaoCreateFull(kt->comp_method,"t",((PetscObject)tao)->comm, &kt->csolver); 
 26:     CHKERRQ(info);
 27:   }
 28:   kt->ktapp = new TaoKTApplication(tao,kt->csolver);
 29:   kt->ktapp->SetItUp1(); CHKERRQ(info);
 30:   kt->ktapp->SetItUp2(); CHKERRQ(info);
 31:   kt->setupcalled=1;
 32:   
 33:   TaoFunctionReturn(0);
 34: }

 36: /* ---------------------------------------------------------- */
 39: static int TaoSetDown_KT(TAO_SOLVER tao, void *solver)
 40: {
 41:   TAO_KT *kt = (TAO_KT *)solver;
 42:   int info;

 44:   TaoFunctionBegin;
 45:   info = TaoDestroy(kt->csolver); CHKERRQ(info); 
 46:   info = TaoDestroyApplication(kt->ktapp); CHKERRQ(info); 
 47:   kt->setupcalled=0;
 48:   kt->csolver=0;
 49:   kt->ktapp=0;
 50:   TaoFunctionReturn(0);
 51: }

 55: static int TaoMonitor_KT(TAO_SOLVER complementaritytao, void *solver)
 56: {
 57:   TaoKTApplication* ktapp= (TaoKTApplication*)solver;
 58:   TaoTerminateReason reason;
 59:   double f, fnorm, cnorm, xdiff;
 60:   TaoInt iterate;
 61:   int info;

 63:   TaoFunctionBegin;
 64:   info = TaoGetSolutionStatus(complementaritytao, &iterate, &f, &fnorm, 
 65:                              &cnorm, &xdiff, &reason); CHKERRQ(info);
 66:   f=ktapp->func;
 67:   info = TaoMonitor(ktapp->orig,iterate,f,fnorm,cnorm,xdiff,&reason); CHKERRQ(info);
 68:   info = TaoSetTerminationReason(complementaritytao,reason); CHKERRQ(info);
 69:   TaoFunctionReturn(0);
 70: }

 72: /*------------------------------------------------------------*/
 75: static int TaoSolve_KT(TAO_SOLVER tao, void *solver)
 76: {
 77:   TAO_KT *kt = (TAO_KT *)solver;
 78:   int info;

 80:   TaoFunctionBegin;
 81:   info = TaoSolve(kt->csolver);  CHKERRQ(info);
 82:   TaoFunctionReturn(0);
 83: }

 85: /*------------------------------------------------------------*/
 88: static int TaoSetOptions_KT(TAO_SOLVER tao, void*solver)
 89: {
 90:   TAO_KT *kt = (TAO_KT *)solver;
 91:   TAO_SOLVER csolver=kt->csolver;
 92:   TaoTruth flg;
 93:   int info;

 95:   TaoFunctionBegin;
 96:   info = TaoOptionString("-tao_kt_method",
 97:                          "Set method for solving kt conditions",
 98:                          "TaoKTSetMethod",kt->comp_method,
 99:                          kt->comp_method,256,&flg);
100:   CHKERRQ(info);

102:   if (csolver==0){
103:       info = TaoCreateFull(kt->comp_method,"t",((PetscObject)tao)->comm, &kt->csolver); 
104:     CHKERRQ(info);
105:   }
106:   csolver=kt->csolver;
107:   if (csolver->setfromoptions) {
108:     info = (*csolver->setfromoptions)(csolver,csolver->data); CHKERRQ(info);
109:   }
110:   TaoFunctionReturn(0);
111: }

113: /*------------------------------------------------------------*/
116: static int TaoView_KT(TAO_SOLVER tao,void* solver)
117: {
118:   TAO_KT   *kt = (TAO_KT *)solver;
119:   int      info;

121:   TaoFunctionBegin;
122:   info = TaoPrintString(tao,"  kt method=%s\n", kt->comp_method); 
123:          CHKERRQ(info);
124:   TaoFunctionReturn(0);
125: }

130: int TaoCreate_KT(TAO_SOLVER tao)
131: {
132:   TAO_KT *kt;
133:   int    info;

135:   TaoFunctionBegin;

137:   info = TaoNew(TAO_KT,&kt); CHKERRQ(info);

139:   kt->csolver = 0;
140:   kt->setupcalled=0;
141:   info = TaoStrcpy(kt->comp_method, "tao_ssils"); CHKERRQ(info);

143:   info=TaoSetTaoSolveRoutine(tao,TaoSolve_KT,(void*)kt); CHKERRQ(info);
144:   info=TaoSetTaoSetUpDownRoutines(tao,TaoSetUp_KT,TaoSetDown_KT); CHKERRQ(info);
145:   info=TaoSetTaoOptionsRoutine(tao,TaoSetOptions_KT); CHKERRQ(info);
146:   info=TaoSetTaoViewRoutine(tao,TaoView_KT); CHKERRQ(info);

148:   info = TaoSetMaximumIterates(tao,2000); CHKERRQ(info);
149:   info = TaoSetMaximumFunctionEvaluations(tao,4000); CHKERRQ(info);

151:   info = TaoSetTolerances(tao,0,0,0,0); CHKERRQ(info);
152:   info = TaoSetGradientTolerances(tao,1.0e-12,0.0,0.0); CHKERRQ(info);

154:   TaoFunctionReturn(0);
155: }

160: TaoKTApplication::TaoKTApplication(TAO_SOLVER outertao, TAO_SOLVER innertao) 
161: {
162:   this->orig=outertao;
163:   this->csolver=innertao;
164:   return;
165: }

169: int TaoKTApplication::SetItUp1() 
170: {
171:   int info;
172:   TaoFunctionBegin;
173:   info = TaoSetConvergenceTest(this->csolver, TAO_NULL, TAO_NULL); CHKERRQ(info);
174:   info = TaoSetTolerances(this->csolver,0,0,0,0); CHKERRQ(info);
175:   info = TaoSetGradientTolerances(this->csolver,0.0,0.0,0.0); CHKERRQ(info);
176:   info = TaoSetMaximumIterates(this->csolver,0); CHKERRQ(info);
177:   info = TaoSetMaximumFunctionEvaluations(this->csolver,0); CHKERRQ(info);
178:   info = TaoSetFunctionLowerBound(this->csolver,0); CHKERRQ(info);
179:   info = TaoSetMonitor(this->csolver, TaoMonitor_KT, (void*)this); CHKERRQ(info);
180:   TaoFunctionReturn(0);
181: }

185: int TaoKTApplication::SetItUp2() 
186: {
187:   int info;
188:   TaoVec *x1,*x2;
189:   TaoFunctionBegin;
190:   info = TaoSetApplication(this->csolver,this); CHKERRQ(info);
191:   info = TaoGetVariableBounds(this->csolver,&x1,&x2); CHKERRQ(info);
192:   info = TaoSetVariableBounds(this->orig,x1,x2); CHKERRQ(info);
193:   info = TaoGetStepDirectionVector(this->csolver,&x1); CHKERRQ(info);
194:   info = TaoSetStepDirectionVector(this->orig,x1); CHKERRQ(info);
195:   TaoFunctionReturn(0);
196: }

200: int TaoKTApplication::EvaluateConstraints(TaoVec *x, TaoVec *f) 
201: {
202:   int info;
203:   TaoFunctionBegin;
204:   info = TaoComputeFunctionGradient(this->orig, x, &this->func, f); 
205:          CHKERRQ(info);
206:   info = TaoSetLagrangianGradientVector(this->orig,f); CHKERRQ(info);
207:   TaoFunctionReturn(0);
208: }

212: int TaoKTApplication::EvaluateJacobian(TaoVec *x, TaoMat *J) 
213: {
214:   int info;
215:   TaoFunctionBegin;
216:   info = TaoComputeHessian(this->orig, x, J); CHKERRQ(info);
217:   TaoFunctionReturn(0);
218: }

222: int TaoKTApplication::InitializeVariables(TaoVec *x) 
223: {
224:   int info;
225:   TaoApplication* theapp;
226:   TaoFunctionBegin;
227:   info = TaoGetApplication(this->orig, &theapp); CHKERRQ(info);
228:   info = theapp->InitializeVariables(x); CHKERRQ(info);
229:   TaoFunctionReturn(0);
230: }

234: int TaoKTApplication::GetVariableVector(TaoVec **x) 
235: {
236:   int info;
237:   TaoFunctionBegin;
238:   info = TaoGetSolution(this->orig, x); CHKERRQ(info);
239:   TaoFunctionReturn(0);
240: }

244: int TaoKTApplication::EvaluateVariableBounds(TaoVec *l, TaoVec *u) 
245: {
246:   int info;
247:   TaoFunctionBegin;
248:   info = TaoEvaluateVariableBounds(this->orig, l, u); CHKERRQ(info);
249:   TaoFunctionReturn(0);
250: }

254: int TaoKTApplication::GetJacobianMatrix(TaoMat **J) 
255: {
256:   int info;
257:   TaoFunctionBegin;
258:   info = TaoGetHessian(this->orig, J); CHKERRQ(info);
259:   TaoFunctionReturn(0);
260: }

264: int TaoKTApplication::GetLinearSolver(TaoMat *H, TaoInt stype, TaoLinearSolver **tksp) {
265:   int info;
266:   TaoFunctionBegin;
267:   info = TaoCreateLinearSolver(this->orig, H, stype,tksp); CHKERRQ(info);
268:   TaoFunctionReturn(0);
269: }