Changeset 271 for trunk

Timestamp:

Mar 14, 2006 10:39:00 AM (14 years ago)

Author:

forrest

Message:

for Pierre (and to annoy Lou:-)

Location:

trunk

Files:

• CbcModel.cpp (modified) (19 diffs)
• CbcNode.cpp (modified) (3 diffs)
• CbcStrategy.cpp (modified) (2 diffs)
• include/CbcModel.hpp (modified) (1 diff)
• include/CbcStrategy.hpp (modified) (2 diffs)

trunk/CbcModel.cpp

@@ -354 +354 @@
   return ; 
 }
-#ifndef CBC_NEXT_VERSION
 
 
@@ -529 +528 @@
   // If NLP then we assume already solved outside branchAndbound
   if (!solverCharacteristics_->solverType()) {
-    feasible=resolve() ;
+    feasible=resolve(NULL,0) != 0 ;
   } else {
     // pick up given status
@@ -810 +809 @@
       numberPassesLeft--;
       if (anyAction == -1)
-      { feasible = resolve() ;
+      { feasible = resolve(NULL,10) != 0 ;
       if (problemFeasibility_->feasible(this,0)<0) {
         feasible=false; // pretend infeasible
@@ -1156 +1155 @@
       int saveNumber = numberIterations_;
       if(solverCharacteristics_->solutionAddsCuts()) {
-        feasible=resolve();
+        int returnCode=resolve(node ? node->nodeInfo() : NULL,1);
+        feasible = returnCode != 0;
         if (feasible) {
           int iObject ;
@@ -1169 +1169 @@
             if (infeasibility ) numberUnsatisfied++ ;
           }
-          if (numberUnsatisfied)   {
-            feasible = solveWithCuts(cuts,maximumCutPasses_,node);
-          } else {
-            // may generate cuts and turn the solution
-            //to an infeasible one
-            feasible = solveWithCuts(cuts, 1,
-                                     node);
+          if (returnCode>0) {
+            if (numberUnsatisfied)   {
+              feasible = solveWithCuts(cuts,maximumCutPasses_,node);
+            } else {
+              // may generate cuts and turn the solution
+              //to an infeasible one
+              feasible = solveWithCuts(cuts, 1,
+                                       node);
 #if 0
-            currentNumberCuts_ = cuts.sizeRowCuts();
-            if (currentNumberCuts_ >= maximumNumberCuts_) {
-              maximumNumberCuts_ = currentNumberCuts;
-              delete [] addedCuts_;
-              addedCuts_ = new CbcCountRowCut * [maximumNumberCuts_];
+              currentNumberCuts_ = cuts.sizeRowCuts();
+              if (currentNumberCuts_ >= maximumNumberCuts_) {
+                maximumNumberCuts_ = currentNumberCuts;
+                delete [] addedCuts_;
+                addedCuts_ = new CbcCountRowCut * [maximumNumberCuts_];
+              }
+#endif
             }
-#endif
           }
           // check extra info on feasibility
@@ -1280 +1282 @@
               int easy=2;
               solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,&easy) ;
-              feasible = resolve() ;
+              feasible = resolve(node ? node->nodeInfo() : NULL,11) != 0 ;
               solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,NULL) ;
               resolved = true ;
@@ -1782 +1784 @@
   }
   return ; }
-#else
-void CbcModel::branchAndBound(int doStatistics) 
-
-{
-/*
-  Capture a time stamp before we start.
-*/
-  dblParam_[CbcStartSeconds] = CoinCpuTime();
-  strongInfo_[0]=0;
-  strongInfo_[1]=0;
-  strongInfo_[2]=0;
-  numberStrongIterations_ = 0;
-  // original solver (only set if pre-processing)
-  OsiSolverInterface * originalSolver=NULL;
-  // Set up strategies
-  if (strategy_) {
-    // May do preprocessing
-    originalSolver = solver_;
-    strategy_->setupOther(*this);
-    if (strategy_->preProcessState()) {
-      // pre-processing done
-      if (strategy_->preProcessState()<0) {
-        // infeasible
-        handler_->message(CBC_INFEAS,messages_)<< CoinMessageEol ;
-        status_ = 0 ;
-        secondaryStatus_ = 1;
-        originalContinuousObjective_ = COIN_DBL_MAX;
-        return ; 
-      }
-    } else {
-      //no preprocessing
-      originalSolver=NULL;
-    }
-    strategy_->setupCutGenerators(*this);
-    strategy_->setupHeuristics(*this);
-    // Set strategy print level to models
-    strategy_->setupPrinting(*this,handler_->logLevel());
-  }
-  eventHappened_=false;
-#ifdef COIN_USE_CLP
-  ClpEventHandler * eventHandler=NULL;
- {
-   OsiClpSolverInterface * clpSolver 
-     = dynamic_cast<OsiClpSolverInterface *> (solver_);
-   if (clpSolver) {
-     ClpSimplex * clpSimplex = clpSolver->getModelPtr();
-     eventHandler = clpSimplex->eventHandler();
-   }
- }
-#endif
-  if (!nodeCompare_)
-    nodeCompare_=new CbcCompareDefault();;
-  if (!problemFeasibility_)
-    problemFeasibility_=new CbcFeasibilityBase();
-# ifdef CBC_DEBUG
-  std::string problemName ;
-  solver_->getStrParam(OsiProbName,problemName) ;
-  printf("Problem name - %s\n",problemName.c_str()) ;
-  solver_->setHintParam(OsiDoReducePrint,false,OsiHintDo,0) ;
-# endif
-/*
-  Assume we're done, and see if we're proven wrong.
-*/
-  status_ = 0 ;
-  secondaryStatus_ = 0;
-  phase_=0;
-/*
-  Scan the variables, noting the integer variables. Create an
-  CbcSimpleInteger object for each integer variable.
-*/
-  findIntegers(false) ;
-  // If dynamic pseudo costs then do
-  if (numberBeforeTrust_)
-    convertToDynamic();
-  // Set up char array to say if integer
-  delete [] integerInfo_;
-  {
-    int n = solver_->getNumCols();
-    integerInfo_ = new char [n];
-    for (int i=0;i<n;i++) {
-      if (solver_->isInteger(i))
-        integerInfo_[i]=1;
-      else
-        integerInfo_[i]=0;
-    }
-  }
-    
-/*
-  Ensure that objects on the lists of CbcObjects, heuristics, and cut
-  generators attached to this model all refer to this model.
-*/
-  synchronizeModel() ;
-  assert (!solverCharacteristics_);
-  OsiBabSolver * solverCharacteristics = dynamic_cast<OsiBabSolver *> (solver_->getAuxiliaryInfo());
-  if (solverCharacteristics) {
-    solverCharacteristics_ = solverCharacteristics;
-  } else {
-    // replace in solver
-    OsiBabSolver defaultC;
-    solver_->setAuxiliaryInfo(&defaultC);
-    solverCharacteristics_ = dynamic_cast<OsiBabSolver *> (solver_->getAuxiliaryInfo());
-  }
-  solverCharacteristics_->setSolver(solver_);
-  // Set so we can tell we are in initial phase in resolve
-  continuousObjective_ = -COIN_DBL_MAX ;
-/*
-  Solve the relaxation.
-
-  Apparently there are circumstances where this will be non-trivial --- i.e.,
-  we've done something since initialSolve that's trashed the solution to the
-  continuous relaxation.
-*/
-  bool feasible = resolve() ;
-  if (problemFeasibility_->feasible(this,0)<0) {
-    feasible=false; // pretend infeasible
-  }
-/*
-  If the linear relaxation of the root is infeasible, bail out now. Otherwise,
-  continue with processing the root node.
-*/
-  if (!feasible)
-  { handler_->message(CBC_INFEAS,messages_)<< CoinMessageEol ;
-    status_ = 0 ;
-    secondaryStatus_ = 1;
-    originalContinuousObjective_ = COIN_DBL_MAX;
-    return ; }
-  // Save objective (just so user can access it)
-  originalContinuousObjective_ = solver_->getObjValue();
-  bestPossibleObjective_=originalContinuousObjective_;
-  sumChangeObjective1_=0.0;
-  sumChangeObjective2_=0.0;
-/*
-  OsiRowCutDebugger knows an optimal answer for a subset of MIP problems.
-  Assuming it recognises the problem, when called upon it will check a cut to
-  see if it cuts off the optimal answer.
-*/
-  // If debugger exists set specialOptions_ bit
-  if (solver_->getRowCutDebuggerAlways())
-    specialOptions_ |= 1;
-
-# ifdef CBC_DEBUG
-  if ((specialOptions_&1)==0)
-    solver_->activateRowCutDebugger(problemName.c_str()) ;
-  if (solver_->getRowCutDebuggerAlways())
-    specialOptions_ |= 1;
-# endif
-
-/*
-  Begin setup to process a feasible root node.
-*/
-  bestObjective_ = CoinMin(bestObjective_,1.0e50) ;
-  numberSolutions_ = 0 ;
-  stateOfSearch_=0;
-  numberHeuristicSolutions_ = 0 ;
-  // Everything is minimization
-  { 
-    // needed to sync cutoffs
-    double value ;
-    solver_->getDblParam(OsiDualObjectiveLimit,value) ;
-    dblParam_[CbcCurrentCutoff]= value * solver_->getObjSense();
-  }
-  double cutoff=getCutoff() ;
-  double direction = solver_->getObjSense() ;
-  dblParam_[CbcOptimizationDirection]=direction;
-  if (cutoff < 1.0e20&&direction<0.0)
-    messageHandler()->message(CBC_CUTOFF_WARNING1,
-                                    messages())
-                                      << cutoff << -cutoff << CoinMessageEol ;
-  if (cutoff > bestObjective_)
-    cutoff = bestObjective_ ;
-  setCutoff(cutoff) ;
-/*
-  We probably already have a current solution, but just in case ...
-*/
-  int numberColumns = getNumCols() ;
-  if (!currentSolution_)
-    currentSolution_ = new double[numberColumns] ;
-  testSolution_ = currentSolution_;
-  /* Tell solver we are in Branch and Cut
-     Could use last parameter for subtle differences */
-  solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,NULL) ;
-/*
-  Create a copy of the solver, thus capturing the original (root node)
-  constraint system (aka the continuous system).
-*/
-  continuousSolver_ = solver_->clone() ;
-#ifdef COIN_USE_CLP
-  OsiClpSolverInterface * clpSolver 
-    = dynamic_cast<OsiClpSolverInterface *> (solver_);
-  if (clpSolver) {
-    ClpSimplex * clpSimplex = clpSolver->getModelPtr();
-    // take off names
-    clpSimplex->dropNames();
-  }
-#endif
-
-  numberRowsAtContinuous_ = getNumRows() ;
-/*
-  Check the objective to see if we can deduce a nontrivial increment. If
-  it's better than the current value for CbcCutoffIncrement, it'll be
-  installed.
-*/
-  if(solverCharacteristics_->reducedCostsAccurate())
-    analyzeObjective() ;
-/*
-  Set up for cut generation. addedCuts_ holds the cuts which are relevant for
-  the active subproblem. whichGenerator will be used to record the generator
-  that produced a given cut.
-*/
-  maximumWhich_ = 1000 ;
-  delete [] whichGenerator_;
-  whichGenerator_ = new int[maximumWhich_] ;
-  memset(whichGenerator_,0,maximumWhich_*sizeof(int));
-  maximumNumberCuts_ = 0 ;
-  currentNumberCuts_ = 0 ;
-  delete [] addedCuts_ ;
-  addedCuts_ = NULL ;
-/*
-  Set up an empty heap and associated data structures to hold the live set
-  (problems which require further exploration).
-*/
-  tree_->setComparison(*nodeCompare_) ;
-/*
-  Used to record the path from a node to the root of the search tree, so that
-  we can then traverse from the root to the node when restoring a subproblem.
-*/
-  maximumDepth_ = 10 ;
-  delete [] walkback_ ;
-  walkback_ = new CbcNodeInfo * [maximumDepth_] ;
-/*
-  Used to generate bound edits for CbcPartialNodeInfo.
-*/
-  double * lowerBefore = new double [numberColumns] ;
-  double * upperBefore = new double [numberColumns] ;
-/*
-  
-  Generate cuts at the root node and reoptimise. solveWithCuts does the heavy
-  lifting. It will iterate a generate/reoptimise loop (including reduced cost
-  fixing) until no cuts are generated, the change in objective falls off,  or
-  the limit on the number of rounds of cut generation is exceeded.
-
-  At the end of all this, any cuts will be recorded in cuts and also
-  installed in the solver's constraint system. We'll have reoptimised, and
-  removed any slack cuts (numberOldActiveCuts_ and numberNewCuts_ have been
-  adjusted accordingly).
-
-  Tell cut generators they can be a bit more aggressive at root node
-
-  TODO: Why don't we make a copy of the solution after solveWithCuts?
-  TODO: If numberUnsatisfied == 0, don't we have a solution?
-*/
-  phase_=1;
-  int iCutGenerator;
-  for (iCutGenerator = 0;iCutGenerator<numberCutGenerators_;iCutGenerator++) {
-    CglCutGenerator * generator = generator_[iCutGenerator]->generator();
-    generator->setAggressiveness(generator->getAggressiveness()+100);
-  }
-  OsiCuts cuts ;
-  int anyAction = -1 ;
-  numberOldActiveCuts_ = 0 ;
-  numberNewCuts_ = 0 ;
-  // Array to mark solution
-  delete [] usedInSolution_;
-  usedInSolution_ = new int[numberColumns];
-  CoinZeroN(usedInSolution_,numberColumns);
-/*
-  For printing totals and for CbcNode (numberNodes_)
-*/
-  numberIterations_ = 0 ;
-  numberNodes_ = 0 ;
-  numberNodes2_ = 0 ;
-  maximumStatistics_=0;
-  statistics_ = NULL;
-  // Do on switch
-  if (doStatistics) {
-    maximumStatistics_=10000;
-    statistics_ = new CbcStatistics * [maximumStatistics_];
-    memset(statistics_,0,maximumStatistics_*sizeof(CbcStatistics *));
-  }
-
-  { int iObject ;
-    int preferredWay ;
-    int numberUnsatisfied = 0 ;
-    memcpy(currentSolution_,solver_->getColSolution(),
-           numberColumns*sizeof(double)) ;
-
-    for (iObject = 0 ; iObject < numberObjects_ ; iObject++)
-    { double infeasibility =
-          object_[iObject]->infeasibility(preferredWay) ;
-      if (infeasibility ) numberUnsatisfied++ ; }
-    if (numberUnsatisfied) { 
-      feasible = solveWithCuts(cuts,maximumCutPassesAtRoot_,NULL);
-    }
-  }
-  // make cut generators less aggressive
-  for (iCutGenerator = 0;iCutGenerator<numberCutGenerators_;iCutGenerator++) {
-    CglCutGenerator * generator = generator_[iCutGenerator]->generator();
-    generator->setAggressiveness(generator->getAggressiveness()-100);
-  }
-  currentNumberCuts_ = numberNewCuts_ ;
-/*
-  We've taken the continuous relaxation as far as we can. Time to branch.
-  The first order of business is to actually create a node. chooseBranch
-  currently uses strong branching to evaluate branch object candidates,
-  unless forced back to simple branching. If chooseBranch concludes that a
-  branching candidate is monotone (anyAction == -1) or infeasible (anyAction
-  == -2) when forced to integer values, it returns here immediately.
-
-  Monotone variables trigger a call to resolve(). If the problem remains
-  feasible, try again to choose a branching variable. At the end of the loop,
-  resolved == true indicates that some variables were fixed.
-
-  Loss of feasibility will result in the deletion of newNode.
-*/
-
-  bool resolved = false ;
-  CbcNode *newNode = NULL ;
-  numberFixedAtRoot_=0;
-  numberFixedNow_=0;
-  int numberIterationsAtContinuous = numberIterations_;
-  if (feasible) {
-    newNode = new CbcNode ;
-    // Set objective value (not so obvious if NLP etc)
-    setObjectiveValue(newNode,NULL);
-    anyAction = -1 ;
-    // To make depth available we may need a fake node
-    CbcNode fakeNode;
-    if (!currentNode_) {
-      // Not true if sub trees assert (!numberNodes_);
-      currentNode_=&fakeNode;
-    }
-    phase_=3;
-    // only allow 1000 passes
-    int numberPassesLeft=1000;
-    // This is first crude step
-    if (numberAnalyzeIterations_) {
-      delete [] analyzeResults_;
-      analyzeResults_ = new double [4*numberIntegers_];
-      numberFixedAtRoot_=newNode->analyze(this,analyzeResults_);
-      if (numberFixedAtRoot_>0) {
-        printf("%d fixed by analysis\n",numberFixedAtRoot_);
-        setPointers(solver_);
-        numberFixedNow_ = numberFixedAtRoot_;
-      } else if (numberFixedAtRoot_<0) {
-        printf("analysis found to be infeasible\n");
-        anyAction=-2;
-        delete newNode ;
-        newNode = NULL ;
-        feasible = false ;
-      }
-    }
-    while (anyAction == -1)
-    {
-      // Set objective value (not so obvious if NLP etc)
-      setObjectiveValue(newNode,NULL);
-      if (numberBeforeTrust_==0 ) {
-        anyAction = newNode->chooseBranch(this,NULL,numberPassesLeft) ;
-      } else {
-        OsiSolverBranch * branches=NULL;
-        anyAction = newNode->chooseDynamicBranch(this,NULL,branches,numberPassesLeft) ;
-        if (anyAction==-3) 
-          anyAction = newNode->chooseBranch(this,NULL,numberPassesLeft) ; // dynamic did nothing
-      }
-      numberPassesLeft--;
-      if (anyAction == -1)
-      { feasible = resolve() ;
-      if (problemFeasibility_->feasible(this,0)<0) {
-        feasible=false; // pretend infeasible
-      }
-      reducedCostFix() ;
-      resolved = true ;
-#       ifdef CBC_DEBUG
-      printf("Resolve (root) as something fixed, Obj value %g %d rows\n",
-             solver_->getObjValue(),
-             solver_->getNumRows()) ;
-#       endif
-      if (!feasible) anyAction = -2 ; }
-      if (anyAction == -2||newNode->objectiveValue() >= cutoff)
-      { delete newNode ;
-        newNode = NULL ;
-        feasible = false ; } } }
-/*
-  At this point, the root subproblem is infeasible or fathomed by bound
-  (newNode == NULL), or we're live with an objective value that satisfies the
-  current objective cutoff.
-*/
-  assert (!newNode || newNode->objectiveValue() <= cutoff) ;
-  // Save address of root node as we don't want to delete it
-  //CbcNode * rootNode = newNode;
-/*
-  The common case is that the lp relaxation is feasible but doesn't satisfy
-  integrality (i.e., newNode->variable() >= 0, indicating we've been able to
-  select a branching variable). Remove any cuts that have gone slack due to
-  forcing monotone variables. Then tack on an CbcFullNodeInfo object and full
-  basis (via createInfo()) and stash the new cuts in the nodeInfo (via
-  addCuts()). If, by some miracle, we have an integral solution at the root
-  (newNode->variable() < 0), takeOffCuts() will ensure that the solver holds
-  a valid solution for use by setBestSolution().
-*/
-  if (feasible && newNode->variable() >= 0)
-  { if (resolved)
-    { bool needValidSolution = (newNode->variable() < 0) ;
-      takeOffCuts(cuts,needValidSolution,NULL) ;
-#     ifdef CHECK_CUT_COUNTS
-      { printf("Number of rows after chooseBranch fix (root)"
-               "(active only) %d\n",
-                numberRowsAtContinuous_+numberNewCuts_+numberOldActiveCuts_) ;
-        const CoinWarmStartBasis* debugws =
-          dynamic_cast <const CoinWarmStartBasis*>(solver_->getWarmStart()) ;
-        debugws->print() ;
-        delete debugws ; }
-#     endif
-    }
-    newNode->createInfo(this,NULL,NULL,NULL,NULL,0,0) ;
-    newNode->nodeInfo()->addCuts(cuts,
-                                 newNode->numberBranches(),whichGenerator_) ;
-  }
-/*
-  Continuous data to be used later
-*/
-  continuousObjective_ = solver_->getObjValue()*solver_->getObjSense();
-  continuousInfeasibilities_ = 0 ;
-  if (newNode)
-  { continuousObjective_ = newNode->objectiveValue() ;
-    delete [] continuousSolution_;
-    continuousSolution_ = CoinCopyOfArray(solver_->getColSolution(),
-                                             numberColumns);
-    continuousInfeasibilities_ = newNode->numberUnsatisfied() ; }
-/*
-  Bound may have changed so reset in objects
-*/
-  { int i ;
-    for (i = 0;i < numberObjects_;i++)
-      object_[i]->resetBounds() ; }
-  stoppedOnGap_ = false ;
-/*
-  Feasible? Then we should have either a live node prepped for future
-  expansion (indicated by variable() >= 0), or (miracle of miracles) an
-  integral solution at the root node.
-
-  initializeInfo sets the reference counts in the nodeInfo object.  Since
-  this node is still live, push it onto the heap that holds the live set.
-*/
-  double bestValue = 0.0 ;
-  if (newNode) {
-    bestValue = newNode->objectiveValue();
-    if (newNode->variable() >= 0) {
-      newNode->initializeInfo() ;
-      tree_->push(newNode) ;
-      if (statistics_) {
-        if (numberNodes2_==maximumStatistics_) {
-          maximumStatistics_ = 2*maximumStatistics_;
-          CbcStatistics ** temp = new CbcStatistics * [maximumStatistics_];
-          memset(temp,0,maximumStatistics_*sizeof(CbcStatistics *));
-          memcpy(temp,statistics_,numberNodes2_*sizeof(CbcStatistics *));
-          delete [] statistics_;
-          statistics_=temp;
-        }
-        assert (!statistics_[numberNodes2_]);
-        statistics_[numberNodes2_]=new CbcStatistics(newNode);
-      }
-      numberNodes2_++;
-#     ifdef CHECK_NODE
-      printf("Node %x on tree\n",newNode) ;
-#     endif
-    } else {
-      // continuous is integer
-      double objectiveValue = newNode->objectiveValue();
-      setBestSolution(CBC_SOLUTION,objectiveValue,
-                      solver_->getColSolution()) ;
-      delete newNode ;
-      newNode = NULL ;
-    }
-  }
-
-  if (printFrequency_ <= 0) {
-    printFrequency_ = 1000 ;
-    if (getNumCols() > 2000)
-      printFrequency_ = 100 ;
-  }
-  /*
-    It is possible that strong branching fixes one variable and then the code goes round
-    again and again.  This can take too long.  So we need to warn user - just once.
-  */
-  numberLongStrong_=0;
-/*
-  At last, the actual branch-and-cut search loop, which will iterate until
-  the live set is empty or we hit some limit (integrality gap, time, node
-  count, etc.). The overall flow is to rebuild a subproblem, reoptimise using
-  solveWithCuts(), choose a branching pattern with chooseBranch(), and finally
-  add the node to the live set.
-
-  The first action is to winnow the live set to remove nodes which are worse
-  than the current objective cutoff.
-*/
-  while (!tree_->empty()) {
-    if (cutoff > getCutoff()) {
-      double newCutoff = getCutoff();
-      if (analyzeResults_) {
-        // see if we could fix any (more)
-        int n=0;
-        double * newLower = analyzeResults_;
-        double * objLower = newLower+numberIntegers_;
-        double * newUpper = objLower+numberIntegers_;
-        double * objUpper = newUpper+numberIntegers_;
-        for (int i=0;i<numberIntegers_;i++) {
-          if (objLower[i]>newCutoff) {
-            n++;
-            if (objUpper[i]>newCutoff) {
-              newCutoff = -COIN_DBL_MAX;
-              break;
-            }
-          } else if (objUpper[i]>newCutoff) {
-            n++;
-          }
-        }
-        if (newCutoff==-COIN_DBL_MAX) {
-          printf("Root analysis says finished\n");
-        } else if (n>numberFixedNow_) {
-          printf("%d more fixed by analysis - now %d\n",n-numberFixedNow_,n);
-          numberFixedNow_=n;
-        }
-      }
-#ifdef COIN_USE_CLP
-      if (eventHandler) {
-        if (!eventHandler->event(ClpEventHandler::solution)) {
-          eventHappened_=true; // exit
-        }
-      }
-#endif
-      // Do from deepest
-      tree_->cleanTree(this, newCutoff,bestPossibleObjective_) ;
-      nodeCompare_->newSolution(this) ;
-      nodeCompare_->newSolution(this,continuousObjective_,
-                                continuousInfeasibilities_) ;
-      tree_->setComparison(*nodeCompare_) ;
-      if (tree_->empty())
-        break; // finished
-    }
-    cutoff = getCutoff() ;
-    /*
-      Periodic activities: Opportunities to
-      + tweak the nodeCompare criteria,
-      + check if we've closed the integrality gap enough to quit, 
-      + print a summary line to let the user know we're working
-    */
-    if ((numberNodes_%1000) == 0) {
-      bool redoTree=nodeCompare_->every1000Nodes(this, numberNodes_) ;
-      // redo tree if wanted
-      if (redoTree)
-        tree_->setComparison(*nodeCompare_) ;
-    }
-    if ((numberNodes_%printFrequency_) == 0) {
-      int j ;
-      int nNodes = tree_->size() ;
-      bestPossibleObjective_ = 1.0e100 ;
-      for (j = 0;j < nNodes;j++) {
-        CbcNode * node = tree_->nodePointer(j) ;
-        if (node&&node->objectiveValue() < bestPossibleObjective_)
-          bestPossibleObjective_ = node->objectiveValue() ;
-      }
-      messageHandler()->message(CBC_STATUS,messages())
-        << numberNodes_<< nNodes<< bestObjective_<< bestPossibleObjective_
-        << CoinMessageEol ;
-#ifdef COIN_USE_CLP
-      if (eventHandler) {
-        if (!eventHandler->event(ClpEventHandler::treeStatus)) {
-          eventHappened_=true; // exit
-        }
-      }
-#endif
-    }
-    // If no solution but many nodes - signal change in strategy
-    if (numberNodes_>2*numberObjects_+1000&&stateOfSearch_!=2)
-      stateOfSearch_=3;
-    // See if can stop on gap
-    double testGap = CoinMax(dblParam_[CbcAllowableGap],
-                             CoinMax(fabs(bestObjective_),fabs(bestPossibleObjective_))
-                             *dblParam_[CbcAllowableFractionGap]);
-    if (bestObjective_-bestPossibleObjective_ < testGap && getCutoffIncrement()>=0.0) {
-      stoppedOnGap_ = true ;
-    }
-
-#   ifdef CHECK_NODE_FULL
-    verifyTreeNodes(tree_,*this) ;
-#   endif
-#   ifdef CHECK_CUT_COUNTS
-    verifyCutCounts(tree_,*this) ;
-#   endif
-    
-    /*
-      Now we come to the meat of the loop. To create the active subproblem, we'll
-      pop the most promising node in the live set, rebuild the subproblem it
-      represents, and then execute the current arm of the branch to create the
-      active subproblem.
-    */
-    CbcNode *node = tree_->bestNode(cutoff) ;
-    // Possible one on tree worse than cutoff
-    if (!node)
-      continue;
-    // Solve node
-    int status;
-    int numberNewNodes;
-    CbcNode ** newNodes = solveOneNode(-1,node,numberNewNodes,status);
-    // put nodes back on tree
-    for (int iPush = 0; iPush<numberNewNodes;iPush++) {
-      tree_->push(newNodes[iPush]) ;
-    }      
-    delete [] newNodes;
-    if (status==2) {
-      /*
-        The next block of code is executed if we've
-        aborted because we hit one of the limits. Clean up by deleting the live set
-        and break out of the node processing loop.
-      */
-      tree_->cleanTree(this,-COIN_DBL_MAX,bestPossibleObjective_) ;
-      delete nextRowCut_;
-      // We need to get rid of node if is has already been popped from tree
-      //if (!nodeOnTree&&!stoppedOnGap_&&node!=rootNode)
-      //delete node;
-      double totalTime = CoinCpuTime()-dblParam_[CbcStartSeconds] ;
-      if (stoppedOnGap_) {
-        messageHandler()->message(CBC_GAP,messages())
-          << bestObjective_-bestPossibleObjective_
-          << dblParam_[CbcAllowableGap]
-          << dblParam_[CbcAllowableFractionGap]*100.0
-          << CoinMessageEol ;
-        secondaryStatus_ = 2;
-        status_ = 0 ;
-      } else if (isNodeLimitReached()) {
-        handler_->message(CBC_MAXNODES,messages_) << CoinMessageEol ;
-        secondaryStatus_ = 3;
-        status_ = 1 ;
-      } else if (totalTime >= dblParam_[CbcMaximumSeconds]) {
-        handler_->message(CBC_MAXTIME,messages_) << CoinMessageEol ; 
-        secondaryStatus_ = 4;
-        status_ = 1 ;
-      } else if (eventHappened_) {
-        handler_->message(CBC_EVENT,messages_) << CoinMessageEol ; 
-        secondaryStatus_ = 5;
-        status_ = 5 ;
-      } else { 
-        handler_->message(CBC_MAXSOLS,messages_) << CoinMessageEol ;
-        secondaryStatus_ = 6;
-        status_ = 1 ;
-      }
-      break ;
-    } else {
-      /*
-        Delete cuts to get back to the original system.
-        
-        I'm thinking this is redundant --- the call to addCuts that conditions entry
-        to this code block also performs this action.
-      */
-      int numberToDelete = getNumRows()-numberRowsAtContinuous_ ;
-      if (numberToDelete) {
-        int * delRows = new int[numberToDelete] ;
-        int i ;
-        for (i = 0 ; i < numberToDelete ; i++) 
-          delRows[i] = i+numberRowsAtContinuous_ ; 
-        solver_->deleteRows(numberToDelete,delRows) ;
-        delete [] delRows ;
-      }
-    }
-  }
-  /*
-    That's it, we've exhausted the search tree, or broken out of the loop because
-    we hit some limit on evaluation.
-    
-    We may have got an intelligent tree so give it one more chance
-  */
-  // Tell solver we are not in Branch and Cut
-  solver_->setHintParam(OsiDoInBranchAndCut,false,OsiHintDo,NULL) ;
-  tree_->endSearch();
-  //  If we did any sub trees - did we give up on any?
-  if ( numberStoppedSubTrees_)
-    status_=1;
-  if (!status_) {
-    bestPossibleObjective_=bestObjective_;
-    handler_->message(CBC_END_GOOD,messages_)
-      << bestObjective_ << numberIterations_ << numberNodes_
-      << CoinMessageEol ;
-  } else {
-    handler_->message(CBC_END,messages_)
-      << bestObjective_ <<bestPossibleObjective_
-      << numberIterations_ << numberNodes_
-      << CoinMessageEol ;
-  }
-  if (numberStrongIterations_)
-    handler_->message(CBC_STRONG_STATS,messages_)
-      << strongInfo_[0] << numberStrongIterations_ << strongInfo_[2]
-      << strongInfo_[1] << CoinMessageEol ;
-  if (statistics_) {
-    // report in some way
-    int * lookup = new int[numberObjects_];
-    int i;
-    for (i=0;i<numberObjects_;i++) 
-      lookup[i]=-1;
-    bool goodIds=true;
-    for (i=0;i<numberObjects_;i++) {
-      int id = object_[i]->id();
-      int iColumn = object_[i]->columnNumber();
-      if (iColumn<0)
-        iColumn = id+numberColumns;
-      if(id>=0&&id<numberObjects_) {
-        if (lookup[id]==-1) {
-          lookup[id]=iColumn;
-        } else {
-          goodIds=false;
-          break;
-        }
-      } else {
-        goodIds=false;
-        break;
-      }
-    }
-    if (!goodIds) {
-      delete [] lookup;
-      lookup=NULL;
-    }
-    if (doStatistics==3) {
-      printf("  node parent depth column   value                    obj      inf\n");
-      for ( i=0;i<numberNodes2_;i++) {
-        statistics_[i]->print(lookup);
-      }
-    }
-    if (doStatistics>1) {
-      // Find last solution
-      int k;
-      for (k=numberNodes2_-1;k>=0;k--) {
-        if (statistics_[k]->endingObjective()!=COIN_DBL_MAX&&
-            !statistics_[k]->endingInfeasibility())
-          break;
-      }
-      if (k>=0) {
-        int depth=statistics_[k]->depth();
-        int * which = new int[depth+1];
-        for (i=depth;i>=0;i--) {
-          which[i]=k;
-          k=statistics_[k]->parentNode();
-        }
-        printf("  node parent depth column   value                    obj      inf\n");
-        for (i=0;i<=depth;i++) {
-          statistics_[which[i]]->print(lookup);
-        }
-        delete [] which;
-      }
-    }
-    // now summary
-    int maxDepth=0;
-    double averageSolutionDepth=0.0;
-    int numberSolutions=0;
-    double averageCutoffDepth=0.0;
-    double averageSolvedDepth=0.0;
-    int numberCutoff=0;
-    int numberDown=0;
-    int numberFirstDown=0;
-    double averageInfDown=0.0;
-    double averageObjDown=0.0;
-    int numberCutoffDown=0;
-    int numberUp=0;
-    int numberFirstUp=0;
-    double averageInfUp=0.0;
-    double averageObjUp=0.0;
-    int numberCutoffUp=0;
-    double averageNumberIterations1=0.0;
-    double averageValue=0.0;
-    for ( i=0;i<numberNodes2_;i++) {
-      int depth =  statistics_[i]->depth(); 
-      int way =  statistics_[i]->way(); 
-      double value = statistics_[i]->value(); 
-      double startingObjective =  statistics_[i]->startingObjective(); 
-      int startingInfeasibility = statistics_[i]->startingInfeasibility(); 
-      double endingObjective = statistics_[i]->endingObjective(); 
-      int endingInfeasibility = statistics_[i]->endingInfeasibility(); 
-      maxDepth = CoinMax(depth,maxDepth);
-      // Only for completed
-      averageNumberIterations1 += statistics_[i]->numberIterations();
-      averageValue += value;
-      if (endingObjective!=COIN_DBL_MAX&&!endingInfeasibility) {
-        numberSolutions++;
-        averageSolutionDepth += depth;
-      }
-      if (endingObjective==COIN_DBL_MAX) {
-        numberCutoff++;
-        averageCutoffDepth += depth;
-        if (way<0) {
-          numberDown++;
-          numberCutoffDown++;
-          if (way==-1)
-            numberFirstDown++;
-        } else {
-          numberUp++;
-          numberCutoffUp++;
-          if (way==1)
-            numberFirstUp++;
-        }
-      } else {
-        averageSolvedDepth += depth;
-        if (way<0) {
-          numberDown++;
-          averageInfDown += startingInfeasibility-endingInfeasibility;
-          averageObjDown += endingObjective-startingObjective;
-          if (way==-1)
-            numberFirstDown++;
-        } else {
-          numberUp++;
-          averageInfUp += startingInfeasibility-endingInfeasibility;
-          averageObjUp += endingObjective-startingObjective;
-          if (way==1)
-            numberFirstUp++;
-        }
-      }
-    }
-    // Now print
-    if (numberSolutions)
-      averageSolutionDepth /= (double) numberSolutions;
-    int numberSolved = numberNodes2_-numberCutoff;
-    double averageNumberIterations2=numberIterations_-averageNumberIterations1
-      -numberIterationsAtContinuous;
-    if(numberCutoff) {
-      averageCutoffDepth /= (double) numberCutoff;
-      averageNumberIterations2 /= (double) numberCutoff;
-    }
-    if (numberNodes2_) 
-      averageValue /= (double) numberNodes2_;
-    if (numberSolved) {
-      averageNumberIterations1 /= (double) numberSolved;
-      averageSolvedDepth /= (double) numberSolved;
-    }
-    printf("%d solution(s) were found (by branching) at an average depth of %g\n",
-           numberSolutions,averageSolutionDepth);
-    printf("average value of variable being branched on was %g\n",
-           averageValue);
-    printf("%d nodes were cutoff at an average depth of %g with iteration count of %g\n",
-           numberCutoff,averageCutoffDepth,averageNumberIterations2);
-    printf("%d nodes were solved at an average depth of %g with iteration count of %g\n",
-           numberSolved,averageSolvedDepth,averageNumberIterations1);
-    if (numberDown) {
-      averageInfDown /= (double) numberDown;
-      averageObjDown /= (double) numberDown;
-    }
-    printf("Down %d nodes (%d first, %d second) - %d cutoff, rest decrease numinf %g increase obj %g\n",
-           numberDown,numberFirstDown,numberDown-numberFirstDown,numberCutoffDown,
-           averageInfDown,averageObjDown);
-    if (numberUp) {
-      averageInfUp /= (double) numberUp;
-      averageObjUp /= (double) numberUp;
-    }
-    printf("Up %d nodes (%d first, %d second) - %d cutoff, rest decrease numinf %g increase obj %g\n",
-           numberUp,numberFirstUp,numberUp-numberFirstUp,numberCutoffUp,
-           averageInfUp,averageObjUp);
-    for ( i=0;i<numberNodes2_;i++) 
-      delete statistics_[i];
-    delete [] statistics_;
-    statistics_=NULL;
-    maximumStatistics_=0;
-    delete [] lookup;
-  }
-/*
-  If we think we have a solution, restore and confirm it with a call to
-  setBestSolution().  We need to reset the cutoff value so as not to fathom
-  the solution on bounds.  Note that calling setBestSolution( ..., true)
-  leaves the continuousSolver_ bounds vectors fixed at the solution value.
-
-  Running resolve() here is a failsafe --- setBestSolution has already
-  reoptimised using the continuousSolver_. If for some reason we fail to
-  prove optimality, run the problem again after instructing the solver to
-  tell us more.
-
-  If all looks good, replace solver_ with continuousSolver_, so that the
-  outside world will be able to obtain information about the solution using
-  public methods.
-*/
-  if (bestSolution_) {
-    setCutoff(1.0e50) ; // As best solution should be worse than cutoff
-    phase_=5;
-    setBestSolution(CBC_SOLUTION,bestObjective_,bestSolution_,true) ;
-    continuousSolver_->resolve() ;
-    if (!continuousSolver_->isProvenOptimal()) {
-      continuousSolver_->messageHandler()->setLogLevel(2) ;
-      continuousSolver_->initialSolve() ;
-    }
-    delete solver_ ;
-    solver_ = continuousSolver_ ;
-    setPointers(solver_);
-    continuousSolver_ = NULL ;
-  }
-  /*
-    Clean up dangling objects. continuousSolver_ may already be toast.
-  */
-  delete [] whichGenerator_ ;
-  whichGenerator_=NULL;
-  delete [] lowerBefore ;
-  delete [] upperBefore ;
-  delete [] walkback_ ;
-  walkback_ = NULL ;
-  delete [] addedCuts_ ;
-  addedCuts_ = NULL ;
-  // Get rid of characteristics
-  solverCharacteristics_=NULL;
-  if (continuousSolver_) {
-    delete continuousSolver_ ;
-    continuousSolver_ = NULL ;
-  }
-  /*
-    Destroy global cuts by replacing with an empty OsiCuts object.
-  */
-  globalCuts_= OsiCuts() ;
-  if (strategy_&&strategy_->preProcessState()>0) {
-    // undo preprocessing
-    CglPreProcess * process = strategy_->process();
-    assert (process);
-    int n = originalSolver->getNumCols();
-    if (bestSolution_) {
-      delete [] bestSolution_;
-      bestSolution_ = new double [n];
-      process->postProcess(*solver_);
-    }
-    strategy_->deletePreProcess();
-    // Solution now back in originalSolver
-    delete solver_;
-    solver_=originalSolver;
-    if (bestSolution_)
-      memcpy(bestSolution_,solver_->getColSolution(),n*sizeof(double));
-  }
-  return ;
-}
-/* Input one node output N nodes to put on tree and optional solution update
-   This should be able to operate in parallel so is given a solver and is const(ish)
-   However we will need to keep an array of solver_ and bases and more
-   status is 0 for normal, 1 if solution, 2 if should stop
-   Calling code should always push nodes back on tree
- */
-CbcNode ** 
-CbcModel::solveOneNode(int whichSolver,CbcNode * node, 
-                    int & numberNodesOutput, int & status) 
-{
-  numberNodesOutput=0;
-  status=0;
-  // Maximum number of new nodes will be known
-  // For normal case can be 2 (old + new)
-  int maximumNewNodes=2+(1<<sizeMiniTree_);
-  CbcNode ** newNodes = new CbcNode * [maximumNewNodes];
-  
-  currentNode_=node; // so can be accessed elsewhere
-#ifdef CBC_DEBUG
-  printf("%d unsat, way %d, obj %g est %g\n",
-         node->numberUnsatisfied(),node->way(),node->objectiveValue(),
-         node->guessedObjectiveValue());
-#endif
-  // Save clone in branching decision
-  if(branchingMethod_)
-    branchingMethod_->saveBranchingObject(node->modifiableBranchingObject());
-  // Say not on optimal path
-  bool onOptimalPath=false;
-#   ifdef CHECK_NODE
-  /*
-    WARNING: The use of integerVariable_[*] here will break as soon as the
-    branching object is something other than an integer variable.
-    This needs some thought.
-  */
-  printf("Node %x popped from tree - %d left, %d count\n",node,
-         node->nodeInfo()->numberBranchesLeft(),
-         node->nodeInfo()->numberPointingToThis()) ;
-  printf("\tdepth = %d, z =  %g, unsat = %d, var = %d.\n",
-         node->depth(),node->objectiveValue(),
-         node->numberUnsatisfied(),
-         integerVariable_[node->variable()]) ;
-#   endif
-  
-  /*
-    Rebuild the subproblem for this node:        Call addCuts() to adjust the model
-    to recreate the subproblem for this node (set proper variable bounds, add
-    cuts, create a basis).  This may result in the problem being fathomed by
-    bound or infeasibility. Returns 1 if node is fathomed.
-    Execute the current arm of the branch: If the problem survives, save the
-    resulting variable bounds and call branch() to modify variable bounds
-    according to the current arm of the branching object. If we're processing
-    the final arm of the branching object, flag the node for removal from the
-    live set.
-  */
-  CbcNodeInfo * nodeInfo = node->nodeInfo() ;
-  // empty basis
-  CoinWarmStartBasis * lastws = new CoinWarmStartBasis();
-  int numberColumns = getNumCols() ;
-  double * lowerBefore = new double[numberColumns];
-  double * upperBefore = new double[numberColumns];
-  if (!addCuts(node,lastws,numberFixedNow_>numberFixedAtRoot_)) {
-    int i ;
-    const double * lower = getColLower() ;
-    const double * upper = getColUpper() ;
-    for (i = 0 ; i < numberColumns ; i++) {
-      lowerBefore[i]= lower[i] ;
-      upperBefore[i]= upper[i] ;
-    }
-    bool deleteNode ;
-    if (node->branch()) { 
-      // set nodenumber correctly
-      node->nodeInfo()->setNodeNumber(numberNodes2_);
-      if (statistics_) {
-        if (numberNodes2_==maximumStatistics_) {
-          maximumStatistics_ = 2*maximumStatistics_;
-          CbcStatistics ** temp = new CbcStatistics * [maximumStatistics_];
-          memset(temp,0,maximumStatistics_*sizeof(CbcStatistics *));
-          memcpy(temp,statistics_,numberNodes2_*sizeof(CbcStatistics *));
-          delete [] statistics_;
-          statistics_=temp;
-        }
-        assert (!statistics_[numberNodes2_]);
-        statistics_[numberNodes2_]=new CbcStatistics(node);
-      }
-      numberNodes2_++;
-      newNodes[numberNodesOutput++]=node;
-      deleteNode = false ;
-#       ifdef CHECK_NODE
-      printf("Node %x pushed back on tree - %d left, %d count\n",node,
-             nodeInfo->numberBranchesLeft(),
-             nodeInfo->numberPointingToThis()) ;
-#       endif
-    } else { 
-      deleteNode = true ;
-    }
-    
-    if ((specialOptions_&1)!=0) {
-      /*
-        This doesn't work as intended --- getRowCutDebugger will return null
-        unless the current feasible solution region includes the optimal solution
-        that RowCutDebugger knows. There's no way to tell inactive from off the
-        optimal path.
-      */
-      const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger() ;
-      if (debugger) {
-        onOptimalPath=true;
-        printf("On optimal path\n") ;
-      }
-    }
-    /*
-      Reoptimize, possibly generating cuts and/or using heuristics to find
-      solutions.  Cut reference counts are unaffected unless we lose feasibility,
-      in which case solveWithCuts() will make the adjustment.
-    */
-    phase_=2;
-    OsiCuts cuts = OsiCuts() ;
-    int saveNumber = numberIterations_;
-    if(solverCharacteristics_->solutionAddsCuts()) {
-      feasible=resolve();
-      if (feasible) {
-        int iObject ;
-        int preferredWay ;
-        int numberUnsatisfied = 0 ;
-        memcpy(currentSolution_,solver_->getColSolution(),
-               numberColumns*sizeof(double)) ;
-        
-        for (iObject = 0 ; iObject < numberObjects_ ; iObject++) {
-          double infeasibility =
-            object_[iObject]->infeasibility(preferredWay) ;
-          if (infeasibility ) numberUnsatisfied++ ;
-        }
-        if (numberUnsatisfied)   {
-          feasible = solveWithCuts(cuts,maximumCutPassesAtRoot_,
-                                   NULL);
-        } else {
-          // may generate cuts and turn the solution
-          //to an infeasible one
-          feasible = solveWithCuts(cuts, 1,
-                                   NULL);
-          currentNumberCuts_ = cuts.sizeRowCuts();
-            if (currentNumberCuts_ >= maximumNumberCuts_) {
-              maximumNumberCuts_ = currentNumberCuts;
-              delete [] addedCuts_;
-              addedCuts_ = new CbcCountRowCut * [maximumNumberCuts_];
-            }
-        }
-        // check extra info on feasibility
-        if (!solverCharacteristics_->mipFeasible())
-          feasible = false;
-      }
-    } else {
-      // normal
-      feasible = solveWithCuts(cuts,maximumCutPasses_,node);
-    }
-    if (statistics_) {
-      assert (numberNodes2_);
-      assert (statistics_[numberNodes2_-1]);
-      assert (statistics_[numberNodes2_-1]->node()==numberNodes2_-1);
-      statistics_[numberNodes2_-1]->endOfBranch(numberIterations_-saveNumber,
-                                               feasible ? solver_->getObjValue()
-                                               : COIN_DBL_MAX);
-    }
-    /*
-      Check for abort on limits: node count, solution count, time, integrality gap.
-    */
-    double totalTime = CoinCpuTime()-dblParam_[CbcStartSeconds] ;
-    if (numberNodes_ < intParam_[CbcMaxNumNode] &&
-        numberSolutions_ < intParam_[CbcMaxNumSol] &&
-        totalTime < dblParam_[CbcMaximumSeconds] &&
-        !stoppedOnGap_&&!eventHappened_) {
-      /*
-        Are we still feasible? If so, create a node and do the work to attach a
-        branching object, reoptimising as needed if chooseBranch() identifies
-        monotone objects.
-        
-        Finally, attach a partial nodeInfo object and store away any cuts that we
-        created back in solveWithCuts. addCuts() will also deal with the cut
-        reference counts.
-      */
-      if (onOptimalPath)
-        assert (feasible);
-      bool checkingNode=false;
-      int anyAction;
-      double direction =  dblParam_[CbcOptimizationDirection];
-      bool resolved = false;
-      CbcNode * newNode=NULL;
-      if (feasible) {
-        newNode = new CbcNode ;
-        // Set objective value (not so obvious if NLP etc)
-        setObjectiveValue(newNode,node);
-        anyAction =-1 ;
-        resolved = false ;
-        if (newNode->objectiveValue() >= getCutoff()) 
-          anyAction=-2;
-        // only allow twenty passes
-        int numberPassesLeft=20;
-        checkingNode=true;
-        OsiSolverBranch * branches=NULL;
-        while (anyAction == -1) { 
-          // Set objective value (not so obvious if NLP etc)
-          setObjectiveValue(newNode,node);
-          if (numberBeforeTrust_==0 ) {
-            anyAction = newNode->chooseBranch(this,node,numberPassesLeft) ;
-          } else {
-            anyAction = newNode->chooseDynamicBranch(this,node,branches,numberPassesLeft) ;
-            if (anyAction==-3) 
-              anyAction = newNode->chooseBranch(this,node,numberPassesLeft) ; // dynamic did nothing
-          }
-          if (onOptimalPath)
-            assert (anyAction!=-2); // can be useful but gives false positives on strong
-          numberPassesLeft--;
-          if (numberPassesLeft<=-1) {
-            if (!numberLongStrong_)
-              messageHandler()->message(CBC_WARNING_STRONG,
-                                        messages()) << CoinMessageEol ;
-            numberLongStrong_++;
-          }
-          if (anyAction == -1) {
-            // can do quick optimality check
-            int easy=2;
-            solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,&easy) ;
-            feasible = resolve() ;
-            solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,NULL) ;
-            resolved = true ;
-            if (problemFeasibility_->feasible(this,0)<0) {
-              feasible=false; // pretend infeasible
-            }
-            if (feasible) {
-              // Set objective value (not so obvious if NLP etc)
-              setObjectiveValue(newNode,node);
-              reducedCostFix() ;
-              if (newNode->objectiveValue() >= getCutoff()) 
-                anyAction=-2;
-            } else {
-              anyAction = -2 ;
-            }
-          }
-        }
-        if (anyAction >= 0) {
-          if (resolved) {
-            bool needValidSolution = (newNode->variable() < 0) ;
-            takeOffCuts(cuts,needValidSolution,NULL) ; 
-#             ifdef CHECK_CUT_COUNTS
-            { printf("Number of rows after chooseBranch fix (node)"
-                     "(active only) %d\n",
-                     numberRowsAtContinuous_+numberNewCuts_+
-                     numberOldActiveCuts_) ;
-            const CoinWarmStartBasis* debugws =
-              dynamic_cast<const CoinWarmStartBasis*>
-              (solver_->getWarmStart()) ;
-            debugws->print() ;
-            delete debugws ; }
-#             endif
-          }
-          if (anyAction==0||!newNode->numberUnsatisfied()) {
-            delete [] branches;
-            newNode->createInfo(this,node,lastws,lowerBefore,upperBefore,
-                                numberOldActiveCuts_,numberNewCuts_) ;
-            if (newNode->numberUnsatisfied()) {
-              newNode->initializeInfo() ;
-              newNode->nodeInfo()->addCuts(cuts,newNode->numberBranches(),
-                                           whichGenerator_) ;
-            }
-          } else {
-            // mini tree
-            int numberBranches=anyAction;
-            int numberResults=1<<numberBranches;
-            OsiSolverResult * result = new OsiSolverResult[numberResults];
-            double * lowerBefore2 = new double[numberColumns];
-            double * upperBefore2 = new double[numberColumns];
-            int i ;
-            const double * lower = solver_->getColLower() ;
-            const double * upper = solver_->getColUpper() ;
-            for (i = 0 ; i < numberColumns ; i++) {
-              lowerBefore2[i]= lower[i] ;
-              upperBefore2[i]= upper[i] ;
-            }
-            int numberIterations;
-            int numberSolves;
-            int numberGood = solver_->solveBranches(numberBranches,branches,result,
-                                                    numberSolves,numberIterations);
-            numberIterations_ += numberIterations;
-            // Add in solves needed to get to leaves
-            numberNodes_ += (numberSolves-numberGood);
-            int numberCutsAdd=-1; // We will be taking off one anyway
-            int saveMini = sizeMiniTree_;
-            sizeMiniTree_=0;
-            int saveNumber = numberNodesOutput;
-            for (int iResult=0;iResult<numberGood;iResult++) {
-              if (result[iResult].objectiveValue()<1.0e50) {
-                // put in correct bounds etc
-                solver_->setColLower(lowerBefore2);
-                solver_->setColUpper(upperBefore2);
-                result[iResult].restoreResult(*solver_);
-                numberNodes_++;
-#if 0
-                // need to tell solver that current factorization is no good
-                // should be better way
-#ifdef COIN_USE_CLP
-                OsiClpSolverInterface * clpSolver 
-                  = dynamic_cast<OsiClpSolverInterface *> (solver_);
-                if (clpSolver) 
-                  clpSolver->getModelPtr()->setWhatsChanged(clpSolver->getModelPtr()->whatsChanged()&(~512));
-#endif
-                solver_->resolve();
-                assert (!solver_->getIterationCount());
-                printf("res obj %g was %g\n",solver_->getObjValue(),
-                       result[iResult].objectiveValue());
-#endif
-                bool checkingNode=false;
-                bool feasible = true;
-                int anyAction;
-                CbcNode * newNode2= new CbcNode ;
-                newNode2->setObjectiveValue(result[iResult].objectiveValue()) ;
-                anyAction =-1 ;
-                // only allow twenty passes
-                int numberPassesLeft=20;
-                checkingNode=true;
-                OsiSolverBranch * branches=NULL;
-                while (anyAction == -1) { 
-                  if (numberBeforeTrust_==0 ) {
-                    anyAction = newNode2->chooseBranch(this,node,numberPassesLeft) ;
-                  } else {
-                    anyAction = newNode2->chooseDynamicBranch(this,node,branches,numberPassesLeft) ;
-                    if (anyAction==-3) 
-                      anyAction = newNode2->chooseBranch(this,node,numberPassesLeft) ; // dynamic did nothing
-                  }
-                  numberPassesLeft--;
-                  if (anyAction == -1) {
-                    // can do quick optimality check
-                    int easy=2;
-                    solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,&easy) ;
-                    feasible = resolve() ;
-                    solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,NULL) ;
-                    if (problemFeasibility_->feasible(this,0)<0) {
-                      feasible=false; // pretend infeasible
-                    }
-                    if (feasible) {
-                      // Set objective value (not so obvious if NLP etc)
-                      setObjectiveValue(newNode2,node);
-                      reducedCostFix() ;
-                      if (newNode2->objectiveValue() >= getCutoff()) 
-                        anyAction=-2;
-                    } else {
-                      anyAction = -2 ;
-                    }
-                  }
-                }
-                // May have slipped through i.e. anyAction == 0 and objective above cutoff
-                if ( anyAction ==0 ) {
-                  assert (newNode2);
-                  if (newNode2->objectiveValue() >= getCutoff()) 
-                    anyAction = -2; // say bad after all
-                }
-                if (anyAction >= 0) {
-                  if (anyAction==0||!newNode2->numberUnsatisfied()) {
-                    newNode2->createInfo(this,node,lastws,lowerBefore,upperBefore,
-                                        numberOldActiveCuts_,numberNewCuts_) ;
-                    if (newNode2->numberUnsatisfied()) {
-                      newNode2->initializeInfo() ;
-                      newNode2->nodeInfo()->addCuts(cuts,newNode2->numberBranches(),
-                                                   whichGenerator_) ;
-                    }
-                  }
-                }
-                /*
-                  If we end up infeasible, we can delete the new node immediately. Since this
-                  node won't be needing the cuts we collected, decrement the reference counts.
-                  If we are feasible, then we'll be placing this node into the live set, so
-                  increment the reference count in the current (parent) nodeInfo.
-                */
-                if (anyAction == -2) { 
-                  delete newNode2 ;
-                  newNode2 = NULL ;
-#if 0
-                  // say strong doing well
-                  if (checkingNode)
-                    setSpecialOptions(specialOptions_|8);
-#endif
-#if 0
-                  for (i = 0 ; i < currentNumberCuts_ ; i++) {
-                    if (addedCuts_[i]) {
-                      if (!addedCuts_[i]->decrement(1)) {
-                        delete addedCuts_[i] ;
-                        addedCuts_[i]=NULL;
-                      }
-                    }
-                  }
-#endif
-                } else {
-                  nodeInfo->increment() ;
-#if 0
-                  if ((numberNodes_%20)==0) {
-                    // say strong not doing as well
-                    setSpecialOptions(specialOptions_&~8);
-                  }
-#endif
-                }
-                /*
-                  At this point, there are three possibilities:
-                  * We have a live node (variable() >= 0) which will require further
-                  branching to resolve. Before we push it onto the search tree, try for
-                  a heuristic solution.
-                  * We have a solution, in which case newNode is non-null but we have no
-                  branching variable. Decrement the cut counts and save the solution.
-                  * The node was found to be infeasible, in which case it's already been
-                  deleted, and newNode is null.
-                  
-                */
-#ifdef COIN_USE_CLP
-                if (eventHandler()) {
-                  if (!eventHandler()->event(ClpEventHandler::node)) {
-                    eventHappened_=true; // exit
-                  }
-                }
-#endif
-                assert (!newNode2 || newNode2->objectiveValue() <= getCutoff()) ;
-                if (statistics_) {
-                  assert (numberNodes2_);
-                  assert (statistics_[numberNodes2_-1]);
-                  assert (statistics_[numberNodes2_-1]->node()==numberNodes2_-1);
-                  if (newNode2)
-                    statistics_[numberNodes2_-1]->updateInfeasibility(newNode2->numberUnsatisfied());
-                  else
-                    statistics_[numberNodes2_-1]->sayInfeasible();
-                }
-                if (newNode2) {
-                  if (newNode2->variable() >= 0) {
-                    handler_->message(CBC_BRANCH,messages_)
-                      << numberNodes_<< newNode2->objectiveValue()
-                      << newNode2->numberUnsatisfied()<< newNode2->depth()
-                      << CoinMessageEol ;
-                    // Increment cut counts
-                    numberCutsAdd += newNode2->numberBranches();
-                    double estValue = newNode2->guessedObjectiveValue() ;
-                    int found = -1 ;
-                    double * newSolution = new double [numberColumns] ;
-                    double heurValue = getCutoff() ;
-                    int iHeur ;
-                    for (iHeur = 0 ; iHeur < numberHeuristics_ ; iHeur++) {
-                      double saveValue = heurValue ;
-                      int ifSol = heuristic_[iHeur]->solution(heurValue,newSolution) ;
-                      if (ifSol > 0) {
-                        // new solution found
-                        found = iHeur ;
-                        incrementUsed(newSolution);
-                      } else if (ifSol < 0) {   // just returning an estimate
-                        estValue = CoinMin(heurValue,estValue) ;
-                        heurValue = saveValue ;
-                      } 
-                    }
-                    if (found >= 0) {
-                      setBestSolution(CBC_ROUNDING,heurValue,newSolution) ;
-                      lastHeuristic_ = heuristic_[found];
-                      status=1;
-                    }
-                    delete [] newSolution ;
-                    newNode2->setGuessedObjectiveValue(estValue) ;
-                    newNodes[numberNodesOutput++] = newNode2 ;
-                    nodeInfo->increment();
-                    if (statistics_) {
-                      if (numberNodes2_==maximumStatistics_) {
-                        maximumStatistics_ = 2*maximumStatistics_;
-                        CbcStatistics ** temp = new CbcStatistics * [maximumStatistics_];
-                        memset(temp,0,maximumStatistics_*sizeof(CbcStatistics *));
-                        memcpy(temp,statistics_,numberNodes2_*sizeof(CbcStatistics *));
-                        delete [] statistics_;
-                        statistics_=temp;
-                      }
-                      assert (!statistics_[numberNodes2_]);
-                      statistics_[numberNodes2_]=new CbcStatistics(newNode2);
-                    }
-                    numberNodes2_++;
-#           ifdef CHECK_NODE
-                    printf("Node %x pushed on tree c\n",newNode2) ;
-#           endif
-                  } else {
-#if 0
-                    for (i = 0 ; i < currentNumberCuts_ ; i++) {
-                      if (addedCuts_[i]) {
-                        if (!addedCuts_[i]->decrement(1)) {
-                          delete addedCuts_[i] ;
-                          addedCuts_[i]=NULL;
-                        }
-                      }
-                    }
-#endif 
-                    double objectiveValue = newNode2->objectiveValue();
-                    setBestSolution(CBC_SOLUTION,objectiveValue,
-                                    solver_->getColSolution()) ;
-                    lastHeuristic_ = NULL;
-                    incrementUsed(solver_->getColSolution());
-                    //assert(nodeInfo->numberPointingToThis() <= 2) ;
-                    // avoid accidental pruning, if newNode was final branch arm
-                    nodeInfo->increment();
-                    delete newNode2 ;
-                    nodeInfo->decrement() ;
-                    status=1;
-                  }
-                }
-              }
-            }
-            if (numberCutsAdd>0) {
-              for (i = 0;i < currentNumberCuts_;i++) {
-                if (addedCuts_[i]) {
-#               ifdef CHECK_CUT_COUNTS
-                  printf("Count on cut %x increased by %d\n",addedCuts_[i],
-                         numberCutsAdd) ;
-#               endif
-                  addedCuts_[i]->increment(numberCutsAdd) ;
-                }
-              }
-            }      
-            sizeMiniTree_=saveMini;
-            delete [] result;
-            delete [] branches;
-            delete newNode ;
-            newNode = NULL ;
-            delete [] lowerBefore2;
-            delete [] upperBefore2;
-            if (saveNumber < numberNodesOutput)
-              anyAction = -4;
-            else
-              anyAction=-2;
-          }
-        }
-      } else {
-        anyAction = -2 ;
-      }
-#if 0
-      if (numberNodesOutput) {
-        if (!sizeMiniTree_)
-          assert(newNode== newNodes[numberNodesOutput-1]);
-        newNode= newNodes[numberNodesOutput-1];
-      } else {
-        assert (!newNode);
-      }
-#endif
-      // May have slipped through i.e. anyAction == 0 and objective above cutoff
-      if ( anyAction >=0 ) {
-        assert (newNode);
-        if (newNode->objectiveValue() >= getCutoff()) 
-          anyAction = -2; // say bad after all
-      }
-      /*
-        If we end up infeasible, we can delete the new node immediately. Since this
-        node won't be needing the cuts we collected, decrement the reference counts.
-        If we are feasible, then we'll be placing this node into the live set, so
-        increment the reference count in the current (parent) nodeInfo.
-      */
-      if (anyAction == -2) { 
-        delete newNode ;
-        newNode = NULL ;
-        // say strong doing well
-        if (checkingNode)
-          setSpecialOptions(specialOptions_|8);
-        for (i = 0 ; i < currentNumberCuts_ ; i++) {
-          if (addedCuts_[i]) {
-            if (!addedCuts_[i]->decrement(1)) {
-              delete addedCuts_[i] ;
-              addedCuts_[i]=NULL;
-            }
-          }
-        }
-      } else if (anyAction>=0) {
-        nodeInfo->increment() ;
-        if ((numberNodes_%20)==0) {
-          // say strong not doing as well
-          setSpecialOptions(specialOptions_&~8);
-        }
-      }
-      /*
-        At this point, there are three possibilities:
-        * We have a live node (variable() >= 0) which will require further
-        branching to resolve. Before we push it onto the search tree, try for
-        a heuristic solution.
-        * We have a solution, in which case newNode is non-null but we have no
-        branching variable. Decrement the cut counts and save the solution.
-        * The node was found to be infeasible, in which case it's already been
-        deleted, and newNode is null.
-        
-      */
-#ifdef COIN_USE_CLP
-      if (eventHandler()) {
-        if (!eventHandler()->event(ClpEventHandler::node)) {
-          eventHappened_=true; // exit
-        }
-      }
-#endif
-      assert (!newNode || newNode->objectiveValue() <= getCutoff()) ;
-      if (statistics_) {
-        assert (numberNodes2_);
-        assert (statistics_[numberNodes2_-1]);
-        assert (statistics_[numberNodes2_-1]->node()==numberNodes2_-1);
-        if (newNode)
-          statistics_[numberNodes2_-1]->updateInfeasibility(newNode->numberUnsatisfied());
-        else
-          statistics_[numberNodes2_-1]->sayInfeasible();
-      }
-      if (newNode) {
-        if (newNode->variable() >= 0) {
-          handler_->message(CBC_BRANCH,messages_)
-            << numberNodes_<< newNode->objectiveValue()
-            << newNode->numberUnsatisfied()<< newNode->depth()
-            << CoinMessageEol ;
-          // Increment cut counts (taking off current)
-          int numberLeft = newNode->numberBranches() ;
-          for (i = 0;i < currentNumberCuts_;i++) {
-            if (addedCuts_[i]) {
-#               ifdef CHECK_CUT_COUNTS
-              printf("Count on cut %x increased by %d\n",addedCuts_[i],
-                     numberLeft-1) ;
-#               endif
-              addedCuts_[i]->increment(numberLeft-1) ;
-            }
-          }
-          
-          double estValue = newNode->guessedObjectiveValue() ;
-          int found = -1 ;
-          double * newSolution = new double [numberColumns] ;
-          double heurValue = getCutoff() ;
-          int iHeur ;
-          for (iHeur = 0 ; iHeur < numberHeuristics_ ; iHeur++) {
-            double saveValue = heurValue ;
-            int ifSol = heuristic_[iHeur]->solution(heurValue,newSolution) ;
-            if (ifSol > 0) {
-              // new solution found
-              found = iHeur ;
-              incrementUsed(newSolution);
-            } else if (ifSol < 0) {     // just returning an estimate
-              estValue = CoinMin(heurValue,estValue) ;
-              heurValue = saveValue ;
-            } 
-          }
-          if (found >= 0) {
-            setBestSolution(CBC_ROUNDING,heurValue,newSolution) ;
-            lastHeuristic_ = heuristic_[found];
-            status=1;
-          }
-          delete [] newSolution ;
-          newNode->setGuessedObjectiveValue(estValue) ;
-          newNodes[numberNodesOutput++] = newNode ;
-          if (statistics_) {
-            if (numberNodes2_==maximumStatistics_) {
-              maximumStatistics_ = 2*maximumStatistics_;
-              CbcStatistics ** temp = new CbcStatistics * [maximumStatistics_];
-              memset(temp,0,maximumStatistics_*sizeof(CbcStatistics *));
-              memcpy(temp,statistics_,numberNodes2_*sizeof(CbcStatistics *));
-              delete [] statistics_;
-              statistics_=temp;
-            }
-            assert (!statistics_[numberNodes2_]);
-            statistics_[numberNodes2_]=new CbcStatistics(newNode);
-          }
-          numberNodes2_++;
-#           ifdef CHECK_NODE
-          printf("Node %x pushed on tree c\n",newNode) ;
-#           endif
-        } else {
-          for (i = 0 ; i < currentNumberCuts_ ; i++) {
-            if (addedCuts_[i]) {
-              if (!addedCuts_[i]->decrement(1)) {
-                delete addedCuts_[i] ;
-                addedCuts_[i]=NULL;
-              }
-            }
-          }
-          double objectiveValue = newNode->objectiveValue();
-          setBestSolution(CBC_SOLUTION,objectiveValue,
-                          solver_->getColSolution()) ;
-          lastHeuristic_ = NULL;
-          incrementUsed(solver_->getColSolution());
-          //assert(nodeInfo->numberPointingToThis() <= 2) ;
-          // avoid accidental pruning, if newNode was final branch arm
-          nodeInfo->increment();
-          delete newNode ;
-          nodeInfo->decrement() ;
-          status=1;
-        }
-      }
-      /*
-        This node has been completely expanded and can be removed from the live
-        set.
-      */
-      if (deleteNode)  
-        delete node ;
-    } else {
-      // max time etc
-      status=2;
-      if (deleteNode)  
-        delete node ;
-    }
-  } else {
-    // node before branching is infeasible (so no nodes output)
-    delete node;
-  }
-  delete lastws;
-  delete [] lowerBefore;
-  delete [] upperBefore;
-  return newNodes;
-}
-#endif
 
 
@@ -4990 +3362 @@
   if (node)
     objectiveValue= node->objectiveValue();
