/home/coin/Smi-0.5.0/Smi/src/SmiScnModel.hpp

Go to the documentation of this file.
00001 // Copyright (C) 2003, International Business Machines
00002 // Corporation and others.  All Rights Reserved.
00003 
00004 #ifndef SmiScnModel_HPP
00005 #define SmiScnModel_HPP
00006 
00007 #if defined(_MSC_VER)
00008 // Turn off compiler warning about long names
00009 #  pragma warning(disable:4786)
00010 #endif
00011 
00012 // Include files
00013 #include "SmiDiscreteDistribution.hpp"
00014 #include "SmiScenarioTree.hpp"
00015 #include "SmiScnData.hpp"
00016 #include "OsiSolverInterface.hpp"
00017 #include "CoinPackedVector.hpp"
00018 
00019 // STL declarations
00020 #include <map>
00021 #include <vector>
00022 using namespace std;
00023 
00024 // forward declaration of SmiScnNode
00025 class SmiScnNode;
00026 
00027 
00028 //#############################################################################
00029 
00052 class SmiScnModel
00053 {
00054         friend void SmiScnModelDiscreteUnitTest();      
00055 public:
00056 
00069         int readSmps(const char *name,
00070                                  SmiCoreCombineRule *r=NULL );
00071 
00072         SmiCoreData * getCore() {return core_;}
00073 
00084 
00085 
00086 
00088         void processDiscreteDistributionIntoScenarios(SmiDiscreteDistribution *s, bool test=false);
00089 
00105         SmiScenarioIndex generateScenario(SmiCoreData *core, 
00106                 CoinPackedMatrix *matrix,
00107                 CoinPackedVector *dclo, CoinPackedVector *dcup,
00108                 CoinPackedVector *dobj,
00109                 CoinPackedVector *drlo, CoinPackedVector *drup,
00110                 vector<int>labels, double prob,
00111                 SmiCoreCombineRule *r = SmiCoreCombineReplace::Instance());
00112 
00129         SmiScenarioIndex generateScenario(SmiCoreData *core, 
00130                                 CoinPackedMatrix *matrix,
00131                                 CoinPackedVector *dclo, CoinPackedVector *dcup,
00132                                 CoinPackedVector *dobj,
00133                                 CoinPackedVector *drlo, CoinPackedVector *drup,
00134                                 SmiStageIndex branch, SmiScenarioIndex anc, double prob,
00135                                 SmiCoreCombineRule *r = SmiCoreCombineReplace::Instance());
00136 
00148         OsiSolverInterface * loadOsiSolverData();
00149 
00151                 
00152         // get scenario problem data
00153         SmiScenarioIndex getNumScenarios(){ return smiTree_.getNumScenarios();}
00154         double getScenarioProb(SmiScenarioIndex ns);
00155         SmiScnNode * getLeafNode(SmiScenarioIndex i){ return smiTree_.getLeaf(i)->getDataPtr(); }
00156         SmiScnNode * getRootNode(){ return smiTree_.getRoot()->getDataPtr(); }
00157 
00158 
00159         // getXXX by scenario
00160         double getObjectiveValue(SmiScenarioIndex ns);
00161         const double *getColSolution(SmiScenarioIndex ns);
00162         const double *getRowSolution(SmiScenarioIndex ns);
00163 
00164         // OsiSolverInterface
00165         void setOsiSolverHandle(OsiSolverInterface &osi)
00166         {
00167                 osiStoch_ = osi.clone(false);
00168         }
00169         OsiSolverInterface * getOsiSolverInterface();
00170 
00171 
00172         // constructor 
00173         SmiScnModel(): 
00174                 osiStoch_(NULL),
00175                 drlo_(NULL), drup_(NULL), dobj_(NULL), dclo_(NULL), dcup_(NULL), matrix_(NULL),
00176                 solve_synch_(false),totalProb_(0),core_(NULL)
00177         { }
00178 
00179         // destructor
00180         ~SmiScnModel();
00181 
00182         void addNode(SmiScnNode *node);
00183 
00184 private:
00185         // internal clone of user declared OSI
00186         OsiSolverInterface * osiStoch_;
00187         // model statistics useful for predefining size of structures
00188         int nrow_;
00189         int ncol_;
00190         int nels_;
00191         // data pointers used in AddNode
00192         double *drlo_; 
00193         double *drup_;
00194         double *dobj_;
00195         double *dclo_; 
00196         double *dcup_;
00197         CoinPackedMatrix *matrix_;
00198         // number of scenarios
00199 //      int scen_;
00200         // not sure if this is used
00201         int minrow_;
00202         // not sure if this is used
00203         bool solve_synch_;
00204         // total probability of added scenarios; used to normalize probability to one
00205         double totalProb_;
00206         //core model --- used for discrete distributions
00207         SmiCoreData * core_;
00208         // scenario tree pointer
00209         SmiScenarioTree<SmiScnNode *> smiTree_;
00210 };
00211 
00212 class SmiScnNode
00213 {
00214         friend class SmiScnModel;
00215 public:
00216         int getCoreColIndex(int i);
00217         int getCoreRowIndex(int i);
00218         inline void setScenarioIndex(SmiScenarioIndex i){ scen_=i;}
00219     inline SmiScenarioIndex getScenarioIndex() {return scen_;}
00220         inline int  getColStart() {return coffset_;}    
00221         inline int  getRowStart() {return roffset_;}
00222         inline int getNumCols(){ return node_->getCore()->getNumCols(node_->getStage());}
00223         inline int getNumRows(){ return node_->getCore()->getNumRows(node_->getStage());}
00224         inline double getModelProb(){return mdl_prob_;}
00225         inline SmiScnNode * getParent(){ return parent_;}
00226 
00227         ~SmiScnNode(){}
00228 
00229 private:
00230         inline void setRowOffset(int r) {roffset_ = r;}
00231         inline void setParent(SmiScnNode * g) {parent_=g;}
00232         inline void setColOffset(int c) {coffset_ = c;}
00233         inline double addProb(double prob){ return prob_+=prob;}
00234         inline double getProb(){return prob_;}
00235         inline void setProb(double p){prob_=p;}
00236         inline void setModelProb(double p){mdl_prob_=p;}
00237         inline SmiNodeData *getNode() {return node_;}
00238         SmiScnNode(SmiNodeData *&node)  {node_=node;prob_=0;parent_=NULL;}
00239 
00240 private:
00241         SmiNodeData *node_;
00242         SmiScnNode *parent_;  
00243         double prob_;
00244         double mdl_prob_;
00245         int coffset_;
00246         int roffset_;
00247         SmiScenarioIndex scen_;
00248 };
00249 
00250 // function object for addnode loop
00251 class SmiScnModelAddNode{
00252 public:
00253         void operator() (SmiScnNode *node)
00254         {
00255                 s_->addNode(node);
00256         }
00257 
00258         SmiScnModelAddNode(SmiScnModel *s) { s_ = s;}
00259 private:
00260         SmiScnModel *s_;
00261 
00262 
00263 };
00264 
00265 
00266 #endif //#define SmiScnModel_HPP

Generated on Wed Aug 22 06:50:16 2007 by  doxygen 1.4.7