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: }