BonIpoptSolver.hpp

Go to the documentation of this file.

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

#ifndef IpoptSolver_HPP
#define IpoptSolver_HPP
#include "BonTNLPSolver.hpp"
#include "IpIpoptApplication.hpp"


namespace Bonmin
{
  class IpoptSolver: public TNLPSolver
  {
  public:
  class UnsolvedIpoptError: public TNLPSolver::UnsolvedError
    {
    public:
      UnsolvedIpoptError(int errorNum,
          Ipopt::SmartPtr<TMINLP2TNLP> problem,
          std::string name):
          TNLPSolver::UnsolvedError(errorNum, problem, name)
      {}
      virtual const std::string& errorName() const;

      virtual const std::string& solverName() const;
      virtual ~UnsolvedIpoptError()
      {}
    private:
      static std::string errorNames [17];
      static std::string solverName_;
    };

    virtual UnsolvedError * newUnsolvedError(int num,
        Ipopt::SmartPtr<TMINLP2TNLP> problem,
        std::string name)
    {
      return new UnsolvedIpoptError(num, problem, name);
    }



    IpoptSolver(bool createEmpty = false);

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

    IpoptSolver(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
        Ipopt::SmartPtr<Ipopt::OptionsList> options,
        Ipopt::SmartPtr<Ipopt::Journalist> journalist);

    IpoptSolver(const IpoptSolver &other);

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

    virtual ~IpoptSolver();

    virtual bool Initialize(std::string params_file);

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

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

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

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

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


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

    virtual CoinWarmStart * getEmptyWarmStart() const;

    virtual bool warmStartIsValid(const CoinWarmStart * ws) const;

    virtual void enableWarmStart();

    virtual void disableWarmStart();


    virtual double CPUTime();

    virtual int IterationCount();

    virtual void setOutputToDefault();
    virtual void forceSolverOutput(int log_level);

    virtual std::string & solverName()
    {
      return solverName_;
    }

    static void RegisterOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions)
    {
      Ipopt::IpoptApplication::RegisterAllIpoptOptions(GetRawPtr(roptions));
    }



    Ipopt::ApplicationReturnStatus getOptStatus() const
    {
      return optimizationStatus_;
    }

    Ipopt::IpoptApplication& getIpoptApp()
    {
      return *app_;
    }

    virtual int errorCode() const
    {
      return (int) optimizationStatus_;
    }
  private:
    void setMinlpDefaults(Ipopt::SmartPtr< Ipopt::OptionsList> Options);

    TNLPSolver::ReturnStatus solverReturnStatus(Ipopt::ApplicationReturnStatus optimization_status) const;

    Ipopt::SmartPtr<Ipopt::IpoptApplication> app_;
    Ipopt::ApplicationReturnStatus optimizationStatus_;


    bool problemHadZeroDimension_;

    int warmStartStrategy_;

    bool enable_warm_start_;

    bool optimized_before_;
    //name of solver (Ipopt)
    static std::string  solverName_;
  };
}
#endif