OSDipApp.h

Go to the documentation of this file.

//===========================================================================//
// This file is part of the Decomp Solver Framework.                         //
//                                                                           //
// Decomp is distributed under the Common Public License as part of the      //
// COIN-OR repository (http://www.coin-or.org).                              //
//                                                                           //
// Author: Matthew Galati, Lehigh University                                 //
//                                                                           //
// Copyright (C) 2002-2008, Lehigh University, Matthew Galati, and Ted Ralphs//
// All Rights Reserved.                                                      //
//===========================================================================//

#ifndef OSDIPAPP_H
#define OSDIPAPP_H

// --------------------------------------------------------------------- //
#include "DecompApp.h"
#include "DecompParam.h"

// --------------------------------------------------------------------- //
#include "OSDipInterface.h"
#include "OSDipParam.h"
#include  "OSDipBlockSolver.h"
#include "OSInstance.h"
#include  "OSDipFactoryInitializer.h"

// --------------------------------------------------------------------- //
// --------------------------------------------------------------------- //
class OSDipApp: public DecompApp {
public:
        
        OSDipFactoryInitializer *factoryInit;
        
        std::vector<OSDipBlockSolver* > m_osDipBlockSolver;
        
        std::vector<OSInstance* > m_blockOSInstances;
        
        std::vector<std::set<int> >  m_blockVars;
        
        std::set<int> m_blockVarsAll; 
        
        std::set<int>  m_coreConstraintIndexes; 
        
        std::vector<std::string >  m_blockFactories;
        
        const std::string m_classTag;

        OS_DipInterface m_osInterface;

        OSDipParam m_appParam;

        double *m_objective;

        DecompConstraintSet *m_modelC;
        std::map<int, DecompConstraintSet*> m_modelR;
        
        std::map<int, DecompConstraintSet*> m_modelMasterOnly;

        void initializeApp(UtilParameters & utilParam);

        void createModels();

        //this creates the coupling/core constraint set
        void createModelPart(DecompConstraintSet * model, const int nRowsPart,
                        const int * rowsPart);

        /* @name Inherited (from virtual) methods. */
        int generateInitVars(DecompVarList & initVars);

        void createModelMasterOnlys2(std::vector<int> & masterOnlyCols);

           /* @name Inherited (from virtual) methods. */
       DecompSolverStatus solveRelaxed(const int          whichBlock,
                                       const double     * redCostX,
                                       const double       convexDual,
                                       std::list<DecompVar*> & vars);  
           
           
           int generateCuts(const double* x, DecompCutList & newCuts);
           
           bool APPisUserFeasible(const double* x, const int n_cols,
                           const double tolZero);

        OSDipApp(UtilParameters & utilParam) :
                DecompApp(utilParam), m_classTag("OSDip-APP"), m_objective(NULL) {
                initializeApp(utilParam);
        }

        virtual ~OSDipApp() {
                std::cout << "INSIDE OSDip DECOMP DESTRUCTOR" << std::endl;
                std::vector<OSDipBlockSolver*>::iterator vit;
                UTIL_DELARR( m_objective);
                UTIL_DELPTR( m_modelC);
                UtilDeleteMapPtr( m_modelR);
                UtilDeleteMapPtr( m_modelMasterOnly);
        
                //garbage collection on the solvers
                for (vit = m_osDipBlockSolver.begin(); vit
                                != m_osDipBlockSolver.end(); vit++) {

                                delete *vit;

                }
                //finally delete the factories
                
                delete factoryInit;
        }
        
        
        



};



#endif