/home/coin/SVN-release/Ipopt-3.9.0/Ipopt/examples/ScalableProblems/MittelmannBndryCntrlDiri3D.hpp

Go to the documentation of this file.
00001 // Copyright (C) 2005, 2007 International Business Machines and others.
00002 // All Rights Reserved.
00003 // This code is published under the Common Public License.
00004 //
00005 // $Id: MittelmannBndryCntrlDiri3D.hpp 1707 2010-07-03 18:25:51Z stefan $
00006 //
00007 // Authors:  Andreas Waechter             IBM    2005-10-18
00008 //           Olaf Schenk   (Univ. of Basel)      2007-08-01
00009 //              modified MittelmannBndryCntrlDiri.hpp for 3-dim problem
00010 
00011 #ifndef __MITTELMANNBNDRYCNTRLDIRI3D_HPP__
00012 #define __MITTELMANNBNDRYCNTRLDIRI3D_HPP__
00013 
00014 #include "RegisteredTNLP.hpp"
00015 
00016 #ifdef HAVE_CMATH
00017 # include <cmath>
00018 #else
00019 # ifdef HAVE_MATH_H
00020 #  include <math.h>
00021 # else
00022 #  error "don't have header file for math"
00023 # endif
00024 #endif
00025 
00026 #include <cstdio>
00027 
00028 using namespace Ipopt;
00029 
00039 class MittelmannBndryCntrlDiriBase3D : public RegisteredTNLP
00040 {
00041 public:
00043   MittelmannBndryCntrlDiriBase3D();
00044 
00046   virtual ~MittelmannBndryCntrlDiriBase3D();
00047 
00051   virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g,
00052                             Index& nnz_h_lag, IndexStyleEnum& index_style);
00053 
00055   virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u,
00056                                Index m, Number* g_l, Number* g_u);
00057 
00059   virtual bool get_starting_point(Index n, bool init_x, Number* x,
00060                                   bool init_z, Number* z_L, Number* z_U,
00061                                   Index m, bool init_lambda,
00062                                   Number* lambda);
00063 
00065   virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value);
00066 
00068   virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f);
00069 
00071   virtual bool eval_g(Index n, const Number* x, bool new_x, Index m, Number* g);
00072 
00077   virtual bool eval_jac_g(Index n, const Number* x, bool new_x,
00078                           Index m, Index nele_jac, Index* iRow, Index *jCol,
00079                           Number* values);
00080 
00085   virtual bool eval_h(Index n, const Number* x, bool new_x,
00086                       Number obj_factor, Index m, const Number* lambda,
00087                       bool new_lambda, Index nele_hess, Index* iRow,
00088                       Index* jCol, Number* values);
00089 
00091 
00093   virtual bool get_scaling_parameters(Number& obj_scaling,
00094                                       bool& use_x_scaling, Index n,
00095                                       Number* x_scaling,
00096                                       bool& use_g_scaling, Index m,
00097                                       Number* g_scaling);
00098 
00103   virtual void finalize_solution(SolverReturn status,
00104                                  Index n, const Number* x, const Number* z_L, const Number* z_U,
00105                                  Index m, const Number* g, const Number* lambda,
00106                                  Number obj_valu,
00107                                  const IpoptData* ip_data,
00108                                  IpoptCalculatedQuantities* ip_cq);
00110 
00111 protected:
00115   void SetBaseParameters(Index N, Number alpha, Number lb_y,
00116                          Number ub_y, Number lb_u, Number ub_u,
00117                          Number d_const, Number B, Number C);
00118 
00122   virtual Number y_d_cont(Number x1, Number x2, Number x3) const =0;
00124 
00125 private:
00137   MittelmannBndryCntrlDiriBase3D(const MittelmannBndryCntrlDiriBase3D&);
00138   MittelmannBndryCntrlDiriBase3D& operator=(const MittelmannBndryCntrlDiriBase3D&);
00140 
00144   Index N_;
00146   Number h_;
00148   Number hh_;
00150   Number hhh_;
00152   Number lb_y_;
00154   Number ub_y_;
00156   Number lb_u_;
00158   Number ub_u_;
00160   Number d_const_;
00163   Number alpha_;
00165   Number* y_d_;
00167 
00172   inline Index y_index(Index i, Index j, Index k) const
00173   {
00174     return k + (N_+2)*j + (N_+2)*(N_+2)*i;
00175   }
00178   inline Index pde_index(Index i, Index j, Index k) const
00179   {
00180     return (k-1) + N_*(j-1) + N_*N_*(i-1);
00181   }
00183   inline Number x1_grid(Index i) const
00184   {
00185     return h_*(Number)i;
00186   }
00188   inline Number x2_grid(Index i) const
00189   {
00190     return h_*(Number)i;
00191   }
00193   inline Number x3_grid(Index i) const
00194   {
00195     return h_*(Number)i;
00196   }
00198   inline Number PenObj(Number t) const
00199   {
00200     //return 0.5*t*t;
00201     if (t > B_) {
00202       return B_*B_/2. + C_*(t - B_);
00203     }
00204     else if (t < -B_) {
00205       return B_*B_/2. + C_*(-t - B_);
00206     }
00207     else {
00208       const Number t2 = t*t;
00209       const Number t4 = t2*t2;
00210       const Number t6 = t4*t2;
00211       return PenA_*t2 + PenB_*t4 + PenC_*t6;
00212     }
00213   }
00215   inline Number PenObj_1(Number t) const
00216   {
00217     //return t;
00218     if (t > B_) {
00219       return C_;
00220     }
00221     else if (t < -B_) {
00222       return -C_;
00223     }
00224     else {
00225       const Number t2 = t*t;
00226       const Number t3 = t*t2;
00227       const Number t5 = t3*t2;
00228       return 2.*PenA_*t + 4.*PenB_*t3 + 6.*PenC_*t5;
00229     }
00230   }
00232   inline Number PenObj_2(Number t) const
00233   {
00234     //return 1.;
00235     if (t > B_) {
00236       return 0.;
00237     }
00238     else if (t < -B_) {
00239       return 0.;
00240     }
00241     else {
00242       const Number t2 = t*t;
00243       const Number t4 = t2*t2;
00244       return 2.*PenA_ + 12.*PenB_*t2 + 30.*PenC_*t4;
00245     }
00246   }
00248 
00251   Number B_;
00252   Number C_;
00253   Number PenA_;
00254   Number PenB_;
00255   Number PenC_;
00257 };
00258 
00260 class MittelmannBndryCntrlDiri3D : public MittelmannBndryCntrlDiriBase3D
00261 {
00262 public:
00263   MittelmannBndryCntrlDiri3D()
00264   {}
00265 
00266   virtual ~MittelmannBndryCntrlDiri3D()
00267   {}
00268 
00269   virtual bool InitializeProblem(Index N)
00270   {
00271     if (N<1) {
00272       printf("N has to be at least 1.");
00273       return false;
00274     }
00275     Number alpha = 0.01;
00276     Number lb_y = -1e20;
00277     Number ub_y = 3.5;
00278     Number lb_u = 0.;
00279     Number ub_u = 10.;
00280     Number d_const = -20.;
00281     Number B = .5;
00282     Number C = 0.01;
00283     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, d_const, B, C);
00284     return true;
00285   }
00286 protected:
00288   virtual Number y_d_cont(Number x1, Number x2, Number x3)  const
00289   {
00290     return 3. + 5.*(x1*(x1-1.)*x2*(x2-1.));
00291   }
00292 private:
00295   MittelmannBndryCntrlDiri3D(const MittelmannBndryCntrlDiri3D&);
00296   MittelmannBndryCntrlDiri3D& operator=(const MittelmannBndryCntrlDiri3D&);
00298 
00299 };
00300 
00301 
00302 #endif

Generated on Sat Nov 6 03:10:31 2010 by  doxygen 1.4.7