BonTNLPSolver.hpp

Go to the documentation of this file.

// (C) Copyright International Business Machines (IBM) 2006, 2007
// All Rights Reserved.
// This code is published under the Common Public License.
//
// Authors :
// Pierre Bonami, IBM
//
// Date : 26/09/2006


#ifndef TNLPSolver_H
#define TNLPSolver_H
#include "IpTNLP.hpp"
#include "BonTMINLP2TNLP.hpp"

//Some declarations
#include "IpOptionsList.hpp"
#include "CoinWarmStart.hpp"
#include "BonRegisteredOptions.hpp"
#include "CoinTime.hpp"
namespace Bonmin  {
class TNLPSolver: public Ipopt::ReferencedObject{
 public:

  enum ReturnStatus {
    iterationLimit = -3,
    timeLimit = 5,
    doesNotConverge = -8,
    computationError = -2,
    notEnoughFreedom = -1,
    illDefinedProblem = -4,
    illegalOption =-5,
    externalException =-6,
    exception =-7,
    solvedOptimal = 1,
    solvedOptimalTol =2,
    provenInfeasible =3,
    unbounded = 4,
    numReturnCodes
  };



//#############################################################################

  class UnsolvedError
  {
  public:
    UnsolvedError(int errorNum = -10000, 
                  Ipopt::SmartPtr<TMINLP2TNLP> model = NULL,
                  std::string name="")
    :
     errorNum_(errorNum),
     model_(model),
     name_(name)
    {if(name_=="") 
{
#ifndef NDEBUG
        std::cerr<<"FIXME"<<std::endl;
#endif
}}
    void printError(std::ostream & os);
    virtual const std::string& errorName() const = 0;
    virtual const std::string& solverName() const = 0;
    int errorNum() const{
    return errorNum_;}
    virtual ~UnsolvedError(){}
    void writeDiffFiles(const std::string prefix=std::string()) const;
  private:
    int errorNum_;

    Ipopt::SmartPtr< TMINLP2TNLP > model_;

    std::string name_;
  }
  ;

  virtual UnsolvedError * newUnsolvedError(int num,
                                           Ipopt::SmartPtr<TMINLP2TNLP> problem,
                                           std::string name) = 0;
 


   TNLPSolver();

TNLPSolver(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
           Ipopt::SmartPtr<Ipopt::OptionsList> options,
           Ipopt::SmartPtr<Ipopt::Journalist> journalist,
           const std::string & prefix);

  virtual Ipopt::SmartPtr<TNLPSolver> clone() = 0;

   virtual ~TNLPSolver();

   virtual bool Initialize(std::string params_file) = 0;

   virtual bool Initialize(std::istream& is) = 0;


   virtual ReturnStatus OptimizeTNLP(const Ipopt::SmartPtr<Ipopt::TNLP> & tnlp) = 0;

   virtual ReturnStatus ReOptimizeTNLP(const Ipopt::SmartPtr<Ipopt::TNLP> & tnlp) = 0;

  virtual bool setWarmStart(const CoinWarmStart * warm, 
                            Ipopt::SmartPtr<TMINLP2TNLP> tnlp) = 0;

  virtual CoinWarmStart * getUsedWarmStart(Ipopt::SmartPtr<TMINLP2TNLP> tnlp) const = 0;

  virtual CoinWarmStart * getWarmStart(Ipopt::SmartPtr<TMINLP2TNLP> tnlp) const = 0;

  virtual CoinWarmStart * getEmptyWarmStart() const = 0;

  virtual bool warmStartIsValid(const CoinWarmStart * ws) const = 0;  

  virtual void enableWarmStart() = 0;

  virtual void disableWarmStart() = 0;

  Ipopt::SmartPtr<Ipopt::Journalist> journalist(){
    return journalist_;}

   Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions(){
     return roptions_;}

   Ipopt::SmartPtr<const Ipopt::OptionsList> options() const {
     return ConstPtr(options_);}

   Ipopt::SmartPtr<Ipopt::OptionsList> options() {
     return options_;}

  const char * prefix(){
    return prefix_.c_str();
  }
static void RegisterOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions){}

   virtual double CPUTime() = 0;

   virtual int IterationCount() = 0;


  virtual void setOutputToDefault() = 0 ;
  virtual void forceSolverOutput(int log_level) = 0;
  virtual std::string & solverName() = 0;

  bool isRecoverable(ReturnStatus &r);

  void setup_global_time_limit(double time_limit){
    time_limit_ = time_limit + 5;
    start_time_ = CoinCpuTime();
  }

  bool isError(ReturnStatus &r){
    return r < 0;}
virtual int errorCode() const = 0;
protected:
   bool zeroDimension(const Ipopt::SmartPtr<Ipopt::TNLP> &tnlp, 
                     ReturnStatus &optimization_status);

   void initializeOptionsAndJournalist();

    Ipopt::SmartPtr<Ipopt::Journalist> journalist_;
    
    Ipopt::SmartPtr<Ipopt::OptionsList> options_;
    
    Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions_;
   
   std::string prefix_;
   double start_time_;

   double time_limit_;

   int default_log_level_;
  TNLPSolver(const TNLPSolver & other);

};
}
#endif