DecompApp.h

Go to the documentation of this file.

//===========================================================================//
// This file is part of the DIP Solver Framework.                            //
//                                                                           //
// DIP is distributed under the Eclipse Public License as part of the        //
// COIN-OR repository (http://www.coin-or.org).                              //
//                                                                           //
// Authors: Matthew Galati, SAS Institute Inc. (matthew.galati@sas.com)      //
//          Ted Ralphs, Lehigh University (ted@lehigh.edu)                   //
//          Jiadong Wang, Lehigh University (jiw408@lehigh.edu)              //
//                                                                           //
// Copyright (C) 2002-2019, Lehigh University, Matthew Galati, Ted Ralphs    //
// All Rights Reserved.                                                      //
//===========================================================================//


#ifndef DECOMP_APP_INCLUDED
#define DECOMP_APP_INCLUDED

//===========================================================================//
#include "UtilParameters.h"
#include "DecompParam.h"
#include "DecompModel.h"
#include "DecompSolution.h"
#include "DecompConstraintSet.h"
#include "CoinMpsIO.hpp"
#include "CoinLpIO.hpp"

extern "C" {
#if defined (COIN_HAS_METIS)
#include "hmetis.h"
#endif
}
//===========================================================================//
class DecompAlgo;

//===========================================================================//
//===========================================================================//
class DecompApp {

private:
   std::string m_classTag;

protected:
   std::ostream* m_osLog;

   double m_bestKnownLB;
   double m_bestKnownUB;

public:

   int NumBlocks;

   DecompParam m_param;
   UtilParameters* m_utilParam;

   const double* m_objective;

   DecompModel m_modelCore;

   std::map<int, DecompModel> m_modelRelax;

   std::map<int, std::vector<DecompModel> > m_modelRelaxNest;

   DecompAlgo* m_decompAlgo;
   /*
    *  The following definitiions was from MILPBlock
    *
    */

   CoinMpsIO m_mpsIO;

   CoinLpIO m_lpIO;

   const CoinPackedMatrix* m_matrix;
   DecompConstraintSet*   m_modelC;
   std::map<int, DecompConstraintSet*>  m_modelR;

   std::map<int, std::vector<int> > m_blocks;


   int m_threadIndex;

   double m_infinity;

public:
   void preprocess();

   void startupLog();

   //TODO:
   //base layer needs to do some kind of check to make sure this actually
   //got done - but also nice to have user version... so base createModel
   //and user uesrCreateModel() which is pure?, in base userCreateModel
   //gets called and checked that it returns good information
   int createModel();

   inline const double getBestKnownLB() const {
      return m_bestKnownLB;
   }
   inline const double getBestKnownUB() const {
      return m_bestKnownUB;
   }

   inline void setBestKnownLB(const double bestKnownLB) {
      m_bestKnownLB = bestKnownLB;
   }
   inline void setBestKnownUB(const double bestKnownUB) {
      m_bestKnownUB = bestKnownUB;
   }


   inline void setModelObjective(const double* objective, const
                                 int length) {
      assert(objective);
      double* obj = new double[length];
      memcpy(obj, objective, length * sizeof(double));
      m_objective = obj;
   }

   //TODO: having these implementations in the header makes
   // it harder to view this as an interface class - it is unclear
   // what the user must do vs can do
   inline void setModelCore(DecompConstraintSet* model,
                            const std::string          modelName) {
      assert(model);

      if (!model->hasPrepRun()) {
     model->prepareModel(m_infinity, true);
      }

      m_modelCore.setModel(model);
      m_modelCore.setModelName(modelName);
   }
   //TODO: change to setModelCore( ... )
   //  to long set of args of basic types - more like how Osi
   //  does loadProblem, etc... or juse use Osi as shell and accept
   //  an OsiSolverInterface?? or an OsiModel... is there one?
   //   maybe use CoinModel?? much cleaner?
   //at least set up an alternative to do it that way
   //still, this is still a function the user must call versus
   // a method they MUST override -which would fit more into the
   // framework concept - for e.g.,
   //virtual CoinModel * createModelCore() - the use must create a CoinModel
   //  or maybe a DecompModel which is derived from a CoinModel with
   //  whatever extra stuff might be needed - but I would try to avoid that
   //is it best to have it returned as return of function - forcing the
   //user to do it? or as arguments? and copy or assign pointers like
   //in SAS load problem design



