#3713 Fracture header : Compute matrix permeability and create weighted average

ApplicationCode/Commands/CompletionExportCommands/RicExportFractureCompletionsImpl.cpp

@@ -338,7 +338,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
             // 2: Calculate new external transmissibilities
             scaledCondenser.calculateCondensedTransmissibilities();
 
-            { // 3: Høgstøl correction.
+            { // 3: H�gst�l correction.
                 
                 // a. Calculate new effective fracture to well transmissiblities
                 std::map<size_t, double> fictitiousFractureToWellTransmissibilities =
@@ -720,10 +720,8 @@ void RicExportFractureCompletionsImpl::calculateAndSetReportItemData(
     const RigEclipseToStimPlanCalculator& eclToFractureCalc,
     RicWellPathFractureReportItem&        reportItem)
 {
-    double aggregatedTransmissibility = sumUpTransmissibilities(allCompletionsForOneFracture);
+    double areaWeightedMatrixPermeability = eclToFractureCalc.areaWeightedMatrixPermeability();
-
+    reportItem.setAreaWeightedPermeability(areaWeightedMatrixPermeability);
-    double areaWeightedMatrixTransmissibility = eclToFractureCalc.areaWeightedMatrixTransmissibility();
-    reportItem.setAreaWeightedTransmissibility(areaWeightedMatrixTransmissibility);
 
     double totalAreaOpenForFlow     = eclToFractureCalc.totalEclipseAreaOpenForFlow();
     double areaWeightedConductivity = eclToFractureCalc.areaWeightedConductivity();
@@ -741,6 +739,7 @@ void RicExportFractureCompletionsImpl::calculateAndSetReportItemData(
         reportItem.setHeightAndHalfLength(height, halfLength);
     }
 
+    double aggregatedTransmissibility = sumUpTransmissibilities(allCompletionsForOneFracture);
     reportItem.setData(aggregatedTransmissibility, allCompletionsForOneFracture.size(), totalAreaOpenForFlow);
 
     reportItem.setWidthAndConductivity(eclToFractureCalc.areaWeightedWidth(), areaWeightedConductivity);

ApplicationCode/Commands/CompletionExportCommands/RicWellPathFractureReportItem.cpp

@@ -85,9 +85,9 @@ void RicWellPathFractureReportItem::setHeightAndHalfLength(double height, double
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicWellPathFractureReportItem::setAreaWeightedTransmissibility(double transmissibility)
+void RicWellPathFractureReportItem::setAreaWeightedPermeability(double permeability)
 {
-    m_km = transmissibility;
+    m_km = permeability;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/Commands/CompletionExportCommands/RicWellPathFractureReportItem.h

@@ -33,7 +33,7 @@ public:
     void setData(double trans, size_t connCount, double area);
     void setWidthAndConductivity(double width, double conductivity);
     void setHeightAndHalfLength(double height, double halfLength);
-    void setAreaWeightedTransmissibility(double transmissibility);
+    void setAreaWeightedPermeability(double permeability);
     void setUnitSystem(RiaEclipseUnitTools::UnitSystem unitSystem);
     void setPressureDepletionParameters(bool performPressureDepletionScaling, QString timeStepString, QString wbhpString, double userWBHP, double actualWBHP, double minPressureDrop, double maxPressureDrop);
 

ApplicationCode/ReservoirDataModel/Completions/RigEclipseToStimPlanCalculator.cpp

@@ -144,15 +144,28 @@ double RigEclipseToStimPlanCalculator::totalEclipseAreaOpenForFlow() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RigEclipseToStimPlanCalculator::areaWeightedMatrixTransmissibility() const
+double RigEclipseToStimPlanCalculator::areaWeightedMatrixPermeability() const
 {
     RiaWeightedMeanCalculator<double> calc;
 
-    for (const auto& singleCellCalc : m_singleFractureCellCalculators)
     {
-        const RigEclipseToStimPlanCellTransmissibilityCalculator& calulator = singleCellCalc.second;
+        std::map<size_t, double> reservoirCellAndIntersectedArea;
 
-        calc.addValueAndWeight(calulator.aggregatedMatrixTransmissibility(), calulator.areaOpenForFlow());
+        for (const auto& singleCellCalc : m_singleFractureCellCalculators)
+        {
+            const RigEclipseToStimPlanCellTransmissibilityCalculator& calulator = singleCellCalc.second;
+
+            const std::vector<double>& areas          = calulator.contributingEclipseCellIntersectionAreas();
+            const std::vector<double>& permeabilities = calulator.contributingEclipseCellPermeabilities();
+
+            if (areas.size() == permeabilities.size())
+            {
+                for (size_t i = 0; i < areas.size(); i++)
+                {
+                    calc.addValueAndWeight(permeabilities[i], areas[i]);
+                }
+            }
+        }
     }
 
     return calc.weightedMean();
@@ -222,8 +235,8 @@ double RigEclipseToStimPlanCalculator::areaWeightedConductivity() const
 //--------------------------------------------------------------------------------------------------
 double RigEclipseToStimPlanCalculator::longestYSectionOpenForFlow() const
 {
-    // For each I, find the longest aggregated distance along J with continuous fracture cells with conductivity above zero
+    // For each I, find the longest aggregated distance along J with continuous fracture cells with conductivity above
-    // connected to Eclipse cells open for flow
+    // zero connected to Eclipse cells open for flow
 
     double longestRange = 0.0;
 

ApplicationCode/ReservoirDataModel/Completions/RigEclipseToStimPlanCalculator.h

@@ -54,7 +54,7 @@ public:
     // Truncated parts of the fracture are not included
     double totalEclipseAreaOpenForFlow() const;
 
-    double areaWeightedMatrixTransmissibility() const;
+    double areaWeightedMatrixPermeability() const;
     double areaWeightedWidth() const;
     double areaWeightedConductivity() const;
     double longestYSectionOpenForFlow() const;

ApplicationCode/ReservoirDataModel/Completions/RigEclipseToStimPlanCellTransmissibilityCalculator.cpp

@@ -72,6 +72,22 @@ const std::vector<double>& RigEclipseToStimPlanCellTransmissibilityCalculator::c
     return m_contributingEclipseCellTransmissibilities;
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const std::vector<double>& RigEclipseToStimPlanCellTransmissibilityCalculator::contributingEclipseCellIntersectionAreas() const
+{
+    return m_contributingEclipseCellAreas;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const std::vector<double>& RigEclipseToStimPlanCellTransmissibilityCalculator::contributingEclipseCellPermeabilities() const
+{
+    return m_contributingEclipseCellPermeabilities;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -280,6 +296,8 @@ void RigEclipseToStimPlanCellTransmissibilityCalculator::calculateStimPlanCellsM
             }
         }
 
+        double matrixPermeability = 0.0;
+
         if (isActive)
         {
             double permX = dataAccessObjectPermX->cellScalarGlobIdx(reservoirCellIndex);
@@ -305,11 +323,14 @@ void RigEclipseToStimPlanCellTransmissibilityCalculator::calculateStimPlanCellsM
 
             transmissibility = sqrt(transmissibility_X * transmissibility_X + transmissibility_Y * transmissibility_Y +
                                     transmissibility_Z * transmissibility_Z);
+
+            matrixPermeability = RigFractureTransmissibilityEquations::matrixPermeability(permX, permY, NTG);
         }
 
         m_globalIndiciesToContributingEclipseCells.push_back(reservoirCellIndex);
         m_contributingEclipseCellTransmissibilities.push_back(transmissibility);
         m_contributingEclipseCellAreas.push_back(fractureArea);
+        m_contributingEclipseCellPermeabilities.push_back(matrixPermeability);
     }
 }
 

ApplicationCode/ReservoirDataModel/Completions/RigEclipseToStimPlanCellTransmissibilityCalculator.h

@@ -54,6 +54,8 @@ public:
     // These three vectors have the same size
     const std::vector<size_t>& globalIndiciesToContributingEclipseCells() const;
     const std::vector<double>& contributingEclipseCellTransmissibilities() const;
+    const std::vector<double>& contributingEclipseCellIntersectionAreas() const;
+    const std::vector<double>& contributingEclipseCellPermeabilities() const;
 
     double areaOpenForFlow() const;
     double aggregatedMatrixTransmissibility() const;
@@ -82,4 +84,5 @@ private:
     std::vector<size_t> m_globalIndiciesToContributingEclipseCells;
     std::vector<double> m_contributingEclipseCellTransmissibilities;
     std::vector<double> m_contributingEclipseCellAreas;
+    std::vector<double> m_contributingEclipseCellPermeabilities;
 };