Enable multiplyWellConnectivity with Metis and Zoltan

Author: michal-toth

opm/grid/GraphOfGridWrappers.cpp

@@ -550,13 +550,13 @@ zoltanPartitioningWithGraphOfGrid(const Dune::CpGrid& grid,
     float mIWC = 1; // multiply edge weights between a well's cells. Used when allowDistributedWells=true.
     for (const auto& [key, value] : params)
     {
-        if (key=="EnvelopeWellLayers")
+        if (key=="EnvelopeWellLayers") {
             layers = std::stoi(value);
-        else if (key=="MultiplyWellConnectivities") {
+        } else if (key=="MultiplyWellConnectivities") {
             mIWC = std::stof(value);
-        }
-        else
+        } else {
             Zoltan_Set_Param(zz, key.c_str(), value.c_str());
+        }
     }
 
     // root process has the whole grid, other ranks nothing

opm/grid/common/MetisPartition.cpp

@@ -276,7 +276,7 @@ metisSerialGraphPartitionGridOnRoot(const CpGrid& cpgrid,
         if( wells )
         {
             // well edge weight for partitioning, big enough that wells should not get split
-            idx_t weWeight = sumOfGridEdges<idx_t>(cpgrid, *gridAndWells);
+            idx_t weWeight = calculateWellEdgeWeight<idx_t>(cpgrid, *gridAndWells);
 
             int neighborCounter = 0;
             for( int cell = 0; cell < n;  cell++ )

opm/grid/common/ZoltanGraphFunctions.cpp

@@ -180,8 +180,8 @@ void getNullEdgeList(void *cpGridPointer, int sizeGID, int sizeLID,
 }
 
 template <typename EdgeWeightType>
-EdgeWeightType sumOfGridEdges(const Dune::CpGrid& grid,
-                              const CombinedGridWellGraph& graph)
+EdgeWeightType calculateWellEdgeWeight(const Dune::CpGrid& grid,
+                                       const CombinedGridWellGraph& graph)
 {
     EdgeWeightType weWeight = 0;
     for (int edge=0; edge<grid.numFaces(); ++edge) {
@@ -191,7 +191,26 @@ EdgeWeightType sumOfGridEdges(const Dune::CpGrid& grid,
             weWeight = std::numeric_limits<EdgeWeightType>::max();
             break;
         }
-        weWeight += graph.transmissibility(edge);
+        weWeight += addend;
+    }
+
+    // when multipltWellConnectivities is provided, set the well weight to the average of grid weight times that coefficient
+    float mWC = graph.getMultiplyWellConnectivities();
+    if (mWC > 0) {
+        if (weWeight != std::numeric_limits<EdgeWeightType>::max()) {
+            weWeight /= grid.numFaces();
+        } else {
+            // grid is too big, start over and use maximum instead of the average
+            weWeight = 0;
+            for (int edge=0; edge<grid.numFaces(); ++edge) {
+                weWeight = std::max(weWeight, static_cast<float>(graph.transmissibility(edge)));
+            }
+        }
+        if (weWeight < std::numeric_limits<EdgeWeightType>::max()/mWC) {
+            weWeight *= mWC;
+        } else {
+            weWeight = std::numeric_limits<EdgeWeightType>::max();
+        }
     }
     return weWeight;
 }
@@ -326,7 +345,7 @@ void getCpGridWellsEdgeList(void *graphPointer, int sizeGID, int sizeLID,
     int neighborCounter = 0;
 
     // well edge weight for partitioning, big enough that wells should not get split
-    float weWeight = sumOfGridEdges<float>(grid, graph);
+    float weWeight = calculateWellEdgeWeight<float>(grid, graph);
 
     for( int cell = 0; cell < numCells;  cell++ )
     {

opm/grid/common/ZoltanGraphFunctions.hpp

@@ -193,6 +193,17 @@ class CombinedGridWellGraph
         else
             return 1.0;
     }
+
+    void setMultiplyWellConnectivities(const float& mWC)
+    {
+        multiplyWellConnectivities = mWC;
+    }
+
+    float getMultiplyWellConnectivities() const
+    {
+        return multiplyWellConnectivities;
+    }
+
 private:
 
     void addCompletionSetToGraph()
@@ -239,6 +250,7 @@ class CombinedGridWellGraph
     int edgeWeightsMethod_;
     WellConnections well_indices_;
     double log_min_;
+    float multiplyWellConnectivities = -1;
 };
 
 /// \brief Get the number of edges of the graph of the grid and the wells for one cell

opm/grid/common/ZoltanPartition.cpp

@@ -326,8 +326,14 @@ zoltanGraphPartitionGridOnRoot(const CpGrid& cpgrid,
     }
     setDefaultZoltanParameters(zz);
     Zoltan_Set_Param(zz, "IMBALANCE_TOL", std::to_string(zoltanImbalanceTol).c_str());
-    for (const auto& [key, value] : params)
-        Zoltan_Set_Param(zz, key.c_str(), value.c_str());
+    float mWC = -1;
+    for (const auto& [key, value] : params) {
+        if (key=="MultiplyWellConnectivities") {
+            mWC = std::stof(value);
+        } else {
+            Zoltan_Set_Param(zz, key.c_str(), value.c_str());
+        }
+    }
 
     // For the load balancer one process has the whole grid and
     // all others an empty partition before loadbalancing.
@@ -344,6 +350,7 @@ zoltanGraphPartitionGridOnRoot(const CpGrid& cpgrid,
                                                        transmissibilities,
                                                        partitionIsEmpty,
                                                        edgeWeightsMethod));
+        gridAndWells->setMultiplyWellConnectivities(mWC);
         Dune::cpgrid::setCpGridZoltanGraphFunctions(zz, *gridAndWells,
                                                     partitionIsEmpty);
     }
@@ -523,8 +530,13 @@ class ZoltanSerialPartitioner
         else
             Zoltan_Set_Param(zz, "NUM_GLOBAL_PARTS", std::to_string(cc.size()).c_str());
 
-        for (const auto& [key, value] : params)
-            Zoltan_Set_Param(zz, key.c_str(), value.c_str());
+        for (const auto& [key, value] : params) {
+            if (key=="MultiplyWellConnectivities") {
+                gridAndWells->setMultiplyWellConnectivities(std::stof(value));
+            } else {
+                 Zoltan_Set_Param(zz, key.c_str(), value.c_str());
+            }
+        }
 
         // For the load balancer one process has the whole grid and
         // all others an empty partition before loadbalancing.