/home/coin/SVN-release/CoinAll-1.1.0/Cbc/src/CbcGenCtlBlk.hpp

Go to the documentation of this file.

/*
  Copyright (C) 2007, Lou Hafer, International Business Machines Corporation
  and others.  All Rights Reserved.

  This file is part of cbc-generic.
*/

#ifndef CbcGenCtlBlk_H
#define CbcGenCtlBlk_H

/* \file CbcGenCtlBlk.hpp
   \brief Declarations for parameters of the cbc-generic main program.
*/

#include "CoinParam.hpp"
#include "CoinMessageHandler.hpp"

#include "CglCutGenerator.hpp"
#include "CglProbing.hpp"
#include "CglClique.hpp"
#include "CglFlowCover.hpp"
#include "CglGomory.hpp"
#include "CglKnapsackCover.hpp"
#include "CglMixedIntegerRounding2.hpp"
#include "CglOddHole.hpp"
#include "CglRedSplit.hpp"
#include "CglTwomir.hpp"

#include "CbcModel.hpp"

#include "CbcHeuristic.hpp"
#include "CbcHeuristicFPump.hpp"
#include "CbcHeuristicGreedy.hpp"
#include "CbcHeuristicLocal.hpp"
#include "CbcTreeLocal.hpp"

#include "CbcGenMessages.hpp"

/*
  It turns out that doxygen is not good with anonymous structures. Hence the
  `struct nameCtl_struct' style used for structured fields in CbcGenCtlBlk.
*/

/*
  $Id$
*/

#define CBC_GENERIC_VERSION "00.01.00"

class CbcGenCtlBlk ;
namespace CbcGenParamUtils
{
  void addCbcGenParams(int &numParams, CoinParamVec &paramVec,
                       CbcGenCtlBlk *ctlBlk) ;
}

/* \brief cbc-generic algorithm control class

  This class defines values and methods used to control the operation of the
  cbc-generic main program.
*/

class CbcGenCtlBlk
{

friend void CbcGenParamUtils::addCbcGenParams(int &numParams,
        CoinParamVec &paramVec, CbcGenCtlBlk *ctlBlk) ;

public:


/*
  In order for initialisation to work properly, the order of declaration of
  the enum constants here must match the order of keyword declaration for
  the PREPROCESS parameter in CbcGenParamUtils::addCbcGenParams
*/
typedef enum { IPPOff = 0, IPPOn, IPPSave, IPPEqual,
               IPPSOS, IPPTrySOS, IPPEqualAll, IPPStrategy } IPPControl ;

/*
  In order for initialisation to work properly, the order of declaration of
  the enum constants here must match the order of keyword declaration for
  the various cut and heuristic control parameters in
  CbcGenParamUtils::addCbcGenParams
*/
typedef enum { CGOff, CGOn, CGRoot, CGIfMove,
               CGForceOn, CGForceBut, CGMarker } CGControl ;

typedef enum { BPOff, BPCost, BPOrder, BPExt } BPControl ;

typedef enum { BACInvalid = -1, BACFinish = 0,
               BACStop = 1, BACAbandon = 2, BACNotRun, BACUser = 5 } BACMajor ;

typedef enum { BACmInvalid = -1, BACmFinish = 0, BACmInfeas, BACmUbnd,
               BACmGap, BACmNodeLimit, BACmTimeLimit, BACmSolnLimit,
               BACmUser, BACmOther } BACMinor ;

typedef enum { BACwInvalid = -1, BACwNotStarted = 0, BACwBareRoot,
               BACwIPP, BACwIPPRelax, BACwBAC } BACWhere ;

  

  CbcGenCtlBlk() ;

  ~CbcGenCtlBlk() ;


  inline int getCutDepth() { return cutDepth_ ; } 

  inline void setCutDepth(int cutDepth) { cutDepth_ = cutDepth ; } 

  /*1 \brief Get action state for use of integer preprocessing */

  inline IPPControl getIPPAction() { return (preProcess_) ; } 

  inline void setIPPAction(IPPControl action)
  { preProcess_ = action ; } 

  CGControl getProbing(CglCutGenerator *&gen) ;

  inline void setProbingAction(CGControl action)
  { probing_.action_ = action ; } 

  CGControl getClique(CglCutGenerator *&gen) ;

  inline void setCliqueAction(CGControl action)
  { clique_.action_ = action ; } 

