Changeset 741 for trunk

Timestamp:

Aug 10, 2007 12:18:20 PM (14 years ago)

Author:

forrest

Message:

event handling

Location:

trunk/Cbc

Files:

• examples/driver4.cpp (modified) (2 diffs)
• src/CbcEventHandler.hpp (modified) (1 diff)
• src/CbcHeuristic.cpp (modified) (1 diff)
• src/CbcModel.cpp (modified) (6 diffs)

trunk/Cbc/examples/driver4.cpp

@@ -85 +85 @@
   return returnCode;
 }
+#include "CbcEventHandler.hpp"
+/** This is so user can trap events and do useful stuff.  
+
+    CbcModel model_ is available as well as anything else you care 
+    to pass in
+*/
+
+class MyEventHandler3 : public CbcEventHandler {
+  
+public:
+  /**@name Overrides */
+  //@{
+  virtual CbcAction event(CbcEvent whichEvent);
+  //@}
+
+  /**@name Constructors, destructor etc*/
+  //@{
+  /** Default constructor. */
+  MyEventHandler3();
+  /// Constructor with pointer to model (redundant as setEventHandler does)
+  MyEventHandler3(CbcModel * model);
+  /** Destructor */
+  virtual ~MyEventHandler3();
+  /** The copy constructor. */
+  MyEventHandler3(const MyEventHandler3 & rhs);
+  /// Assignment
+  MyEventHandler3& operator=(const MyEventHandler3 & rhs);
+  /// Clone
+  virtual CbcEventHandler * clone() const ;
+  //@}
+   
+    
+protected:
+  // data goes here
+};
+//-------------------------------------------------------------------
+// Default Constructor 
+//-------------------------------------------------------------------
+MyEventHandler3::MyEventHandler3 () 
+  : CbcEventHandler()
+{
+}
+
+//-------------------------------------------------------------------
+// Copy constructor 
+//-------------------------------------------------------------------
+MyEventHandler3::MyEventHandler3 (const MyEventHandler3 & rhs) 
+: CbcEventHandler(rhs)
+{  
+}
+
+// Constructor with pointer to model
+MyEventHandler3::MyEventHandler3(CbcModel * model)
+  : CbcEventHandler(model)
+{
+}
+
+//-------------------------------------------------------------------
+// Destructor 
+//-------------------------------------------------------------------
+MyEventHandler3::~MyEventHandler3 ()
+{
+}
+
+//----------------------------------------------------------------
+// Assignment operator 
+//-------------------------------------------------------------------
+MyEventHandler3 &
+MyEventHandler3::operator=(const MyEventHandler3& rhs)
+{
+  if (this != &rhs) {
+    CbcEventHandler::operator=(rhs);
+  }
+  return *this;
+}
+//-------------------------------------------------------------------
+// Clone
+//-------------------------------------------------------------------
+CbcEventHandler * MyEventHandler3::clone() const
+{
+  return new MyEventHandler3(*this);
+}
+
+CbcEventHandler::CbcAction 
+MyEventHandler3::event(CbcEvent whichEvent)
+{
+  // If in sub tree carry on
+  if (!model_->parentModel()) {
+    if (whichEvent==solution||whichEvent==heuristicSolution)
+      return stop; // say finished
+    else
+      return noAction; // carry on
+  } else {
+      return noAction; // carry on
+  }
+}
 
 int main (int argc, const char *argv[])
@@ -107 +203 @@
   CbcModel model(solver1);    
   CbcMain0(model);
+  // Event handler
+  MyEventHandler3 eventHandler;
+  model.passInEventHandler(&eventHandler);
   /* Now go into code for standalone solver
      Could copy arguments and add -quit at end to be safe

trunk/Cbc/src/CbcEventHandler.hpp

@@ -88 +88 @@
     treeStatus,
     /*! A solution has been found. */
-    solution 
+    solution, 
+    /*! A heuristic solution has been found. */
+    heuristicSolution 
   } ;
 

trunk/Cbc/src/CbcHeuristic.cpp

@@ -157 +157 @@
                solver->getNumRows(),solver->getNumCols(),
                solver2->getNumRows(),solver2->getNumCols());
-      if (after>fractionSmall_*before)
+      if (after>fractionSmall_*before&&after>300)
         return 0;
       solver2->resolve();

trunk/Cbc/src/CbcModel.cpp

@@ -691 +691 @@
   eventHappened_=false;
   CbcEventHandler *eventHandler = getEventHandler() ;
+  if (eventHandler)
+    eventHandler->setModel(this);
   // set up for probing
   probingInfo_ = new CglTreeProbingInfo(solver_);
@@ -1132 +1134 @@
         }
       }
+      if (eventHandler) {
+        if (!eventHandler->event(CbcEventHandler::solution)) {
+          eventHappened_=true; // exit
+        }
+      }
     }
     delete [] newSolution ;
@@ -1159 +1166 @@
 
       if (numberUnsatisfied)   {
-        feasible = solveWithCuts(cuts,maximumCutPassesAtRoot_,
-                                 NULL);
+        // User event
+        if (!eventHappened_)
+          feasible = solveWithCuts(cuts,maximumCutPassesAtRoot_,
+                                   NULL);
+        else
+          feasible=false;
       } else if (solverCharacteristics_->solutionAddsCuts()||
                  solverCharacteristics_->alwaysTryCutsAtRootNode()) {
@@ -1190 +1201 @@
     feasible = false;
   }
+  // User event
+  if (eventHappened_)
+    feasible=false;
 /*
   We've taken the continuous relaxation as far as we can. Time to branch.
@@ -3253 +3267 @@
   lastHeuristic_ = NULL;
   if (rhs.eventHandler_)
-  { eventHandler_ = new CbcEventHandler(*rhs.eventHandler_) ; }
+    { eventHandler_ = rhs.eventHandler_->clone() ; }
   else
   { eventHandler_ = NULL ; }
@@ -3574 +3588 @@
       delete eventHandler_ ;
     if (rhs.eventHandler_)
-    { eventHandler_ = new CbcEventHandler(*rhs.eventHandler_) ; }
+      { eventHandler_ = rhs.eventHandler_->clone() ; }
     else
     { eventHandler_ = NULL ; }