ParReliabilityBrancher.h

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2009 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURPARRELIABILITYBRANCHER_H
#define MINOTAURPARRELIABILITYBRANCHER_H
 
#include "Brancher.h"
#include "ParTreeManager.h"
 
namespace Minotaur {
 
class Engine;
class Timer;
typedef Engine* EnginePtr;
 
struct ParRelBrStats {
  UInt bndChange;  
  UInt calls;      
  UInt engProbs;   
  UInt iters;      
  UInt strBrCalls; 
  double strTime;  
};
 
 
class ParReliabilityBrancher : public Brancher {
 
public:
  ParReliabilityBrancher(EnvPtr env, HandlerVector & handlers);
 
  ~ParReliabilityBrancher();
 
  // base class function.
  Branches findBranches(RelaxationPtr, NodePtr, 
                        ConstSolutionPtr, SolutionPoolPtr, 
                        BrancherStatus &, ModVector &) {return Branches();};
 
  // Overloaded base class function.
  Branches findBranches(RelaxationPtr rel, NodePtr node, 
                        ConstSolutionPtr sol, SolutionPoolPtr s_pool, 
                        BrancherStatus & br_status, ModVector &mods,
                        UIntVector timesUp, UIntVector timesDown,
                        DoubleVector pseudoUp, DoubleVector pseudoDown,
                        UInt nodesProc);
 
  bool getTrustCutoff();
 
  UInt getIterLim();
 
  UIntVector getLastStrBranched() {return lastStrBranched_;}
 
  // base class function.
  std::string getName() const;
 
  DoubleVector getPCUp() const { return pseudoUp_; }
 
  DoubleVector getPCDown() const { return pseudoDown_; }
  
  UIntVector getTimesDown() const { return timesDown_; }
 
  UIntVector getTimesUp() const { return timesUp_; }
 
  UInt getThresh() const;
 
  void initialize(RelaxationPtr rel);
 
  void setTrustCutoff(bool val);
 
  void setEngine(EnginePtr engine);
 
  void setIterLim(UInt k);
 
  void setLastStrBranched(UIntVector lastStrBranched) {lastStrBranched_ = lastStrBranched ;};
 
  void setMaxDepth(UInt k);
 
  void setMinNodeDist(UInt k);
 
  void setPCUp(DoubleVector psuedoUp) { pseudoUp_ = psuedoUp; };
 
  void setPCDown(DoubleVector psuedoDown) { pseudoDown_ = psuedoDown; };
  
   void setTimesDown(UIntVector timesDown) { timesDown_ = timesDown; };
 
   void setTimesUp(UIntVector timesUp) { timesUp_ = timesUp; };
 
 
  void setThresh(UInt k);
 
  // base class function.
  void updateAfterSolve(NodePtr node, ConstSolutionPtr sol);
 
  void writeStats(std::ostream &out) const;
 
private:
 
  BrCandPtr findBestCandidate_(const double objval, double cutoff,
                               NodePtr node, DoubleVector pseudoUp,
                               DoubleVector pseudoDown, UInt nodesProc);
 
  void findCandidates_(UIntVector *timesUp, UIntVector *timesDown,
                       DoubleVector *pseudoUp, DoubleVector *pseudoDown,
                       UInt nodesProc);
 
  void freeCandidates_(BrCandPtr no_del);
 
  void getPCScore_(BrCandPtr cand, double *ch_down, double *ch_up, 
                   double *score, DoubleVector pseudoUp, DoubleVector pseudoDown);
 
  double getScore_(const double & up_score, const double & down_score);
 
  bool shouldPrune_(const double &chcutoff, const double &change, 
                    const EngineStatus & status, bool *is_rel);
 
  void strongBranch_(BrCandPtr cand, double & obj_up, double & obj_down, 
                     EngineStatus & status_up, EngineStatus & status_down);
 
  void updatePCost_(const int &i, const double &new_cost, 
                    DoubleVector &cost, UIntVector &count);
 
  void useStrongBranchInfo_(BrCandPtr cand, const double & chcutoff,
                            double & change_up, double & change_down, 
                            const EngineStatus & status_up,
                            const EngineStatus & status_down);
 
  void writeScore_(BrCandPtr cand, double score, double change_up, 
                   double change_down);
 
  void writeScores_(std::ostream &out);
 
  EnginePtr engine_;
 
  const double eTol_;
 
  HandlerVector handlers_;
 
  bool init_;
 
  UIntVector lastStrBranched_;
 
  UInt maxDepth_;
 
  UInt maxIterations_;
 
  UInt maxStrongCands_;
 
  const static std::string me_; 
 
  UInt minNodeDist_;
 
  ModVector mods_;
 
  DoubleVector pseudoDown_;
 
  DoubleVector pseudoUp_;
 
  RelaxationPtr rel_;
 
  std::vector<BrCandPtr> relCands_;
 
  ParRelBrStats * stats_;
 
  BrancherStatus status_;
 
  Timer *timer_;
 
  UIntVector timesDown_;
 
  UIntVector timesUp_;
 
  UInt thresh_;
 
  bool trustCutoff_;
 
  std::vector<BrCandPtr> unrelCands_;
 
  DoubleVector x_;
 
};
typedef ParReliabilityBrancher* ParReliabilityBrancherPtr;
}
#endif