BonOaDecBase.hpp

Go to the documentation of this file.

// (C) Copyright International Business Machines (IBM) 2006
// All Rights Reserved.
// This code is published under the Common Public License.
//
// Authors :
// P. Bonami, International Business Machines
//
// Date :  12/07/2006
#ifndef BonOaDecBase_HPP
#define BonOaDecBase_HPP
#include "BonSubMipSolver.hpp"
#include "CglCutGenerator.hpp"
#include "BonBabSetupBase.hpp"
#include "BonOAMessages.hpp"
#include "CbcModel.hpp"

#include "CbcStrategy.hpp"

#include "CoinTime.hpp"
#include "OsiAuxInfo.hpp"
#include "OsiBranchingObject.hpp"
#include <iostream>
#include "BonBabInfos.hpp"
namespace Bonmin
{
  class OaDecompositionBase : public CglCutGenerator
  {
  public:


    class solverManip
    {
    public:
      solverManip(OsiSolverInterface *si , bool saveNumRows=true,
          bool saveBasis=true, bool saveBounds=false,
          bool saveCutoff = false, bool resolve=true);

      solverManip(const OsiSolverInterface & si);
      ~solverManip();
      void restore();
      
      OsiSolverInterface * si()
      {
        return si_;
      }

      void setObjects(OsiObject ** objects, int nObjects)
      {
        objects_ = objects;
        nObjects_ = nObjects;
      }

    private:
      OsiSolverInterface * si_;
      int initialNumberRows_;

      double * colLower_;

      double * colUpper_;

      CoinWarmStart * warm_;

      double cutoff_;

      bool deleteSolver_;

      OsiObject * * objects_;
      int nObjects_;
      int numcols_;
      int numrows_;
      const double * siColLower_;
      const double * siColUpper_;

      void getCached();
    };

    OaDecompositionBase(BabSetupBase &b, bool leaveSiUnchanged,
        bool reassignLpsolver);

    OaDecompositionBase(const OaDecompositionBase & copy);


    virtual ~OaDecompositionBase();

    virtual void generateCuts(const OsiSolverInterface &si,  OsiCuts & cs,
        const CglTreeInfo info = CglTreeInfo());

    void assignNlpInterface(OsiTMINLPInterface * nlp)
    {
      nlp_ = nlp;
    }

    void assignLpInterface(OsiSolverInterface * si)
    {
      lp_ = si;
    }

    bool reassignLpsolver()
    {
      return reassignLpsolver_;
    }
    void setObjects(OsiObject ** objects, int nObjects)
    {
      objects_ = objects;
      nObjects_ = nObjects;
    }
    inline void setLeaveSiUnchanged(bool yesno)
    {
      leaveSiUnchanged_ = yesno;
    }

    struct Parameters
    {
      bool global_;
      bool addOnlyViolated_;
      double cbcCutoffIncrement_;
      double cbcIntegerTolerance_; 
      double gap_tol_;
      int maxLocalSearch_;
      double maxLocalSearchTime_;
      int subMilpLogLevel_;
      int maxSols_;
      double logFrequency_;
     
      
      Parameters();

      Parameters(const Parameters & other);

      ~Parameters()
      {
        if (strategy_) delete strategy_;
      }

      void setStrategy(const CbcStrategy & strategy)
      {
        if (strategy_) delete strategy_;
        strategy_ = strategy.clone();
      }

      const CbcStrategy * strategy() const
      {
        return strategy_;
      }

private:
      CbcStrategy * strategy_;

    };

    Parameters& parameter()
    {
      return parameters_;
    }

    const Parameters& parameter()const
    {
      return parameters_;
    }

    void setLogLevel(int level)
    {
      handler_->setLogLevel(level);
    }

    void setReassignLpSolver(bool v){
      reassignLpsolver_ = v;
    }
    void passInMessageHandler(CoinMessageHandler * handler);
  protected:
      void setupMipSolver(BabSetupBase &b, const std::string &prefix);

    bool post_nlp_solve(BabInfo * babInfo, double cutoff) const;

    virtual double performOa(OsiCuts &cs, solverManip &lpManip,
                             BabInfo * babInfo, double &, const CglTreeInfo & info) const = 0;
    virtual bool doLocalSearch(BabInfo * babInfo) const = 0;



    mutable OsiTMINLPInterface * nlp_;
    BabSetupBase * s_;
    mutable int nSolve_;
    mutable OsiSolverInterface * lp_;
    OsiObject * * objects_;
    int nObjects_;
    mutable int nLocalSearch_;
    CoinMessageHandler * handler_;
    CoinMessages messages_;
    bool leaveSiUnchanged_;
    bool reassignLpsolver_;
    double timeBegin_;
    mutable int numSols_;
    
    Parameters parameters_;

    mutable OsiCuts savedCuts_;
    mutable int currentNodeNumber_;
#ifdef OA_DEBUG
    class OaDebug
    {
      public:
      bool checkInteger(const OsiSolverInterface&nlp, std::ostream & os) const;

      void printEndOfProcedureDebugMessage(const OsiCuts &cs,
          bool foundSolution,
          double solValue,
          double milpBound,
          bool isInteger,
          bool feasible,
          std::ostream & os) const;
    };

    OaDebug debug_;

#endif
  };
}
#endif