  CGControl getFlow(CglCutGenerator *&gen) ;

  inline void setFlowAction(CGControl action)
  { flow_.action_ = action ; } 

  CGControl getGomory(CglCutGenerator *&gen) ;

  inline void setGomoryAction(CGControl action)
  { gomory_.action_ = action ; } 

  CGControl getKnapsack(CglCutGenerator *&gen) ;

  inline void setKnapsackAction(CGControl action)
  { knapsack_.action_ = action ; } 

/*  \brief Obtain a prototype for a lift-and-project cut generator.

  CGControl getLandP(CglCutGenerator *&gen) ;

   \brief Set action state for use of lift-and-project cut generator.

  inline void setLandPAction(CGControl action)
  { landp_.action_ = action ; } 
*/

  CGControl getMir(CglCutGenerator *&gen) ;

  inline void setMirAction(CGControl action)
  { mir_.action_ = action ; } 

  CGControl getRedSplit(CglCutGenerator *&gen) ;

  inline void setRedSplitAction(CGControl action)
  { redSplit_.action_ = action ; } 

  CGControl getTwomir(CglCutGenerator *&gen) ;

  inline void setTwomirAction(CGControl action)
  { twomir_.action_ = action ; } 


  CGControl getFPump(CbcHeuristic *&gen, CbcModel *model,
                     bool alwaysCreate = true) ;

  inline void setFPumpAction(CGControl action)
  { fpump_.action_ = action ; } 

  CGControl getCombine(CbcHeuristic *&gen, CbcModel *model,
                        bool alwaysCreate = true) ;

  inline void setCombineAction(CGControl action)
  { combine_.action_ = action ; } 

  CGControl getGreedyCover(CbcHeuristic *&gen, CbcModel *model,
                            bool alwaysCreate = true) ;

  inline void setGreedyCoverAction(CGControl action)
  { greedyCover_.action_ = action ; } 

  CGControl getGreedyEquality(CbcHeuristic *&gen, CbcModel *model,
                               bool alwaysCreate = true) ;

  inline void setGreedyEqualityAction(CGControl action)
  { greedyEquality_.action_ = action ; } 

  CGControl getRounding(CbcHeuristic *&gen, CbcModel *model,
                        bool alwaysCreate = true) ;

  inline void setRoundingAction(CGControl action)
  { rounding_.action_ = action ; } 

  CGControl getTreeLocal(CbcTreeLocal *&localTree, CbcModel *model,
                         bool alwaysCreate = true) ;

  inline void setTreeLocalAction(CGControl action)
  { localTree_.action_ = action ; } 



  inline void setBaBStatus(BACMajor majorStatus, BACMinor minorStatus,
                           BACWhere where, bool haveAnswer,
                           OsiSolverInterface *answerSolver)
  { bab_.majorStatus_ = majorStatus ;
    bab_.minorStatus_ = minorStatus ;
    bab_.where_ = where ;
    bab_.haveAnswer_ = haveAnswer ;
    bab_.answerSolver_ = answerSolver ; }

  void setBaBStatus(const CbcModel *model, BACWhere where,
                    bool haveAnswer = false,
                    OsiSolverInterface *answerSolver = 0) ;

  BACMajor translateMajor(int status) ;

  BACMinor translateMinor(int status) ;

  BACMinor translateMinor(const OsiSolverInterface *osi) ;

  void printBaBStatus() ;



  CoinMessageHandler &message(CbcGenMsgCode inID) ;

  void passInMessageHandler(CoinMessageHandler *handler) ;

  inline CoinMessageHandler *messageHandler() const { return msgHandler_ ; } 

  void setMessages(CoinMessages::Language lang = CoinMessages::us_en) ;

  inline void setLogLevel(int lvl)
  { logLvl_ = lvl ;
    if (msgHandler_) msgHandler_->setLogLevel(lvl) ; } 

  inline int logLevel() const { return (logLvl_) ; } 

  int printOpt_ ;


  std::string version_ ;

  std::string dfltDirectory_ ;

  std::string lastMpsIn_ ;

  bool allowImportErrors_ ;

  std::string lastSolnOut_ ;

  int printMode_ ;

  std::string printMask_ ;

  CoinParamVec *paramVec_ ;

  struct genParamsInfo_struct
  { int first_ ;
    int last_ ; } genParams_ ;

  struct cbcParamsInfo_struct
  { int first_ ;
    int last_ ; } cbcParams_ ;

