BlisTreeNode.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the Bcps Linear Solver (BLIS).                       *
 *                                                                           *
 * BLIS is distributed under the Eclipse Public License as part of the       *
 * COIN-OR repository (http://www.coin-or.org).                              *
 *                                                                           *
 * Authors:                                                                  *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *                                                                           *
 * Conceptual Design:                                                        *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *          Laszlo Ladanyi, IBM T.J. Watson Research Center                  *
 *          Matthew Saltzman, Clemson University                             *
 *                                                                           * 
 *                                                                           *
 * Copyright (C) 2001-2013, Lehigh University, Yan Xu, and Ted Ralphs.       *
 * All Rights Reserved.                                                      *
 *===========================================================================*/

#ifndef BlisTreeNode_h_
#define BlisTreeNode_h_

//#############################################################################

#include "AlpsNodeDesc.h"

#include "BcpsObjectPool.h"
#include "BcpsTreeNode.h"

#include "BcpsNodeDesc.h"
#include "BlisNodeDesc.h"

class BcpsModel;
class BlisModel;


//#############################################################################
//#############################################################################


class BlisTreeNode : public BcpsTreeNode {

 private:

    BlisTreeNode(const BlisTreeNode&);

    BlisTreeNode& operator=(const BlisTreeNode&);
    
    //BcpsConstraintPool *constraintPool_;
    
    //BcpsVariablePool *variablePool_;

    //void saveExplicit();
    
    bool parallel(BlisModel *model, 
                  OsiCuts *newCutSet,
                  int lastNew,
                  OsiRowCut *rowCut);

 public:

    BlisTreeNode() 
        : 
        BcpsTreeNode() 
        { init(); }
    
    BlisTreeNode(BlisModel* m) {
        init();
        desc_ = new BlisNodeDesc(m);
    }

    BlisTreeNode(AlpsNodeDesc *&desc) {
        init();
        desc_ = desc;
        desc = NULL;
    }

    virtual ~BlisTreeNode() {
        //delete constraintPool_;
        //delete variablePool_;
    }
    
    void init() {
        //constraintPool_ = new BcpsConstraintPool;
        //variablePool_ = new BcpsVariablePool;
    }
    
    AlpsTreeNode* createNewTreeNode(AlpsNodeDesc *&desc) const;

    virtual void convertToExplicit();
    virtual void convertToRelative();
    
    virtual int installSubProblem(BcpsModel *mode);
    
    virtual int process(bool isRoot = false, bool rampUp = false);
    
    virtual int bound(BcpsModel *model);

    virtual std::vector< CoinTriple<AlpsNodeDesc*, AlpsNodeStatus, double> > 
        branch();
    
    int selectBranchObject(BlisModel *model, 
                           bool& foundSol, 
                           int numPassesLeft);

    virtual int chooseBranchingObject(BcpsModel*) { return AlpsReturnStatusOk;}
    
    int generateConstraints(BlisModel *model, OsiCuts & cutPool);

    int applyConstraints(BlisModel *model,
                         OsiCuts & cutPool,
                         const double *solution); 

    int reducedCostFix(BlisModel *model);
    
    //BcpsConstraintPool * constraintPool() { return constraintPool_; }

    //BcpsVariablePool * variablePool() { return variablePool_; }
    
    virtual AlpsEncoded* encode() const;

    virtual AlpsKnowledge* decode(AlpsEncoded&) const;
};

#endif