Changeset 779


Ignore:
Timestamp:
Sep 7, 2007 10:18:19 AM (12 years ago)
Author:
forrest
Message:

on way to CbcSolver? class

Location:
trunk/Cbc/src
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcModel.cpp

    r777 r779  
    16351635    if ((numberNodes_%printFrequency_) == 0) {
    16361636      lockThread();
    1637       int j ;
    16381637      int nNodes = tree_->size() ;
    16391638
     
    27622761  presolve_(0),
    27632762  numberStrong_(5),
    2764   numberBeforeTrust_(0),
     2763  numberBeforeTrust_(10),
    27652764  numberPenalties_(20),
    27662765  penaltyScaleFactor_(3.0),
     
    29002899  presolve_(0),
    29012900  numberStrong_(5),
    2902   numberBeforeTrust_(0),
     2901  numberBeforeTrust_(10),
    29032902  numberPenalties_(20),
    29042903  penaltyScaleFactor_(3.0),
  • trunk/Cbc/src/CbcModel.hpp

    r765 r779  
    20932093// When we want to load up CbcModel with options first
    20942094void CbcMain0 (CbcModel & babSolver);
    2095 int CbcMain1 (int argc, const char *argv[],CbcModel & babSolver,
    2096               int call_CbcClpUnitTest_on_777 = 0);
     2095int CbcMain1 (int argc, const char *argv[],CbcModel & babSolver);
    20972096// two ways of calling
    20982097int callCbc(const char * input2, CbcModel & babSolver);
     
    21042103int callCbc1(const char * input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
    21052104int callCbc1(const std::string input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
    2106 int CbcMain1 (int argc, const char *argv[],CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom), int call_CbcClpUnitTest_on_777 = 0);
     2105int CbcMain1 (int argc, const char *argv[],CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
    21072106#endif
  • trunk/Cbc/src/CbcSolver.cpp

    r777 r779  
    141141
    142142#include "OsiClpSolverInterface.hpp"
     143//#define NEW_STYLE_SOLVER
     144#ifdef NEW_STYLE_SOLVER
     145#include "CbcSolver.hpp"
     146CbcSolver::CbcSolver()
     147  : babModel_(NULL),
     148    userFunction_(NULL),
     149    numberUserFunctions_(0),
     150    startTime_(CoinCpuTime()),
     151    parameters_(NULL),
     152    numberParameters_(0),
     153    doMiplib_(false),
     154    noPrinting_(false)
     155{
     156  callBack_ = new CbcStopNow();
     157  fillParameters();
     158}
     159CbcSolver::CbcSolver(const OsiClpSolverInterface & solver)
     160  : babModel_(NULL),
     161    userFunction_(NULL),
     162    numberUserFunctions_(0),
     163    startTime_(CoinCpuTime()),
     164    parameters_(NULL),
     165    numberParameters_(0),
     166    doMiplib_(false),
     167    noPrinting_(false)
     168{
     169  callBack_ = new CbcStopNow();
     170  model_ = CbcModel(solver);
     171  fillParameters();
     172}
     173CbcSolver::CbcSolver(const CbcModel & solver)
     174  : babModel_(NULL),
     175    userFunction_(NULL),
     176    numberUserFunctions_(0),
     177    startTime_(CoinCpuTime()),
     178    parameters_(NULL),
     179    numberParameters_(0),
     180    doMiplib_(false),
     181    noPrinting_(false)
     182{
     183  callBack_ = new CbcStopNow();
     184  model_ = solver;
     185  fillParameters();
     186}
     187CbcSolver::~CbcSolver()
     188{
     189  int i;
     190  for (i=0;i<numberUserFunctions_;i++)
     191    delete userFunction_[i];
     192  delete [] userFunction_;
     193  delete babModel_;
     194  delete [] parameters_;
     195  delete callBack_;
     196}
     197// Copy constructor
     198CbcSolver::CbcSolver ( const CbcSolver & rhs)
     199  : model_(rhs.model_),
     200    babModel_(NULL),
     201    userFunction_(NULL),
     202    numberUserFunctions_(rhs.numberUserFunctions_),
     203    startTime_(CoinCpuTime()),
     204    parameters_(NULL),
     205    numberParameters_(rhs.numberParameters_),
     206    doMiplib_(rhs.doMiplib_),
     207    noPrinting_(rhs.noPrinting_)
     208{
     209  fillParameters();
     210  if (rhs.babModel_)
     211    babModel_ = new CbcModel(*rhs.babModel_);
     212  userFunction_ = new CbcUser * [numberUserFunctions_];
     213  int i;
     214  for (i=0;i<numberUserFunctions_;i++)
     215    userFunction_[i] = rhs.userFunction_[i]->clone();
     216  for (i=0;i<numberParameters_;i++)
     217    parameters_[i]=rhs.parameters_[i];
     218  callBack_ = rhs.callBack_->clone();
     219}
     220// Assignment operator
     221CbcSolver &
     222CbcSolver::operator=(const CbcSolver & rhs)
     223{
     224  if (this != &rhs) {
     225    int i;
     226    for (i=0;i<numberUserFunctions_;i++)
     227      delete userFunction_[i];
     228    delete [] userFunction_;
     229    delete babModel_;
     230    delete [] parameters_;
     231    delete callBack_;
     232    numberUserFunctions_ = rhs.numberUserFunctions_;
     233    startTime_ = rhs.startTime_;
     234    numberParameters_= rhs.numberParameters_;
     235    for (i=0;i<numberParameters_;i++)
     236      parameters_[i]=rhs.parameters_[i];
     237    noPrinting_ = rhs.noPrinting_;
     238    doMiplib_ = rhs.doMiplib_;
     239    model_ = rhs.model_;
     240    if (rhs.babModel_)
     241      babModel_ = new CbcModel(*rhs.babModel_);
     242    else
     243      babModel_ = NULL;
     244    userFunction_ = new CbcUser * [numberUserFunctions_];
     245    for (i=0;i<numberUserFunctions_;i++)
     246      userFunction_[i] = rhs.userFunction_[i]->clone();
     247    callBack_ = rhs.callBack_->clone();
     248}
     249  return *this;
     250}
     251// Get int value
     252int CbcSolver::intValue(CbcOrClpParameterType type) const
     253{
     254  return parameters_[whichParam(type,numberParameters_,parameters_)].intValue();
     255}
     256// Set int value
     257void CbcSolver::setIntValue(CbcOrClpParameterType type,int value)
     258{
     259  parameters_[whichParam(type,numberParameters_,parameters_)].setIntValue(value);
     260}
     261// Get double value
     262double CbcSolver::doubleValue(CbcOrClpParameterType type) const
     263{
     264  return parameters_[whichParam(type,numberParameters_,parameters_)].doubleValue();
     265}
     266// Set double value
     267void CbcSolver::setDoubleValue(CbcOrClpParameterType type,double value)
     268{
     269  parameters_[whichParam(type,numberParameters_,parameters_)].setDoubleValue(value);
     270}
     271// User function (NULL if no match)
     272CbcUser * CbcSolver::userFunction(const char * name) const
     273{
     274  int i;
     275  for (i=0;i<numberUserFunctions_;i++) {
     276    if (!strcmp(name,userFunction_[i]->name().c_str()))
     277      break;
     278  }
     279  if (i<numberUserFunctions_)
     280    return userFunction_[i];
     281  else
     282    return NULL;
     283}
     284void CbcSolver::fillParameters()
     285{
     286  int maxParam = 200;
     287  CbcOrClpParam * parameters = new CbcOrClpParam [maxParam];
     288  numberParameters_=0 ;
     289  establishParams(numberParameters_,parameters) ;
     290  assert (numberParameters_<=maxParam);
     291  parameters_ = new CbcOrClpParam [numberParameters_];
     292  int i;
     293  for (i=0;i<numberParameters_;i++)
     294    parameters_[i]=parameters[i];
     295  delete [] parameters;
     296  const char dirsep =  CoinFindDirSeparator();
     297  std::string directory;
     298  std::string dirSample;
     299  std::string dirNetlib;
     300  std::string dirMiplib;
     301  if (dirsep == '/') {
     302    directory = "./";
     303    dirSample = "../../Data/Sample/";
     304    dirNetlib = "../../Data/Netlib/";
     305    dirMiplib = "../../Data/miplib3/";
     306  } else {
     307    directory = ".\\";
     308    dirSample = "..\\..\\Data\\Sample\\";
     309    dirNetlib = "..\\..\\Data\\Netlib\\";
     310    dirMiplib = "..\\..\\Data\\miplib3\\";
     311  }
     312  std::string defaultDirectory = directory;
     313  std::string importFile ="";
     314  std::string exportFile ="default.mps";
     315  std::string importBasisFile ="";
     316  std::string importPriorityFile ="";
     317  std::string debugFile="";
     318  std::string printMask="";
     319  std::string exportBasisFile ="default.bas";
     320  std::string saveFile ="default.prob";
     321  std::string restoreFile ="default.prob";
     322  std::string solutionFile ="stdout";
     323  std::string solutionSaveFile ="solution.file";
     324  int doIdiot=-1;
     325  int outputFormat=2;
     326  int substitution=3;
     327  int dualize=0;
     328  int preSolve=5;
     329  int doSprint=-1;
     330  int testOsiParameters=-1;
     331  int createSolver=0;
     332  ClpSimplex * lpSolver;
     333  OsiClpSolverInterface * clpSolver;
     334  if (model_.solver()) {
     335    clpSolver = dynamic_cast<OsiClpSolverInterface *> (model_.solver());
     336    assert (clpSolver);
     337    lpSolver = clpSolver->getModelPtr();
     338    assert (lpSolver);
     339  } else {
     340    lpSolver = new ClpSimplex();
     341    clpSolver = new OsiClpSolverInterface(lpSolver,true);
     342    createSolver =1 ;
     343  }
     344  parameters_[whichParam(BASISIN,numberParameters_,parameters_)].setStringValue(importBasisFile);
     345  parameters_[whichParam(PRIORITYIN,numberParameters_,parameters_)].setStringValue(importPriorityFile);
     346  parameters_[whichParam(BASISOUT,numberParameters_,parameters_)].setStringValue(exportBasisFile);
     347  parameters_[whichParam(DEBUG,numberParameters_,parameters_)].setStringValue(debugFile);
     348  parameters_[whichParam(PRINTMASK,numberParameters_,parameters_)].setStringValue(printMask);
     349  parameters_[whichParam(DIRECTORY,numberParameters_,parameters_)].setStringValue(directory);
     350  parameters_[whichParam(DIRSAMPLE,numberParameters_,parameters_)].setStringValue(dirSample);
     351  parameters_[whichParam(DIRNETLIB,numberParameters_,parameters_)].setStringValue(dirNetlib);
     352  parameters_[whichParam(DIRMIPLIB,numberParameters_,parameters_)].setStringValue(dirMiplib);
     353  parameters_[whichParam(DUALBOUND,numberParameters_,parameters_)].setDoubleValue(lpSolver->dualBound());
     354  parameters_[whichParam(DUALTOLERANCE,numberParameters_,parameters_)].setDoubleValue(lpSolver->dualTolerance());
     355  parameters_[whichParam(EXPORT,numberParameters_,parameters_)].setStringValue(exportFile);
     356  parameters_[whichParam(IDIOT,numberParameters_,parameters_)].setIntValue(doIdiot);
     357  parameters_[whichParam(IMPORT,numberParameters_,parameters_)].setStringValue(importFile);
     358  parameters_[whichParam(PRESOLVETOLERANCE,numberParameters_,parameters_)].setDoubleValue(1.0e-8);
     359  int iParam = whichParam(SOLVERLOGLEVEL,numberParameters_,parameters_);
     360  int value=1;
     361  clpSolver->messageHandler()->setLogLevel(1) ;
     362  lpSolver->setLogLevel(1);
     363  parameters_[iParam].setIntValue(value);
     364  iParam = whichParam(LOGLEVEL,numberParameters_,parameters_);
     365  model_.messageHandler()->setLogLevel(value);
     366  parameters_[iParam].setIntValue(value);
     367  parameters_[whichParam(MAXFACTOR,numberParameters_,parameters_)].setIntValue(lpSolver->factorizationFrequency());
     368  parameters_[whichParam(MAXITERATION,numberParameters_,parameters_)].setIntValue(lpSolver->maximumIterations());
     369  parameters_[whichParam(OUTPUTFORMAT,numberParameters_,parameters_)].setIntValue(outputFormat);
     370  parameters_[whichParam(PRESOLVEPASS,numberParameters_,parameters_)].setIntValue(preSolve);
     371  parameters_[whichParam(PERTVALUE,numberParameters_,parameters_)].setIntValue(lpSolver->perturbation());
     372  parameters_[whichParam(PRIMALTOLERANCE,numberParameters_,parameters_)].setDoubleValue(lpSolver->primalTolerance());
     373  parameters_[whichParam(PRIMALWEIGHT,numberParameters_,parameters_)].setDoubleValue(lpSolver->infeasibilityCost());
     374  parameters_[whichParam(RESTORE,numberParameters_,parameters_)].setStringValue(restoreFile);
     375  parameters_[whichParam(SAVE,numberParameters_,parameters_)].setStringValue(saveFile);
     376  //parameters_[whichParam(TIMELIMIT,numberParameters_,parameters_)].setDoubleValue(1.0e8);
     377  parameters_[whichParam(TIMELIMIT_BAB,numberParameters_,parameters_)].setDoubleValue(1.0e8);
     378  parameters_[whichParam(SOLUTION,numberParameters_,parameters_)].setStringValue(solutionFile);
     379  parameters_[whichParam(SAVESOL,numberParameters_,parameters_)].setStringValue(solutionSaveFile);
     380  parameters_[whichParam(SPRINT,numberParameters_,parameters_)].setIntValue(doSprint);
     381  parameters_[whichParam(SUBSTITUTION,numberParameters_,parameters_)].setIntValue(substitution);
     382  parameters_[whichParam(DUALIZE,numberParameters_,parameters_)].setIntValue(dualize);
     383  parameters_[whichParam(NUMBERBEFORE,numberParameters_,parameters_)].setIntValue(model_.numberBeforeTrust());
     384  parameters_[whichParam(MAXNODES,numberParameters_,parameters_)].setIntValue(model_.getMaximumNodes());
     385  parameters_[whichParam(STRONGBRANCHING,numberParameters_,parameters_)].setIntValue(model_.numberStrong());
     386  parameters_[whichParam(INFEASIBILITYWEIGHT,numberParameters_,parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcInfeasibilityWeight));
     387  parameters_[whichParam(INTEGERTOLERANCE,numberParameters_,parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcIntegerTolerance));
     388  parameters_[whichParam(INCREMENT,numberParameters_,parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcCutoffIncrement));
     389  parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].setIntValue(testOsiParameters);
     390  parameters_[whichParam(FPUMPTUNE,numberParameters_,parameters_)].setIntValue(1003);
     391#ifdef CBC_THREAD
     392  parameters_[whichParam(THREADS,numberParameters_,parameters_)].setIntValue(0);
     393#endif
     394  // Set up likely cut generators and defaults
     395  parameters_[whichParam(PREPROCESS,numberParameters_,parameters_)].setCurrentOption("on");
     396  parameters_[whichParam(MIPOPTIONS,numberParameters_,parameters_)].setIntValue(128|64|1);
     397  parameters_[whichParam(MIPOPTIONS,numberParameters_,parameters_)].setIntValue(1);
     398  parameters_[whichParam(CUTPASSINTREE,numberParameters_,parameters_)].setIntValue(1);
     399  parameters_[whichParam(MOREMIPOPTIONS,numberParameters_,parameters_)].setIntValue(-1);
     400  parameters_[whichParam(MAXHOTITS,numberParameters_,parameters_)].setIntValue(100);
     401  parameters_[whichParam(CUTSSTRATEGY,numberParameters_,parameters_)].setCurrentOption("on");
     402  parameters_[whichParam(HEURISTICSTRATEGY,numberParameters_,parameters_)].setCurrentOption("on");
     403  parameters_[whichParam(NODESTRATEGY,numberParameters_,parameters_)].setCurrentOption("fewest");
     404  parameters_[whichParam(GOMORYCUTS,numberParameters_,parameters_)].setCurrentOption("ifmove");
     405  parameters_[whichParam(PROBINGCUTS,numberParameters_,parameters_)].setCurrentOption("ifmove");
     406  parameters_[whichParam(KNAPSACKCUTS,numberParameters_,parameters_)].setCurrentOption("ifmove");
     407  parameters_[whichParam(REDSPLITCUTS,numberParameters_,parameters_)].setCurrentOption("off");
     408  parameters_[whichParam(CLIQUECUTS,numberParameters_,parameters_)].setCurrentOption("ifmove");
     409  parameters_[whichParam(MIXEDCUTS,numberParameters_,parameters_)].setCurrentOption("ifmove");
     410  parameters_[whichParam(FLOWCUTS,numberParameters_,parameters_)].setCurrentOption("ifmove");
     411  parameters_[whichParam(TWOMIRCUTS,numberParameters_,parameters_)].setCurrentOption("root");
     412  parameters_[whichParam(LANDPCUTS,numberParameters_,parameters_)].setCurrentOption("off");
     413  parameters_[whichParam(RESIDCUTS,numberParameters_,parameters_)].setCurrentOption("off");
     414  parameters_[whichParam(ROUNDING,numberParameters_,parameters_)].setCurrentOption("on");
     415  parameters_[whichParam(FPUMP,numberParameters_,parameters_)].setCurrentOption("on");
     416  parameters_[whichParam(GREEDY,numberParameters_,parameters_)].setCurrentOption("on");
     417  parameters_[whichParam(COMBINE,numberParameters_,parameters_)].setCurrentOption("on");
     418  parameters_[whichParam(RINS,numberParameters_,parameters_)].setCurrentOption("off");
     419  parameters_[whichParam(LOCALTREE,numberParameters_,parameters_)].setCurrentOption("off");
     420  parameters_[whichParam(COSTSTRATEGY,numberParameters_,parameters_)].setCurrentOption("off");
     421  if (createSolver)
     422    delete clpSolver;
     423}
     424void CbcSolver::fillValuesInSolver()
     425{
     426  OsiSolverInterface * solver = model_.solver();
     427  OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
     428  assert (clpSolver);
     429  noPrinting_ = (clpSolver->getModelPtr()->logLevel()==0);
     430  CoinMessageHandler * generalMessageHandler = clpSolver->messageHandler();
     431  generalMessageHandler->setPrefix(true);
     432  ClpSimplex * lpSolver = clpSolver->getModelPtr();
     433  lpSolver->setPerturbation(50);
     434  lpSolver->messageHandler()->setPrefix(false);
     435  parameters_[whichParam(DUALBOUND,numberParameters_,parameters_)].setDoubleValue(lpSolver->dualBound());
     436  parameters_[whichParam(DUALTOLERANCE,numberParameters_,parameters_)].setDoubleValue(lpSolver->dualTolerance());
     437  int iParam = whichParam(SOLVERLOGLEVEL,numberParameters_,parameters_);
     438  int value=parameters_[iParam].intValue();
     439  clpSolver->messageHandler()->setLogLevel(value) ;
     440  lpSolver->setLogLevel(value);
     441  iParam = whichParam(LOGLEVEL,numberParameters_,parameters_);
     442  value=parameters_[iParam].intValue();
     443  model_.messageHandler()->setLogLevel(value);
     444  parameters_[whichParam(LOGLEVEL,numberParameters_,parameters_)].setIntValue(model_.logLevel());
     445  parameters_[whichParam(SOLVERLOGLEVEL,numberParameters_,parameters_)].setIntValue(lpSolver->logLevel());
     446  parameters_[whichParam(MAXFACTOR,numberParameters_,parameters_)].setIntValue(lpSolver->factorizationFrequency());
     447  parameters_[whichParam(MAXITERATION,numberParameters_,parameters_)].setIntValue(lpSolver->maximumIterations());
     448  parameters_[whichParam(PERTVALUE,numberParameters_,parameters_)].setIntValue(lpSolver->perturbation());
     449  parameters_[whichParam(PRIMALTOLERANCE,numberParameters_,parameters_)].setDoubleValue(lpSolver->primalTolerance());
     450  parameters_[whichParam(PRIMALWEIGHT,numberParameters_,parameters_)].setDoubleValue(lpSolver->infeasibilityCost());
     451  parameters_[whichParam(NUMBERBEFORE,numberParameters_,parameters_)].setIntValue(model_.numberBeforeTrust());
     452  parameters_[whichParam(MAXNODES,numberParameters_,parameters_)].setIntValue(model_.getMaximumNodes());
     453  parameters_[whichParam(STRONGBRANCHING,numberParameters_,parameters_)].setIntValue(model_.numberStrong());
     454  parameters_[whichParam(INFEASIBILITYWEIGHT,numberParameters_,parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcInfeasibilityWeight));
     455  parameters_[whichParam(INTEGERTOLERANCE,numberParameters_,parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcIntegerTolerance));
     456  parameters_[whichParam(INCREMENT,numberParameters_,parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcCutoffIncrement));
     457}
     458// User stuff (base class)
     459CbcUser::CbcUser()
     460  : coinModel_(NULL),
     461    userName_("null")
     462{
     463}
     464CbcUser::~CbcUser()
     465{
     466  delete coinModel_;
     467}
     468// Copy constructor
     469CbcUser::CbcUser ( const CbcUser & rhs)
     470{
     471  if (rhs.coinModel_)
     472    coinModel_ = new CoinModel(*rhs.coinModel_);
     473  else
     474    coinModel_ = NULL;
     475  userName_ = rhs.userName_;
     476}
     477// Assignment operator
     478CbcUser &
     479CbcUser::operator=(const CbcUser & rhs)
     480{
     481  if (this != &rhs) {
     482    if (rhs.coinModel_)
     483      coinModel_ = new CoinModel(*rhs.coinModel_);
     484    else
     485      coinModel_ = NULL;
     486    userName_ = rhs.userName_;
     487  }
     488  return *this;
     489}
     490/* Updates model_ from babModel_ according to returnMode
     491   returnMode -
     492   0 model and solver untouched - babModel updated
     493   1 model updated - just with solution basis etc
     494   2 model updated i.e. as babModel (babModel NULL)
     495*/
     496void
     497CbcSolver::updateModel(ClpSimplex * model2, int returnMode)
     498{
     499  if (!returnMode)
     500    return;
     501  if (returnMode==2&&babModel_)
     502    model_ = *babModel_;
     503  if (model2) {
     504    // Only continuous valid
     505    // update with basis etc
     506    // map states
     507    /* clp status
     508       -1 - unknown e.g. before solve or if postSolve says not optimal
     509       0 - optimal
     510       1 - primal infeasible
     511       2 - dual infeasible
     512       3 - stopped on iterations or time
     513       4 - stopped due to errors
     514       5 - stopped by event handler (virtual int ClpEventHandler::event()) */
     515    /* cbc status
     516       -1 before branchAndBound
     517       0 finished - check isProvenOptimal or isProvenInfeasible to see if solution found
     518       (or check value of best solution)
     519       1 stopped - on maxnodes, maxsols, maxtime
     520       2 difficulties so run was abandoned
     521       (5 event user programmed event occurred) */
     522    /* clp secondary status of problem - may get extended
     523       0 - none
     524       1 - primal infeasible because dual limit reached OR probably primal
     525       infeasible but can't prove it (main status 4)
     526       2 - scaled problem optimal - unscaled problem has primal infeasibilities
     527       3 - scaled problem optimal - unscaled problem has dual infeasibilities
     528       4 - scaled problem optimal - unscaled problem has primal and dual infeasibilities
     529       5 - giving up in primal with flagged variables
     530       6 - failed due to empty problem check
     531       7 - postSolve says not optimal
     532       8 - failed due to bad element check
     533       9 - status was 3 and stopped on time
     534       100 up - translation of enum from ClpEventHandler
     535    */
     536    /* cbc secondary status of problem
     537       -1 unset (status_ will also be -1)
     538       0 search completed with solution
     539       1 linear relaxation not feasible (or worse than cutoff)
     540       2 stopped on gap
     541       3 stopped on nodes
     542       4 stopped on time
     543       5 stopped on user event
     544       6 stopped on solutions
     545       7 linear relaxation unbounded
     546    */
     547    int iStatus = model2->status();
     548    int iStatus2 = model2->secondaryStatus();
     549    if (iStatus==0) {
     550      iStatus2=0;
     551    } else if (iStatus==1) {
     552      iStatus=0;
     553      iStatus2=1; // say infeasible
     554    } else if (iStatus==2) {
     555      iStatus=0;
     556      iStatus2=7; // say unbounded
     557    } else if (iStatus==3) {
     558      iStatus=1;
     559      if (iStatus2==9)
     560        iStatus2=4;
     561      else
     562        iStatus2=3; // Use nodes - as closer than solutions
     563    } else if (iStatus==4) {
     564      iStatus=2; // difficulties
     565      iStatus2=0;
     566    }
     567    model_.setProblemStatus(iStatus);
     568    model_.setSecondaryStatus(iStatus2);
     569    OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model_.solver());
     570    ClpSimplex * lpSolver = clpSolver->getModelPtr();
     571    if (model2!=lpSolver) {
     572      lpSolver->moveInfo(*model2);
     573    }
     574    clpSolver->setWarmStart(NULL); // synchronize bases
     575  } else if (returnMode==1) {
     576    OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model_.solver());
     577    ClpSimplex * lpSolver = clpSolver->getModelPtr();
     578    if (babModel_) {
     579      model_.moveInfo(*babModel_);
     580      int numberColumns = babModel_->getNumCols();
     581      if (babModel_->bestSolution())
     582        model_.setBestSolution(babModel_->bestSolution(),numberColumns,babModel_->getObjValue());
     583      OsiClpSolverInterface * clpSolver1 = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
     584      ClpSimplex * lpSolver1 = clpSolver1->getModelPtr();
     585      if (lpSolver1!=lpSolver) {
     586        lpSolver->moveInfo(*lpSolver1);
     587      }
     588    }
     589    clpSolver->setWarmStart(NULL); // synchronize bases
     590  }
     591  if (returnMode==2) {
     592    delete babModel_;
     593    babModel_=NULL;
     594  }
     595}
     596// Clone
     597CbcUser *
     598CbcUser::clone() const
     599{
     600  return new CbcUser(*this);
     601}
     602// Stop now stuff (base class)
     603CbcStopNow::CbcStopNow()
     604{
     605}
     606CbcStopNow::~CbcStopNow()
     607{
     608}
     609// Copy constructor
     610CbcStopNow::CbcStopNow ( const CbcStopNow & rhs)
     611{
     612}
     613// Assignment operator
     614CbcStopNow &
     615CbcStopNow::operator=(const CbcStopNow & rhs)
     616{
     617  if (this != &rhs) {
     618  }
     619  return *this;
     620}
     621// Clone
     622CbcStopNow *
     623CbcStopNow::clone() const
     624{
     625  return new CbcStopNow(*this);
     626}
     627#endif
    143628#ifdef COIN_HAS_ASL
    144629#include "Cbc_ampl.h"
     
    184669}
    185670#endif
    186 
     671#if 0
     672/* Updates model_ from babModel_ according to returnMode
     673   returnMode -
     674   0 model and solver untouched
     675   1 model updated - just with solution basis etc
     676*/
     677static void updateModel(CbcModel & model_,int returnMode)
     678{
     679  if (!returnMode)
     680    return;
     681  assert (returnMode==1);
     682}
     683#endif
    187684int CbcOrClpRead_mode=1;
    188685FILE * CbcOrClpReadCommand=stdin;
    189686static bool noPrinting=false;
     687#ifdef NEW_STYLE_SOLVER
     688int * CbcSolver::analyze(OsiClpSolverInterface * solverMod, int & numberChanged, double & increment,
     689                     bool changeInt,  CoinMessageHandler * generalMessageHandler)
     690#else
    190691static int * analyze(OsiClpSolverInterface * solverMod, int & numberChanged, double & increment,
    191692                     bool changeInt,  CoinMessageHandler * generalMessageHandler)
     693#endif
    192694{
     695#ifndef NEW_STYLE_SOLVER
     696  bool noPrinting_ = noPrinting;
     697#endif
    193698  OsiSolverInterface * solver = solverMod->clone();
    194699  char generalPrint[200];
     
    433938  delete [] changeRhs;
    434939  delete [] ignore;
    435   //if (numberInteger&&!noPrinting)
     940  //if (numberInteger&&!noPrinting_)
    436941  //printf("%d integer variables",numberInteger);
    437942  if (changeInt) {
    438     //if (!noPrinting) {
     943    //if (!noPrinting_) {
    439944    //if (numberChanged)
    440945    //  printf(" and %d variables made integer\n",numberChanged);
     
    457962    }
    458963  } else {
    459     //if (!noPrinting) {
     964    //if (!noPrinting_) {
    460965    //if (numberChanged)
    461966    //  printf(" and %d variables could be made integer\n",numberChanged);
     
    467972    CbcModel model(*solver);
    468973    model.passInMessageHandler(generalMessageHandler);
    469     if (noPrinting)
     974    if (noPrinting_)
    470975      model.setLogLevel(0);
    471976    model.analyzeObjective();
     
    473978    double increment2=model.getCutoffIncrement();
    474979    if (increment2>increment&&increment2>0.0) {
    475       if (!noPrinting) {
     980      if (!noPrinting_) {
    476981        sprintf(generalPrint,"Cutoff increment increased from %g to %g",increment,increment2);
    477982        CoinMessages generalMessages = solverMod->getModelPtr()->messages();
     
    12671772        if (fixColumn[iColumn+1]-fixColumn[iColumn]==0&&doAction<10)
    12681773          continue;
    1269         double value = fullSolution[iColumn];
     1774        //double value = fullSolution[iColumn];
    12701775        double djValue = dj[iColumn];
    12711776        if (state[iColumn]==1) {
     
    21562661#endif
    21572662}
     2663#ifndef NEW_STYLE_SOLVER
    21582664int callCbc1(const char * input2, CbcModel & model, int callBack(CbcModel * currentSolver, int whereFrom))
    21592665{
     
    22652771}
    22662772int CbcMain1 (int argc, const char *argv[],
    2267               CbcModel  & model, int call_CbcClpUnitTest_on_777)
     2773              CbcModel  & model)
    22682774{
    2269   return CbcMain1(argc,argv,model,dummyCallBack, call_CbcClpUnitTest_on_777);
     2775  return CbcMain1(argc,argv,model,dummyCallBack);
    22702776}
    22712777int callCbc1(const std::string input2, CbcModel & babSolver, int callBack(CbcModel * currentSolver, int whereFrom))
     
    24152921  parameters[whichParam(COSTSTRATEGY,numberParameters,parameters)].setCurrentOption("off");
    24162922}
    2417 
     2923#endif
    24182924/* 1 - add heuristics to model
    24192925   2 - do heuristics (and set cutoff and best solution)
    24202926   3 - for miplib test so skip some
    24212927*/
     2928#ifndef NEW_STYLE_SOLVER
    24222929static int doHeuristics(CbcModel * model,int type)
     2930#else
     2931int
     2932  CbcSolver::doHeuristics(CbcModel * model,int type)
     2933#endif
    24232934{
     2935#ifndef NEW_STYLE_SOLVER
     2936  CbcOrClpParam * parameters_ = parameters;
     2937  int numberParameters_ = numberParameters;
     2938#endif
    24242939  bool anyToDo=false;
    2425   int logLevel = parameters[whichParam(LOGLEVEL,numberParameters,parameters)].intValue();
    2426   int useFpump = parameters[whichParam(FPUMP,numberParameters,parameters)].currentOptionAsInteger();
    2427   int useRounding = parameters[whichParam(ROUNDING,numberParameters,parameters)].currentOptionAsInteger();
    2428   int useGreedy = parameters[whichParam(GREEDY,numberParameters,parameters)].currentOptionAsInteger();
    2429   int useCombine = parameters[whichParam(COMBINE,numberParameters,parameters)].currentOptionAsInteger();
    2430   int useRINS = parameters[whichParam(RINS,numberParameters,parameters)].currentOptionAsInteger();
     2940  int logLevel = parameters_[whichParam(LOGLEVEL,numberParameters_,parameters_)].intValue();
     2941  int useFpump = parameters_[whichParam(FPUMP,numberParameters_,parameters_)].currentOptionAsInteger();
     2942  int useRounding = parameters_[whichParam(ROUNDING,numberParameters_,parameters_)].currentOptionAsInteger();
     2943  int useGreedy = parameters_[whichParam(GREEDY,numberParameters_,parameters_)].currentOptionAsInteger();
     2944  int useCombine = parameters_[whichParam(COMBINE,numberParameters_,parameters_)].currentOptionAsInteger();
     2945  int useRINS = parameters_[whichParam(RINS,numberParameters_,parameters_)].currentOptionAsInteger();
    24312946  // FPump done first as it only works if no solution
    24322947  int kType = (type<3) ? type : 1;
     
    24352950    CbcHeuristicFPump heuristic4(*model);
    24362951    heuristic4.setFractionSmall(0.5);
    2437     double dextra3 = parameters[whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();
     2952    double dextra3 = parameters_[whichParam(DEXTRA3,numberParameters_,parameters_)].doubleValue();
    24382953    if (dextra3)
    24392954      heuristic4.setFractionSmall(dextra3);
    2440     heuristic4.setMaximumPasses(parameters[whichParam(FPUMPITS,numberParameters,parameters)].intValue());
    2441     int pumpTune=parameters[whichParam(FPUMPTUNE,numberParameters,parameters)].intValue();
     2955    heuristic4.setMaximumPasses(parameters_[whichParam(FPUMPITS,numberParameters_,parameters_)].intValue());
     2956    int pumpTune=parameters_[whichParam(FPUMPTUNE,numberParameters_,parameters_)].intValue();
    24422957    if (pumpTune>0) {
    24432958      /*
     
    24772992        model->solver()->getDblParam(OsiDualObjectiveLimit,cutoff);
    24782993        cutoff = CoinMin(cutoff,value + 0.1*fabs(value)*c);
    2479         double dextra1 = parameters[whichParam(DEXTRA1,numberParameters,parameters)].doubleValue();
     2994        double dextra1 = parameters_[whichParam(DEXTRA1,numberParameters_,parameters_)].doubleValue();
    24802995        if (dextra1)
    24812996          cutoff=dextra1;
     
    24883003        //double increment = (0.01*i+0.005)*(fabs(value)+1.0e-12);
    24893004        double increment = 0.0;
    2490         double dextra2 = parameters[whichParam(DEXTRA2,numberParameters,parameters)].doubleValue();
     3005        double dextra2 = parameters_[whichParam(DEXTRA2,numberParameters_,parameters_)].doubleValue();
    24913006        if (dextra2)
    24923007          increment = dextra2;
     
    26153130*/
    26163131
     3132#ifndef NEW_STYLE_SOLVER
    26173133int CbcMain1 (int argc, const char *argv[],
    26183134              CbcModel  & model,
    2619               int callBack(CbcModel * currentSolver, int whereFrom),
    2620               int call_CbcClpUnitTest_on_777)
     3135              int callBack(CbcModel * currentSolver, int whereFrom))
     3136#else
     3137/* This takes a list of commands, does "stuff" and returns
     3138   returnMode -
     3139   0 model and solver untouched - babModel updated
     3140   1 model updated - just with solution basis etc
     3141   2 model updated i.e. as babModel (babModel NULL)
     3142*/
     3143int
     3144  CbcSolver::solve (int argc, const char *argv[], int returnMode)
     3145#endif
    26213146{
     3147#ifndef NEW_STYLE_SOLVER
     3148  CbcOrClpParam * parameters_ = parameters;
     3149  int numberParameters_ = numberParameters;
     3150  CbcModel & model_ = model;
     3151  CbcModel * babModel_ = NULL;
     3152  int returnMode=1;
     3153#else
     3154  delete babModel_;
     3155  babModel_ = NULL;
     3156#endif
    26223157  /* Note
    26233158     This is meant as a stand-alone executable to do as much of coin as possible.
    26243159     It should only have one solver known to it.
    26253160  */
    2626   OsiClpSolverInterface * originalSolver = dynamic_cast<OsiClpSolverInterface *> (model.solver());
     3161  OsiClpSolverInterface * originalSolver = dynamic_cast<OsiClpSolverInterface *> (model_.solver());
    26273162  assert (originalSolver);
    2628   CoinMessageHandler * generalMessageHandler = model.messageHandler();
     3163  CoinMessageHandler * generalMessageHandler = model_.messageHandler();
    26293164  generalMessageHandler->setPrefix(false);
    26303165  // Move handler across if not default
     
    26353170  if (originalSolver->getModelPtr()->logLevel()==0)
    26363171    noPrinting=true;
     3172#ifndef NEW_STYLE_SOLVER
     3173  bool noPrinting_=noPrinting;
     3174#endif
    26373175  // see if log in list
    26383176  for (int i=1;i<argc;i++) {
     
    26403178      const char * equals = strchr(argv[i],'=');
    26413179      if (equals&&atoi(equals+1)>0)
    2642         noPrinting=false;
     3180        noPrinting_=false;
    26433181      else
    2644         noPrinting=true;
     3182        noPrinting_=true;
    26453183      break;
    26463184    } else if (!strncmp(argv[i],"-log",4)&&i<argc-1) {
    26473185      if (atoi(argv[i+1])>0)
    2648         noPrinting=false;
     3186        noPrinting_=false;
    26493187      else
    2650         noPrinting=true;
     3188        noPrinting_=true;
    26513189      break;
    26523190    }
    26533191  }
    2654   CbcModel * babModel = NULL;
    26553192  double time0;
    26563193  {
     
    26693206    // 0 normal, 1 from ampl or MIQP etc (2 allows cuts)
    26703207    int complicatedInteger=0;
    2671     OsiSolverInterface * solver = model.solver();
     3208    OsiSolverInterface * solver = model_.solver();
    26723209    OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
    26733210    ClpSimplex * lpSolver = clpSolver->getModelPtr();
    2674     if (noPrinting) {
     3211    if (noPrinting_) {
    26753212      setCbcOrClpPrinting(false);
    26763213      lpSolver->setLogLevel(0);
     
    27043241      usingAmpl=true;
    27053242      // see if log in list
    2706       noPrinting=true;
     3243      noPrinting_=true;
    27073244      for (int i=1;i<argc;i++) {
    27083245        if (!strncmp(argv[i],"log",3)) {
    27093246          const char * equals = strchr(argv[i],'=');
    27103247          if (equals&&atoi(equals+1)>0) {
    2711             noPrinting=false;
     3248            noPrinting_=false;
    27123249            info.logLevel=atoi(equals+1);
    2713             int log = whichParam(LOGLEVEL,numberParameters,parameters);
    2714             parameters[log].setIntValue(info.logLevel);
     3250            int log = whichParam(LOGLEVEL,numberParameters_,parameters_);
     3251            parameters_[log].setIntValue(info.logLevel);
    27153252            // mark so won't be overWritten
    27163253            info.numberRows=-1234567;
     
    27273264        if (!strcmp(info.arguments[i],"log")) {
    27283265          if (i<info.numberArguments-1&&atoi(info.arguments[i+1])>0)
    2729             noPrinting=false;
     3266            noPrinting_=false;
    27303267          break;
    27313268        }
    27323269      }
    2733       if (noPrinting) {
    2734         model.messageHandler()->setLogLevel(0);
     3270      if (noPrinting_) {
     3271        model_.messageHandler()->setLogLevel(0);
    27353272        setCbcOrClpPrinting(false);
    27363273      }
    2737       if (!noPrinting)
     3274      if (!noPrinting_)
    27383275        printf("%d rows, %d columns and %d elements\n",
    27393276               info.numberRows,info.numberColumns,info.numberElements);
     
    27813318        OsiSolverLink solver1;
    27823319        OsiSolverInterface * solver2 = solver1.clone();
    2783         model.assignSolver(solver2,false);
     3320        model_.assignSolver(solver2,false);
    27843321        OsiSolverLink * si =
    2785           dynamic_cast<OsiSolverLink *>(model.solver()) ;
     3322          dynamic_cast<OsiSolverLink *>(model_.solver()) ;
    27863323        assert (si != NULL);
    27873324        si->setDefaultMeshSize(0.001);
    27883325        // need some relative granularity
    27893326        si->setDefaultBound(100.0);
    2790         double dextra3 = parameters[whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();
     3327        double dextra3 = parameters_[whichParam(DEXTRA3,numberParameters_,parameters_)].doubleValue();
    27913328        if (dextra3)
    27923329          si->setDefaultMeshSize(dextra3);
     
    27953332        si->setBiLinearPriority(10000);
    27963333        CoinModel * model2 = (CoinModel *) coinModel;
    2797         int logLevel = whichParam(LOGLEVEL,numberParameters,parameters);
     3334        int logLevel = whichParam(LOGLEVEL,numberParameters_,parameters_);
    27983335        si->load(*model2,true,logLevel);
    27993336        // redo
    2800         solver = model.solver();
     3337        solver = model_.solver();
    28013338        clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
    28023339        lpSolver = clpSolver->getModelPtr();
    28033340        clpSolver->messageHandler()->setLogLevel(0) ;
    28043341        testOsiParameters=0;
    2805         parameters[whichParam(TESTOSI,numberParameters,parameters)].setIntValue(0);
     3342        parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].setIntValue(0);
    28063343        complicatedInteger=1;
    28073344        if (info.cut) {
     
    29323469    std::string solutionFile ="stdout";
    29333470    std::string solutionSaveFile ="solution.file";
    2934     int slog = whichParam(SOLVERLOGLEVEL,numberParameters,parameters);
    2935     int log = whichParam(LOGLEVEL,numberParameters,parameters);
    2936     double normalIncrement=model.getCutoffIncrement();;
     3471    int slog = whichParam(SOLVERLOGLEVEL,numberParameters_,parameters_);
     3472    int log = whichParam(LOGLEVEL,numberParameters_,parameters_);
     3473    double normalIncrement=model_.getCutoffIncrement();;
    29373474    if (testOsiParameters>=0) {
    29383475      // trying nonlinear - switch off some stuff
     
    30273564   
    30283565    std::string field;
    3029     if (!noPrinting) {
     3566    if (!noPrinting_) {
    30303567      sprintf(generalPrint,"Coin Cbc and Clp Solver version %s, build %s",
    30313568              CBCVERSION,__DATE__);
     
    30943631      int numberMatches=0;
    30953632      int firstMatch=-1;
    3096       for ( iParam=0; iParam<numberParameters; iParam++ ) {
    3097         int match = parameters[iParam].matches(field);
     3633      for ( iParam=0; iParam<numberParameters_; iParam++ ) {
     3634        int match = parameters_[iParam].matches(field);
    30983635        if (match==1) {
    30993636          numberMatches = 1;
     
    31063643        }
    31073644      }
    3108       if (iParam<numberParameters&&!numberQuery) {
     3645      if (iParam<numberParameters_&&!numberQuery) {
    31093646        // found
    3110         CbcOrClpParam found = parameters[iParam];
     3647        CbcOrClpParam found = parameters_[iParam];
    31113648        CbcOrClpParameterType type = found.type();
    31123649        int valid;
     
    31223659          lpSolver = clpSolver->getModelPtr();
    31233660          if (!lpSolver->integerInformation()&&!numberSOS&&
    3124               !clpSolver->numberSOS()&&!model.numberObjects()&&!clpSolver->numberObjects())
     3661              !clpSolver->numberSOS()&&!model_.numberObjects()&&!clpSolver->numberObjects())
    31253662            type=DUALSIMPLEX;
    31263663        }
     
    31713708            if ((verbose&2)!=0)
    31723709              std::cout<<std::endl;
    3173             for ( iParam=0; iParam<numberParameters; iParam++ ) {
    3174               int type = parameters[iParam].type();
    3175               if ((parameters[iParam].displayThis()||evenHidden)&&
     3710            for ( iParam=0; iParam<numberParameters_; iParam++ ) {
     3711              int type = parameters_[iParam].type();
     3712              if ((parameters_[iParam].displayThis()||evenHidden)&&
    31763713                  type>=limits[iType]
    31773714                  &&type<limits[iType+1]) {
    31783715                // but skip if not useful for ampl (and in ampl mode)
    3179                 if (verbose>=4&&(parameters[iParam].whereUsed()&4)==0)
     3716                if (verbose>=4&&(parameters_[iParam].whereUsed()&4)==0)
    31803717                  continue;
    31813718                if (!across) {
     
    31853722                    std::cout<<"Command ";
    31863723                }
    3187                 std::cout<<parameters[iParam].matchName()<<"  ";
     3724                std::cout<<parameters_[iParam].matchName()<<"  ";
    31883725                across++;
    31893726                if (across==maxAcross) {
     
    31923729                    // put out description as well
    31933730                    if ((verbose&1)!=0)
    3194                       std::cout<<parameters[iParam].shortHelp();
     3731                      std::cout<<parameters_[iParam].shortHelp();
    31953732                    std::cout<<std::endl;
    31963733                    if ((verbose&2)!=0) {
    31973734                      std::cout<<"---- description"<<std::endl;
    3198                       parameters[iParam].printLongHelp();
     3735                      parameters_[iParam].printLongHelp();
    31993736                      std::cout<<"----"<<std::endl<<std::endl;
    32003737                    }
     
    32253762            int across=0;
    32263763            std::cout<<types[iType]<<"  ";
    3227             for ( iParam=0; iParam<numberParameters; iParam++ ) {
    3228               int type = parameters[iParam].type();
     3764            for ( iParam=0; iParam<numberParameters_; iParam++ ) {
     3765              int type = parameters_[iParam].type();
    32293766              if (type>=limits[iType]
    32303767                  &&type<limits[iType+1]) {
    32313768                if (!across)
    32323769                  std::cout<<"  ";
    3233                 std::cout<<parameters[iParam].matchName()<<"  ";
     3770                std::cout<<parameters_[iParam].matchName()<<"  ";
    32343771                across++;
    32353772                if (across==maxAcross) {
     
    32473784          if (!valid) {
    32483785            if (type<51) {
    3249               parameters[iParam].setDoubleParameter(lpSolver,value);
     3786              parameters_[iParam].setDoubleParameter(lpSolver,value);
    32503787            } else if (type<81) {
    3251               parameters[iParam].setDoubleParameter(model,value);
     3788              parameters_[iParam].setDoubleParameter(model_,value);
    32523789            } else {
    3253               parameters[iParam].setDoubleParameter(lpSolver,value);
     3790              parameters_[iParam].setDoubleParameter(lpSolver,value);
    32543791              switch(type) {
    32553792              case DJFIX:
     
    32573794                if (goodModel&&djFix<1.0e20) {
    32583795                  // do some fixing
    3259                   clpSolver = dynamic_cast< OsiClpSolverInterface*> (model.solver());
     3796                  clpSolver = dynamic_cast< OsiClpSolverInterface*> (model_.solver());
    32603797                  clpSolver->initialSolve();
    32613798                  lpSolver = clpSolver->getModelPtr();
     
    32683805                  double * dj = lpSolver->dualColumnSolution();
    32693806                  int numberFixed=0;
    3270                   double dextra4 = parameters[whichParam(DEXTRA4,numberParameters,parameters)].doubleValue();
     3807                  double dextra4 = parameters_[whichParam(DEXTRA4,numberParameters_,parameters_)].doubleValue();
    32713808                  if (dextra4)
    32723809                    printf("Multiple for continuous dj fixing is %g\n",dextra4);
     
    33073844            }
    33083845          } else if (valid==1) {
    3309             std::cout<<" is illegal for double parameter "<<parameters[iParam].name()<<" value remains "<<
    3310               parameters[iParam].doubleValue()<<std::endl;
     3846            std::cout<<" is illegal for double parameter "<<parameters_[iParam].name()<<" value remains "<<
     3847              parameters_[iParam].doubleValue()<<std::endl;
    33113848          } else {
    3312             std::cout<<parameters[iParam].name()<<" has value "<<
    3313               parameters[iParam].doubleValue()<<std::endl;
     3849            std::cout<<parameters_[iParam].name()<<" has value "<<
     3850              parameters_[iParam].doubleValue()<<std::endl;
    33143851          }
    33153852        } else if (type<201) {
     
    33183855          if (!valid) {
    33193856            if (type<151) {
    3320               if (parameters[iParam].type()==PRESOLVEPASS)
     3857              if (parameters_[iParam].type()==PRESOLVEPASS)
    33213858                preSolve = value;
    3322               else if (parameters[iParam].type()==IDIOT)
     3859              else if (parameters_[iParam].type()==IDIOT)
    33233860                doIdiot = value;
    3324               else if (parameters[iParam].type()==SPRINT)
     3861              else if (parameters_[iParam].type()==SPRINT)
    33253862                doSprint = value;
    3326               else if (parameters[iParam].type()==OUTPUTFORMAT)
     3863              else if (parameters_[iParam].type()==OUTPUTFORMAT)
    33273864                outputFormat = value;
    3328               else if (parameters[iParam].type()==SLPVALUE)
     3865              else if (parameters_[iParam].type()==SLPVALUE)
    33293866                slpValue = value;
    3330               else if (parameters[iParam].type()==CPP)
     3867              else if (parameters_[iParam].type()==CPP)
    33313868                cppValue = value;
    3332               else if (parameters[iParam].type()==PRESOLVEOPTIONS)
     3869              else if (parameters_[iParam].type()==PRESOLVEOPTIONS)
    33333870                presolveOptions = value;
    3334               else if (parameters[iParam].type()==PRINTOPTIONS)
     3871              else if (parameters_[iParam].type()==PRINTOPTIONS)
    33353872                printOptions = value;
    3336               else if (parameters[iParam].type()==SUBSTITUTION)
     3873              else if (parameters_[iParam].type()==SUBSTITUTION)
    33373874                substitution = value;
    3338               else if (parameters[iParam].type()==DUALIZE)
     3875              else if (parameters_[iParam].type()==DUALIZE)
    33393876                dualize = value;
    3340               else if (parameters[iParam].type()==PROCESSTUNE)
     3877              else if (parameters_[iParam].type()==PROCESSTUNE)
    33413878                tunePreProcess = value;
    3342               else if (parameters[iParam].type()==VERBOSE)
     3879              else if (parameters_[iParam].type()==VERBOSE)
    33433880                verbose = value;
    3344               parameters[iParam].setIntParameter(lpSolver,value);
     3881              parameters_[iParam].setIntParameter(lpSolver,value);
    33453882            } else {
    3346               if (parameters[iParam].type()==CUTPASS)
     3883              if (parameters_[iParam].type()==CUTPASS)
    33473884                cutPass = value;
    3348               else if (parameters[iParam].type()==CUTPASSINTREE)
     3885              else if (parameters_[iParam].type()==CUTPASSINTREE)
    33493886                cutPassInTree = value;
    3350               else if (parameters[iParam].type()==STRONGBRANCHING||
    3351                        parameters[iParam].type()==NUMBERBEFORE)
     3887              else if (parameters_[iParam].type()==STRONGBRANCHING||
     3888                       parameters_[iParam].type()==NUMBERBEFORE)
    33523889                strongChanged=true;
    3353               parameters[iParam].setIntParameter(model,value);
     3890              parameters_[iParam].setIntParameter(model_,value);
    33543891            }
    33553892          } else if (valid==1) {
    3356             std::cout<<" is illegal for integer parameter "<<parameters[iParam].name()<<" value remains "<<
    3357               parameters[iParam].intValue()<<std::endl;
     3893            std::cout<<" is illegal for integer parameter "<<parameters_[iParam].name()<<" value remains "<<
     3894              parameters_[iParam].intValue()<<std::endl;
    33583895          } else {
    3359             std::cout<<parameters[iParam].name()<<" has value "<<
    3360               parameters[iParam].intValue()<<std::endl;
     3896            std::cout<<parameters_[iParam].name()<<" has value "<<
     3897              parameters_[iParam].intValue()<<std::endl;
    33613898          }
    33623899        } else if (type<301) {
    33633900          // one of several strings
    33643901          std::string value = CoinReadGetString(argc,argv);
    3365           int action = parameters[iParam].parameterOption(value);
     3902          int action = parameters_[iParam].parameterOption(value);
    33663903          if (action<0) {
    33673904            if (value!="EOL") {
    33683905              // no match
    3369               parameters[iParam].printOptions();
     3906              parameters_[iParam].printOptions();
    33703907            } else {
    33713908              // print current value
    3372               std::cout<<parameters[iParam].name()<<" has value "<<
    3373                 parameters[iParam].currentOption()<<std::endl;
     3909              std::cout<<parameters_[iParam].name()<<" has value "<<
     3910                parameters_[iParam].currentOption()<<std::endl;
    33743911            }
    33753912          } else {
    3376             parameters[iParam].setCurrentOption(action,!noPrinting);
     3913            parameters_[iParam].setCurrentOption(action,!noPrinting_);
    33773914            // for now hard wired
    33783915            switch (type) {
     
    35574094              twomirAction = action;
    35584095              //landpAction = action;
    3559               parameters[whichParam(GOMORYCUTS,numberParameters,parameters)].setCurrentOption(action);
    3560               parameters[whichParam(PROBINGCUTS,numberParameters,parameters)].setCurrentOption(action);
    3561               parameters[whichParam(KNAPSACKCUTS,numberParameters,parameters)].setCurrentOption(action);
    3562               parameters[whichParam(CLIQUECUTS,numberParameters,parameters)].setCurrentOption(action);
    3563               parameters[whichParam(FLOWCUTS,numberParameters,parameters)].setCurrentOption(action);
    3564               parameters[whichParam(MIXEDCUTS,numberParameters,parameters)].setCurrentOption(action);
    3565               parameters[whichParam(TWOMIRCUTS,numberParameters,parameters)].setCurrentOption(action);
     4096              parameters_[whichParam(GOMORYCUTS,numberParameters_,parameters_)].setCurrentOption(action);
     4097              parameters_[whichParam(PROBINGCUTS,numberParameters_,parameters_)].setCurrentOption(action);
     4098              parameters_[whichParam(KNAPSACKCUTS,numberParameters_,parameters_)].setCurrentOption(action);
     4099              parameters_[whichParam(CLIQUECUTS,numberParameters_,parameters_)].setCurrentOption(action);
     4100              parameters_[whichParam(FLOWCUTS,numberParameters_,parameters_)].setCurrentOption(action);
     4101              parameters_[whichParam(MIXEDCUTS,numberParameters_,parameters_)].setCurrentOption(action);
     4102              parameters_[whichParam(TWOMIRCUTS,numberParameters_,parameters_)].setCurrentOption(action);
    35664103              if (!action) {
    35674104                redsplitAction = action;
    3568                 parameters[whichParam(REDSPLITCUTS,numberParameters,parameters)].setCurrentOption(action);
     4105                parameters_[whichParam(REDSPLITCUTS,numberParameters_,parameters_)].setCurrentOption(action);
    35694106                landpAction = action;
    3570                 parameters[whichParam(LANDPCUTS,numberParameters,parameters)].setCurrentOption(action);
     4107                parameters_[whichParam(LANDPCUTS,numberParameters_,parameters_)].setCurrentOption(action);
    35714108                residualCapacityAction = action;
    3572                 parameters[whichParam(RESIDCUTS,numberParameters,parameters)].setCurrentOption(action);
     4109                parameters_[whichParam(RESIDCUTS,numberParameters_,parameters_)].setCurrentOption(action);
    35734110              }
    35744111              break;
    35754112            case HEURISTICSTRATEGY:
    3576               parameters[whichParam(ROUNDING,numberParameters,parameters)].setCurrentOption(action);
    3577               parameters[whichParam(GREEDY,numberParameters,parameters)].setCurrentOption(action);
    3578               parameters[whichParam(COMBINE,numberParameters,parameters)].setCurrentOption(action);
    3579               //parameters[whichParam(LOCALTREE,numberParameters,parameters)].setCurrentOption(action);
    3580               parameters[whichParam(FPUMP,numberParameters,parameters)].setCurrentOption(action);
     4113              parameters_[whichParam(ROUNDING,numberParameters_,parameters_)].setCurrentOption(action);
     4114              parameters_[whichParam(GREEDY,numberParameters_,parameters_)].setCurrentOption(action);
     4115              parameters_[whichParam(COMBINE,numberParameters_,parameters_)].setCurrentOption(action);
     4116              //parameters_[whichParam(LOCALTREE,numberParameters_,parameters_)].setCurrentOption(action);
     4117              parameters_[whichParam(FPUMP,numberParameters_,parameters_)].setCurrentOption(action);
    35814118              break;
    35824119            case GREEDY:
     
    36294166            if (goodModel) {
    36304167              double objScale =
    3631                 parameters[whichParam(OBJSCALE2,numberParameters,parameters)].doubleValue();
     4168                parameters_[whichParam(OBJSCALE2,numberParameters_,parameters_)].doubleValue();
    36324169              if (objScale!=1.0) {
    36334170                int iColumn;
     
    36644201                model2->setOptimizationDirection(1.0);
    36654202              }
    3666               if (noPrinting)
     4203              if (noPrinting_)
    36674204                lpSolver->setLogLevel(0);
    36684205              ClpSolve solveOptions;
     
    37764313                solveOptions.setSpecialOption(4,barrierOptions);
    37774314              }
    3778               model2->setMaximumSeconds(model.getMaximumSeconds());
     4315              model2->setMaximumSeconds(model_.getMaximumSeconds());
    37794316#ifdef COIN_HAS_LINK
    3780               OsiSolverInterface * coinSolver = model.solver();
     4317              OsiSolverInterface * coinSolver = model_.solver();
    37814318              OsiSolverLink * linkSolver = dynamic_cast< OsiSolverLink*> (coinSolver);
    37824319              if (!linkSolver) {
     
    37844321              } else {
    37854322                // special solver
    3786                 int testOsiOptions = parameters[whichParam(TESTOSI,numberParameters,parameters)].intValue();
     4323                int testOsiOptions = parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].intValue();
    37874324                double * solution = NULL;
    37884325                if (testOsiOptions<10) {
     
    38714408                  iStatus2=0;
    38724409                }
    3873                 model.setProblemStatus(iStatus);
    3874                 model.setSecondaryStatus(iStatus2);
     4410                model_.setProblemStatus(iStatus);
     4411                model_.setSecondaryStatus(iStatus2);
    38754412                assert (lpSolver==clpSolver->getModelPtr());
    3876                 assert (clpSolver==model.solver());
     4413                assert (clpSolver==model_.solver());
    38774414                clpSolver->setWarmStart(NULL);
    38784415                // and in babModel if exists
    3879                 if (babModel) {
    3880                   babModel->setProblemStatus(iStatus);
    3881                   babModel->setSecondaryStatus(iStatus2);
     4416                if (babModel_) {
     4417                  babModel_->setProblemStatus(iStatus);
     4418                  babModel_->setSecondaryStatus(iStatus2);
    38824419                }
     4420#ifdef NEW_STYLE_SOLVER
     4421                int returnCode = callBack_->callBack(&model_,1);
     4422#else
    38834423                int returnCode=callBack(&model,1);
     4424#endif
    38844425                if (returnCode) {
    38854426                  // exit if user wants
    3886                   delete babModel;
     4427#ifdef NEW_STYLE_SOLVER
     4428                  updateModel(model2,returnMode);
     4429#else
     4430                  delete babModel_;
     4431                  babModel_ = NULL;
     4432#endif
    38874433                  return returnCode;
    38884434                }
     
    39774523                  pinfo.statistics();
    39784524                double presolveTolerance =
    3979                   parameters[whichParam(PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();
     4525                  parameters_[whichParam(PRESOLVETOLERANCE,numberParameters_,parameters_)].doubleValue();
    39804526                model2 =
    39814527                  pinfo.presolvedModel(*lpSolver,presolveTolerance,
     
    40424588              storedCuts = dupcuts.outDuplicates(clpSolver)!=0;
    40434589              int nOut = numberRows-clpSolver->getNumRows();
    4044               if (nOut&&!noPrinting)
     4590              if (nOut&&!noPrinting_)
    40454591                sprintf(generalPrint,"%d rows eliminated",nOut);
    40464592              generalMessageHandler->message(CLP_GENERAL,generalMessages)
     
    40784624          case DOHEURISTIC:
    40794625            if (goodModel) {
    4080               int vubAction = parameters[whichParam(VUBTRY,numberParameters,parameters)].intValue();
     4626              int vubAction = parameters_[whichParam(VUBTRY,numberParameters_,parameters_)].intValue();
    40814627              if (vubAction!=-1) {
    40824628                // look at vubs
    40834629                // Just ones which affect >= extra3
    4084                 int extra3 = parameters[whichParam(EXTRA3,numberParameters,parameters)].intValue();
     4630                int extra3 = parameters_[whichParam(EXTRA3,numberParameters_,parameters_)].intValue();
    40854631                /* 3 is fraction of integer variables fixed (0.97)
    40864632                   4 is fraction of all variables fixed (0.0)
    40874633                */
    40884634                double dextra[5];
    4089                 dextra[1] = parameters[whichParam(DEXTRA1,numberParameters,parameters)].doubleValue();
    4090                 dextra[2] = parameters[whichParam(DEXTRA2,numberParameters,parameters)].doubleValue();
    4091                 dextra[3] = parameters[whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();
    4092                 dextra[4] = parameters[whichParam(DEXTRA4,numberParameters,parameters)].doubleValue();
     4635                dextra[1] = parameters_[whichParam(DEXTRA1,numberParameters_,parameters_)].doubleValue();
     4636                dextra[2] = parameters_[whichParam(DEXTRA2,numberParameters_,parameters_)].doubleValue();
     4637                dextra[3] = parameters_[whichParam(DEXTRA3,numberParameters_,parameters_)].doubleValue();
     4638                dextra[4] = parameters_[whichParam(DEXTRA4,numberParameters_,parameters_)].doubleValue();
    40934639                if (!dextra[3])
    40944640                  dextra[3] = 0.97;
    4095                 OsiClpSolverInterface * newSolver = fixVubs(model,extra3,vubAction,generalMessageHandler,
     4641                OsiClpSolverInterface * newSolver = fixVubs(model_,extra3,vubAction,generalMessageHandler,
    40964642                                                            debugValues,dextra);
    40974643                assert (!newSolver);
    40984644              }
    40994645              // Actually do heuristics
    4100               doHeuristics(&model,2);
    4101               if (model.bestSolution()) {
    4102                 model.setProblemStatus(1);
    4103                 model.setSecondaryStatus(6);
     4646              doHeuristics(&model_,2);
     4647              if (model_.bestSolution()) {
     4648                model_.setProblemStatus(1);
     4649                model_.setSecondaryStatus(6);
    41044650              }
     4651#ifdef NEW_STYLE_SOLVER
     4652              int returnCode = callBack_->callBack(&model_,6);
     4653#else
    41054654              int returnCode=callBack(&model,6);
     4655#endif
    41064656              if (returnCode) {
    41074657                // exit if user wants
    4108                 delete babModel;
     4658#ifdef NEW_STYLE_SOLVER
     4659                updateModel(NULL,returnMode);
     4660#else
     4661                delete babModel_;
     4662                babModel_ = NULL;
     4663#endif
    41094664                return returnCode;
    41104665              }
     
    41224677            if (goodModel) {
    41234678              bool miplib = type==MIPLIB;
    4124               int logLevel = parameters[slog].intValue();
     4679              int logLevel = parameters_[slog].intValue();
    41254680              // Reduce printout
    41264681              if (logLevel<=1)
    4127                 model.solver()->setHintParam(OsiDoReducePrint,true,OsiHintTry);
     4682                model_.solver()->setHintParam(OsiDoReducePrint,true,OsiHintTry);
    41284683              {
    4129                 OsiSolverInterface * solver = model.solver();
     4684                OsiSolverInterface * solver = model_.solver();
    41304685                OsiClpSolverInterface * si =
    41314686                  dynamic_cast<OsiClpSolverInterface *>(solver) ;
     
    41384693                  if (obj) {
    41394694                    preProcess=0;
    4140                     int testOsiOptions = parameters[whichParam(TESTOSI,numberParameters,parameters)].intValue();
    4141                     parameters[whichParam(TESTOSI,numberParameters,parameters)].setIntValue(CoinMax(0,testOsiOptions));
     4695                    int testOsiOptions = parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].intValue();
     4696                    parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].setIntValue(CoinMax(0,testOsiOptions));
    41424697                    // create coin model
    41434698                    coinModel = lpSolver->createCoinModel();
     
    41464701                    OsiSolverLink solver1;
    41474702                    OsiSolverInterface * solver2 = solver1.clone();
    4148                     model.assignSolver(solver2,false);
     4703                    model_.assignSolver(solver2,false);
    41494704                    OsiSolverLink * si =
    4150                       dynamic_cast<OsiSolverLink *>(model.solver()) ;
     4705                      dynamic_cast<OsiSolverLink *>(model_.solver()) ;
    41514706                    assert (si != NULL);
    41524707                    si->setDefaultMeshSize(0.001);
    41534708                    // need some relative granularity
    41544709                    si->setDefaultBound(100.0);
    4155                     double dextra3 = parameters[whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();
     4710                    double dextra3 = parameters_[whichParam(DEXTRA3,numberParameters_,parameters_)].doubleValue();
    41564711                    if (dextra3)
    41574712                      si->setDefaultMeshSize(dextra3);
     
    41614716                    si->setSpecialOptions2(2+4+8);
    41624717                    CoinModel * model2 = (CoinModel *) coinModel;
    4163                     si->load(*model2,true, parameters[log].intValue());
     4718                    si->load(*model2,true, parameters_[log].intValue());
    41644719                    // redo
    4165                     solver = model.solver();
     4720                    solver = model_.solver();
    41664721                    clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
    41674722                    lpSolver = clpSolver->getModelPtr();
     
    41694724                    testOsiParameters=0;
    41704725                    complicatedInteger=2;  // allow cuts
    4171                     OsiSolverInterface * coinSolver = model.solver();
     4726                    OsiSolverInterface * coinSolver = model_.solver();
    41724727                    OsiSolverLink * linkSolver = dynamic_cast< OsiSolverLink*> (coinSolver);
    41734728                    if (linkSolver->quadraticModel()) {
     
    42914846                      cbcModel->initialSolve();
    42924847#ifdef CBC_THREAD
    4293                       int numberThreads =parameters[whichParam(THREADS,numberParameters,parameters)].intValue();
     4848                      int numberThreads =parameters_[whichParam(THREADS,numberParameters_,parameters_)].intValue();
    42944849                      cbcModel->setNumberThreads(numberThreads%100);
    42954850                      cbcModel->setThreadMode(numberThreads/100);
     
    43024857                      linkSolver->setBestObjectiveValue(bestObjectiveValue);
    43034858                      linkSolver->setBestSolution(solution,solver3->getNumCols());
    4304                       CbcHeuristicDynamic3 dynamic(model);
     4859                      CbcHeuristicDynamic3 dynamic(model_);
    43054860                      dynamic.setHeuristicName("dynamic pass thru");
    4306                       model.addHeuristic(&dynamic);
     4861                      model_.addHeuristic(&dynamic);
    43074862                      // if convex
    43084863                      if ((linkSolver->specialOptions2()&4)!=0) {
     
    43424897              if (!miplib) {
    43434898                if (!preSolve) {
    4344                   model.solver()->setHintParam(OsiDoPresolveInInitial,false,OsiHintTry);
    4345                   model.solver()->setHintParam(OsiDoPresolveInResolve,false,OsiHintTry);
     4899                  model_.solver()->setHintParam(OsiDoPresolveInInitial,false,OsiHintTry);
     4900                  model_.solver()->setHintParam(OsiDoPresolveInResolve,false,OsiHintTry);
    43464901                }
    43474902                double time1a = CoinCpuTime();
    4348                 model.initialSolve();
    4349                 OsiSolverInterface * solver = model.solver();
     4903                model_.initialSolve();
     4904                OsiSolverInterface * solver = model_.solver();
    43504905                OsiClpSolverInterface * si =
    43514906                  dynamic_cast<OsiClpSolverInterface *>(solver) ;
     
    43714926                  iStatus2=0;
    43724927                }
    4373                 model.setProblemStatus(iStatus);
    4374                 model.setSecondaryStatus(iStatus2);
     4928                model_.setProblemStatus(iStatus);
     4929                model_.setSecondaryStatus(iStatus2);
    43754930                si->setWarmStart(NULL);
    4376                 int returnCode=callBack(&model,1);
     4931#ifdef NEW_STYLE_SOLVER
     4932                int returnCode = callBack_->callBack(&model_,1);
     4933#else
     4934                int returnCode=callBack(&model_,1);
     4935#endif
    43774936                if (returnCode) {
    43784937                  // exit if user wants
    4379                   delete babModel;
     4938#ifdef NEW_STYLE_SOLVER
     4939                  updateModel(NULL,returnMode);
     4940#else
     4941                  delete babModel_;
     4942                  babModel_ = NULL;
     4943#endif
    43804944                  return returnCode;
    43814945                }
    43824946                clpSolver->setSpecialOptions(clpSolver->specialOptions()|0x01000000); // say is Cbc (and in branch and bound)
    4383                 if (!noPrinting) {
     4947                if (!noPrinting_) {
    43844948                  sprintf(generalPrint,"Continuous objective value is %g - %.2f seconds",
    43854949                          solver->getObjValue(),CoinCpuTime()-time1a);
     
    43924956                  std::cout<<"Problem is infeasible - tightenPrimalBounds!"<<std::endl;
    43934957#endif
    4394                   model.setProblemStatus(0);
    4395                   model.setSecondaryStatus(1);
     4958                  model_.setProblemStatus(0);
     4959                  model_.setSecondaryStatus(1);
    43964960                  // and in babModel if exists
    4397                   if (babModel) {
    4398                     babModel->setProblemStatus(0);
    4399                     babModel->setSecondaryStatus(1);
     4961                  if (babModel_) {
     4962                    babModel_->setProblemStatus(0);
     4963                    babModel_->setSecondaryStatus(1);
    44004964                  }
    44014965                  break;
     
    44465010                      largest = CoinMax(largest,below);
    44475011                  }
    4448                   //if (!noPrinting)
     5012                  //if (!noPrinting_)
    44495013                  //std::cout<<"Largest (scaled) away from bound "<<largest<<std::endl;
    44505014                  clpSolver->setDualBound(CoinMax(1.0001e8,CoinMin(1000.0*largest,1.00001e10)));
     
    44545018              // If user made settings then use them
    44555019              if (!defaultSettings) {
    4456                 OsiSolverInterface * solver = model.solver();
     5020                OsiSolverInterface * solver = model_.solver();
    44575021                if (!doScaling)
    44585022                  solver->setHintParam(OsiDoScale,false,OsiHintTry);
     
    44725036                    std::cout<<"Problem is infeasible!"<<std::endl;
    44735037#endif
    4474                     model.setProblemStatus(0);
    4475                     model.setSecondaryStatus(1);
     5038                    model_.setProblemStatus(0);
     5039                    model_.setSecondaryStatus(1);
    44765040                    // and in babModel if exists
    4477                     if (babModel) {
    4478                       babModel->setProblemStatus(0);
    4479                       babModel->setSecondaryStatus(1);
     5041                    if (babModel_) {
     5042                      babModel_->setProblemStatus(0);
     5043                      babModel_->setSecondaryStatus(1);
    44805044                    }
    44815045                    break;
     
    44885052              // Say integers in sync
    44895053              bool integersOK=true;
    4490               delete babModel;
    4491               babModel = new CbcModel(model);
     5054              delete babModel_;
     5055              babModel_ = new CbcModel(model_);
    44925056              OsiSolverInterface * solver3 = clpSolver->clone();
    4493               babModel->assignSolver(solver3);
    4494               OsiClpSolverInterface * clpSolver2 = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     5057              babModel_->assignSolver(solver3);
     5058              OsiClpSolverInterface * clpSolver2 = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    44955059              int numberChanged=0;
    44965060              if (clpSolver2->messageHandler()->logLevel())
     
    45215085              totalTime += time2-time1;
    45225086              time1 = time2;
    4523               double timeLeft = babModel->getMaximumSeconds();
    4524               int numberOriginalColumns = babModel->solver()->getNumCols();
     5087              double timeLeft = babModel_->getMaximumSeconds();
     5088              int numberOriginalColumns = babModel_->solver()->getNumCols();
    45255089              if (preProcess==7) {
    45265090                // use strategy instead
     
    45685132                  }
    45695133                }
    4570                 saveSolver=babModel->solver()->clone();
     5134                saveSolver=babModel_->solver()->clone();
    45715135                /* Do not try and produce equality cliques and
    45725136                   do up to 10 passes */
     
    45865150                  process.addCutGenerator(&generator1);
    45875151                  int translate[]={9999,0,0,-1,2,3,-2};
    4588                   process.passInMessageHandler(babModel->messageHandler());
    4589                   //process.messageHandler()->setLogLevel(babModel->logLevel());
     5152                  process.passInMessageHandler(babModel_->messageHandler());
     5153                  //process.messageHandler()->setLogLevel(babModel_->logLevel());
    45905154#ifdef COIN_HAS_ASL
    45915155                  if (info.numberSos&&doSOS&&usingAmpl) {
     
    46095173                    delete [] prohibited;
    46105174                  }
    4611                   if (model.numberObjects()) {
    4612                     OsiObject ** oldObjects = babModel->objects();
    4613                     int numberOldObjects = babModel->numberObjects();
     5175                  if (model_.numberObjects()) {
     5176                    OsiObject ** oldObjects = babModel_->objects();
     5177                    int numberOldObjects = babModel_->numberObjects();
    46145178                    // SOS
    46155179                    int numberColumns = saveSolver->getNumCols();
     
    46845248                }
    46855249#endif
    4686                 if (!noPrinting) {
     5250                if (!noPrinting_) {
    46875251                  if (!solver2) {
    46885252                    sprintf(generalPrint,"Pre-processing says infeasible or unbounded");
     
    46965260                }
    46975261                if (!solver2) {
    4698                   model.setProblemStatus(0);
    4699                   model.setSecondaryStatus(1);
    4700                   babModel->setProblemStatus(0);
    4701                   babModel->setSecondaryStatus(1);
     5262                  model_.setProblemStatus(0);
     5263                  model_.setSecondaryStatus(1);
     5264                  babModel_->setProblemStatus(0);
     5265                  babModel_->setSecondaryStatus(1);
    47025266                } else {
    4703                   model.setProblemStatus(-1);
    4704                   babModel->setProblemStatus(-1);
     5267                  model_.setProblemStatus(-1);
     5268                  babModel_->setProblemStatus(-1);
    47055269                }
    4706                 int returnCode=callBack(babModel,2);
     5270#ifdef NEW_STYLE_SOLVER
     5271                int returnCode = callBack_->callBack(babModel_,2);
     5272#else
     5273                int returnCode=callBack(babModel_,2);
     5274#endif
    47075275                if (returnCode) {
    47085276                  // exit if user wants
    4709                   delete babModel;
     5277#ifdef NEW_STYLE_SOLVER
     5278                  updateModel(NULL,returnMode);
     5279#else
     5280                  delete babModel_;
     5281                  babModel_ = NULL;
     5282#endif
    47105283                  return returnCode;
    47115284                }
    47125285                if (!solver2)
    47135286                  break;
    4714                 if (model.bestSolution()) {
     5287                if (model_.bestSolution()) {
    47155288                  // need to redo - in case no better found in BAB
    47165289                  // just get integer part right
    47175290                  const int * originalColumns = process.originalColumns();
    47185291                  int numberColumns = solver2->getNumCols();
    4719                   double * bestSolution = babModel->bestSolution();
    4720                   const double * oldBestSolution = model.bestSolution();
     5292                  double * bestSolution = babModel_->bestSolution();
     5293                  const double * oldBestSolution = model_.bestSolution();
    47215294                  for (int i=0;i<numberColumns;i++) {
    47225295                    int jColumn = originalColumns[i];
     
    47335306                // we have to keep solver2 so pass clone
    47345307                solver2 = solver2->clone();
    4735                 babModel->assignSolver(solver2);
    4736                 babModel->setOriginalColumns(process.originalColumns());
    4737                 babModel->initialSolve();
    4738                 babModel->setMaximumSeconds(timeLeft-(CoinCpuTime()-time1));
     5308                babModel_->assignSolver(solver2);
     5309                babModel_->setOriginalColumns(process.originalColumns());
     5310                babModel_->initialSolve();
     5311                babModel_->setMaximumSeconds(timeLeft-(CoinCpuTime()-time1));
    47395312              }
    47405313              // now tighten bounds
    47415314              if (!miplib) {
    47425315                OsiClpSolverInterface * si =
    4743                   dynamic_cast<OsiClpSolverInterface *>(babModel->solver()) ;
     5316                  dynamic_cast<OsiClpSolverInterface *>(babModel_->solver()) ;
    47445317                assert (si != NULL);
    47455318                // get clp itself
    47465319                ClpSimplex * modelC = si->getModelPtr();
    4747                 //if (noPrinting)
     5320                //if (noPrinting_)
    47485321                //modelC->setLogLevel(0);
    47495322                if (!complicatedInteger&&modelC->tightenPrimalBounds()!=0) {
     
    47515324                  std::cout<<"Problem is infeasible!"<<std::endl;
    47525325#endif
    4753                   model.setProblemStatus(0);
    4754                   model.setSecondaryStatus(1);
    4755                   // and in babModel if exists
    4756                   if (babModel) {
    4757                     babModel->setProblemStatus(0);
    4758                     babModel->setSecondaryStatus(1);
     5326                  model_.setProblemStatus(0);
     5327                  model_.setSecondaryStatus(1);
     5328                  // and in babModel_ if exists
     5329                  if (babModel_) {
     5330                    babModel_->setProblemStatus(0);
     5331                    babModel_->setSecondaryStatus(1);
    47595332                  }
    47605333                  break;
     
    47785351                // for debug
    47795352                std::string problemName ;
    4780                 babModel->solver()->getStrParam(OsiProbName,problemName) ;
    4781                 babModel->solver()->activateRowCutDebugger(problemName.c_str()) ;
     5353                babModel_->solver()->getStrParam(OsiProbName,problemName) ;
     5354                babModel_->solver()->activateRowCutDebugger(problemName.c_str()) ;
    47825355                twomirGen.probname_=strdup(problemName.c_str());
    47835356                // checking seems odd
    4784                 //redsplitGen.set_given_optsol(babModel->solver()->getRowCutDebuggerAlways()->optimalSolution(),
    4785                 //                         babModel->getNumCols());
     5357                //redsplitGen.set_given_optsol(babModel_->solver()->getRowCutDebuggerAlways()->optimalSolution(),
     5358                //                         babModel_->getNumCols());
    47865359              }
    4787               int testOsiOptions = parameters[whichParam(TESTOSI,numberParameters,parameters)].intValue();
     5360              int testOsiOptions = parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].intValue();
    47885361#ifdef COIN_HAS_ASL
    47895362              // If linked then see if expansion wanted
    47905363              {
    4791                 OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel->solver());
    4792                 int options = parameters[whichParam(MIPOPTIONS,numberParameters,parameters)].intValue()/10000;
     5364                OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel_->solver());
     5365                int options = parameters_[whichParam(MIPOPTIONS,numberParameters_,parameters_)].intValue()/10000;
    47935366                if (solver3||(options&16)!=0) {
    47945367                  if (options) {
     
    48075380                      knapsackRow=new int[numberRows];
    48085381                      numberKnapsack=10000;
    4809                       int extra1 = parameters[whichParam(EXTRA1,numberParameters,parameters)].intValue();
    4810                       int extra2 = parameters[whichParam(EXTRA2,numberParameters,parameters)].intValue();
    4811                       int logLevel = parameters[log].intValue();
     5382                      int extra1 = parameters_[whichParam(EXTRA1,numberParameters_,parameters_)].intValue();
     5383                      int extra2 = parameters_[whichParam(EXTRA2,numberParameters_,parameters_)].intValue();
     5384                      int logLevel = parameters_[log].intValue();
    48125385                      OsiSolverInterface * solver = expandKnapsack(saveCoinModel,whichColumn,knapsackStart,
    48135386                                                                   knapsackRow,numberKnapsack,
     
    48185391                        assert (clpSolver);
    48195392                        lpSolver = clpSolver->getModelPtr();
    4820                         babModel->assignSolver(solver);
     5393                        babModel_->assignSolver(solver);
    48215394                        testOsiOptions=0;
    48225395                        // allow gomory
     
    48405413#endif
    48415414              if (useCosts&&testOsiOptions<0) {
    4842                 int numberColumns = babModel->getNumCols();
     5415                int numberColumns = babModel_->getNumCols();
    48435416                int * sort = new int[numberColumns];
    48445417                double * dsort = new double[numberColumns];
    48455418                int * priority = new int [numberColumns];
    4846                 const double * objective = babModel->getObjCoefficients();
    4847                 const double * lower = babModel->getColLower() ;
    4848                 const double * upper = babModel->getColUpper() ;
    4849                 const CoinPackedMatrix * matrix = babModel->solver()->getMatrixByCol();
     5419                const double * objective = babModel_->getObjCoefficients();
     5420                const double * lower = babModel_->getColLower() ;
     5421                const double * upper = babModel_->getColUpper() ;
     5422                const CoinPackedMatrix * matrix = babModel_->solver()->getMatrixByCol();
    48505423                const int * columnLength = matrix->getVectorLengths();
    48515424                int iColumn;
    48525425                int n=0;
    48535426                for (iColumn=0;iColumn<numberColumns;iColumn++) {
    4854                   if (babModel->isInteger(iColumn)) {
     5427                  if (babModel_->isInteger(iColumn)) {
    48555428                    sort[n]=n;
    48565429                    if (useCosts==1)
     
    48775450                  priority[iPut]=level;
    48785451                }
    4879                 babModel->passInPriorities( priority,false);
     5452                babModel_->passInPriorities( priority,false);
    48805453                integersOK=true;
    48815454                delete [] priority;
     
    48845457              }
    48855458              // Set up heuristics
    4886               doHeuristics(babModel,(!miplib) ? 1 : 3);
     5459              doHeuristics(babModel_,(!miplib) ? 1 : 3);
    48875460              if (!miplib) {
    4888                 if(parameters[whichParam(LOCALTREE,numberParameters,parameters)].currentOptionAsInteger()) {
    4889                   CbcTreeLocal localTree(babModel,NULL,10,0,0,10000,2000);
    4890                   babModel->passInTreeHandler(localTree);
     5461                if(parameters_[whichParam(LOCALTREE,numberParameters_,parameters_)].currentOptionAsInteger()) {
     5462                  CbcTreeLocal localTree(babModel_,NULL,10,0,0,10000,2000);
     5463                  babModel_->passInTreeHandler(localTree);
    48915464                }
    48925465              }
    48935466              if (type==MIPLIB) {
    4894                 if (babModel->numberStrong()==5&&babModel->numberBeforeTrust()==5)
    4895                   babModel->setNumberBeforeTrust(10);
     5467                if (babModel_->numberStrong()==5&&babModel_->numberBeforeTrust()==5)
     5468                  babModel_->setNumberBeforeTrust(10);
    48965469              }
    48975470              // add cut generators if wanted
     
    49105483                  probingGen.setMaxLookRoot(50);
    49115484                }
    4912                 babModel->addCutGenerator(&probingGen,translate[probingAction],"Probing");
     5485                babModel_->addCutGenerator(&probingGen,translate[probingAction],"Probing");
    49135486                switches[numberGenerators++]=0;
    49145487              }
    49155488              if (gomoryAction&&(complicatedInteger!=1||
    49165489                                 (gomoryAction==1||gomoryAction==4))) {
    4917                 babModel->addCutGenerator(&gomoryGen,translate[gomoryAction],"Gomory");
     5490                babModel_->addCutGenerator(&gomoryGen,translate[gomoryAction],"Gomory");
    49185491                switches[numberGenerators++]=-1;
    49195492              }
    49205493              if (knapsackAction) {
    4921                 babModel->addCutGenerator(&knapsackGen,translate[knapsackAction],"Knapsack");
     5494                babModel_->addCutGenerator(&knapsackGen,translate[knapsackAction],"Knapsack");
    49225495                switches[numberGenerators++]=0;
    49235496              }
    49245497              if (redsplitAction&&!complicatedInteger) {
    4925                 babModel->addCutGenerator(&redsplitGen,translate[redsplitAction],"Reduce-and-split");
     5498                babModel_->addCutGenerator(&redsplitGen,translate[redsplitAction],"Reduce-and-split");
    49265499                switches[numberGenerators++]=1;
    49275500              }
    49285501              if (cliqueAction) {
    4929                 babModel->addCutGenerator(&cliqueGen,translate[cliqueAction],"Clique");
     5502                babModel_->addCutGenerator(&cliqueGen,translate[cliqueAction],"Clique");
    49305503                switches[numberGenerators++]=0;
    49315504              }
    49325505              if (mixedAction) {
    4933                 babModel->addCutGenerator(&mixedGen,translate[mixedAction],"MixedIntegerRounding2");
     5506                babModel_->addCutGenerator(&mixedGen,translate[mixedAction],"MixedIntegerRounding2");
    49345507                switches[numberGenerators++]=-1;
    49355508              }
    49365509              if (flowAction) {
    4937                 babModel->addCutGenerator(&flowGen,translate[flowAction],"FlowCover");
     5510                babModel_->addCutGenerator(&flowGen,translate[flowAction],"FlowCover");
    49385511                switches[numberGenerators++]=1;
    49395512              }
    49405513              if (twomirAction&&!complicatedInteger) {
    4941                 babModel->addCutGenerator(&twomirGen,translate[twomirAction],"TwoMirCuts");
     5514                babModel_->addCutGenerator(&twomirGen,translate[twomirAction],"TwoMirCuts");
    49425515                switches[numberGenerators++]=1;
    49435516              }
    49445517              if (landpAction) {
    4945                 babModel->addCutGenerator(&landpGen,translate[landpAction],"LiftAndProject");
     5518                babModel_->addCutGenerator(&landpGen,translate[landpAction],"LiftAndProject");
    49465519                switches[numberGenerators++]=1;
    49475520              }
    49485521              if (residualCapacityAction) {
    4949                 babModel->addCutGenerator(&residualCapacityGen,translate[residualCapacityAction],"ResidualCapacity");
     5522                babModel_->addCutGenerator(&residualCapacityGen,translate[residualCapacityAction],"ResidualCapacity");
    49505523                switches[numberGenerators++]=1;
    49515524              }
    49525525              if (storedCuts)
    4953                 babModel->setSpecialOptions(babModel->specialOptions()|64);
     5526                babModel_->setSpecialOptions(babModel_->specialOptions()|64);
    49545527              // Say we want timings
    4955               numberGenerators = babModel->numberCutGenerators();
     5528              numberGenerators = babModel_->numberCutGenerators();
    49565529              int iGenerator;
    49575530              int cutDepth=
    4958                 parameters[whichParam(CUTDEPTH,numberParameters,parameters)].intValue();
     5531                parameters_[whichParam(CUTDEPTH,numberParameters_,parameters_)].intValue();
    49595532              for (iGenerator=0;iGenerator<numberGenerators;iGenerator++) {
    4960                 CbcCutGenerator * generator = babModel->cutGenerator(iGenerator);
     5533                CbcCutGenerator * generator = babModel_->cutGenerator(iGenerator);
    49615534                int howOften = generator->howOften();
    49625535                if (howOften==-98||howOften==-99)
     
    49685541              // Could tune more
    49695542              if (!miplib) {
    4970                 babModel->setMinimumDrop(min(5.0e-2,
    4971                                              fabs(babModel->getMinimizationObjValue())*1.0e-3+1.0e-4));
     5543                babModel_->setMinimumDrop(min(5.0e-2,
     5544                                             fabs(babModel_->getMinimizationObjValue())*1.0e-3+1.0e-4));
    49725545                if (cutPass==-1234567) {
    4973                   if (babModel->getNumCols()<500)
    4974                     babModel->setMaximumCutPassesAtRoot(-100); // always do 100 if possible
    4975                   else if (babModel->getNumCols()<5000)
    4976                     babModel->setMaximumCutPassesAtRoot(100); // use minimum drop
     5546                  if (babModel_->getNumCols()<500)
     5547                    babModel_->setMaximumCutPassesAtRoot(-100); // always do 100 if possible
     5548                  else if (babModel_->getNumCols()<5000)
     5549                    babModel_->setMaximumCutPassesAtRoot(100); // use minimum drop
    49775550                  else
    4978                     babModel->setMaximumCutPassesAtRoot(20);
     5551                    babModel_->setMaximumCutPassesAtRoot(20);
    49795552                } else {
    4980                   babModel->setMaximumCutPassesAtRoot(cutPass);
     5553                  babModel_->setMaximumCutPassesAtRoot(cutPass);
    49815554                }
    49825555                if (cutPassInTree==-1234567)
    4983                   babModel->setMaximumCutPasses(1);
     5556                  babModel_->setMaximumCutPasses(1);
    49845557                else
    4985                   babModel->setMaximumCutPasses(cutPassInTree);
     5558                  babModel_->setMaximumCutPasses(cutPassInTree);
    49865559              }
    49875560              // Do more strong branching if small
    4988               //if (babModel->getNumCols()<5000)
    4989               //babModel->setNumberStrong(20);
     5561              //if (babModel_->getNumCols()<5000)
     5562              //babModel_->setNumberStrong(20);
    49905563              // Switch off strong branching if wanted
    4991               //if (babModel->getNumCols()>10*babModel->getNumRows())
    4992               //babModel->setNumberStrong(0);
    4993               if (!noPrinting) {
    4994                 int iLevel = parameters[log].intValue();
     5564              //if (babModel_->getNumCols()>10*babModel_->getNumRows())
     5565              //babModel_->setNumberStrong(0);
     5566              if (!noPrinting_) {
     5567                int iLevel = parameters_[log].intValue();
    49955568                if (iLevel<0) {
    4996                   babModel->setPrintingMode(1);
     5569                  babModel_->setPrintingMode(1);
    49975570                  iLevel = -iLevel;
    49985571                }
    4999                 babModel->messageHandler()->setLogLevel(iLevel);
    5000                 if (babModel->getNumCols()>2000||babModel->getNumRows()>1500||
    5001                     babModel->messageHandler()->logLevel()>1)
    5002                   babModel->setPrintFrequency(100);
     5572                babModel_->messageHandler()->setLogLevel(iLevel);
     5573                if (babModel_->getNumCols()>2000||babModel_->getNumRows()>1500||
     5574                    babModel_->messageHandler()->logLevel()>1)
     5575                  babModel_->setPrintFrequency(100);
    50035576              }
    50045577             
    5005               babModel->solver()->setIntParam(OsiMaxNumIterationHotStart,
    5006                     parameters[whichParam(MAXHOTITS,numberParameters,parameters)].intValue());
    5007               OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     5578              babModel_->solver()->setIntParam(OsiMaxNumIterationHotStart,
     5579                    parameters_[whichParam(MAXHOTITS,numberParameters_,parameters_)].intValue());
     5580              OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    50085581              // go faster stripes
    50095582              if (osiclp->getNumRows()<300&&osiclp->getNumCols()<500) {
    5010                 osiclp->setupForRepeatedUse(2,parameters[slog].intValue());
     5583                osiclp->setupForRepeatedUse(2,parameters_[slog].intValue());
    50115584              } else {
    5012                 osiclp->setupForRepeatedUse(0,parameters[slog].intValue());
     5585                osiclp->setupForRepeatedUse(0,parameters_[slog].intValue());
    50135586              }
    5014               double increment=babModel->getCutoffIncrement();;
     5587              double increment=babModel_->getCutoffIncrement();;
    50155588              int * changed = NULL;
    50165589              if (!miplib&&increment==normalIncrement)
    50175590                changed=analyze( osiclp,numberChanged,increment,false,generalMessageHandler);
    50185591              if (debugValues) {
    5019                 if (numberDebugValues==babModel->getNumCols()) {
     5592                if (numberDebugValues==babModel_->getNumCols()) {
    50205593                  // for debug
    5021                   babModel->solver()->activateRowCutDebugger(debugValues) ;
     5594                  babModel_->solver()->activateRowCutDebugger(debugValues) ;
    50225595                } else {
    50235596                  printf("debug file has incorrect number of columns\n");
    50245597                }
    50255598              }
    5026               babModel->setCutoffIncrement(CoinMax(babModel->getCutoffIncrement(),increment));
     5599              babModel_->setCutoffIncrement(CoinMax(babModel_->getCutoffIncrement(),increment));
    50275600              // Turn this off if you get problems
    50285601              // Used to be automatically set
    5029               int mipOptions = parameters[whichParam(MIPOPTIONS,numberParameters,parameters)].intValue()%10000;
     5602              int mipOptions = parameters_[whichParam(MIPOPTIONS,numberParameters_,parameters_)].intValue()%10000;
    50305603              if (mipOptions!=(1)) {
    50315604                sprintf(generalPrint,"mip options %d",mipOptions);
     
    50365609              osiclp->setSpecialOptions(mipOptions);
    50375610              if (gapRatio < 1.0e100) {
    5038                 double value = babModel->solver()->getObjValue() ;
     5611                double value = babModel_->solver()->getObjValue() ;
    50395612                double value2 = gapRatio*(1.0e-5+fabs(value)) ;
    5040                 babModel->setAllowableGap(value2) ;
     5613                babModel_->setAllowableGap(value2) ;
    50415614                std::cout << "Continuous " << value
    50425615                          << ", so allowable gap set to "
     
    50445617              }
    50455618              // probably faster to use a basis to get integer solutions
    5046               babModel->setSpecialOptions(babModel->specialOptions()|2);
    5047               currentBranchModel = babModel;
     5619              babModel_->setSpecialOptions(babModel_->specialOptions()|2);
     5620              currentBranchModel = babModel_;
    50485621              OsiSolverInterface * strengthenedModel=NULL;
    50495622              if (type==BAB||type==MIPLIB) {
    5050                 int moreMipOptions = parameters[whichParam(MOREMIPOPTIONS,numberParameters,parameters)].intValue();
     5623                int moreMipOptions = parameters_[whichParam(MOREMIPOPTIONS,numberParameters_,parameters_)].intValue();
    50515624                if (moreMipOptions>=0) {
    50525625                  sprintf(generalPrint,"more mip options %d",moreMipOptions);
     
    50545627                    << generalPrint
    50555628                    <<CoinMessageEol;
    5056                   OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     5629                  OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    50575630                  if (moreMipOptions==10000) {
    50585631                    // test memory saving
     
    50655638                  }
    50665639                  if (((moreMipOptions+1)%1000000)!=0)
    5067                     babModel->setSearchStrategy(moreMipOptions%1000000);
     5640                    babModel_->setSearchStrategy(moreMipOptions%1000000);
    50685641                  // go faster stripes
    50695642                  if( moreMipOptions >=999999) {
     
    50995672                if (solutionIn&&useSolution) {
    51005673                  if (preProcess) {
    5101                     int numberColumns = babModel->getNumCols();
     5674                    int numberColumns = babModel_->getNumCols();
    51025675                    // extend arrays in case SOS
    51035676                    int n = originalColumns[numberColumns-1]+1;
     
    51235696                        prioritiesIn2[i]=prioritiesIn2[iColumn];
    51245697                    }
    5125                     babModel->setHotstartSolution(solutionIn2,prioritiesIn2);
     5698                    babModel_->setHotstartSolution(solutionIn2,prioritiesIn2);
    51265699                    delete [] solutionIn2;
    51275700                    delete [] prioritiesIn2;
    51285701                  } else {
    5129                     babModel->setHotstartSolution(solutionIn,prioritiesIn);
     5702                    babModel_->setHotstartSolution(solutionIn,prioritiesIn);
    51305703                  }
    51315704                }
    5132                 OsiSolverInterface * testOsiSolver= (testOsiOptions>=0) ? babModel->solver() : NULL;
     5705                OsiSolverInterface * testOsiSolver= (testOsiOptions>=0) ? babModel_->solver() : NULL;
    51335706                if (!testOsiSolver) {
    51345707                  // *************************************************************
    51355708                  // CbcObjects
    5136                   if (preProcess&&(process.numberSOS()||babModel->numberObjects())) {
     5709                  if (preProcess&&(process.numberSOS()||babModel_->numberObjects())) {
    51375710                    int numberSOS = process.numberSOS();
    5138                     int numberIntegers = babModel->numberIntegers();
     5711                    int numberIntegers = babModel_->numberIntegers();
    51395712                    /* model may not have created objects
    51405713                       If none then create
    51415714                    */
    5142                     if (!numberIntegers||!babModel->numberObjects()) {
     5715                    if (!numberIntegers||!babModel_->numberObjects()) {
    51435716                      int type = (pseudoUp) ? 1 : 0;
    5144                       babModel->findIntegers(true,type);
    5145                       numberIntegers = babModel->numberIntegers();
     5717                      babModel_->findIntegers(true,type);
     5718                      numberIntegers = babModel_->numberIntegers();
    51465719                      integersOK=true;
    51475720                    }
    5148                     OsiObject ** oldObjects = babModel->objects();
     5721                    OsiObject ** oldObjects = babModel_->objects();
    51495722                    // Do sets and priorities
    51505723                    OsiObject ** objects = new OsiObject * [numberSOS];
    51515724                    // set old objects to have low priority
    5152                     int numberOldObjects = babModel->numberObjects();
    5153                     int numberColumns = babModel->getNumCols();
     5725                    int numberOldObjects = babModel_->numberObjects();
     5726                    int numberColumns = babModel_->getNumCols();
    51545727                    // backward pointer to new variables
    51555728                    int * newColumn = new int[numberOriginalColumns];
     
    51805753                        }
    51815754                      }
    5182                       babModel->setNumberObjects(n);
    5183                       babModel->zapIntegerInformation();
     5755                      babModel_->setNumberObjects(n);
     5756                      babModel_->zapIntegerInformation();
    51845757                    }
    51855758                    int nMissing=0;
     
    52495822                      int iStart = starts[iSOS];
    52505823                      int n=starts[iSOS+1]-iStart;
    5251                       objects[iSOS] = new CbcSOS(babModel,n,which+iStart,weight+iStart,
     5824                      objects[iSOS] = new CbcSOS(babModel_,n,which+iStart,weight+iStart,
    52525825                                                 iSOS,type[iSOS]);
    52535826                      // branch on long sets first
     
    52555828                    }
    52565829                    if (numberSOS)
    5257                       babModel->addObjects(numberSOS,objects);
     5830                      babModel_->addObjects(numberSOS,objects);
    52585831                    for (iSOS=0;iSOS<numberSOS;iSOS++)
    52595832                      delete objects[iSOS];
     
    52615834                  } else if (priorities||branchDirection||pseudoDown||pseudoUp||numberSOS) {
    52625835                    // do anyway for priorities etc
    5263                     int numberIntegers = babModel->numberIntegers();
     5836                    int numberIntegers = babModel_->numberIntegers();
    52645837                    /* model may not have created objects
    52655838                       If none then create
    52665839                    */
    5267                     if (!numberIntegers||!babModel->numberObjects()) {
     5840                    if (!numberIntegers||!babModel_->numberObjects()) {
    52685841                      int type = (pseudoUp) ? 1 : 0;
    5269                       babModel->findIntegers(true,type);
     5842                      babModel_->findIntegers(true,type);
    52705843                    }
    52715844                    if (numberSOS) {
     
    52755848                      if (originalColumns) {
    52765849                        // redo sequence numbers
    5277                         int numberColumns = babModel->getNumCols();
     5850                        int numberColumns = babModel_->getNumCols();
    52785851                        int nOld = originalColumns[numberColumns-1]+1;
    52795852                        int * back = new int[nOld];
     
    53055878                        int iStart = sosStart[iSOS];
    53065879                        int n=sosStart[iSOS+1]-iStart;
    5307                         objects[iSOS] = new CbcSOS(babModel,n,sosIndices+iStart,sosReference+iStart,
     5880                        objects[iSOS] = new CbcSOS(babModel_,n,sosIndices+iStart,sosReference+iStart,
    53085881                                                   iSOS,sosType[iSOS]);
    53095882                        if (sosPriority)
     
    53135886                      }
    53145887                      // delete any existing SOS objects
    5315                       int numberObjects=babModel->numberObjects();
    5316                       OsiObject ** oldObjects=babModel->objects();
     5888                      int numberObjects=babModel_->numberObjects();
     5889                      OsiObject ** oldObjects=babModel_->objects();
    53175890                      int nNew=0;
    53185891                      for (int i=0;i<numberObjects;i++) {
     
    53285901                        }
    53295902                      }
    5330                       babModel->setNumberObjects(nNew);
    5331                       babModel->addObjects(numberSOS,objects);
     5903                      babModel_->setNumberObjects(nNew);
     5904                      babModel_->addObjects(numberSOS,objects);
    53325905                      for (iSOS=0;iSOS<numberSOS;iSOS++)
    53335906                        delete objects[iSOS];
     
    53355908                    }
    53365909                  }
    5337                   OsiObject ** objects = babModel->objects();
    5338                   int numberObjects = babModel->numberObjects();
     5910                  OsiObject ** objects = babModel_->objects();
     5911                  int numberObjects = babModel_->numberObjects();
    53395912                  for (int iObj = 0;iObj<numberObjects;iObj++) {
    53405913                    // skip sos
     
    55066079                  OsiObject ** objects = testOsiSolver->objects();
    55076080                  int numberObjects = testOsiSolver->numberObjects();
    5508                   int logLevel = parameters[log].intValue();
     6081                  int logLevel = parameters_[log].intValue();
    55096082                  for (int iObj = 0;iObj<numberObjects;iObj++) {
    55106083                    // skip sos
     
    55826155                    // up or down
    55836156                    int way = (((nodeStrategy-1)%1)==1) ? -1 : +1;
    5584                     babModel->setPreferredWay(way);
     6157                    babModel_->setPreferredWay(way);
    55856158#if 0
    5586                     OsiObject ** objects = babModel->objects();
    5587                     int numberObjects = babModel->numberObjects();
     6159                    OsiObject ** objects = babModel_->objects();
     6160                    int numberObjects = babModel_->numberObjects();
    55886161                    for (int iObj = 0;iObj<numberObjects;iObj++) {
    55896162                      CbcObject * obj =
     
    55986171                    CbcCompareDefault compare;
    55996172                    compare.setWeight(-3.0);
    5600                     babModel->setNodeComparison(compare);
     6173                    babModel_->setNodeComparison(compare);
    56016174                  } else if (nodeStrategy==0) {
    56026175                    // hybrid was default i.e. mixture of low depth and infeasibility
     
    56056178                    CbcCompareDefault compare;
    56066179                    compare.setWeight(-2.0);
    5607                     babModel->setNodeComparison(compare);
     6180                    babModel_->setNodeComparison(compare);
    56086181                  }
    56096182                }
     
    56146187                  if (fp) {
    56156188                    // generate enough to do BAB
    5616                     babModel->generateCpp(fp,1);
    5617                     OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     6189                    babModel_->generateCpp(fp,1);
     6190                    OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    56186191                    // Make general so do factorization
    56196192                    int factor = osiclp->getModelPtr()->factorizationFrequency();
     
    56246197                    fclose(fp);
    56256198                    // now call generate code
    5626                     generateCode(babModel,"user_driver.cpp",cppValue,prepro);
     6199                    generateCode(babModel_,"user_driver.cpp",cppValue,prepro);
    56276200                  } else {
    56286201                    std::cout<<"Unable to open file user_driver.cpp"<<std::endl;
    56296202                  }
    56306203                }
    5631                 if (!babModel->numberStrong())
    5632                   babModel->setNumberBeforeTrust(0);
     6204                if (!babModel_->numberStrong())
     6205                  babModel_->setNumberBeforeTrust(0);
    56336206                if (useStrategy) {
    5634                   CbcStrategyDefault strategy(true,babModel->numberStrong(),babModel->numberBeforeTrust());
     6207                  CbcStrategyDefault strategy(true,babModel_->numberStrong(),babModel_->numberBeforeTrust());
    56356208                  strategy.setupPreProcessing(1);
    5636                   babModel->setStrategy(strategy);
     6209                  babModel_->setStrategy(strategy);
    56376210                }
    56386211                if (testOsiOptions>=0) {
     
    56426215                    <<CoinMessageEol;
    56436216                  if (!numberSOS) {
    5644                     babModel->solver()->findIntegersAndSOS(false);
     6217                    babModel_->solver()->findIntegersAndSOS(false);
    56456218#ifdef COIN_HAS_LINK
    56466219                    // If linked then pass in model
    5647                     OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel->solver());
     6220                    OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel_->solver());
    56486221                    if (solver3) {
    5649                       CbcHeuristicDynamic3 serendipity(*babModel);
     6222                      CbcHeuristicDynamic3 serendipity(*babModel_);
    56506223                      serendipity.setHeuristicName("linked");
    5651                       babModel->addHeuristic(&serendipity);
    5652                       double dextra3 = parameters[whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();
     6224                      babModel_->addHeuristic(&serendipity);
     6225                      double dextra3 = parameters_[whichParam(DEXTRA3,numberParameters_,parameters_)].doubleValue();
    56536226                      if (dextra3)
    56546227                        solver3->setMeshSizes(dextra3);
    5655                       int options = parameters[whichParam(MIPOPTIONS,numberParameters,parameters)].intValue()/10000;
     6228                      int options = parameters_[whichParam(MIPOPTIONS,numberParameters_,parameters_)].intValue()/10000;
    56566229                      CglStored stored;
    56576230                      if (options) {
     
    56776250                          solver3->sayConvex((options&32)==0);
    56786251                        }
    5679                         int extra1 = parameters[whichParam(EXTRA1,numberParameters,parameters)].intValue();
     6252                        int extra1 = parameters_[whichParam(EXTRA1,numberParameters_,parameters_)].intValue();
    56806253                        if ((options&1)!=0&&extra1>0)
    56816254                          solver3->setFixedPriority(extra1);
     
    56836256                        if ((options&8))
    56846257                          cutoff=solver3->linearizedBAB(&stored);
    5685                         if (cutoff<babModel->getCutoff()) {
    5686                           babModel->setCutoff(cutoff);
     6258                        if (cutoff<babModel_->getCutoff()) {
     6259                          babModel_->setCutoff(cutoff);
    56876260                          // and solution
    5688                           //babModel->setBestObjectiveValue(solver3->bestObjectiveValue());
    5689                           babModel->setBestSolution(solver3->bestSolution(),solver3->getNumCols(),
     6261                          //babModel_->setBestObjectiveValue(solver3->bestObjectiveValue());
     6262                          babModel_->setBestSolution(solver3->bestSolution(),solver3->getNumCols(),
    56906263                                                    solver3->bestObjectiveValue());
    56916264                        }
     
    56936266                          solver3->setBranchingStrategyOnVariables(16,-1,4);
    56946267                      }
    5695                       solver3->setCbcModel(babModel);
     6268                      solver3->setCbcModel(babModel_);
    56966269                      if (stored.sizeRowCuts())
    5697                         babModel->addCutGenerator(&stored,1,"Stored");
     6270                        babModel_->addCutGenerator(&stored,1,"Stored");
    56986271                      CglTemporary temp;
    5699                       babModel->addCutGenerator(&temp,1,"OnceOnly");
     6272                      babModel_->addCutGenerator(&temp,1,"OnceOnly");
    57006273                      //choose.setNumberBeforeTrusted(2000);
    57016274                      //choose.setNumberStrong(20);
    57026275                    }
    57036276                    // For temporary testing of heuristics
    5704                     //int testOsiOptions = parameters[whichParam(TESTOSI,numberParameters,parameters)].intValue();
     6277                    //int testOsiOptions = parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].intValue();
    57056278                    if (testOsiOptions>=10) {
    57066279                      if (testOsiOptions>=20)
    57076280                        testOsiOptions -= 10;
    57086281                      printf("*** Temp heuristic with mode %d\n",testOsiOptions-10);
    5709                       OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel->solver());
     6282                      OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel_->solver());
    57106283                      assert (solver3) ;
    5711                       int extra1 = parameters[whichParam(EXTRA1,numberParameters,parameters)].intValue();
     6284                      int extra1 = parameters_[whichParam(EXTRA1,numberParameters_,parameters_)].intValue();
    57126285                      solver3->setBiLinearPriority(extra1);
    57136286                      printf("bilinear priority now %d\n",extra1);
    5714                       int extra2 = parameters[whichParam(EXTRA2,numberParameters,parameters)].intValue();
     6287                      int extra2 = parameters_[whichParam(EXTRA2,numberParameters_,parameters_)].intValue();
    57156288                      double saveDefault = solver3->defaultBound();
    57166289                      solver3->setDefaultBound((double) extra2);
     
    57236296                  } else {
    57246297                    // move across
    5725                     babModel->deleteObjects(false);
    5726                     //babModel->addObjects(babModel->solver()->numberObjects(),babModel->solver()->objects());
     6298                    babModel_->deleteObjects(false);
     6299                    //babModel_->addObjects(babModel_->solver()->numberObjects(),babModel_->solver()->objects());
    57276300                  }
    57286301                  CbcBranchDefaultDecision decision;
    5729                   if (babModel->numberStrong()) {
    5730                     OsiChooseStrong choose(babModel->solver());
    5731                     choose.setNumberBeforeTrusted(babModel->numberBeforeTrust());
    5732                     choose.setNumberStrong(babModel->numberStrong());
     6302                  if (babModel_->numberStrong()) {
     6303                    OsiChooseStrong choose(babModel_->solver());
     6304                    choose.setNumberBeforeTrusted(babModel_->numberBeforeTrust());
     6305                    choose.setNumberStrong(babModel_->numberStrong());
    57336306                    choose.setShadowPriceMode(testOsiOptions);
    57346307                    decision.setChooseMethod(choose);
    57356308                  } else {
    5736                     OsiChooseVariable choose(babModel->solver());
     6309                    OsiChooseVariable choose(babModel_->solver());
    57376310                    decision.setChooseMethod(choose);
    57386311                  }
    5739                   babModel->setBranchingMethod(decision);
     6312                  babModel_->setBranchingMethod(decision);
    57406313                  if (useCosts&&testOsiOptions>=0) {
    5741                     int numberColumns = babModel->getNumCols();
     6314                    int numberColumns = babModel_->getNumCols();
    57426315                    int * sort = new int[numberColumns];
    57436316                    double * dsort = new double[numberColumns];
    57446317                    int * priority = new int [numberColumns];
    5745                     const double * objective = babModel->getObjCoefficients();
    5746                     const double * lower = babModel->getColLower() ;
    5747                     const double * upper = babModel->getColUpper() ;
    5748                     const CoinPackedMatrix * matrix = babModel->solver()->getMatrixByCol();
     6318                    const double * objective = babModel_->getObjCoefficients();
     6319                    const double * lower = babModel_->getColLower() ;
     6320                    const double * upper = babModel_->getColUpper() ;
     6321                    const CoinPackedMatrix * matrix = babModel_->solver()->getMatrixByCol();
    57496322                    const int * columnLength = matrix->getVectorLengths();
    57506323                    int iColumn;
     
    57736346                      priority[iPut]=level;
    57746347                    }
    5775                     OsiObject ** objects = babModel->objects();
    5776                     int numberObjects = babModel->numberObjects();
     6348                    OsiObject ** objects = babModel_->objects();
     6349                    int numberObjects = babModel_->numberObjects();
    57776350                    for (int iObj = 0;iObj<numberObjects;iObj++) {
    57786351                      OsiObject * obj = objects[iObj] ;
     
    57866359                  }
    57876360                }
    5788                 checkSOS(babModel, babModel->solver());
     6361                checkSOS(babModel_, babModel_->solver());
    57896362                if (doSprint>0) {
    57906363                  // Sprint for primal solves
     
    58006373                  // say use in OsiClp
    58016374                  clpSolve.setSpecialOption(6,1);
    5802                   OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     6375                  OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    58036376                  osiclp->setSolveOptions(clpSolve);
    58046377                  osiclp->setHintParam(OsiDoDualInResolve,false);
     
    58116384                  if (preProcess) {
    58126385                    const int * originalColumns = process.originalColumns();
    5813                     int numberColumns = babModel->getNumCols();
     6386                    int numberColumns = babModel_->getNumCols();
    58146387                    int * newColumn = new int[numberOriginalColumns];
    58156388                    int i;
     
    58626435#endif
    58636436                if (outputFormat==5) {
    5864                   osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     6437                  osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    58656438                  lpSolver = osiclp->getModelPtr();
    58666439                  lpSolver->setPersistenceFlag(1);
     
    58696442                // add in lotsizing
    58706443                if (usingAmpl&&info.special) {
    5871                   int numberColumns = babModel->getNumCols();
     6444                  int numberColumns = babModel_->getNumCols();
    58726445                  int i;
    58736446                  int n=0;
     
    58896462                    int numberOldObjects=0;
    58906463                    OsiObject ** oldObjects=NULL;
    5891                     const double * lower = babModel->solver()->getColLower();
    5892                     const double * upper = babModel->solver()->getColUpper();
     6464                    const double * lower = babModel_->solver()->getColLower();
     6465                    const double * upper = babModel_->solver()->getColUpper();
    58936466                    if (testOsiOptions<0) {
    58946467                      // *************************************************************
    58956468                      // CbcObjects
    5896                       numberIntegers = babModel->numberIntegers();
     6469                      numberIntegers = babModel_->numberIntegers();
    58976470                      /* model may not have created objects
    58986471                         If none then create
    58996472                      */
    5900                       if (!numberIntegers||!babModel->numberObjects()) {
     6473                      if (!numberIntegers||!babModel_->numberObjects()) {
    59016474                        int type = (pseudoUp) ? 1 : 0;
    5902                         babModel->findIntegers(true,type);
    5903                         numberIntegers = babModel->numberIntegers();
     6475                        babModel_->findIntegers(true,type);
     6476                        numberIntegers = babModel_->numberIntegers();
    59046477                      }
    5905                       oldObjects = babModel->objects();
    5906                       numberOldObjects = babModel->numberObjects();
     6478                      oldObjects = babModel_->objects();
     6479                      numberOldObjects = babModel_->numberObjects();
    59076480                    } else {
    59086481                      numberIntegers = testOsiSolver->getNumIntegers();
     
    59296502                          int priority = oldObjects[iObj]->priority();
    59306503                          if (testOsiOptions<0) {
    5931                             objects[n] = new CbcLotsize(babModel,iColumn,2,ranges,true);
     6504                            objects[n] = new CbcLotsize(babModel_,iColumn,2,ranges,true);
    59326505                          } else {
    59336506                            objects[n] = new OsiLotsize(testOsiSolver,iColumn,2,ranges,true);
     
    59386511                    }
    59396512                    if (testOsiOptions<0) {
    5940                       babModel->addObjects(n,objects);
     6513                      babModel_->addObjects(n,objects);
    59416514                    } else {
    59426515                      testOsiSolver->addObjects(n,objects);
     
    59496522#endif
    59506523                if (storedAmpl.sizeRowCuts()) {
    5951                   //babModel->addCutGenerator(&storedAmpl,1,"AmplStored");
     6524                  //babModel_->addCutGenerator(&storedAmpl,1,"AmplStored");
    59526525                  int numberRowCuts = storedAmpl.sizeRowCuts();
    59536526                  for (int i=0;i<numberRowCuts;i++) {
    59546527                    const OsiRowCut * rowCutPointer = storedAmpl.rowCutPointer(i);
    5955                     babModel->makeGlobalCut(rowCutPointer);
     6528                    babModel_->makeGlobalCut(rowCutPointer);
    59566529                  }
    59576530                } 
    59586531                // If defaults then increase trust for small models
    59596532                if (!strongChanged) {
    5960                   int numberColumns = babModel->getNumCols();
     6533                  int numberColumns = babModel_->getNumCols();
    59616534                  if (numberColumns<=50)
    5962                     babModel->setNumberBeforeTrust(1000);
     6535                    babModel_->setNumberBeforeTrust(1000);
    59636536                  else if (numberColumns<=100)
    5964                     babModel->setNumberBeforeTrust(100);
     6537                    babModel_->setNumberBeforeTrust(100);
    59656538                  else if (numberColumns<=300)
    5966                     babModel->setNumberBeforeTrust(50);
     6539                    babModel_->setNumberBeforeTrust(50);
    59676540                }
    59686541#ifdef CBC_THREAD
    5969                 int numberThreads =parameters[whichParam(THREADS,numberParameters,parameters)].intValue();
    5970                 babModel->setNumberThreads(numberThreads%100);
    5971                 babModel->setThreadMode(numberThreads/100);
    5972 #endif
    5973                 int returnCode=callBack(babModel,3);
     6542                int numberThreads =parameters_[whichParam(THREADS,numberParameters_,parameters_)].intValue();
     6543                babModel_->setNumberThreads(numberThreads%100);
     6544                babModel_->setThreadMode(numberThreads/100);
     6545#endif
     6546#ifdef NEW_STYLE_SOLVER
     6547                int returnCode = callBack_->callBack(babModel_,3);
     6548#else
     6549                int returnCode=callBack(babModel_,3);
     6550#endif
    59746551                if (returnCode) {
    59756552                  // exit if user wants
    5976                   delete babModel;
     6553#ifdef NEW_STYLE_SOLVER
     6554                  updateModel(NULL,returnMode);
     6555#else
     6556                  delete babModel_;
     6557                  babModel_ = NULL;
     6558#endif
    59776559                  return returnCode;
    59786560                }
    5979                 babModel->branchAndBound(statistics);
    5980                 returnCode=callBack(babModel,4);
     6561                babModel_->branchAndBound(statistics);
     6562#ifdef NEW_STYLE_SOLVER
     6563                returnCode = callBack_->callBack(babModel_,4);
     6564#else
     6565                returnCode=callBack(babModel_,4);
     6566#endif
    59816567                if (returnCode) {
    59826568                  // exit if user wants
    5983                   model.moveInfo(*babModel);
    5984                   delete babModel;
     6569#ifdef NEW_STYLE_SOLVER
     6570                  updateModel(NULL,returnMode);
     6571#else
     6572                  model_.moveInfo(*babModel_);
     6573                  delete babModel_;
     6574                  babModel_ = NULL;
     6575#endif
    59856576                  return returnCode;
    59866577                }
     
    59896580                malloc_stats2();
    59906581#endif
    5991                 checkSOS(babModel, babModel->solver());
     6582                checkSOS(babModel_, babModel_->solver());
    59926583              } else if (type==MIPLIB) {
    5993                 CbcStrategyDefault strategy(true,babModel->numberStrong(),babModel->numberBeforeTrust());
     6584                CbcStrategyDefault strategy(true,babModel_->numberStrong(),babModel_->numberBeforeTrust());
    59946585                // Set up pre-processing
    59956586                int translate2[]={9999,1,1,3,2,4,5};
    59966587                if (preProcess)
    59976588                  strategy.setupPreProcessing(translate2[preProcess]);
    5998                 babModel->setStrategy(strategy);
     6589                babModel_->setStrategy(strategy);
    59996590#ifdef CBC_THREAD
    6000                 int numberThreads =parameters[whichParam(THREADS,numberParameters,parameters)].intValue();
    6001                 babModel->setNumberThreads(numberThreads%100);
    6002                 babModel->setThreadMode(numberThreads/100);
     6591                int numberThreads =parameters_[whichParam(THREADS,numberParameters_,parameters_)].intValue();
     6592                babModel_->setNumberThreads(numberThreads%100);
     6593                babModel_->setThreadMode(numberThreads/100);
    60036594#endif
    60046595                if (outputFormat==5) {
    6005                   osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     6596                  osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    60066597                  lpSolver = osiclp->getModelPtr();
    60076598                  lpSolver->setPersistenceFlag(1);
     
    60106601                  printf("Testing OsiObject options %d\n",testOsiOptions);
    60116602                  CbcBranchDefaultDecision decision;
    6012                   OsiChooseStrong choose(babModel->solver());
    6013                   choose.setNumberBeforeTrusted(babModel->numberBeforeTrust());
    6014                   choose.setNumberStrong(babModel->numberStrong());
     6603                  OsiChooseStrong choose(babModel_->solver());
     6604                  choose.setNumberBeforeTrusted(babModel_->numberBeforeTrust());
     6605                  choose.setNumberStrong(babModel_->numberStrong());
    60156606                  choose.setShadowPriceMode(testOsiOptions);
    6016                   //babModel->deleteObjects(false);
     6607                  //babModel_->deleteObjects(false);
    60176608                  decision.setChooseMethod(choose);
    6018                   babModel->setBranchingMethod(decision);
     6609                  babModel_->setBranchingMethod(decision);
    60196610                }
    6020                 model = *babModel;
     6611                model_ = *babModel_;
    60216612                /* LL: this was done in CoinSolve.cpp: main(argc, argv).
    60226613                   I have moved it here so that the miplib directory location
    60236614                   could be passed to CbcClpUnitTest. */
    6024                 if (call_CbcClpUnitTest_on_777 == 777) {
    6025                   CbcClpUnitTest(model, dirMiplib, false);
    6026                 }
     6615                /* JJF: No need to have 777 flag at all - user
     6616                   says -miplib
     6617                */
     6618                CbcClpUnitTest(model_, dirMiplib, false);
    60276619                return 777;
    60286620              } else {
    6029                 strengthenedModel = babModel->strengthenedModel();
     6621                strengthenedModel = babModel_->strengthenedModel();
    60306622              }
    60316623              currentBranchModel = NULL;
    6032               osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
    6033               if (debugFile=="createAfterPre"&&babModel->bestSolution()) {
     6624              osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
     6625              if (debugFile=="createAfterPre"&&babModel_->bestSolution()) {
    60346626                lpSolver = osiclp->getModelPtr();
    60356627                //move best solution (should be there -- but ..)
    60366628                int n = lpSolver->getNumCols();
    6037                 memcpy(lpSolver->primalColumnSolution(),babModel->bestSolution(),n*sizeof(double));
     6629                memcpy(lpSolver->primalColumnSolution(),babModel_->bestSolution(),n*sizeof(double));
    60386630                saveSolution(osiclp->getModelPtr(),"debug.file");
    60396631              }
    6040               if (!noPrinting) {
     6632              if (!noPrinting_) {
    60416633                // Print more statistics
    60426634                sprintf(generalPrint,"Cuts at root node changed objective from %g to %g",
    6043                         babModel->getContinuousObjective(),babModel->rootObjectiveAfterCuts());
     6635                        babModel_->getContinuousObjective(),babModel_->rootObjectiveAfterCuts());
    60446636                generalMessageHandler->message(CLP_GENERAL,generalMessages)
    60456637                  << generalPrint
    60466638                  <<CoinMessageEol;
    60476639               
    6048                 numberGenerators = babModel->numberCutGenerators();
     6640                numberGenerators = babModel_->numberCutGenerators();
    60496641                char timing[30];
    60506642                for (iGenerator=0;iGenerator<numberGenerators;iGenerator++) {
    6051                   CbcCutGenerator * generator = babModel->cutGenerator(iGenerator);
     6643                  CbcCutGenerator * generator = babModel_->cutGenerator(iGenerator);
    60526644                  sprintf(generalPrint,"%s was tried %d times and created %d cuts of which %d were active after adding rounds of cuts",
    60536645                          generator->cutGeneratorName(),
     
    60696661              // For best solution
    60706662              double * bestSolution = NULL;
    6071               if (babModel->getMinimizationObjValue()<1.0e50&&type==BAB) {
     6663              if (babModel_->getMinimizationObjValue()<1.0e50&&type==BAB) {
    60726664                // post process
    60736665                int n;
     
    60756667                  n = saveSolver->getNumCols();
    60766668                  bestSolution = new double [n];
    6077                   OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     6669                  OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    60786670                  ClpSimplex * lpSolver = clpSolver->getModelPtr();
    60796671                  lpSolver->setSpecialOptions(lpSolver->specialOptions()|0x01000000); // say is Cbc (and in branch and bound)
    6080                   process.postProcess(*babModel->solver());
     6672                  process.postProcess(*babModel_->solver());
    60816673                  // Solution now back in saveSolver
    6082                   babModel->assignSolver(saveSolver);
    6083                   memcpy(bestSolution,babModel->solver()->getColSolution(),n*sizeof(double));
     6674                  babModel_->assignSolver(saveSolver);
     6675                  memcpy(bestSolution,babModel_->solver()->getColSolution(),n*sizeof(double));
    60846676                } else {
    6085                   n = babModel->solver()->getNumCols();
     6677                  n = babModel_->solver()->getNumCols();
    60866678                  bestSolution = new double [n];
    6087                   memcpy(bestSolution,babModel->solver()->getColSolution(),n*sizeof(double));
     6679                  memcpy(bestSolution,babModel_->solver()->getColSolution(),n*sizeof(double));
    60886680                }
    6089                 model.setBestSolution(bestSolution,n,babModel->getObjValue());
     6681#ifndef NEW_STYLE_SOLVER
     6682                if (returnMode==1)
     6683                  model_.setBestSolution(bestSolution,n,babModel_->getObjValue());
     6684#endif
     6685                babModel_->setBestSolution(bestSolution,n,babModel_->getObjValue());
     6686#ifndef NEW_STYLE_SOLVER
    60906687                // and put back in very original solver
    60916688                {
     
    60956692                  double * solution = original->primalColumnSolution();
    60966693                  int n = original->numberColumns();
    6097                   //assert (!n||n==babModel->solver()->getNumCols());
     6694                  //assert (!n||n==babModel_->solver()->getNumCols());
    60986695                  for (int i=0;i<n;i++) {
    60996696                    solution[i]=bestSolution[i];
     
    61046701                  }
    61056702                  // basis
    6106                   CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis *> (babModel->solver()->getWarmStart());
     6703                  CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis *> (babModel_->solver()->getWarmStart());
    61076704                  originalSolver->setBasis(*basis);
    61086705                  delete basis;
    61096706                }
    6110                 checkSOS(babModel, babModel->solver());
    6111               } else if (model.bestSolution()&&type==BAB&&model.getMinimizationObjValue()&&preProcess) {
    6112                 sprintf(generalPrint,"Restoring heuristic best solution of %g",model.getMinimizationObjValue());
     6707#endif
     6708                checkSOS(babModel_, babModel_->solver());
     6709              } else if (model_.bestSolution()&&type==BAB&&model_.getMinimizationObjValue()<1.0e50&&preProcess) {
     6710                sprintf(generalPrint,"Restoring heuristic best solution of %g",model_.getMinimizationObjValue());
    61136711                generalMessageHandler->message(CLP_GENERAL,generalMessages)
    61146712                  << generalPrint
     
    61176715                bestSolution = new double [n];
    61186716                // Put solution now back in saveSolver
    6119                 babModel->assignSolver(saveSolver);
    6120                 saveSolver->setColSolution(model.bestSolution());
    6121                 memcpy(bestSolution,babModel->solver()->getColSolution(),n*sizeof(double));
     6717                babModel_->assignSolver(saveSolver);
     6718                saveSolver->setColSolution(model_.bestSolution());
     6719                memcpy(bestSolution,babModel_->solver()->getColSolution(),n*sizeof(double));
     6720#ifndef NEW_STYLE_SOLVER
    61226721                // and put back in very original solver
    61236722                {
     
    61276726                  double * solution = original->primalColumnSolution();
    61286727                  int n = original->numberColumns();
    6129                   //assert (!n||n==babModel->solver()->getNumCols());
     6728                  //assert (!n||n==babModel_->solver()->getNumCols());
    61306729                  for (int i=0;i<n;i++) {
    61316730                    solution[i]=bestSolution[i];
     
    61366735                  }
    61376736                  // basis
    6138                   CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis *> (babModel->solver()->getWarmStart());
     6737                  CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis *> (babModel_->solver()->getWarmStart());
    61396738                  originalSolver->setBasis(*basis);
    61406739                  delete basis;
    61416740                }
     6741#endif
    61426742              }
    61436743              if (type==STRENGTHEN&&strengthenedModel)
     
    61456745#ifdef COIN_HAS_ASL
    61466746              else if (usingAmpl)
    6147                 clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     6747                clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    61486748#endif
    61496749              lpSolver = clpSolver->getModelPtr();
     
    61656765                  memset (rowSolution,0,numberRows*sizeof(double));
    61666766                  lpSolver->clpMatrix()->times(1.0,bestSolution,rowSolution);
    6167                   lpSolver->setObjectiveValue(babModel->getObjValue());
     6767                  lpSolver->setObjectiveValue(babModel_->getObjValue());
    61686768                }
    61696769                if (debugFile=="create"&&bestSolution) {
     
    61746774                                          "","","User ctrl-c"};
    61756775                std::string minor[]={"","","gap","nodes","time","","solutions","user ctrl-c"};
    6176                 int iStat = babModel->status();
    6177                 int iStat2 = babModel->secondaryStatus();
    6178                 if (!noPrinting) {
     6776                int iStat = babModel_->status();
     6777                int iStat2 = babModel_->secondaryStatus();
     6778                if (!noPrinting_) {
    61796779                  sprintf(generalPrint,"Result - %s%s objective %.16g after %d nodes and %d iterations - took %.2f seconds (total time %.2f)",
    61806780                          statusName[iStat].c_str(),minor[iStat2].c_str(),
    6181                           babModel->getObjValue(),babModel->getNodeCount(),
    6182                           babModel->getIterationCount(),time2-time1,time2-time0);
     6781                          babModel_->getObjValue(),babModel_->getNodeCount(),
     6782                          babModel_->getIterationCount(),time2-time1,time2-time0);
    61836783                  generalMessageHandler->message(CLP_GENERAL,generalMessages)
    61846784                    << generalPrint
    61856785                    <<CoinMessageEol;
    61866786                }
    6187                 int returnCode=callBack(babModel,5);
     6787#ifdef NEW_STYLE_SOLVER
     6788                int returnCode = callBack_->callBack(babModel_,5);
     6789#else
     6790                int returnCode=callBack(babModel_,5);
     6791#endif
    61886792                if (returnCode) {
    61896793                  // exit if user wants
    6190                   model.moveInfo(*babModel);
    6191                   delete babModel;
     6794#ifdef NEW_STYLE_SOLVER
     6795                  updateModel(NULL,returnMode);
     6796#else
     6797                  model_.moveInfo(*babModel_);
     6798                  delete babModel_;
     6799                  babModel_ = NULL;
     6800#endif
    61926801                  return returnCode;
    61936802                }
    61946803#ifdef COIN_HAS_ASL
    61956804                if (usingAmpl) {
    6196                   clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     6805                  clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    61976806                  lpSolver = clpSolver->getModelPtr();
    6198                   double value = babModel->getObjValue()*lpSolver->getObjSense();
     6807                  double value = babModel_->getObjValue()*lpSolver->getObjSense();
    61996808                  char buf[300];
    62006809                  int pos=0;
    62016810                  if (iStat==0) {
    6202                     if (babModel->getObjValue()<1.0e40) {
     6811                    if (babModel_->getObjValue()<1.0e40) {
    62036812                      pos += sprintf(buf+pos,"optimal," );
    62046813                    } else {
     
    62256834                  info.problemStatus=iStat;
    62266835                  info.objValue = value;
    6227                   if (babModel->getObjValue()<1.0e40) {
     6836                  if (babModel_->getObjValue()<1.0e40) {
    62286837                    int precision = ampl_obj_prec();
    62296838                    if (precision>0)
     
    62346843                  }
    62356844                  sprintf(buf+pos,"\n%d nodes, %d iterations, %g seconds",
    6236                           babModel->getNodeCount(),
    6237                           babModel->getIterationCount(),
     6845                          babModel_->getNodeCount(),
     6846                          babModel_->getIterationCount(),
    62386847                          totalTime);
    62396848                  if (bestSolution) {
     
    62726881              if (usingAmpl) {
    62736882                // keep if going to be destroyed
    6274                 OsiSolverInterface * solver = babModel->solver();
     6883                OsiSolverInterface * solver = babModel_->solver();
    62756884                OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
    62766885                ClpSimplex * lpSolver2 = clpSolver->getModelPtr();
    62776886                if (lpSolver==lpSolver2)
    6278                   babModel->setModelOwnsSolver(false);
     6887                  babModel_->setModelOwnsSolver(false);
    62796888              }
    62806889#endif
    6281               //delete babModel;
    6282               //babModel=NULL;
     6890              //delete babModel_;
     6891              //babModel_=NULL;
    62836892            } else {
    62846893#ifndef DISALLOW_PRINTING
     
    63196928              }
    63206929#endif               
    6321               //delete babModel;
    6322               //babModel=NULL;
     6930              //delete babModel_;
     6931              //babModel_=NULL;
    63236932              // get next field
    63246933              field = CoinReadGetString(argc,argv);
    63256934              if (field=="$") {
    6326                 field = parameters[iParam].stringValue();
     6935                field = parameters_[iParam].stringValue();
    63276936              } else if (field=="EOL") {
    6328                 parameters[iParam].printString();
     6937                parameters_[iParam].printString();
    63296938                break;
    63306939              } else {
    6331                 parameters[iParam].setStringValue(field);
     6940                parameters_[iParam].setStringValue(field);
    63326941              }
    63336942              std::string fileName;
     
    64647073              field = CoinReadGetString(argc,argv);
    64657074              if (field=="$") {
    6466                 field = parameters[iParam].stringValue();
     7075                field = parameters_[iParam].stringValue();
    64677076              } else if (field=="EOL") {
    6468                 parameters[iParam].printString();
     7077                parameters_[iParam].printString();
    64697078                break;
    64707079              } else {
    6471                 parameters[iParam].setStringValue(field);
     7080                parameters_[iParam].setStringValue(field);
    64727081              }
    64737082              std::string fileName;
     
    65177126                OsiSolverLink solver1;
    65187127                OsiSolverInterface * solver2 = solver1.clone();
    6519                 model.assignSolver(solver2,false);
     7128                model_.assignSolver(solver2,false);
    65207129                OsiSolverLink * si =
    6521                   dynamic_cast<OsiSolverLink *>(model.solver()) ;
     7130                  dynamic_cast<OsiSolverLink *>(model_.solver()) ;
    65227131                assert (si != NULL);
    65237132                si->setDefaultMeshSize(0.001);
    65247133                // need some relative granularity
    65257134                si->setDefaultBound(100.0);
    6526                 double dextra3 = parameters[whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();
     7135                double dextra3 = parameters_[whichParam(DEXTRA3,numberParameters_,parameters_)].doubleValue();
    65277136                if (dextra3)
    65287137                  si->setDefaultMeshSize(dextra3);
     
    65337142                si->load(*model2);
    65347143                // redo
    6535                 solver = model.solver();
     7144                solver = model_.solver();
    65367145                clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
    65377146                lpSolver = clpSolver->getModelPtr();
     
    65487157              field = CoinReadGetString(argc,argv);
    65497158              if (field=="$") {
    6550                 field = parameters[iParam].stringValue();
     7159                field = parameters_[iParam].stringValue();
    65517160              } else if (field=="EOL") {
    6552                 parameters[iParam].printString();
     7161                parameters_[iParam].printString();
    65537162                break;
    65547163              } else {
    6555                 parameters[iParam].setStringValue(field);
     7164                parameters_[iParam].setStringValue(field);
    65567165              }
    65577166              std::string fileName;
     
    66117220                    pinfo.statistics();
    66127221                  double presolveTolerance =
    6613                     parameters[whichParam(PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();
     7222                    parameters_[whichParam(PRESOLVETOLERANCE,numberParameters_,parameters_)].doubleValue();
    66147223                  model2 =
    66157224                    pinfo.presolvedModel(*lpSolver,presolveTolerance,
     
    66917300              field = CoinReadGetString(argc,argv);
    66927301              if (field=="$") {
    6693                 field = parameters[iParam].stringValue();
     7302                field = parameters_[iParam].stringValue();
    66947303              } else if (field=="EOL") {
    6695                 parameters[iParam].printString();
     7304                parameters_[iParam].printString();
    66967305                break;
    66977306              } else {
    6698                 parameters[iParam].setStringValue(field);
     7307                parameters_[iParam].setStringValue(field);
    66997308              }
    67007309              std::string fileName;
     
    67487357              field = CoinReadGetString(argc,argv);
    67497358              if (field=="$") {
    6750                 field = parameters[iParam].stringValue();
     7359                field = parameters_[iParam].stringValue();
    67517360              } else if (field=="EOL") {
    6752                 parameters[iParam].printString();
     7361                parameters_[iParam].printString();
    67537362                break;
    67547363              } else {
    6755                 parameters[iParam].setStringValue(field);
     7364                parameters_[iParam].setStringValue(field);
    67567365              }
    67577366              std::string fileName;
     
    69867595                      }
    69877596                    }
    6988                     if (!noPrinting) {
     7597                    if (!noPrinting_) {
    69897598                      printf("%d fields and %d records",nAcross,nLine);
    69907599                      if (nBadPseudo)
     
    70237632              field = CoinReadGetString(argc,argv);
    70247633              if (field=="$") {
    7025                 field = parameters[iParam].stringValue();
     7634                field = parameters_[iParam].stringValue();
    70267635              } else if (field=="EOL") {
    7027                 parameters[iParam].printString();
     7636                parameters_[iParam].printString();
    70287637                break;
    70297638              } else {
    7030                 parameters[iParam].setStringValue(field);
     7639                parameters_[iParam].setStringValue(field);
    70317640                debugFile=field;
    70327641                if (debugFile=="create"||
     
    70797688              std::string name = CoinReadGetString(argc,argv);
    70807689              if (name!="EOL") {
    7081                 parameters[iParam].setStringValue(name);
     7690                parameters_[iParam].setStringValue(name);
    70827691                printMask = name;
    70837692              } else {
    7084                 parameters[iParam].printString();
     7693                parameters_[iParam].printString();
    70857694              }
    70867695            }
     
    70917700              field = CoinReadGetString(argc,argv);
    70927701              if (field=="$") {
    7093                 field = parameters[iParam].stringValue();
     7702                field = parameters_[iParam].stringValue();
    70947703              } else if (field=="EOL") {
    7095                 parameters[iParam].printString();
     7704                parameters_[iParam].printString();
    70967705                break;
    70977706              } else {
    7098                 parameters[iParam].setStringValue(field);
     7707                parameters_[iParam].setStringValue(field);
    70997708              }
    71007709              std::string fileName;
     
    71407749              field = CoinReadGetString(argc,argv);
    71417750              if (field=="$") {
    7142                 field = parameters[iParam].stringValue();
     7751                field = parameters_[iParam].stringValue();
    71437752              } else if (field=="EOL") {
    7144                 parameters[iParam].printString();
     7753                parameters_[iParam].printString();
    71457754                break;
    71467755              } else {
    7147                 parameters[iParam].setStringValue(field);
     7756                parameters_[iParam].setStringValue(field);
    71487757              }
    71497758              std::string fileName;
     
    71797788                  ClpPresolve pinfo;
    71807789                  double presolveTolerance =
    7181                     parameters[whichParam(PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();
     7790                    parameters_[whichParam(PRESOLVETOLERANCE,numberParameters_,parameters_)].doubleValue();
    71827791                  model2 =
    71837792                    pinfo.presolvedModel(*lpSolver,presolveTolerance,
     
    72187827              field = CoinReadGetString(argc,argv);
    72197828              if (field=="$") {
    7220                 field = parameters[iParam].stringValue();
     7829                field = parameters_[iParam].stringValue();
    72217830              } else if (field=="EOL") {
    7222                 parameters[iParam].printString();
     7831                parameters_[iParam].printString();
    72237832                break;
    72247833              } else {
    7225                 parameters[iParam].setStringValue(field);
     7834                parameters_[iParam].setStringValue(field);
    72267835              }
    72277836              std::string fileName;
     
    73047913                  directory = name+dirsep;
    73057914                }
    7306                 parameters[iParam].setStringValue(directory);
     7915                parameters_[iParam].setStringValue(directory);
    73077916              } else {
    7308                 parameters[iParam].printString();
     7917                parameters_[iParam].printString();
    73097918              }
    73107919            }
     
    73207929                  dirSample = name+dirsep;
    73217930                }
    7322                 parameters[iParam].setStringValue(dirSample);
     7931                parameters_[iParam].setStringValue(dirSample);
    73237932              } else {
    7324                 parameters[iParam].printString();
     7933                parameters_[iParam].printString();
    73257934              }
    73267935            }
     
    73367945                  dirNetlib = name+dirsep;
    73377946                }
    7338                 parameters[iParam].setStringValue(dirNetlib);
     7947                parameters_[iParam].setStringValue(dirNetlib);
    73397948              } else {
    7340                 parameters[iParam].printString();
     7949                parameters_[iParam].printString();
    73417950              }
    73427951            }
     
    73527961                  dirMiplib = name+dirsep;
    73537962                }
    7354                 parameters[iParam].setStringValue(dirMiplib);
     7963                parameters_[iParam].setStringValue(dirMiplib);
    73557964              } else {
    7356                 parameters[iParam].printString();
     7965                parameters_[iParam].printString();
    73577966              }
    73587967            }
     
    73737982          case UNITTEST:
    73747983            {
    7375               CbcClpUnitTest(model, dirSample, true);
     7984              CbcClpUnitTest(model_, dirSample, true);
    73767985            }
    73777986            break;
     
    73817990              double value = CoinReadGetDoubleField(argc,argv,&valid);
    73827991              if (!valid) {
    7383                 std::cout<<"Setting "<<parameters[iParam].name()<<
     7992                std::cout<<"Setting "<<parameters_[iParam].name()<<
    73847993                  " to DEBUG "<<value<<std::endl;
    73857994                int iRow;
     
    74098018                abort();
    74108019              } else {
    7411                 std::cout<<"enter value for "<<parameters[iParam].name()<<
     8020                std::cout<<"enter value for "<<parameters_[iParam].name()<<
    74128021                  std::endl;
    74138022              }
     
    74278036            if (goodModel) {
    74288037              // Way of using an existing piece of code
    7429               OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model.solver());
     8038              OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model_.solver());
    74308039              ClpSimplex * lpSolver = clpSolver->getModelPtr();
    74318040              // set time from integer model
    7432               double timeToGo = model.getMaximumSeconds();
     8041              double timeToGo = model_.getMaximumSeconds();
    74338042              lpSolver->setMaximumSeconds(timeToGo);
    7434               int extra1 = parameters[whichParam(EXTRA1,numberParameters,parameters)].intValue();
     8043              int extra1 = parameters_[whichParam(EXTRA1,numberParameters_,parameters_)].intValue();
    74358044              fakeMain2(*lpSolver,*clpSolver,extra1);
    74368045              lpSolver = clpSolver->getModelPtr();
     
    74438052            }
    74448053#endif
     8054#ifdef NEW_STYLE_SOLVER
     8055            if (goodModel) {
     8056              std::string name = CoinReadGetString(argc,argv);
     8057              if (name!="EOL") {
     8058                int length = name.size();
     8059                int percent = name.find('%');
     8060                std::string command = name;
     8061                std::string options = "";
     8062                if (percent<length&&percent>0) {
     8063                  command = name.substr(0,percent);
     8064                  options = name.substr(percent+1);
     8065                }
     8066                CbcUser * userCode = userFunction(command.c_str());
     8067                if (userCode)
     8068                  userCode->solve(this,options.c_str());
     8069              } else {
     8070                parameters_[iParam].printString();
     8071              }
     8072            }
     8073#endif
    74458074            break;
    74468075          case USERCBC:
     
    74498078            if (goodModel) {
    74508079              // Way of using an existing piece of code
    7451               OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model.solver());
     8080              OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model_.solver());
    74528081              ClpSimplex * lpSolver = clpSolver->getModelPtr();
    74538082              // set time from integer model
    7454               double timeToGo = model.getMaximumSeconds();
     8083              double timeToGo = model_.getMaximumSeconds();
    74558084              lpSolver->setMaximumSeconds(timeToGo);
    74568085              fakeMain(*lpSolver,*clpSolver,model);
     
    74628091#endif
    74638092              // make sure solution back in correct place
    7464               clpSolver = dynamic_cast< OsiClpSolverInterface*> (model.solver());
     8093              clpSolver = dynamic_cast< OsiClpSolverInterface*> (model_.solver());
    74658094              lpSolver = clpSolver->getModelPtr();
    74668095#ifdef COIN_HAS_ASL
     
    75018130                                 value);
    75028131                sprintf(buf+pos,"\n%d nodes, %d iterations",
    7503                         model.getNodeCount(),
    7504                         model.getIterationCount());
     8132                        model_.getNodeCount(),
     8133                        model_.getIterationCount());
    75058134                if (objectiveValue<1.0e50) {
    75068135                  free(info.primalSolution);
     
    75448173              field = CoinReadGetString(argc,argv);
    75458174              if (field=="$") {
    7546                 field = parameters[iParam].stringValue();
     8175                field = parameters_[iParam].stringValue();
    75478176              } else if (field=="EOL") {
    7548                 parameters[iParam].printString();
     8177                parameters_[iParam].printString();
    75498178                break;
    75508179              } else {
    7551                 parameters[iParam].setStringValue(field);
     8180                parameters_[iParam].setStringValue(field);
    75528181              }
    75538182              std::string fileName;
     
    77548383                  fprintf(fp,"\tint intIndicesV[]={\n");
    77558384                  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    7756                     if(primalColumnSolution[iColumn]>0.5&&model.solver()->isInteger(iColumn)) {
     8385                    if(primalColumnSolution[iColumn]>0.5&&model_.solver()->isInteger(iColumn)) {
    77578386                      if (comma)
    77588387                        fprintf(fp,",");
     
    77758404                  fprintf(fp,"\tdouble intSolnV[]={\n");
    77768405                  for ( iColumn=0;iColumn<numberColumns;iColumn++) {
    7777                     if(primalColumnSolution[iColumn]>0.5&&model.solver()->isInteger(iColumn)) {
     8406                    if(primalColumnSolution[iColumn]>0.5&&model_.solver()->isInteger(iColumn)) {
    77788407                      if (comma)
    77798408                        fprintf(fp,",");
     
    78158444              field = CoinReadGetString(argc,argv);
    78168445              if (field=="$") {
    7817                 field = parameters[iParam].stringValue();
     8446                field = parameters_[iParam].stringValue();
    78188447              } else if (field=="EOL") {
    7819                 parameters[iParam].printString();
     8448                parameters_[iParam].printString();
    78208449                break;
    78218450              } else {
    7822                 parameters[iParam].setStringValue(field);
     8451                parameters_[iParam].setStringValue(field);
    78238452              }
    78248453              std::string fileName;
     
    78568485        if (!numberQuery) {
    78578486          std::cout<<"Short match for "<<field<<" - completion: ";
    7858           std::cout<<parameters[firstMatch].matchName()<<std::endl;
     8487          std::cout<<parameters_[firstMatch].matchName()<<std::endl;
    78598488        } else if (numberQuery) {
    7860           std::cout<<parameters[firstMatch].matchName()<<" : ";
    7861           std::cout<<parameters[firstMatch].shortHelp()<<std::endl;
     8489          std::cout<<parameters_[firstMatch].matchName()<<" : ";
     8490          std::cout<<parameters_[firstMatch].shortHelp()<<std::endl;
    78628491          if (numberQuery>=2)
    7863             parameters[firstMatch].printLongHelp();
     8492            parameters_[firstMatch].printLongHelp();
    78648493        }
    78658494      } else {
     
    78698498        else
    78708499          std::cout<<"Completions of "<<field<<":"<<std::endl;
    7871         for ( iParam=0; iParam<numberParameters; iParam++ ) {
    7872           int match = parameters[iParam].matches(field);
    7873           if (match&&parameters[iParam].displayThis()) {
    7874             std::cout<<parameters[iParam].matchName();
     8500        for ( iParam=0; iParam<numberParameters_; iParam++ ) {
     8501          int match = parameters_[iParam].matches(field);
     8502          if (match&&parameters_[iParam].displayThis()) {
     8503            std::cout<<parameters_[iParam].matchName();
    78758504            if (numberQuery>=2)
    7876               std::cout<<" : "<<parameters[iParam].shortHelp();
     8505              std::cout<<" : "<<parameters_[iParam].shortHelp();
    78778506            std::cout<<std::endl;
    78788507          }
     
    78868515  //dmalloc_shutdown();
    78878516#endif
    7888   if (babModel) {
    7889     model.moveInfo(*babModel);
    7890     //babModel->setModelOwnsSolver(false);
     8517#ifdef NEW_STYLE_SOLVER
     8518  updateModel(NULL,returnMode);
     8519  sprintf(generalPrint,"Total time %.2f",CoinCpuTime()-startTime_);
     8520#else
     8521  if (babModel_) {
     8522    model_.moveInfo(*babModel_);
     8523    //babModel_->setModelOwnsSolver(false);
    78918524  }
    78928525#ifdef CBC_SIG_TRAP
     
    78958528  // register signal handler
    78968529  saveSignal=signal(SIGSEGV,signal_handler_error);
    7897   // to force failure!babModel->setNumberObjects(20000);
     8530  // to force failure!babModel_->setNumberObjects(20000);
    78988531  if (!sigsetjmp(cbc_seg_buffer,1)) {
    78998532#endif
    7900     delete babModel;
     8533    delete babModel_;
    79018534#ifdef CBC_SIG_TRAP
    79028535  } else {
    7903     std::cerr<<"delete babModel failed"<<std::endl;
     8536    std::cerr<<"delete babModel_ failed"<<std::endl;
    79048537  }
    7905   #endif
    7906   model.solver()->setWarmStart(NULL);
     8538#endif
     8539  babModel_ = NULL;
     8540  model_.solver()->setWarmStart(NULL);
    79078541  sprintf(generalPrint,"Total time %.2f",CoinCpuTime()-time0);
     8542#endif
    79088543  generalMessageHandler->message(CLP_GENERAL,generalMessages)
    79098544    << generalPrint
  • trunk/Cbc/src/CoinSolve.cpp

    r765 r779  
    55#include "CoinPragma.hpp"
    66#include "CbcModel.hpp"
     7#include "CbcOrClpParam.hpp"
    78#include "OsiClpSolverInterface.hpp"
    89
     
    1314#include <cstring>
    1415#include <iostream>
     16//#define NEW_STYLE_SOLVER
     17#ifndef NEW_STYLE_SOLVER
    1518  // define TEST_MESSAGE_HANDLER to check works on all messages
    1619//#define TEST_MESSAGE_HANDLER
     
    215218  setCbcOrClpPrinting(false);
    216219#endif
    217   int returnCode = CbcMain1 (argc, argv,model, 777);
     220  int returnCode = CbcMain1 (argc, argv,model);
    218221#if 0
    219222  /* The call to CbcClpUnitTest was moved into CbcMain1. To make sure
     
    239242#endif
    240243}
    241 
     244#else
     245#include "CbcSolver.hpp"
     246int main (int argc, const char *argv[])
     247{
     248  OsiClpSolverInterface solver1;
     249  CbcSolver control(solver1);
     250  // initialize
     251  control.fillValuesInSolver();
     252  return control.solve (argc, argv, 2);
     253}
     254#endif
    242255/*
    243256  Version 1.00.00 November 16 2005.
Note: See TracChangeset for help on using the changeset viewer.