ParBndProcessor.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2009 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURPARBNDPROCESSOR_H
#define MINOTAURPARBNDPROCESSOR_H
 
#include "NodeProcessor.h"
#include "Types.h"
 
namespace Minotaur {
 
  class Solution;
  class Engine;
  typedef Engine* EnginePtr;
  typedef const Solution* ConstSolutionPtr;
 
  struct ParBPStats {
    UInt bra;    
    UInt inf;    
    UInt opt;    
    UInt prob;   
    UInt proc;   
    UInt ub;     
  };
 
  class ParBndProcessor : public NodeProcessor {
 
    friend class ParBranchAndBound;
 
  public:
    ParBndProcessor();
 
    ParBndProcessor(EnvPtr env, EnginePtr engine, HandlerVector handlers_);
 
    ~ParBndProcessor();
 
    // True if a new solution was found while processing this node.
    bool foundNewSolution(); 
 
    // Find branches that will be used to branch at this node.
    Branches getBranches();
 
    // Get the recent solution from the engine.
    ConstSolutionPtr getSolution();
 
    // Get warm-start information.
    WarmStartPtr getWarmStart();
 
    // Implement NodeProcessor::process().
    void process(NodePtr node, RelaxationPtr rel, 
                 SolutionPoolPtr s_pool);
 
    void process(NodePtr node, RelaxationPtr rel, 
                 SolutionPoolPtr s_pool, bool init);
 
    // write statistics. Base class method.
    void writeStats(std::ostream &out) const; 
 
    // write statistics. Base class method.
    void writeStats() const; 
 
  protected:
 
    Branches branches_;
 
    bool contOnErr_;
 
    double cutOff_;
 
    EnginePtr engine_;
 
    EngineStatus engineStatus_;
 
    HandlerVector handlers_;
 
    LoggerPtr logger_;
 
    static const std::string me_;
 
    UInt numSolutions_;
 
    RelaxationPtr relaxation_;
 
    ParBPStats stats_;
 
    WarmStartPtr ws_;
 
    virtual bool isFeasible_(NodePtr node, ConstSolutionPtr sol, 
                             SolutionPoolPtr s_pool, bool &should_prune);
 
    virtual void solveRelaxation_();
 
    virtual bool shouldPrune_(NodePtr node, double solval, 
                              SolutionPoolPtr s_pool);
 
  };
 
  typedef ParBndProcessor* ParBndProcessorPtr;
 
}
#endif