MipHandler.h

Go to the documentation of this file.

/*Copyright (C) 2006/2007, Professorship (p.p.) for Land Use Economics in the Tropics and
Subtropics, Institute for Agricultural Economics and Social Sciences in the Tropics
and Subtropics, University of Hohenheim, Stuttgart
Thomas Berger, Lutz Göhring
All rights reserved
*/
#ifndef LP_OLD
#ifndef __MIP_HANDLER__
#define __MIP_HANDLER__

#include <string>

#include "BasicEnums.h"
#include "OsiSolverInterface.hpp"
#include "AgentProblem.h"
#include "AgentSolution.h"
#include "ProblemDescription.h"


struct mat // Charakteristika der LP-MatrixDouble
{       public:
        int lpanzahl;
   int lpfehler;
   int lpkritisch;
        int m1;//Anzahl der Restriktionen LE
        int m2;//Anzahl der Restriktionen GE
        int m3;//Anzahl der Restriktionen E
};//Tbe taken from "funktio9.h"



class MipHandler {

public:


  
  int getAgentID()const; 
  
  int getSubcatchmentID()const;
  
  AgentProblem* const getSpecificProblemPtr()const;
 
  AgentProblem getSpecificProblem()const;
  
  ProblemDescription* const getProblemDescriptionPtr()const;

 //----------------------------------------------------------------


  
  virtual void setAgentID(int agentID); 
  
  virtual void setSubcatchmentID(int subcatchmentID);
  virtual int setSpecificProblem(const AgentProblem& specificProblem);
  virtual void resetProblem();
  


  
  virtual int solve(AgentSolution& solution_);



  virtual void setSolverType(SolverType solver);
  
  virtual void setTestFlag(int test);

  virtual void setTolerance(double eps);
  
  
  virtual bool setVerbosity(int verbosity);
  virtual void setSafePrimalSolutionFlag(bool safePrimalSolution);
  


  virtual SolverType getSolverType()const;
  bool getTestFlag()const;

  double getTolerance()const;

  int getNumberOfSolvedMIPs() const;

  bool getSafePrimalSolutionFlag();
  virtual string getSolverName();
  
  //------------------------------------------------------------------------------------------------------------



  virtual int readMtx(char* filename);
  virtual int readDat(char* filename);
  
  virtual int writeMtx(char* filename)const;
  
  virtual int writeDat(char* filename)const;
  virtual void writeSolutionPrimal(char* filename)const;
  void writeSolverProblemExcel(char* filename)const;
  virtual void writeMps(const string filename, const string extension = "mps") const;
   virtual void readMps(const string infile, const string extension = "mps");
  virtual void templateOutput(string name);
  virtual void specificOutput(string name);
  virtual void outputSolver(string name);
  virtual void manipulateObjective();
  



  MipHandler();
  //Default copy constructor//TODO: implement if neccessary
  //Default asignment operator//TODO: implement if neccessary
  ~MipHandler();
 
//----------------------------------------------------------------------------------------------------------------
private:


  AgentProblem* templateProblem;
  AgentProblem* specificProblem;
  
  ProblemDescription* problemDescriptionObject;
  OsiSolverInterface* mipSolver;
  // Data structure where solution of MIP problem is temporarily stored
  
  AgentSolution* solution;



  SolverType solver;
  string solvername;
  //int numberofblocks; 
  // boolean flag: true if MatrixDouble is transposed
  int istransposed;  
  int test;
  double eps;        
  int agentID;
  int subcatchmentID;
   int verbosity;
  int nudC; 
  mat lpmatrix;
  int mp;
  int forcedSolutionFlag;
  bool savePrimalSolution;
  


  virtual int switchSolver();
  void setInitialParamSym();

  virtual int loadProblem();

  virtual int solve();
  int solveSym();
  int solveOsl();
  int warmstart1Osl();
  int warmstart2Osl();
  int coldstart1Osl();
  int coldstart2Osl();
  int coldstart3Osl();
  
  virtual void forcedSolution(const AgentProblem& problem_,AgentSolution& solution_, bool save);
  
  virtual void forcedSolution();
  virtual int loadSolutionSym();
  virtual int loadSolutionOsl();
  
  virtual void deleteEmptyRowsAndCols();//TODO:set to private as soon as stable
  void preForcedSolutionMessages();
  void postSolveTest();
  void printTime(char* mode);
  template <class ClassType> int copy(ClassType*& finalObjectPtr_, const ClassType* const originalObjectPtr_);
  virtual void errormessage()const;
};

//Allocates memory for class member finalObjectPtr_ if necessary and copies data from the object originalObjectPtr_ points to
template <class ClassType> int MipHandler::copy(ClassType*& finalObjectPtr_, const ClassType* const originalObjectPtr_){
        if (originalObjectPtr_ != NULL){
                if (finalObjectPtr_ == NULL)
                        try {
                                finalObjectPtr_ = new ClassType(*originalObjectPtr_);
                        }
                        catch (exception& exceptionObject){
                                cerr << "Exception: "<< exceptionObject.what() << endl;
                                cerr << "Error in "<< typeid(*this).name()<<"::copy(): cannot allocate memory for"<< typeid(ClassType).name()  << endl;
                                errormessage();
                                return 0;
                        }
                else {
                        delete finalObjectPtr_;
                        finalObjectPtr_ = NULL;
                        try {
                                finalObjectPtr_ = new ClassType(*originalObjectPtr_);
                        }
                        catch (exception& exceptionObject){
                                cerr << "Exception: "<< exceptionObject.what() << endl;
                                cerr << "Error in "<< typeid(*this).name()<<"::copy(): cannot allocate memory for"<< typeid(ClassType).name() << endl;
                                errormessage();
                                return 0;
                        }
                }
        }
        else if (test) cerr << "Warning in "<< typeid(*this).name() << "::copy():  "<<typeid(originalObjectPtr_).name() <<"  == NULL!" << endl;
        return 1;
}
#endif
#endif /* LP_OLD*/

---