BlisTreeNode.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the BiCePS Linear Integer 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,
                  BcpsConstraintPool &conPool,
                  int lastNew,
                  BlisConstraint *aCon);

    double estimateSolution(BlisModel *model,
                            const double *lpSolution,
                            double lpObjValue) const;
    
public:

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

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

    virtual ~BlisTreeNode() {
        //std::cout << "------ Delete blis part of node" << std::endl;
    }
    
    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;}
    
    // Why need below?
    //using BcpsTreeNode::generateConstraints ;

    int generateConstraints(BlisModel *model, BcpsConstraintPool &conPool);

    int callHeuristics(BlisModel *model, bool onlyBeforeRoot=false);

    void getViolatedConstraints(BlisModel *model, 
                                const double *currLpSolution, 
                                BcpsConstraintPool & conPool);

    BlisReturnStatus applyConstraints(BlisModel *model,
                                      const double *solution,
                                      BcpsConstraintPool & conPool); 

    BlisReturnStatus reducedCostFix(BlisModel *model);

    //BcpsConstraintPool * constraintPool() { return constraintPool_; }

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

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

#endif