-  feasible = resolve() ;
+  int returnCode = resolve(node ? node->nodeInfo() : NULL,1);
+  feasible = returnCode  != 0 ;
+  if (returnCode<0)
+    numberTries=0;
   if (problemFeasibility_->feasible(this,0)<0) {
     feasible=false; // pretend infeasible
@@ -5150 +3525 @@
         !solver_->optimalBasisIsAvailable()) {
       //printf("XXXXYY no opt basis\n");
-      resolve();
+      resolve(node ? node->nodeInfo() : NULL,3);
     }
     if (nextRowCut_) {
@@ -5217 +3592 @@
 #endif
           if (mustResolve) {
-            feasible = resolve() ;
+            int returncode = resolve(node ? node->nodeInfo() : NULL,2);
+            feasible = returnCode  != 0 ;
+            if (returncode<0)
+              numberTries=0;
             if ((specialOptions_&1)!=0) {
               debugger = solver_->getRowCutDebugger() ;
@@ -5523 +3901 @@
         delete basis;
       }
-      feasible = resolve() ;
+      feasible = resolve(node ? node->nodeInfo() : NULL,2) ;
       if ( CoinCpuTime()-dblParam_[CbcStartSeconds] > dblParam_[CbcMaximumSeconds] )
         numberTries=0; // exit
@@ -6157 +4535 @@
 
 
-bool
-CbcModel::resolve()
+int
+CbcModel::resolve(CbcNodeInfo * parent, int whereFrom)
 {
   // We may have deliberately added in violated cuts - check to avoid message
@@ -6213 +4591 @@
 */
   if (feasible)
-  {
-    solver_->resolve() ;
-    numberIterations_ += solver_->getIterationCount() ;
-    feasible = (solver_->isProvenOptimal() &&
-                !solver_->isDualObjectiveLimitReached()) ;
-  }
+    {
+      solver_->resolve() ;
+      numberIterations_ += solver_->getIterationCount() ;
+      feasible = (solver_->isProvenOptimal() &&
+                  !solver_->isDualObjectiveLimitReached()) ;
+    }
   if (0&&feasible) {
     const double * lb = solver_->getColLower();
@@ -6246 +4624 @@
   }
   setPointers(solver_);
-  return feasible ; }
+  int returnStatus = feasible ? 1 : 0;
+  if (strategy_) {
+    // user can play clever tricks here
+    int status = strategy_->status(this,parent,whereFrom);
+    if (status>=0) {
+      if (status==0)
+        returnStatus = 1;
+      else if(status==1)
+        returnStatus=-1;
+      else
+        returnStatus=0;
+    }
+  }
+  return returnStatus ;
+}
 
 
@@ -7867 +6259 @@
   // solve LP
   //solver_->writeMps("bad");
-  bool feasible = resolve();
+  bool feasible = resolve(NULL,3);
 
   CbcModel * newModel = NULL;
@@ -7899 +6291 @@
   status_ = 0;
   // solve LP
-  bool feasible = resolve();
+  bool feasible = resolve(NULL,3);
 
   bestObjective_=1.0e50;
@@ -8082 +6474 @@
         // just point to solver_
         continuousSolver_ = solver_;
-        feasible=resolve();
+        feasible=resolve(NULL,3);
         if (!feasible||!doIntegerPresolve||weak) break;
         // see if we can get solution by heuristics
@@ -8253 +6645 @@
     if (bestSolution_) {
       // solve problem
-      resolve();
+      resolve(NULL,3);
       // should be feasible
       if (!currentSolution_)
@@ -8612 +7004 @@
   continuous relaxation.
 */
-  bool feasible = resolve() ;
+  bool feasible = resolve(NULL,0) != 0 ;
 /*
   If the linear relaxation of the root is infeasible, bail out now. Otherwise,

trunk/CbcNode.cpp

@@ -21 +21 @@
 #include "CbcNode.hpp"
 #include "CbcStatistics.hpp"
+#include "CbcStrategy.hpp"
 #include "CbcBranchActual.hpp"
 #include "CbcBranchDynamic.hpp"
@@ -684 +685 @@
                      int numberOldActiveCuts,int numberNewCuts)
 { OsiSolverInterface * solver = model->solver();
+ CbcStrategy * strategy = model->strategy();
 /*
   The root --- no parent. Create full basis and bounds information.
 */
   if (!lastNode)
-  { nodeInfo_=new CbcFullNodeInfo(model,solver->getNumRows()); }
+  { 
+    if (!strategy)
+      nodeInfo_=new CbcFullNodeInfo(model,solver->getNumRows());
+    else
+      nodeInfo_ = strategy->fullNodeInfo(model,solver->getNumRows());
+  }
 /*
   Not the root. Create an edit from the parent's basis & bound information.
@@ -826 +833 @@
   return.
 */
-    nodeInfo_ =
-      new CbcPartialNodeInfo(lastNode->nodeInfo_,this,numberChangedBounds,
-                             variables,boundChanges,basisDiff) ;
+    if (!strategy)
+      nodeInfo_ =
+        new CbcPartialNodeInfo(lastNode->nodeInfo_,this,numberChangedBounds,
+                               variables,boundChanges,basisDiff) ;
+    else
+      nodeInfo_ = strategy->partialNodeInfo(model, lastNode->nodeInfo_,this,numberChangedBounds,
+                               variables,boundChanges,basisDiff) ;
     delete basisDiff ;
     delete [] boundChanges;

trunk/CbcStrategy.cpp

@@ -18 +18 @@
 #include "CbcCutGenerator.hpp"
 #include "CbcBranchActual.hpp"
+#include "CbcNode.hpp"
+#include "CoinWarmStart.hpp"
 #include "CglPreProcess.hpp"
 // Cuts
@@ -52 +54 @@
   delete process_;
   process_=NULL;
+}
+// Return a new Full node information pointer (descendant of CbcFullNodeInfo)
+CbcNodeInfo * 
+CbcStrategy::fullNodeInfo(CbcModel * model,int numberRowsAtContinuous) const
+{
+  return new CbcFullNodeInfo(model,numberRowsAtContinuous);
+}
+// Return a new Partial node information pointer (descendant of CbcPartialNodeInfo)
+CbcNodeInfo * 
+CbcStrategy::partialNodeInfo(CbcModel * model, CbcNodeInfo * parent, CbcNode * owner,
+                             int numberChangedBounds,const int * variables,
+                             const double * boundChanges,
+                             const CoinWarmStartDiff *basisDiff) const
+{
+  return new CbcPartialNodeInfo(parent, owner, numberChangedBounds, variables,
+                            boundChanges,basisDiff);
+}
+/* After a CbcModel::resolve this can return a status
+   -1 no effect
+   0 treat as optimal
+   1 as 0 but do not do any more resolves (i.e. no more cuts)
+   2 treat as infeasible
+*/
+int
+CbcStrategy::status(CbcModel * model, CbcNodeInfo * parent,int whereFrom)
+{
+  return -1;
 }
 

trunk/include/CbcModel.hpp

@@ -244 +244 @@
     
       Invoke the solver's %resolve() method.
+      whereFrom -
+      0 - initial continuous
+      1 - resolve on branch (before new cuts)
+      2 - after new cuts
+      3  - obsolete code or something modified problem in unexpected way
+      10 - after strong branching has fixed variables at root
+      11 - after strong branching has fixed variables in tree
+
+      returns 1 feasible, 0 infeasible, -1 feasible but skip cuts
     */
-    bool resolve();
+    int resolve(CbcNodeInfo * parent, int whereFrom);
     /// Make given rows (L or G) into global cuts and remove from lp
     void makeGlobalCuts(int numberRows,const int * which); 

trunk/include/CbcStrategy.hpp

@@ -6 +6 @@
 #include "CbcModel.hpp"
 class CglPreProcess;
+class CbcNodeInfo;
+class CbcNode;
+class CoinWarmStartDiff;
 
 //#############################################################################
@@ -45 +48 @@
   /// Delete pre-processing object to save memory
   void deletePreProcess();
+  /// Return a new Full node information pointer (descendant of CbcFullNodeInfo)
+  virtual CbcNodeInfo * fullNodeInfo(CbcModel * model,int numberRowsAtContinuous) const;
+  /// Return a new Partial node information pointer (descendant of CbcPartialNodeInfo)
+  virtual CbcNodeInfo * partialNodeInfo(CbcModel * model, CbcNodeInfo * parent, CbcNode * owner,
+                                        int numberChangedBounds,const int * variables,
+                                        const double * boundChanges,
+                                        const CoinWarmStartDiff *basisDiff) const;
+  /** After a CbcModel::resolve this can return a status
+      -1 no effect
+      0 treat as optimal
+      1 as 0 but do not do any more resolves (i.e. no more cuts)
+      2 treat as infeasible
+  */
+  virtual int status(CbcModel * model, CbcNodeInfo * parent, int whereFrom);
 private: