source: trunk/Clp/src/ClpEventHandler.hpp @ 1769

Last change on this file since 1769 was 1769, checked in by forrest, 9 years ago

changes for advanced use of Clp

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 5.1 KB
Line 
1/* $Id: ClpEventHandler.hpp 1769 2011-07-26 09:31:51Z forrest $ */
2// Copyright (C) 2004, International Business Machines
3// Corporation and others.  All Rights Reserved.
4// This code is licensed under the terms of the Eclipse Public License (EPL).
5
6#ifndef ClpEventHandler_H
7#define ClpEventHandler_H
8
9#include "ClpSimplex.hpp"
10/** Base class for Clp event handling
11
12This is just here to allow for event handling.  By event I mean a Clp event
13e.g. end of values pass.
14
15One use would be to let a user handle a system event e.g. Control-C.  This could be done
16by deriving a class MyEventHandler which knows about such events.  If one occurs
17MyEventHandler::event() could clear event status and return 3 (stopped).
18
19Clp would then return to user code.
20
21As it is called every iteration this should be fine grained enough.
22
23User can derive and construct from CbcModel  - not pretty
24
25*/
26
27class ClpEventHandler  {
28
29public:
30     /** enums for what sort of event.
31
32         These will also be returned in ClpModel::secondaryStatus() as int
33     */
34     enum Event {
35          endOfIteration = 100, // used to set secondary status
36          endOfFactorization, // after gutsOfSolution etc
37          endOfValuesPass,
38          node, // for Cbc
39          treeStatus, // for Cbc
40          solution, // for Cbc
41          theta, // hit in parametrics
42          pivotRow, // used to choose pivot row
43          presolveStart, // ClpSolve presolve start
44          presolveSize, // sees if ClpSolve presolve too big or too small
45          presolveInfeasible, // ClpSolve presolve infeasible
46          presolveBeforeSolve, // ClpSolve presolve before solve
47          presolveAfterFirstSolve, // ClpSolve presolve after solve
48          presolveAfterSolve, // ClpSolve presolve after solve
49          presolveEnd, // ClpSolve presolve end
50          goodFactorization, // before gutsOfSolution
51          complicatedPivotIn, // in modifyCoefficients
52          noCandidateInPrimal, // tentative end
53          looksEndInPrimal, // About to declare victory (or defeat)
54          endInPrimal, // Victory (or defeat)
55          beforeStatusOfProblemInPrimal,
56          startOfStatusOfProblemInPrimal,
57          complicatedPivotOut, // in modifyCoefficients
58          noCandidateInDual, // tentative end
59          looksEndInDual, // About to declare victory (or defeat)
60          endInDual, // Victory (or defeat)
61          beforeStatusOfProblemInDual,
62          startOfStatusOfProblemInDual,
63          startOfIterationInDual,
64          updateDualsInDual,
65          endOfCreateRim,
66          noTheta // At end (because no pivot)
67     };
68     /**@name Virtual method that the derived classes should provide.
69      The base class instance does nothing and as event() is only useful method
70      it would not be very useful NOT providing one!
71     */
72     //@{
73     /** This can do whatever it likes.  If return code -1 then carries on
74         if 0 sets ClpModel::status() to 5 (stopped by event) and will return to user.
75         At present if <-1 carries on and if >0 acts as if 0 - this may change.
76         For ClpSolve 2 -> too big return status of -2 and -> too small 3
77     */
78     virtual int event(Event whichEvent);
79     //@}
80
81
82     /**@name Constructors, destructor */
83
84     //@{
85     /** Default constructor. */
86     ClpEventHandler(ClpSimplex * model = NULL);
87     /** Destructor */
88     virtual ~ClpEventHandler();
89     // Copy
90     ClpEventHandler(const ClpEventHandler&);
91     // Assignment
92     ClpEventHandler& operator=(const ClpEventHandler&);
93     /// Clone
94     virtual ClpEventHandler * clone() const;
95
96     //@}
97
98     /**@name Sets/gets */
99
100     //@{
101     /** set model. */
102     void setSimplex(ClpSimplex * model);
103     /// Get model
104     inline ClpSimplex * simplex() const {
105          return model_;
106     }
107     //@}
108
109
110protected:
111     /**@name Data members
112        The data members are protected to allow access for derived classes. */
113     //@{
114     /// Pointer to simplex
115     ClpSimplex * model_;
116     //@}
117};
118/** Base class for Clp disaster handling
119
120This is here to allow for disaster handling.  By disaster I mean that Clp
121would otherwise give up
122
123*/
124
125class ClpDisasterHandler  {
126
127public:
128     /**@name Virtual methods that the derived classe should provide.
129     */
130     //@{
131     /// Into simplex
132     virtual void intoSimplex() = 0;
133     /// Checks if disaster
134     virtual bool check() const = 0;
135     /// saves information for next attempt
136     virtual void saveInfo() = 0;
137     /// Type of disaster 0 can fix, 1 abort
138     virtual int typeOfDisaster();
139     //@}
140
141
142     /**@name Constructors, destructor */
143
144     //@{
145     /** Default constructor. */
146     ClpDisasterHandler(ClpSimplex * model = NULL);
147     /** Destructor */
148     virtual ~ClpDisasterHandler();
149     // Copy
150     ClpDisasterHandler(const ClpDisasterHandler&);
151     // Assignment
152     ClpDisasterHandler& operator=(const ClpDisasterHandler&);
153     /// Clone
154     virtual ClpDisasterHandler * clone() const = 0;
155
156     //@}
157
158     /**@name Sets/gets */
159
160     //@{
161     /** set model. */
162     void setSimplex(ClpSimplex * model);
163     /// Get model
164     inline ClpSimplex * simplex() const {
165          return model_;
166     }
167     //@}
168
169
170protected:
171     /**@name Data members
172        The data members are protected to allow access for derived classes. */
173     //@{
174     /// Pointer to simplex
175     ClpSimplex * model_;
176     //@}
177};
178#endif
Note: See TracBrowser for help on using the repository browser.