PCBProcessor.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2009 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURPCBPROCESSOR_H
#define MINOTAURPCBPROCESSOR_H
 
#include "NodeProcessor.h"
#include "Types.h"
 
namespace Minotaur
{
 
class CutManager;
//class Problem;
 
struct NodeStats {
  UInt bra;     
  UInt inf;     
  UInt opt;     
  UInt prob;    
  UInt proc;    
  UInt ub;      
  UInt tol_err; 
};
 
class PCBProcessor : public NodeProcessor
{
 
public:
  PCBProcessor() { }
 
  PCBProcessor(EnvPtr env, EnginePtr engine, HandlerVector handlers_);
 
  ~PCBProcessor();
 
  // 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();
 
  // Get warm-start information.
  WarmStartPtr getWarmStart();
 
  // Implement NodeProcessor::process().
  void process(NodePtr node, RelaxationPtr rel, SolutionPoolPtr s_pool);
 
  void setCutManager(CutManager* cutman);
 
  // write statistics. Base class method.
  void writeStats(std::ostream& out) const;
 
  // write statistics. Base class method.
  void writeStats() const;
 
private:
  Branches branches_;
 
  bool contOnErr_;
 
  CutManager* cutMan_;
 
  double cutOff_;
 
  EnginePtr engine_;
 
  EngineStatus engineStatus_;
 
  EnvPtr env_;
 
  HandlerVector handlers_;
 
  HeurVector heurs_;
 
  HandlerPtr infHand_;
 
  LoggerPtr logger_;
 
  static const std::string me_;
 
  int presFreq_;
 
  UInt numSolutions_;
 
  double oATol_;
 
  double oRTol_;
 
  RelaxationPtr relaxation_;
 
  NodeStats stats_;
 
  WarmStartPtr ws_;
 
  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 removeCuts_(ConstSolutionPtr sol);
 
 
  void separate_(ConstSolutionPtr sol, NodePtr node, SolutionPoolPtr s_pool,
                 SeparationStatus* status);
 
  // Implement NodeProcessor::tightenBounds_()
  virtual void tightenBounds_(NodePtr node, SolutionPoolPtr s_pool,
                              ConstSolutionPtr sol, SeparationStatus* status);
};
 
typedef PCBProcessor* PCBProcessorPtr;
 
} // namespace Minotaur
#endif