/home/coin/SVN-release/CoinAll-1.1.0/OS/src/OSSolverInterfaces/OSIpoptSolver.h

Go to the documentation of this file.

#ifndef IPOPTSOLVER_H 
#define IPOPTSOLVER_H

#include "OSConfig.h" 
#include "OSDefaultSolver.h"
#include "OSrLWriter.h"
#include "OSInstance.h"
#include "OSParameters.h"
#include "OSnLNode.h"
#include "OSiLReader.h"
#include "OSInstance.h"
#include "OSExpressionTree.h"
#include "OSnLNode.h"
#include "OSDataStructures.h"
#include "OSFileUtil.h"  
#include "OSErrorClass.h"

#include "OSResult.h"
#include "OSInstance.h"

# include <cstddef>
# include <cstdlib>
# include <cctype>
# include <cassert>
# include <stack>
#include <string>
# include <cppad/cppad.hpp>
#include<iostream>

#ifdef HAVE_CTIME
# include <ctime>
#else
# ifdef HAVE_TIME_H
#  include <time.h>
# else
#  error "don't have header file for time"
# endif
#endif 

 
#ifdef HAVE_CMATH
# include <cmath>
#else
# ifdef HAVE_MATH_H
#  include <math.h>
# else
#  error "don't have header file for math"
# endif
#endif
#include<vector>
#include <map>  


#include "IpTNLP.hpp"
#include "IpIpoptApplication.hpp"

using namespace Ipopt;



// for Stefan
class IpoptProblem : public TNLP{  
public:
        
        IpoptProblem(OSInstance *osinstance_ , OSResult *osresult_);
        
        virtual ~IpoptProblem();
        
        OSResult *osresult;
        
        OSInstance *osinstance;
        

        
        virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g,
                            Index& nnz_h_lag, IndexStyleEnum& index_style);

        virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u,
                                                                Index m, Number* g_l, Number* g_u);

        virtual bool get_starting_point(Index n, bool init_x, Number* x,
                                                                        bool init_z, Number* z_L, Number* z_U,
                                                                        Index m, bool init_lambda,
                                                                        Number* lambda);

        virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value);

        virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f);

        virtual bool eval_g(Index n, const Number* x, bool new_x, Index m, Number* g);

        virtual bool eval_jac_g(Index n, const Number* x, bool new_x,
                                                        Index m, Index nele_jac, Index* iRow, Index *jCol,
                                                        Number* values);

        virtual bool eval_h(Index n, const Number* x, bool new_x,
                                                Number obj_factor, Index m, const Number* lambda,
                                                bool new_lambda, Index nele_hess, Index* iRow,
                                                Index* jCol, Number* values);

        
        
        virtual bool get_scaling_parameters(Number& obj_scaling,
                                    bool& use_x_scaling, Index n,
                                    Number* x_scaling,
                                    bool& use_g_scaling, Index m,
                                    Number* g_scaling);

        virtual void finalize_solution(SolverReturn status,
                                                                        Index n, const Number* x, const Number* z_L, const Number* z_U,
                                                                        Index m, const Number* g, const Number* lambda,
                                                                        Number obj_value,
                                   const IpoptData* ip_data,
                                   IpoptCalculatedQuantities* ip_cq);


        
private:
  //  HS071_NLP();
        IpoptProblem(const IpoptProblem&);
        IpoptProblem& operator=(const IpoptProblem&);
        
        std::string ipoptErrorMsg;
        
};


//class IpoptSolver : public DefaultSolver, public TNLP{  

class IpoptSolver : public DefaultSolver{       
public:
        


        IpoptSolver();
        
        ~IpoptSolver();
        
        SmartPtr<TNLP> nlp;
        
        SmartPtr<IpoptApplication> app;
        
        
        virtual void  solve() throw (ErrorClass) ;
        
        virtual void  buildSolverInstance() throw(ErrorClass);
        
        void dataEchoCheck();
        
        OSiLReader *m_osilreader;


private:
        OSrLWriter  *osrlwriter;

        //  IpoptSolver();
        //IpoptSolver(const IpoptSolver&);
        //IpoptSolver& operator=(const IpoptSolver&);
        //std::string ipoptErrorMsg;
        std::string ipoptErrorMsg;
};


#endif /*IPOPTSOLVER_H*/

---