OSBearcatSolverXij.h

Go to the documentation of this file.

/* $Id: OSBearcatSolverXij.h 3038 2009-11-07 11:43:44Z kmartin $ */
#ifndef OSBEARCATSOLVERXIJ_H
#define OSBEARCATSOLVERXIJ_H

#include "OSDecompSolver.h"
#include "OSDecompSolverFactory.h"
#include "OSInstance.h"
#include "OSOption.h"
#include "ClpSimplex.hpp"
#include "OSCoinSolver.h"
#include <map>
// --------------------------------------------------------------------- //
// --------------------------------------------------------------------- //
class OSBearcatSolverXij : public OSDecompSolver {
public:
        
        


/***************** Bearcat Specific Solver Parameters ***********************/
        //kipp move to the method
        std::map<int, std::string> m_tmpVarMap;
        
        std::map<std::pair<int, int>,int>m_xVarIndexMap;
        
        int *m_hubPoint;
        
        
        std::string m_initOSiLFile;
        
        std::map<int, std::map<int, std::vector<int> > > m_initSolMap;
        
        std::vector<CoinSolver*> m_multCommodCutSolvers;
        
        bool m_use1OPTstart;
        
        int m_maxThetaNonz;
        


        
        int* m_routeCapacity;
        
        int* m_routeMinPickup;
        
        
        
        int* m_upperBoundL;
        
        
        int* m_lowerBoundL;
        
        int m_upperBoundLMax;
        
        int m_minDemand;
        
        int* m_demand;
        
        std::string* m_nodeName;
        
        double* m_cost;

        bool m_costSetInOption;
        
        double** m_rc;
        

        //will be the optimal reduced cost for each hub
        double* m_optValHub;
        
        
        //start variables for the q-route dynamic program
        double** m_u; 
        double** m_v;
        int** m_px;
        int** m_tx;
        double** m_g;
        int* m_varIdx;
        //end variables for the q-route  dynamic programming solution
        
        //variables for the outer dynamic program 
        //get the optimal l value for each route
        int* m_optL; //size is number of routes
        int* m_optD; //size is number of routes
        double** m_vv;
        int** m_vvpnt;
        //end of variable on the outer dynamic program
        
        
        int m_totalDemand;
        int m_numberOfSolutions;
        
        
        //below  is a scatter array we scatter into in order
        //to multiply the transformation matrix times the A matrix
        int* m_tmpScatterArray;
        
        //arguments for getColumns
        double m_lowerBnd;
        int* m_newColumnNonz;
        double* m_costVec;
        int** m_newColumnRowIdx;
        double** m_newColumnRowValue;
                
        //arguments for getRows
        int* m_newRowNonz;
        int** m_newRowColumnIdx;
        double** m_newRowColumnValue;
        double* m_newRowUB;
        double* m_newRowLB;
        
        //arguments for the getBranchingCut
        int* branchCutIndexes;
        double* branchCutValues;
        //end arguments for the getBranchingCut
                

        

        
        //kipp -- be carefull does m_thetaCost have
        // artificial variables -- it is 
        double* m_thetaCost;
        
        int* m_convexityRowIndex;
        
        
        int* m_BmatrixRowIndex;
        

        int* m_separationIndexMap;
        
        //
        OSInstance *m_osinstanceSeparation;
        
        //the Clp model 
        ClpSimplex*  m_separationClpModel;

        //create the initial restricted master
        virtual OSInstance* getInitialRestrictedMaster( );

        
        //this method generates the instance for 
        //separating the tour breaking constraints
        OSInstance* getSeparationInstance();

        // note -- this c vector is only for hub k
        double qrouteCost(const int& k, const int& l, const double* c, int* kountVar) ;
        
        //this c vector is for the entire cost vector
        void getOptL( double** c) ;
        
        
        void getCutsTheta(const  double* thetaVar, const int numThetaVar,
                        int &numNewRows, int*  &numNonz, int** &colIdx,
                        double** &values, double* &rowLB, double* &rowUB) ;     
        
        
        void getCutsX(const  double* xVar, const int numXVar,
                        int &numNewRows, int*  &numNonz, int** &colIdx,
                        double** &values, double* &rowLB, double* &rowUB) ;     
        
        
        virtual void getBranchingCut(const double* thetaVar, const int numThetaVar,
                        const std::map<int, int> &varConMap, int &varIdx,  int &numNonz, 
                        int* &indexes,  double* &values) ;      
        
        
        
        virtual void getBranchingCut(const int* thetaIdx, const double* theta, 
                        const int numThetaVar, const std::map<int, int> &varConMap, 
                        int &varIdx,  int &numNonz, int* &indexes, double* &values) ;
        
        
        
        void getCutsMultiCommod(const  double* thetaVar, const int numThetaVar,
                        int &numNewRows, int*  &numNonz, int** &colIdx,
                        double** &values, double* &rowLB, double* &rowUB) ;     
        
        
        
        int getBranchingVar(const  double* theta, const int numThetaVar ) ;     
        
        
        int getBranchingVar(const int* thetaIdx, const double* theta, const int numThetaVar ) ; 
        
        
        virtual void getColumns(const  double* yA, const int numARows,
                        const  double* yB, const int numBRows,
                        int &numNewColumns, int*  &numNonz, double* &cost, 
                        int** &rowIdx, double** &values, double &lowerBound) ;
        
        

        void getOptions( OSOption *osoption);
        
        void getVariableIndexMap();
        
        
        void permuteHubs();
        
        
        //some utility methods are below
        
        void calcReducedCost(const double* yA,  const double* yB );
        
        //these are the variable in x(i, j) space
        void createVariableNames( );
        
        //this is the matrix that says we must visit each node
        //this A matrix defines the "coupling constraints"
        void createAmatrix();
                
        virtual void initializeDataStructures();
        
        void getInitialSolution();
                
        virtual void resetMaster( std::map<int, int> &inVars, 
                        OsiSolverInterface *si );
        
        
        double getRouteDistance(int numNodes, int hubIndex, 
                        CoinSolver* solver, std::vector<int> zk, 
                        double* xVar);
        
        
        CoinSolver* getTSP(int numNodes, double* cost); 
        
        
        
        CoinSolver* getMultiCommodInstance(int hubIndex);
        
        
        void getFeasibleSolution();
        
        
        bool OneOPT();  
        
                
        //this method gets called when we are done
        virtual void pauHana(std::vector<int> &m_zOptIndexes, 
                        std::vector<double> &m_zRootLPx_vals,
                        int numNodes, int numColsGen, std::string message);
        
        double calcNonlinearRelax( std::vector<double> &m_zRootLPx_vals);
        
        
        OSBearcatSolverXij();
        
        OSBearcatSolverXij(OSOption* osoption);
        
        
        ~OSBearcatSolverXij();
        
        
        class Factory;
        class Factory : public OSDecompSolverFactory{
                
        public:
                
                Factory(){
                        
                }
                
                ~Factory(){
                        
                }
                
                OSDecompSolver* create() {  return new OSBearcatSolverXij(  osoption); };
                
        };// end class OSDecompSolverFactory
        

};//end class OSBearcatSolverXij

#endif