OSDipInterface.h

Go to the documentation of this file.

/* $Id: OSDipInterface.h 3038 2009-11-07 11:43:44Z Gassmann $ */
#ifndef OSDIPINTERFACE_H
#define OSDIPINTERFACE_H

//===========================================================================//
#include "UtilMacros.h"
#include "OSInstance.h"
#include "OSCoinSolver.h"
#include "OSConfig.h"
#include "OSResult.h" 
#include "OSOption.h"
#include "OSiLReader.h"        
#include "OSiLWriter.h" 
#include "OSoLReader.h"        
#include "OSoLWriter.h" 
#include "OSrLReader.h"          
#include "OSrLWriter.h"      
#include "OSInstance.h"  
#include "OSFileUtil.h"  
#include "CoinError.hpp"
#include "OSDefaultSolver.h"  
#include "OSWSUtil.h"     
#include "OSErrorClass.h"
#include "OSMathUtil.h"
#include "CoinHelperFunctions.hpp"



#include <set>
#include <map>
#include <vector>

//===========================================================================//
//===========================================================================//
class OS_DipInterface {


public:

        bool      m_isProvenOptimal;
        double    m_bestKnownLB;
        double    m_bestKnownUB;



        OSInstance *m_osinstance;
        OSOption *m_osoption;   
        OSiLReader *m_osilreader;
        OSoLReader *m_osolreader;
        char* m_integerVars;
        CoinPackedMatrix *m_coinpm;
        CoinPackedVector *m_row ;


        void readOSiL(std::string & filename);
        
        void readOSoL(std::string & filename);

        CoinPackedVector *getRow( int i);
        
        //return a CoinPackedMatrix
        CoinPackedMatrix *getCoinPackedMatrix( );
        
        const char* getIntegerColumns();
        
        //get the objective function constant
        double getObjectiveOffset()     ;
        
        
        //get the set of variable indexes for each block in the model
        std::vector<std::set<int> > getBlockVarIndexes();
        std::vector<std::set<int> > m_blockVariableIndexes;
        bool m_blockVariableIndexesProcessed;
                
        //get the set of core constraint indexes
        std::set<int>  getCoreConstraintIndexes();
        std::set<int> m_coreConstraintIndexes;
        bool m_coreConstraintIndexesProcessed;
        
        //get a map of constraint indexes for each block in the model
        //the key is the index of the constraint in the original problem
        //the key points to the index number in the block
        std::vector<std::map<int, int> > getBlockConstraintIndexes();
        std::vector<std::map<int, int> > m_blockConstraintIndexes;
        bool m_blockConstraintIndexesProcessed;
        
        //get and osinstance that corresponds to each block in the model
        std::vector<OSInstance* > getBlockOSInstances();
        std::vector<OSInstance* > m_blockOSInstances;
        bool m_blockOSInstancesProcessed;
        
        
        //get factory solver for each block in the model
        std::vector<std::string > getBlockFactories();
        std::vector<std::string > m_blockFactories;
        bool m_blockFactoriesProcessed;
        
        
        //get the objective function coefficients
        double *getObjectiveFunctionCoeff();
        

        inline const double getBestKnownLB() const {return m_bestKnownLB;} //kipp can we get rid of this
        inline const double getBestKnownUB() const {return m_bestKnownUB;} // kipp can we get rid of this


        //some OS wrapper methods

        inline const std::string* getObjectiveMaxOrMins() const {return m_osinstance->getObjectiveMaxOrMins();} 


        inline const double* getObjectiveConstants() const {return m_osinstance->getObjectiveConstants();} 

        inline const double* getObjectiveWeights() const {return m_osinstance->getObjectiveWeights();} 

        inline const int getNumberOfIntegerVariables() const {return m_osinstance->getNumberOfIntegerVariables();} 

        inline const int getNumberOfBinaryVariables() const {return m_osinstance->getNumberOfBinaryVariables();}
        

        inline const int getVariableNumber() const {return m_osinstance->getVariableNumber();} 

        inline const int getConstraintNumber() const {return m_osinstance->getConstraintNumber();} 
        
        inline const double* getColLower() const {return m_osinstance->getVariableLowerBounds();} 
        
                
        inline const double* getColUpper() const {return m_osinstance->getVariableUpperBounds();} 
        
        
        inline const std::string* getVariableNames() const {return m_osinstance->getVariableNames();} 
        
        
        inline const double* getRowLower() const {return m_osinstance->getConstraintLowerBounds();} 
        

        inline const double* getRowUpper() const {return m_osinstance->getConstraintUpperBounds();} 
        
        
        inline const std::string* getConstraintNames() const {return m_osinstance->getConstraintNames();} 
        
        
        std::map<int, std::vector< int> > generateInitialMaster();
        
        //end wrapper methods

        OS_DipInterface();
        
        ~OS_DipInterface();
};

#endif