ParPCBProcessor.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2009 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURPARPCBPROCESSOR_H
#define MINOTAURPARPCBPROCESSOR_H
 
#include "NodeProcessor.h"
#include "ParCutMan.h"
#include "ParReliabilityBrancher.h"
#include "ParTreeManager.h"
#include "Types.h"
 
namespace Minotaur {
 
  //class Engine;
  //class Problem;
  class Solution;
  typedef const Solution* ConstSolutionPtr;
 
  struct ParNodeStats {
    UInt bra;    
    UInt inf;    
    UInt opt;    
    UInt prob;   
    UInt proc;   
    UInt ub;     
  };
 
  class ParPCBProcessor : public NodeProcessor {
 
    friend class ParBranchAndBound;
    friend class ParQGBranchAndBound;
 
  public:
    ParPCBProcessor();
 
    ParPCBProcessor(EnvPtr env, EnginePtr engine, HandlerVector handlers_);
 
    ~ParPCBProcessor();
 
    // Translate and add constraint to relaxation
    //void addConsToRel(std::vector<ConstraintPtr> cons, UInt cIndex);
 
    // Add a heuristic.
    void addHeur(HeurPtr h);
 
    // 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();
    
    // Return the cut manager used with this processor.
    CutManager* getCutManager() {return cutMan_;};
 
    // 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, UIntVector timesUp,
                 UIntVector timesDown, DoubleVector pseudoUp,
                 DoubleVector pseudoDown, UInt nodesProc);
 
    // set cut manager
    void setCutManager(CutManager* cutman);
 
    // write statistics. Base class method.
    void writeStats(std::ostream &out) const; 
 
    // write statistics. Base class method.
    void writeStats() const; 
 
  protected:
 
    Branches branches_;
 
    bool contOnErr_;
 
    CutManager *cutMan_;
 
    double cutOff_;
 
    EnginePtr engine_;
 
    EngineStatus engineStatus_;
 
    HandlerVector handlers_;
 
    HeurVector heurs_;
 
    LoggerPtr logger_;
 
    static const std::string me_;
 
    int presFreq_;
 
    UInt numSolutions_;
 
    RelaxationPtr relaxation_;
 
    ParNodeStats stats_;
 
    WarmStartPtr ws_;
 
    double oATol_;
 
    double oRTol_;
 
    virtual bool isFeasible_(NodePtr node, ConstSolutionPtr sol, 
                             SolutionPoolPtr s_pool, bool &should_prune);
 
    virtual bool presolveNode_(NodePtr node, SolutionPoolPtr s_pool);
 
 
    virtual void solveRelaxation_();
 
    virtual bool shouldPrune_(NodePtr node, double solval, 
                              SolutionPoolPtr s_pool);
 
 
 
    void separate_(ConstSolutionPtr sol, NodePtr node, SolutionPoolPtr s_pool, 
                     SeparationStatus *status);
 
    // Implement NodeProcessor::tightenBounds_()
    virtual void tightenBounds_(); 
 
  };
 
  typedef ParPCBProcessor* ParPCBProcessorPtr;
 
}
#endif