00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #ifndef __MITTELMANNBNDRYCNTRLDIRI_HPP__
00011 #define __MITTELMANNBNDRYCNTRLDIRI_HPP__
00012
00013 #include "RegisteredTNLP.hpp"
00014
00015 #ifdef HAVE_CMATH
00016 # include <cmath>
00017 #else
00018 # ifdef HAVE_MATH_H
00019 # include <math.h>
00020 # else
00021 # error "don't have header file for math"
00022 # endif
00023 #endif
00024
00025 #include <cstdio>
00026
00027 using namespace Ipopt;
00028
00038 class MittelmannBndryCntrlDiriBase : public RegisteredTNLP
00039 {
00040 public:
00042 MittelmannBndryCntrlDiriBase();
00043
00045 virtual ~MittelmannBndryCntrlDiriBase();
00046
00050 virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g,
00051 Index& nnz_h_lag, IndexStyleEnum& index_style);
00052
00054 virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u,
00055 Index m, Number* g_l, Number* g_u);
00056
00058 virtual bool get_starting_point(Index n, bool init_x, Number* x,
00059 bool init_z, Number* z_L, Number* z_U,
00060 Index m, bool init_lambda,
00061 Number* lambda);
00062
00064 virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value);
00065
00067 virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f);
00068
00070 virtual bool eval_g(Index n, const Number* x, bool new_x, Index m, Number* g);
00071
00076 virtual bool eval_jac_g(Index n, const Number* x, bool new_x,
00077 Index m, Index nele_jac, Index* iRow, Index *jCol,
00078 Number* values);
00079
00084 virtual bool eval_h(Index n, const Number* x, bool new_x,
00085 Number obj_factor, Index m, const Number* lambda,
00086 bool new_lambda, Index nele_hess, Index* iRow,
00087 Index* jCol, Number* values);
00088
00090
00092 virtual bool get_scaling_parameters(Number& obj_scaling,
00093 bool& use_x_scaling, Index n,
00094 Number* x_scaling,
00095 bool& use_g_scaling, Index m,
00096 Number* g_scaling);
00097
00102 virtual void finalize_solution(SolverReturn status,
00103 Index n, const Number* x, const Number* z_L, const Number* z_U,
00104 Index m, const Number* g, const Number* lambda,
00105 Number obj_valu,
00106 const IpoptData* ip_data,
00107 IpoptCalculatedQuantities* ip_cq);
00109
00110 protected:
00114 void SetBaseParameters(Index N, Number alpha, Number lb_y,
00115 Number ub_y, Number lb_u, Number ub_u,
00116 Number d_const);
00117
00121 virtual Number y_d_cont(Number x1, Number x2) const =0;
00123
00124 private:
00136 MittelmannBndryCntrlDiriBase(const MittelmannBndryCntrlDiriBase&);
00137 MittelmannBndryCntrlDiriBase& operator=(const MittelmannBndryCntrlDiriBase&);
00139
00143 Index N_;
00145 Number h_;
00147 Number hh_;
00149 Number lb_y_;
00151 Number ub_y_;
00153 Number lb_u_;
00155 Number ub_u_;
00157 Number d_const_;
00160 Number alpha_;
00162 Number* y_d_;
00164
00169 inline Index y_index(Index i, Index j) const
00170 {
00171 return j + (N_+2)*i;
00172 }
00175 inline Index pde_index(Index i, Index j) const
00176 {
00177 return (j-1) + N_*(i-1);
00178 }
00180 inline Number x1_grid(Index i) const
00181 {
00182 return h_*(Number)i;
00183 }
00185 inline Number x2_grid(Index i) const
00186 {
00187 return h_*(Number)i;
00188 }
00190 };
00191
00193 class MittelmannBndryCntrlDiri1 : public MittelmannBndryCntrlDiriBase
00194 {
00195 public:
00196 MittelmannBndryCntrlDiri1()
00197 {}
00198
00199 virtual ~MittelmannBndryCntrlDiri1()
00200 {}
00201
00202 virtual bool InitializeProblem(Index N)
00203 {
00204 if (N<1) {
00205 printf("N has to be at least 1.");
00206 return false;
00207 }
00208 Number alpha = 0.01;
00209 Number lb_y = -1e20;
00210 Number ub_y = 3.5;
00211 Number lb_u = 0.;
00212 Number ub_u = 10.;
00213 Number d_const = -20.;
00214 SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, d_const);
00215 return true;
00216 }
00217 protected:
00219 virtual Number y_d_cont(Number x1, Number x2) const
00220 {
00221 return 3. + 5.*(x1*(x1-1.)*x2*(x2-1.));
00222 }
00223 private:
00226 MittelmannBndryCntrlDiri1(const MittelmannBndryCntrlDiri1&);
00227 MittelmannBndryCntrlDiri1& operator=(const MittelmannBndryCntrlDiri1&);
00229 };
00230
00232 class MittelmannBndryCntrlDiri2 : public MittelmannBndryCntrlDiriBase
00233 {
00234 public:
00235 MittelmannBndryCntrlDiri2()
00236 {}
00237
00238 virtual ~MittelmannBndryCntrlDiri2()
00239 {}
00240
00241 virtual bool InitializeProblem(Index N)
00242 {
00243 if (N<1) {
00244 printf("N has to be at least 1.");
00245 return false;
00246 }
00247 Number alpha = 0.;
00248 Number lb_y = -1e20;
00249 Number ub_y = 3.5;
00250 Number lb_u = 0.;
00251 Number ub_u = 10.;
00252 Number d_const = -20.;
00253 SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, d_const);
00254 return true;
00255 }
00256 protected:
00258 virtual Number y_d_cont(Number x1, Number x2) const
00259 {
00260 return 3. + 5.*(x1*(x1-1.)*x2*(x2-1.));
00261 }
00262 private:
00265 MittelmannBndryCntrlDiri2(const MittelmannBndryCntrlDiri2&);
00266 MittelmannBndryCntrlDiri2& operator=(const MittelmannBndryCntrlDiri2&);
00268 };
00269
00271 class MittelmannBndryCntrlDiri3 : public MittelmannBndryCntrlDiriBase
00272 {
00273 public:
00274 MittelmannBndryCntrlDiri3()
00275 {}
00276
00277 virtual ~MittelmannBndryCntrlDiri3()
00278 {}
00279
00280 virtual bool InitializeProblem(Index N)
00281 {
00282 if (N<1) {
00283 printf("N has to be at least 1.");
00284 return false;
00285 }
00286 Number alpha = 0.01;
00287 Number lb_y = -1e20;
00288 Number ub_y = 3.2;
00289 Number lb_u = 1.6;
00290 Number ub_u = 2.3;
00291 Number d_const = -20.;
00292 SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, d_const);
00293 return true;
00294 }
00295 protected:
00297 virtual Number y_d_cont(Number x1, Number x2) const
00298 {
00299 return 3. + 5.*(x1*(x1-1.)*x2*(x2-1.));
00300 }
00301 private:
00304 MittelmannBndryCntrlDiri3(const MittelmannBndryCntrlDiri3&);
00305 MittelmannBndryCntrlDiri3& operator=(const MittelmannBndryCntrlDiri3&);
00307 };
00308
00310 class MittelmannBndryCntrlDiri4 : public MittelmannBndryCntrlDiriBase
00311 {
00312 public:
00313 MittelmannBndryCntrlDiri4()
00314 {}
00315
00316 virtual ~MittelmannBndryCntrlDiri4()
00317 {}
00318
00319 virtual bool InitializeProblem(Index N)
00320 {
00321 if (N<1) {
00322 printf("N has to be at least 1.");
00323 return false;
00324 }
00325 Number alpha = 0.;
00326 Number lb_y = -1e20;
00327 Number ub_y = 3.2;
00328 Number lb_u = 1.6;
00329 Number ub_u = 2.3;
00330 Number d_const = -20.;
00331 SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, d_const);
00332 return true;
00333 }
00334 protected:
00336 virtual Number y_d_cont(Number x1, Number x2) const
00337 {
00338 return 3. + 5.*(x1*(x1-1.)*x2*(x2-1.));
00339 }
00340 private:
00343 MittelmannBndryCntrlDiri4(const MittelmannBndryCntrlDiri4&);
00344 MittelmannBndryCntrlDiri4& operator=(const MittelmannBndryCntrlDiri4&);
00346 };
00347
00348 #endif