Give all lp relaxations a index

Author: Opt-Mucca

highs/mip/HighsLpRelaxation.cpp

@@ -169,7 +169,8 @@ double HighsLpRelaxation::slackUpper(HighsInt row,
   return kHighsInf;
 }
 
-HighsLpRelaxation::HighsLpRelaxation(const HighsMipSolver& mipsolver)
+HighsLpRelaxation::HighsLpRelaxation(const HighsMipSolver& mipsolver,
+                                     HighsInt index)
     : mipsolver(mipsolver) {
   lpsolver.setOptionValue("output_flag", false);
   lpsolver.setOptionValue("random_seed", mipsolver.options_mip_->random_seed);
@@ -189,9 +190,11 @@ HighsLpRelaxation::HighsLpRelaxation(const HighsMipSolver& mipsolver)
   currentbasisstored = false;
   adjustSymBranchingCol = true;
   row_ep.size = 0;
+  index_ = index;
 }
 
-HighsLpRelaxation::HighsLpRelaxation(const HighsLpRelaxation& other)
+HighsLpRelaxation::HighsLpRelaxation(const HighsLpRelaxation& other,
+                                     HighsInt index)
     : mipsolver(other.mipsolver),
       lprows(other.lprows),
       fractionalints(other.fractionalints),
@@ -214,6 +217,7 @@ HighsLpRelaxation::HighsLpRelaxation(const HighsLpRelaxation& other)
   lastAgeCall = 0;
   objective = -kHighsInf;
   row_ep.size = 0;
+  index_ = index;
 }
 
 void HighsLpRelaxation::loadModel() {
@@ -927,7 +931,8 @@ void HighsLpRelaxation::storeDualInfProof() {
     for (HighsInt j = 0; j < len; ++j) row_ap.add(inds[j], weight * vals[j]);
   }
 
-  const HighsDomain& globaldomain = mipsolver.mipdata_->domain;
+  assert(index_ <= mipsolver.mipdata_->domains.size() - 1);
+  const HighsDomain& globaldomain = mipsolver.mipdata_->domains[index_];
 
   for (HighsInt i : row_ap.getNonzeros()) {
     double val = row_ap.getValue(i);
@@ -972,7 +977,7 @@ void HighsLpRelaxation::storeDualInfProof() {
   }
 
   dualproofrhs = double(upper);
-  mipsolver.mipdata_->domain.tightenCoefficients(
+  mipsolver.mipdata_->domains[index_].tightenCoefficients(
       dualproofinds.data(), dualproofvals.data(), dualproofinds.size(),
       dualproofrhs);
 
@@ -993,12 +998,14 @@ void HighsLpRelaxation::storeDualUBProof() {
   dualproofinds.clear();
   dualproofvals.clear();
 
-  if (lpsolver.getSolution().dual_valid)
-    hasdualproof = computeDualProof(mipsolver.mipdata_->domain,
+  if (lpsolver.getSolution().dual_valid) {
+    assert(index_ <= mipsolver.mipdata_->domains.size() - 1);
+    hasdualproof = computeDualProof(mipsolver.mipdata_->domains[index_],
                                     mipsolver.mipdata_->upper_limit,
                                     dualproofinds, dualproofvals, dualproofrhs);
-  else
+  } else {
     hasdualproof = false;
+  }
 
   if (!hasdualproof) dualproofrhs = kHighsInf;
 }
@@ -1330,8 +1337,11 @@ HighsLpRelaxation::Status HighsLpRelaxation::resolveLp(HighsDomain* domain) {
             if (lpsolver.getBasis().col_status[i] == HighsBasisStatus::kBasic)
               continue;
 
-            const double glb = mipsolver.mipdata_->domain.col_lower_[i];
-            const double gub = mipsolver.mipdata_->domain.col_upper_[i];
+            assert(index_ <= mipsolver.mipdata_->domains.size() - 1);
+            const double glb =
+                mipsolver.mipdata_->domains[index_].col_lower_[i];
+            const double gub =
+                mipsolver.mipdata_->domains[index_].col_upper_[i];
 
             if (std::min(gub - sol.col_value[i], sol.col_value[i] - glb) <=
                 mipsolver.mipdata_->feastol)

highs/mip/HighsLpRelaxation.h

@@ -84,6 +84,7 @@ class HighsLpRelaxation {
   HighsInt maxNumFractional;
   Status status;
   bool adjustSymBranchingCol;
+  HighsInt index_;
 
   void storeDualInfProof();
 
@@ -92,9 +93,9 @@ class HighsLpRelaxation {
   bool checkDualProof() const;
 
  public:
-  HighsLpRelaxation(const HighsMipSolver& mip);
+  HighsLpRelaxation(const HighsMipSolver& mip, HighsInt index = 0);
 
-  HighsLpRelaxation(const HighsLpRelaxation& other);
+  HighsLpRelaxation(const HighsLpRelaxation& other, HighsInt index = 0);
 
   void getCutPool(HighsInt& num_col, HighsInt& num_cut,
                   std::vector<double>& cut_lower,

highs/mip/HighsMipSolver.cpp

@@ -321,13 +321,13 @@ void HighsMipSolver::run() {
   for (int i = 1; i < mip_search_concurrency; i++) {
     if (mipdata_->numRestarts <= mipdata_->numRestartsRoot) {
       mipdata_->domains.emplace_back(mipdata_->domain);
-      mipdata_->lps.emplace_back(mipdata_->lp);
+      mipdata_->lps.emplace_back(mipdata_->lp, i);
       mipdata_->cutpools.emplace_back(
-          HighsCutPool(numCol(), options_mip_->mip_pool_age_limit,
-                       options_mip_->mip_pool_soft_limit, i));
+          numCol(), options_mip_->mip_pool_age_limit,
+                       options_mip_->mip_pool_soft_limit, i);
       mipdata_->conflictpools.emplace_back(
-          HighsConflictPool(5 * options_mip_->mip_pool_age_limit,
-                            options_mip_->mip_pool_soft_limit));
+          5 * options_mip_->mip_pool_age_limit,
+                            options_mip_->mip_pool_soft_limit);
       mipdata_->workers.emplace_back(
           *this, mipdata_->lps.back(), mipdata_->domains.back(),
           mipdata_->cutpools.back(), mipdata_->conflictpools.back());