   void setModelRelax(DecompConstraintSet* model,
              const std::string    modelName = "",
              const int            blockId   = 0);

   void setModelRelaxNest(DecompConstraintSet* model,
              const std::string    modelName,
              const int            blockId = 0);

   inline DecompAlgo* getDecompAlgo() const  {
      return m_decompAlgo;
   }


public:
   virtual void initDualVector(std::vector<double>& dualVector) {}


   //TODO: change name - no other one is using APP, why here?
   //TODO: what is doxy tag for function return
   //TOOD: don't need numCols and tolZero should not be user overidable
   virtual bool APPisUserFeasible(const double* x,
                                  const int      numCols,
                                  const double   tolZero) {
      return true;
   };

   virtual int APPheuristics(const double*             xhat,
                             const double*             origCost,
                             std::vector<DecompSolution*>& xhatIPFeas) {
      return 0;
   }

   virtual const double* getDualForGenerateVars(const double* dual) {
      return 0;
   }

   virtual int generateInitVars(DecompVarList& initVars);

   virtual int generateCuts(const double*   x,
                            DecompCutList& newCuts);

   virtual void solveRelaxedWhich(std::vector<int>& blocksToSolve,
                                  std::map< int,
                  std::vector<double> >& userDualsByBlock) {
   };

   virtual DecompSolverStatus solveRelaxed(const int          whichBlock,
                                           const double*      redCostX,
                       const double       target,
                                           DecompVarList&     varList) {
      return DecompSolStatNoSolution;
   }
   virtual DecompSolverStatus solveRelaxedNest(const int          whichBlock,
                           const double*      redCostX,
                           const double       target,
                           DecompVarList&     varList) {
      return DecompSolStatNoSolution;
   }


   virtual void printOriginalColumn(const int   index,
                                    std::ostream*    os = &std::cout) const;

   //TODO: change api so colNames comes from modelCore if exists
   //  rather than - to simplify API
   virtual void printOriginalSolution(const int              n_cols,
                                      const std::vector<std::string>& colNames,
                                      const double*          solution,
                                      std::ostream*          os = &std::cout) const;

public:

   virtual void initializeApp();

   void createModels();

   DecompConstraintSet* createModelPart(const int nRowsPart,
                                        const int* rowsPart);

   void createModelPart(DecompConstraintSet* model,
                        const int             nRowsPart,
                        const int*            rowsPart);

   void createModelPartSparse(DecompConstraintSet* model,
                              const int             nRowsPart,
                              const int*            rowsPart);


   void readInitSolutionFile(DecompVarList& initVars);

   void readBlockFile();

   void readProblem();


   void singlyBorderStructureDetection();

   void findActiveColumns(const std::vector<int>& rowsPart,
                          std::set<int>&           activeColsSet);

   const std::string getInstanceName() {
      return m_param.Instance;
   }
   /*
   void  HMETIS_PartKway(int nvtxs, int nhedges, int *vwgts, int *eptr,
          int *eind, int *hewgts, int nparts, int ubfactor,
          int * options, int * part, int *edgecut);

   void  HMETIS_PartRecursive(int nvtxs, int nhedges, int *vwgts, int *eptr,
           int *eind, int *hewgts, int nparts, int ubfactor,
           int * options, int * part, int *edgecut);
   */

   const CoinPackedMatrix* getMatrix() { return m_matrix; }

   void setInfinity();

public:
   DecompApp(UtilParameters& utilParam) :
      m_classTag   ("D-APP"),
      m_osLog      (&std::cout  ),
      m_bestKnownLB(-1e75  ),
      m_bestKnownUB( 1e75  ),
      NumBlocks    (  0    ),
      m_utilParam  (&utilParam),
      m_objective  ( NULL  ),
      m_modelCore  (utilParam),
      m_matrix     ( NULL  ),
      m_modelC     ( NULL  ),
      m_threadIndex(  0    )
   {
      //---
      //--- get application parameters
      //---
      m_param.getSettings(utilParam);
      
      if (m_param.LogLevel >= 1) {
     m_param.dumpSettings();
      }

      startupLog();

      setInfinity();
   };

   virtual ~DecompApp() {
      UTIL_DELARR(m_objective);
      UtilDeleteMapPtr(m_modelR);
      UTIL_DELPTR(m_modelC);
   };
};

#endif