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                                        *
 *          Aykut Bulut, 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-2019, Lehigh University, Yan Xu, Aykut Bulut, and      *
 *                          Ted Ralphs.                                      *
 * All Rights Reserved.                                                      *
 *===========================================================================*/
 
 
#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:
    int branchedOn_;
 
    double branchedOnVal_;
 
    int branchedDir_;
 
    double guessedObjectiveValue_;
 
    int numberUnsatisfied_;
 
 public:
    AbcTreeNode()
        :
      AlpsTreeNode(),
        branchedOn_(-1),
        branchedOnVal_(ALPS_BND_MAX),
        branchedDir_(0),
        guessedObjectiveValue_(ALPS_OBJ_MAX),
        numberUnsatisfied_(0)
        {
          desc_ = new AbcNodeDesc();
        }
 
    AbcTreeNode(AbcNodeDesc*& desc)
        :
      AlpsTreeNode(),
        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());
        }
 
    virtual ~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_; }
 
  using AlpsKnowledge::encode;
  virtual AlpsReturnStatus encode(AlpsEncoded * encoded) const;
 
  virtual AlpsKnowledge * decode(AlpsEncoded & encoded) const;
 
  virtual AlpsReturnStatus decodeToSelf(AlpsEncoded & encoded) {
    std::cerr << "Not implemented!" << std::endl;
    throw std::exception();
  }
 
private:
  AbcTreeNode(AbcTreeNode const &);
  AbcTreeNode & operator=(AbcTreeNode const &);
 
};
 
#endif