BonBabSetupBase.hpp

Go to the documentation of this file.

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

#ifndef BabSetupBase_H
#define BabSetupBase_H

#include <string>
#include <list>
#include "CglCutGenerator.hpp"
#include "CbcHeuristic.hpp"
#include "OsiChooseVariable.hpp"
#include "BonOsiTMINLPInterface.hpp"
#include "IpSmartPtr.hpp"
#include "BonTMINLP2OsiLP.hpp"

namespace Bonmin
{
  class BabSetupBase
  {
  public:
    struct CuttingMethod 
    {
      int frequency;
      std::string id;
      CglCutGenerator * cgl;
      bool atSolution;
      bool normal;
      bool always;
      CuttingMethod():
          atSolution(false),
          normal(true),
          always(false)
      {}

      CuttingMethod(const CuttingMethod & other):
          frequency(other.frequency),
          id(other.id),
          cgl(other.cgl),
          atSolution(other.atSolution),
          normal(other.normal),
          always(other.always)
      {}
    };
    struct HeuristicMethod
    {
      std::string id;
      CbcHeuristic* heuristic;
      HeuristicMethod()
      {}

      HeuristicMethod(const HeuristicMethod & other):
          id(other.id),
          heuristic(other.heuristic)
      {}
    };
    typedef std::list<CuttingMethod> CuttingMethods;
    typedef std::list<HeuristicMethod  > HeuristicMethods;

    enum NodeComparison {
      bestBound = 0 ,
      DFS ,
      BFS ,
      dynamic ,
      bestGuess 
    };

    enum TreeTraversal {
      HeapOnly=0 ,
      DiveFromBest ,
      ProbedDive ,
      DfsDiveFromBest ,
      DfsDiveDynamic 
    };


    enum VarSelectStra_Enum {
      MOST_FRACTIONAL=0,
      STRONG_BRANCHING,
      RELIABILITY_BRANCHING,
#ifdef BONMIN_CURVATURE_BRANCHING
      CURVATURE_ESTIMATOR,
#endif
      QP_STRONG_BRANCHING,
      LP_STRONG_BRANCHING,
      NLP_STRONG_BRANCHING,
      OSI_SIMPLE,
      OSI_STRONG,
      RANDOM
    };

    enum IntParameter{
      BabLogLevel = 0 ,
      BabLogInterval,
      MaxFailures ,
      FailureBehavior ,
      MaxInfeasible ,
      NumberStrong ,
      MinReliability ,
      MaxNodes ,
      MaxSolutions ,
      MaxIterations ,
      SpecialOption ,
      DisableSos ,
      NumCutPasses,
      NumCutPassesAtRoot,
      RootLogLevel,
      NumberIntParam 
    };


    enum DoubleParameter{
      CutoffDecr = 0 ,
      Cutoff ,
      AllowableGap ,
      AllowableFractionGap ,
      IntTol ,
      MaxTime ,
      NumberDoubleParam 
    };

    BabSetupBase(const CoinMessageHandler * handler = NULL);

    BabSetupBase(Ipopt::SmartPtr<TMINLP> tminlp, const CoinMessageHandler * handler = NULL);
    BabSetupBase(Ipopt::SmartPtr<TNLPSolver> app);
    BabSetupBase(const OsiTMINLPInterface& nlp);
    BabSetupBase(const BabSetupBase &setup,
                 OsiTMINLPInterface &nlp);

    BabSetupBase(const BabSetupBase &setup,
                 OsiTMINLPInterface &nlp,
                 const std::string &prefix);

    BabSetupBase(const BabSetupBase & other);

    virtual BabSetupBase * clone() const = 0;

    virtual BabSetupBase *clone(OsiTMINLPInterface&nlp)const;
    virtual ~BabSetupBase();

    void use(const OsiTMINLPInterface& nlp);
    void use(Ipopt::SmartPtr<TMINLP> tminlp );
    void use(Ipopt::SmartPtr<TMINLP2TNLP> prob);
    void setNonlinearSolver(OsiTMINLPInterface * s)
    {
      nonlinearSolver_ = s;
    }
    virtual void registerOptions();
    virtual void setBabDefaultOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions)
    {}
    static void registerAllOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);

    virtual void readOptionsFile()
    {
      if (readOptions_) return;
      readOptionsFile("bonmin.opt");
    }

    void readOptionsFile(std::string fileName);

    void readOptionsString(std::string opt_string);

    void readOptionsStream(std::istream& is);

    void mayPrintDoc();


    const char * prefix() const {
      return prefix_.c_str();
    }

    void setOptionsAndJournalist(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
        Ipopt::SmartPtr<Ipopt::OptionsList> options,
        Ipopt::SmartPtr<Ipopt::Journalist> journalist)
    {
      options_ = options;
      roptions_ = roptions;
      journalist_ = journalist;
    }

    void initializeOptionsAndJournalist();
    OsiTMINLPInterface * nonlinearSolver()
    {
      return nonlinearSolver_;
    }
    OsiSolverInterface * continuousSolver()
    {
      return continuousSolver_;
    }
    CuttingMethods& cutGenerators()
    {
      return cutGenerators_;
    }
    HeuristicMethods& heuristics()
    {
      return heuristics_;
    }
    OsiChooseVariable * branchingMethod()
    {
      return branchingMethod_;
    }
    NodeComparison& nodeComparisonMethod()
    {
      return nodeComparisonMethod_;
    }
    TreeTraversal treeTraversalMethod()
    {
      return treeTraversalMethod_;
    }
    int getIntParameter(const IntParameter &p) const
    {
      return intParam_[p];
    }
    double getDoubleParameter(const DoubleParameter &p) const
    {
      return doubleParam_[p];
    }
    void setIntParameter(const IntParameter &p, const int v)
    {
      intParam_[p] = v;
    }
    void setDoubleParameter(const DoubleParameter &p, const double v)
    {
      doubleParam_[p] = v;
    }
    void gatherParametersValues()
    {
      gatherParametersValues(options_);
    }
    void gatherParametersValues(Ipopt::SmartPtr<Ipopt::OptionsList> options);
    Ipopt::SmartPtr<Ipopt::Journalist> journalist()
    {
      return journalist_;
    }

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

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

    const vector<OsiObject *>& objects() const
    {
      return objects_;
    }

    vector<OsiObject *>& objects()
    {
      return objects_;
    }
  
    void addCutGenerator(CuttingMethod & cg){
      cutGenerators_.push_back(cg);
    }

    void set_linearizer(TMINLP2OsiLP * linearizer){
      linearizer_ = linearizer;
    }

  protected:
    void setPriorities();
    void addSos();

    int intParam_[NumberIntParam];
    static int defaultIntParam_[NumberIntParam];
    double doubleParam_[NumberDoubleParam];
    static double defaultDoubleParam_[NumberDoubleParam];
    OsiTMINLPInterface * nonlinearSolver_;
    OsiSolverInterface * continuousSolver_;
    Ipopt::SmartPtr<TMINLP2OsiLP> linearizer_;
    CuttingMethods cutGenerators_;
    HeuristicMethods heuristics_;
    OsiChooseVariable * branchingMethod_;
    NodeComparison nodeComparisonMethod_;
    TreeTraversal treeTraversalMethod_;
    vector<OsiObject *> objects_;
    

    Ipopt::SmartPtr<Ipopt::Journalist> journalist_;

    Ipopt::SmartPtr<Ipopt::OptionsList> options_;

    Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions_;

    bool readOptions_;
    CoinMessageHandler * messageHandler_;
    std::string prefix_;
  };
}/* End namespace Bonmin. */
#endif