/home/coin/SVN-release/Ipopt-3.9.1/Ipopt/examples/ScalableProblems/MittelmannBndryCntrlDiri3D_27.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_27.hpp 1707 2010-07-03 18:25:51Z stefan $
00006 //
00007 // Authors:  Olaf Schenk   (Univ. of Basel)      2007-08-01
00008 //              modified MittelmannBndryCntrlDiri.hpp for 3-dim problem
00009 //                  based on MyNLP.hpp
00010 
00011 #ifndef __MITTELMANNBNDRYCNTRLDIRI3D_27_HPP__
00012 #define __MITTELMANNBNDRYCNTRLDIRI3D_27_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_27 : public RegisteredTNLP
00040 {
00041 public:
00043   MittelmannBndryCntrlDiriBase3D_27();
00044 
00046   virtual ~MittelmannBndryCntrlDiriBase3D_27();
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_27(const MittelmannBndryCntrlDiriBase3D_27&);
00138   MittelmannBndryCntrlDiriBase3D_27& operator=(const MittelmannBndryCntrlDiriBase3D_27&);
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     if (B_ == 0.) {
00201       return 0.5*t*t;
00202     }
00203     else if (t > B_) {
00204       return B_*B_/2. + C_*(t - B_);
00205     }
00206     else if (t < -B_) {
00207       return B_*B_/2. + C_*(-t - B_);
00208     }
00209     else {
00210       const Number t2 = t*t;
00211       const Number t4 = t2*t2;
00212       const Number t6 = t4*t2;
00213       return PenA_*t2 + PenB_*t4 + PenC_*t6;
00214     }
00215   }
00217   inline Number PenObj_1(Number t) const
00218   {
00219     if (B_ == 0.) {
00220       return t;
00221     }
00222     else if (t > B_) {
00223       return C_;
00224     }
00225     else if (t < -B_) {
00226       return -C_;
00227     }
00228     else {
00229       const Number t2 = t*t;
00230       const Number t3 = t*t2;
00231       const Number t5 = t3*t2;
00232       return 2.*PenA_*t + 4.*PenB_*t3 + 6.*PenC_*t5;
00233     }
00234   }
00236   inline Number PenObj_2(Number t) const
00237   {
00238     if (B_ == 0.) {
00239       return 1.;
00240     }
00241     else if (t > B_) {
00242       return 0.;
00243     }
00244     else if (t < -B_) {
00245       return 0.;
00246     }
00247     else {
00248       const Number t2 = t*t;
00249       const Number t4 = t2*t2;
00250       return 2.*PenA_ + 12.*PenB_*t2 + 30.*PenC_*t4;
00251     }
00252   }
00254 
00257   Number B_;
00258   Number C_;
00259   Number PenA_;
00260   Number PenB_;
00261   Number PenC_;
00263 };
00264 
00266 class MittelmannBndryCntrlDiri3D_27 : public MittelmannBndryCntrlDiriBase3D_27
00267 {
00268 public:
00269   MittelmannBndryCntrlDiri3D_27()
00270   {}
00271 
00272   virtual ~MittelmannBndryCntrlDiri3D_27()
00273   {}
00274 
00275   virtual bool InitializeProblem(Index N)
00276   {
00277     if (N<1) {
00278       printf("N has to be at least 1.");
00279       return false;
00280     }
00281     Number alpha = 1e-2;
00282     Number lb_y = -1e20;
00283     Number ub_y = 3.5;
00284     Number lb_u = 0.;
00285     Number ub_u = 10.;
00286     Number d_const = -20.;
00287     Number B = 0.; // convex case (quadratic penalty)
00288     Number C = 0.;
00289     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, d_const, B, C);
00290     return true;
00291   }
00292 protected:
00294   virtual Number y_d_cont(Number x1, Number x2, Number x3)  const
00295   {
00296     return 3. + 5.*(x1*(x1-1.)*x2*(x2-1.));
00297   }
00298 private:
00301   MittelmannBndryCntrlDiri3D_27(const MittelmannBndryCntrlDiri3D_27&);
00302   MittelmannBndryCntrlDiri3D_27& operator=(const MittelmannBndryCntrlDiri3D_27&);
00304 
00305 };
00306 
00309 class MittelmannBndryCntrlDiri3D_27BT : public MittelmannBndryCntrlDiriBase3D_27
00310 {
00311 public:
00312   MittelmannBndryCntrlDiri3D_27BT()
00313   {}
00314 
00315   virtual ~MittelmannBndryCntrlDiri3D_27BT()
00316   {}
00317 
00318   virtual bool InitializeProblem(Index N)
00319   {
00320     if (N<1) {
00321       printf("N has to be at least 1.");
00322       return false;
00323     }
00324     Number alpha = 1e-2;
00325     Number lb_y = -1e20;
00326     Number ub_y = 3.5;
00327     Number lb_u = 0.;
00328     Number ub_u = 10.;
00329     Number d_const = -20.;
00330     Number B = .25; // nonconves case with beaton-tukey-type penalty function
00331     Number C = 0.01;
00332     SetBaseParameters(N, alpha, lb_y, ub_y, lb_u, ub_u, d_const, B, C);
00333     return true;
00334   }
00335 protected:
00337   virtual Number y_d_cont(Number x1, Number x2, Number x3)  const
00338   {
00339     return 3. + 5.*(x1*(x1-1.)*x2*(x2-1.));
00340   }
00341 private:
00344   MittelmannBndryCntrlDiri3D_27BT(const MittelmannBndryCntrlDiri3D_27BT&);
00345   MittelmannBndryCntrlDiri3D_27BT& operator=(const MittelmannBndryCntrlDiri3D_27BT&);
00347 
00348 };
00349 
00350 #endif

Generated on Sun Nov 28 03:01:53 2010 by  doxygen 1.4.7