AbcTreeNode.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the Abstract Library for Parallel Search (ALPS).     *
 *                                                                           *
 * ALPS 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.       *
 *===========================================================================*/

#ifndef AbcTreeNode_h_
#define AbcTreeNode_h_

//#include <utility>
#include "AlpsKnowledgeBroker.h"
#include "AlpsTreeNode.h"

#include "AbcModel.h"
#include "AbcNodeDesc.h"

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

enum AbcVarStatus {
    AbcVarFree,
    AbcVarFixedToUB,
    AbcVarFixedToLB
};

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

class AbcTreeNode : public AlpsTreeNode {
 private:
    // NO: default constructor, copy constructor, assignment operator
    AbcTreeNode(const AbcTreeNode&);
    AbcTreeNode& operator=(const AbcTreeNode&);

 private:
    int branchedOn_;

    double branchedOnVal_;

    int branchedDir_;
    
    double guessedObjectiveValue_;

    int numberUnsatisfied_;
    
 public:
    AbcTreeNode()
        : 
        branchedOn_(-1),
        branchedOnVal_(ALPS_BND_MAX),
        branchedDir_(0),
        guessedObjectiveValue_(ALPS_OBJ_MAX),
        numberUnsatisfied_(0)
        {
            desc_ = new AbcNodeDesc(dynamic_cast<AbcModel*>
                       (getKnowledgeBroker()->getModel()));
        }

    AbcTreeNode(AbcModel* m)
        : 
        branchedOn_(-1),
        branchedOnVal_(ALPS_BND_MAX),
        branchedDir_(0),
        guessedObjectiveValue_(ALPS_OBJ_MAX),
        numberUnsatisfied_(0)
        {
            desc_ = new AbcNodeDesc(m);
        }

    AbcTreeNode(AbcNodeDesc*& desc) 
        : 
        branchedOn_(-1),
        branchedOnVal_(ALPS_BND_MAX),
        branchedDir_(0),
        guessedObjectiveValue_(ALPS_OBJ_MAX),
        numberUnsatisfied_(0)
        {
            desc_ = desc;
            desc = 0;
            //At the time of registering node, that node hasn't set broker
            //desc_->setModel(getKnowledgeBroker()->getDataPool()->getModel());
        }
        
    ~AbcTreeNode() 
        { 
        }
  
    virtual AlpsTreeNode* createNewTreeNode(AlpsNodeDesc*& desc) const;
  
    virtual int process(bool isRoot = false, bool rampUp = false);
        
    int chooseBranch (AbcModel * model, bool& strongFound);

    inline double getObjValue() const { return quality_; }
    inline void setObjValue(const double objValue) { quality_ = objValue; }

    virtual std::vector< CoinTriple<AlpsNodeDesc*, AlpsNodeStatus, double> > 
        branch();

    inline int numberUnsatisfied() const
        { return numberUnsatisfied_; }

    inline double guessedObjectiveValue() const
        { return guessedObjectiveValue_; }
    inline void setGuessedObjectiveValue(double value)
        { guessedObjectiveValue_ = value; }
    void setBranchedOn(int b) { branchedOn_ = b; }
    void setBranchedDir(int d) { branchedDir_ = d; }
    void setBranchedOnValue(double b) { branchedOnVal_ = b; }
    int getBranchedOn() const { return branchedOn_; }
    int getBranchedDir() const { return branchedDir_; }
    double getBranchedOnValue() const { return branchedOnVal_; }
    virtual AlpsEncoded* encode() const;
    virtual AlpsKnowledge* decode(AlpsEncoded&) const;
    
};

#endif