  struct osiParamsInfo_struct
  { int first_ ;
    int last_ ; } osiParams_ ;

  int verbose_ ;

  int paramsProcessed_ ;

  std::vector<bool> setByUser_ ;

  bool defaultSettings_ ;

  std::string debugCreate_ ;

  std::string debugFile_ ;

  struct debugSolInfo_struct
  { int numCols_ ;
    double *values_ ; } debugSol_ ;

/* \name Timing */

  double totalTime_ ;



  CbcModel *model_ ;

  OsiSolverInterface *dfltSolver_ ;

  bool goodModel_ ;

  struct babState_struct
  { BACMajor majorStatus_ ;
    BACMinor minorStatus_ ;
    BACWhere where_ ;
    bool haveAnswer_ ;
    OsiSolverInterface *answerSolver_ ; } bab_ ;



  struct djFixCtl_struct
  { bool action_ ;
    double threshold_ ; } djFix_ ;

  BPControl priorityAction_ ;



  struct chooseStrongCtl_struct
  { int numBeforeTrust_ ;
    int numStrong_ ;
    int shadowPriceMode_ ; } chooseStrong_ ;

private:


  IPPControl preProcess_ ;

  int cutDepth_ ;

  struct probingCtl_struct
  { CGControl action_ ;
    CglProbing *proto_ ;
    bool usingObjective_ ;
    int maxPass_ ;
    int maxPassRoot_ ;
    int maxProbe_ ;
    int maxProbeRoot_ ;
    int maxLook_ ;
    int maxLookRoot_ ;
    int maxElements_ ;
    int rowCuts_ ; } probing_ ;

  struct cliqueCtl_struct
  { CGControl action_ ;
    CglClique *proto_ ;
    bool starCliqueReport_ ;
    bool rowCliqueReport_ ;
    double minViolation_ ; } clique_ ;

  struct flowCtl_struct
  { CGControl action_ ;
    CglFlowCover *proto_ ; } flow_ ;

  struct gomoryCtl_struct
  { CGControl action_ ;
    CglGomory *proto_ ;
    int limit_ ;
    int limitAtRoot_ ; } gomory_ ;

/*   \brief Control variable and prototype for lift-and-project cut
             generator
   struct landpCtl_struct
   { CGControl action_ ;
     CglLandP *proto_ ; } landp_ ;
*/

  struct knapsackCtl_struct
  { CGControl action_ ;
    CglKnapsackCover *proto_ ; } knapsack_ ;

  struct mirCtl_struct
  { CGControl action_ ;
    CglMixedIntegerRounding2 *proto_ ; } mir_ ;

  struct oddHoleCtl_struct
  { CGControl action_ ;
    CglOddHole *proto_ ; } oddHole_ ;

  struct redSplitCtl_struct
  { CGControl action_ ;
    CglRedSplit *proto_ ; } redSplit_ ;

  struct twomirCtl_struct
  { CGControl action_ ;
    CglTwomir *proto_ ;
    int maxElements_ ; } twomir_ ;

  struct fpumpCtl_struct
  { CGControl action_ ;
    CbcHeuristicFPump *proto_ ;
    int iters_ ; } fpump_ ;

  struct combineCtl_struct
  { CGControl action_ ;
    CbcHeuristicLocal *proto_ ;
    int trySwap_ ; } combine_ ;

  struct greedyCoverCtl_struct
  { CGControl action_ ;
    CbcHeuristicGreedyCover *proto_ ; } greedyCover_ ;

  struct greedyEqualityCtl_struct
  { CGControl action_ ;
    CbcHeuristicGreedyEquality *proto_ ; } greedyEquality_ ;

  struct roundingCtl_struct
  { CGControl action_ ;
    CbcRounding *proto_ ; } rounding_ ;


  struct localTreeCtl_struct
  { CGControl action_ ;
    CbcTreeLocal *proto_ ;
    double *soln_ ;
    int range_ ;
    int typeCuts_ ;
    int maxDiverge_ ;
    int timeLimit_ ;
    int nodeLimit_ ;
    bool refine_ ; } localTree_ ;



  CoinMessageHandler *msgHandler_ ;

  bool ourMsgHandler_ ;

  CoinMessages::Language cur_lang_ ;

  CoinMessages *msgs_ ;

  int logLvl_ ;


} ;


#endif

---