BonFilterSolver.hpp

Go to the documentation of this file.

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

#ifndef FilterSolver_H
#define FilterSolver_H

#include "BonTNLPSolver.hpp"
#include "BonFilterTypes.hpp"
#include "BonBqpdSolver.hpp"
#include "BonFilterWarmStart.hpp"

namespace Bonmin
{
  class FilterSolver : public TNLPSolver
  {
  public:

    friend struct BqpdSolver::cachedInfo;

  class UnsolvedFilterError: public TNLPSolver::UnsolvedError
    {
    public:
      UnsolvedFilterError(int errorNum,
          Ipopt::SmartPtr<TMINLP2TNLP> model,
          const std::string &name):
          TNLPSolver::UnsolvedError(errorNum, model, name)
      {}
      virtual const std::string& errorName() const;

      virtual const std::string& solverName() const;
      virtual ~UnsolvedFilterError()
      {}

    private:
      static std::string errorNames_[1];
      static std::string solverName_;
    };

    typedef FilterTypes::fint fint;
    typedef FilterTypes::real real;


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


    FilterSolver(bool createEmpty = false);


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

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

    FilterSolver(const FilterSolver & other);
    virtual ~FilterSolver();

    virtual bool Initialize(std::string params_file);

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


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

    virtual 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{
     if(warmF_.IsValid())
       return new FilterWarmStart(*warmF_);
     else return NULL;
   }


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

    virtual CoinWarmStart * getEmptyWarmStart() const;

    virtual bool warmStartIsValid(const CoinWarmStart * ws) const;


    virtual void enableWarmStart()
    {//No options to be set
    }
    virtual void disableWarmStart()
    {
      warmF_ = NULL;
     //No options to be set
    }

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

    virtual double CPUTime()
    {
      return (cached_.IsValid()) ? cached_->cpuTime_: 0.;
    }

    virtual int IterationCount()
    {
      return (cached_.IsValid()) ? cached_->istat[1]:0;
    }

    virtual void setOutputToDefault()
    {
      if (cached_.IsValid()) cached_->iprint = default_log_level_;
    }
    virtual void forceSolverOutput(int log_level)
    {
      if (cached_.IsValid()) cached_->iprint = log_level;
    }

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

    void registerOptions()
    {
      registerOptions(roptions_);
    }

    virtual int errorCode() const
    {
      return -1;
    }
    static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
  private:
    TNLPSolver::ReturnStatus callOptimizer();
    Coin::SmartPtr<FilterWarmStart> warmF_;

  struct cachedInfo : public Coin::ReferencedObject
    {
      fint n;
      fint m;
      fint nnz_h_;
      fint kmax;
      fint maxa;
      fint maxf;
      fint mlp;
      fint maxWk;
      fint maxiWk;
      fint iprint;
      fint nout;
      fint ifail;
      real rho;
      real * x;
      real * c;
      real f;
      real fmin;
      real * bounds;
      real * s;
      real * a;
      fint * la;
      real * ws;
      fint * lws;
      real * lam;
      char * cstype;
      fint maxiter;
      fint * istat;
      real * rstat;
      Ipopt::TNLP * tnlp_;
      fint * hStruct_;
      int * permutationJac_;
      int * permutationHess_;
      double cpuTime_;
      bool use_warm_start_in_cache_;


      cachedInfo():
          n(-1),
          m(-1),
          nnz_h_(-1),
          kmax(-1),
          maxa(-1),
          maxf(-1),
          mlp(-1),
          maxWk(-1),
          maxiWk(-1),
          iprint(-1),
          nout(6),
          ifail(-100),
          rho(0),
          x(NULL),
          c(NULL),
          f(1e100),
          fmin(-1e100),
          bounds(NULL),
          s(NULL),
          a(NULL),
          la(NULL),
          ws(NULL),
          lws(NULL),
          lam(NULL),
          cstype(NULL),
          maxiter(1000),
          istat(NULL),
          rstat(NULL),
          tnlp_(NULL),
          hStruct_(NULL),
          permutationJac_(NULL),
          permutationHess_(NULL),
          cpuTime_(0),
          use_warm_start_in_cache_(false)
      {}

      cachedInfo(const Ipopt::SmartPtr<Ipopt::TNLP> &tnlp,
          Ipopt::SmartPtr<Ipopt::OptionsList>& options):
          n(-1),
          m(-1),
          nnz_h_(-1),
          kmax(-1),
          maxa(-1),
          maxf(-1),
          mlp(-1),
          maxWk(-1),
          maxiWk(-1),
          iprint(-1),
          nout(6),
          ifail(0),
          rho(0),
          x(NULL),
          c(NULL),
          f(1e100),
          fmin(-1e100),
          bounds(NULL),
          s(NULL),
          a(NULL),
          la(NULL),
          ws(NULL),
          lws(NULL),
          lam(NULL),
          cstype(NULL),
          maxiter(1000),
          istat(NULL),
          rstat(NULL),
          tnlp_(NULL),
          hStruct_(NULL),
          permutationJac_(NULL),
          permutationHess_(NULL),
          cpuTime_(0),
          use_warm_start_in_cache_(false)
      {
        initialize(tnlp, options);
      }

      void initialize(const Ipopt::SmartPtr<Ipopt::TNLP> &tnlp,
          Ipopt::SmartPtr<Ipopt::OptionsList>& options);

      void optimize();

      ~cachedInfo()
      {
        delete [] x;
        delete [] c;
        delete [] bounds;
        delete [] s;
        delete [] a;
        delete [] la;
        delete [] ws;
        delete [] lws;
        delete [] lam;
        delete [] cstype;
        delete [] istat;
        delete [] rstat;
        delete [] permutationJac_;
        delete [] permutationHess_;
        delete [] hStruct_;
        tnlp_ = NULL;
      }

      void load_ws(Coin::SmartPtr<FilterWarmStart>);
    };

    Coin::SmartPtr<cachedInfo> cached_;

    //name of solver (Filter)
    static std::string  solverName_;

     int default_log_level_;
    static void TMat2RowPMat(bool symmetric, fint n, fint m, int nnz, const Ipopt::Index* iRow,
        const Ipopt::Index* iCol, int * permutation2,
        fint * lws, int nnz_offset, int n_offset,
        Ipopt::TNLP::IndexStyleEnum index_style);
  };

}// end namespace Bonmin
#endif