#3670 Implement new Pressure Depletion behaviour

* Removed choice of different scaling
* Always use current pressure delta
* Use the maximum of an epsilon value and the absolute value of the matrix to well pressure drop as the scaling factor
* Remove file name suffixes and update information table in export file.

ApplicationCode/CommandFileInterface/RicfExportWellPathCompletions.cpp

@@ -56,9 +56,9 @@ RicfExportWellPathCompletions::RicfExportWellPathCompletions()
     
     RICF_InitField(&m_excludeMainBoreForFishbones, "excludeMainBoreForFishbones", false, "Exclude Main Bore for Fishbones",  "", "", "");
 
-    RICF_InitField(&m_transScalingType, "transScalingType", RicExportCompletionDataSettingsUi::TransScalingType(), "Transmissibility Scaling Type", "", "", "");
+    RICF_InitField(&m_performTransScaling, "performTransScaling", false, "Perform Transmissibility Scaling", "", "", "");
     RICF_InitField(&m_transScalingTimeStep, "transScalingTimeStep", 0, "Transmissibility Scaling Pressure Time Step", "", "", "");
-    RICF_InitField(&m_transScalingInitialWBHP, "transScalingWBHPFromSummary", RicExportCompletionDataSettingsUi::TransScalingInitialWBHP(), "Transmissibility Scaling WBHP from summary", "", "", "");
+    RICF_InitField(&m_transScalingInitialWBHP, "transScalingWBHPFromSummary", RicExportCompletionDataSettingsUi::TransScalingWBHPSource(), "Transmissibility Scaling WBHP from summary", "", "", "");
     RICF_InitField(&m_transScalingWBHP,     "transScalingWBHP", 200.0, "Transmissibility Scaling Constant WBHP Value", "", "", "");
 }
 
@@ -84,9 +84,9 @@ void RicfExportWellPathCompletions::execute()
     exportSettings->fileSplit = m_fileSplit;
     exportSettings->compdatExport = m_compdatExport;
 
-    exportSettings->transScalingType = m_transScalingType;
+    exportSettings->performTransScaling = m_performTransScaling;
     exportSettings->transScalingTimeStep = m_transScalingTimeStep;
-    exportSettings->transScalingInitialWBHP = m_transScalingInitialWBHP;
+    exportSettings->transScalingWBHPSource = m_transScalingInitialWBHP;
     exportSettings->transScalingWBHP = m_transScalingWBHP;
 
     exportSettings->useLateralNTG = m_useLateralNTG;

ApplicationCode/CommandFileInterface/RicfExportWellPathCompletions.h

@@ -48,10 +48,10 @@ private:
     caf::PdmField<RicExportCompletionDataSettingsUi::CompdatExportType>   m_compdatExport;
     caf::PdmField<RicExportCompletionDataSettingsUi::CombinationModeType> m_combinationMode;
 
-    caf::PdmField<RicExportCompletionDataSettingsUi::TransScalingType>        m_transScalingType;
+    caf::PdmField<bool>                                                      m_performTransScaling;
-    caf::PdmField<int>                                                        m_transScalingTimeStep;
+    caf::PdmField<int>                                                       m_transScalingTimeStep;
-    caf::PdmField<RicExportCompletionDataSettingsUi::TransScalingInitialWBHP> m_transScalingInitialWBHP;
+    caf::PdmField<RicExportCompletionDataSettingsUi::TransScalingWBHPSource> m_transScalingInitialWBHP;
-    caf::PdmField<double>                                                     m_transScalingWBHP;
+    caf::PdmField<double>                                                    m_transScalingWBHP;
 
     caf::PdmField<bool> m_useLateralNTG;
     caf::PdmField<bool> m_includePerforations;

ApplicationCode/Commands/CompletionExportCommands/RicExportCompletionDataSettingsUi.cpp

@@ -57,23 +57,12 @@ namespace caf
     }
 
     template<>
-    void RicExportCompletionDataSettingsUi::TransScalingType::setUp()
+    void RicExportCompletionDataSettingsUi::TransScalingWBHPSource::setUp()
     {
-        addItem(RicExportFractureCompletionsImpl::NO_SCALING, "NO_SCALING", "No scaling");
+        addItem(RicExportFractureCompletionsImpl::WBHP_FROM_SUMMARY, "WBHP_SUMMARY", "WBHP From Summary Case");
-        addItem(RicExportFractureCompletionsImpl::MATRIX_TO_WELL_DP_OVER_INITIAL_DP, "MATWELL_DP_OVER_INITIALDP", "Matrix to Well dP over initial dP");
+        addItem(RicExportFractureCompletionsImpl::WBHP_FROM_USER_DEF, "WBHP_USER_DEFINED", "Fixed User Defined WBHP");
-        addItem(RicExportFractureCompletionsImpl::MATRIX_TO_WELL_DP_OVER_MAX_INITIAL_DP, "MATWELL_DP_OVER_MAX_INITIALDP", "Matrix to Well dP over max initial dP");
 
-        setDefault(RicExportFractureCompletionsImpl::NO_SCALING);
+        setDefault(RicExportFractureCompletionsImpl::WBHP_FROM_SUMMARY);
-    }
-
-    template<>
-    void RicExportCompletionDataSettingsUi::TransScalingInitialWBHP::setUp()
-    {
-        addItem(RicExportFractureCompletionsImpl::FROM_PRODUCTION_START, "PROD_START", "Initial WBHP From Production Start");
-        addItem(RicExportFractureCompletionsImpl::FROM_PRODUCTION_START_W_MIN, "PROD_START_MIN", "Initial WBHP From Production Start With Minimum WBHP");
-        addItem(RicExportFractureCompletionsImpl::FIXED_INITIAL_WBHP, "FIXED_INITIAL_WBHP", "Fixed Initial WBHP");
-
-        setDefault(RicExportFractureCompletionsImpl::FROM_PRODUCTION_START);
     }
 }
 // clang-format on
@@ -101,10 +90,10 @@ RicExportCompletionDataSettingsUi::RicExportCompletionDataSettingsUi()
     CAF_PDM_InitField(&includeFishbones, "IncludeFishbones", true, "Fishbones", "", "", "");
     CAF_PDM_InitField(&includeFractures, "IncludeFractures", true, "Fractures", "", "", "");
 
-    CAF_PDM_InitFieldNoDefault(&transScalingType, "TransScalingType", "  Pressure Diff. Depletion Transmissibility Scaling", "", "", "");
+    CAF_PDM_InitField(&performTransScaling, "TransScalingType", false, "Perform Transmissibility Scaling", "", "", "");
-    CAF_PDM_InitField(&transScalingTimeStep, "TransScalingTimeStep", 0, "  PDD Current WBHP Time Step", "", "", "");
+    CAF_PDM_InitField(&transScalingTimeStep, "TransScalingTimeStep", 0, "Current Time Step", "", "", "");
-    CAF_PDM_InitFieldNoDefault(&transScalingInitialWBHP, "TransScalingInitialWBHP", "  PDD Initial WBHP Selection", "", "", "");
+    CAF_PDM_InitFieldNoDefault(&transScalingWBHPSource, "TransScalingWBHPSource", "WBHP Selection", "", "", "");
-    CAF_PDM_InitField(&transScalingWBHP, "TransScalingWBHP", 200.0, "  PDD Initial WBHP Value", "", "", "");
+    CAF_PDM_InitField(&transScalingWBHP, "TransScalingWBHP", 200.0, "WBHP Before Production Start", "", "", "");
 
     CAF_PDM_InitField(&excludeMainBoreForFishbones,
                       "ExcludeMainBoreForFishbones",
@@ -325,39 +314,42 @@ void RicExportCompletionDataSettingsUi::defineUiOrdering(QString uiConfigName, c
         {
             group->add(&includeFractures);
 
-            if (RiaApplication::enableDevelopmentFeatures())
+            caf::PdmUiGroup* pddGroup = group->addNewGroup("Pressure Differential Depletion Scaling");
-            {
+            pddGroup->setUiReadOnly(!includeFractures());
-                group->add(&transScalingType);
-                group->add(&transScalingTimeStep);
-                group->add(&transScalingInitialWBHP);
-                group->add(&transScalingWBHP);
 
-                if (transScalingType() == RicExportFractureCompletionsImpl::NO_SCALING)
+            pddGroup->add(&performTransScaling);
+            pddGroup->add(&transScalingTimeStep);
+            pddGroup->add(&transScalingWBHPSource);
+            pddGroup->add(&transScalingWBHP);
+
+            if (!includeFractures())
+            {
+                performTransScaling = false;
+                performTransScaling.uiCapability()->setUiReadOnly(true);
+            }
+            else
+            {
+                performTransScaling.uiCapability()->setUiReadOnly(false);
+            }
+
+            if (!performTransScaling())
+            {
+                transScalingTimeStep.uiCapability()->setUiReadOnly(true);
+                transScalingWBHPSource.uiCapability()->setUiReadOnly(true);
+                transScalingWBHP.uiCapability()->setUiReadOnly(true);
+            }
+            else
+            {                
+                transScalingTimeStep.uiCapability()->setUiReadOnly(false);
+                transScalingWBHPSource.uiCapability()->setUiReadOnly(false);
+                transScalingWBHP.uiCapability()->setUiReadOnly(false);
+                if (transScalingWBHPSource == RicExportFractureCompletionsImpl::WBHP_FROM_SUMMARY)
                 {
-                    transScalingTimeStep.uiCapability()->setUiReadOnly(true);
+                    transScalingWBHP.uiCapability()->setUiName("WBHP Before Production Start");
-                    transScalingInitialWBHP.uiCapability()->setUiReadOnly(true);
-                    transScalingWBHP.uiCapability()->setUiReadOnly(true);
                 }
                 else
                 {
-                    transScalingTimeStep.uiCapability()->setUiReadOnly(false);
+                    transScalingWBHP.uiCapability()->setUiName("User Defined WBHP");
-                    transScalingInitialWBHP.uiCapability()->setUiReadOnly(false);
-                    if (transScalingInitialWBHP == RicExportFractureCompletionsImpl::FROM_PRODUCTION_START)
-                    {
-                        transScalingWBHP.uiCapability()->setUiReadOnly(true);
-                    }
-                    else
-                    {
-                        transScalingWBHP.uiCapability()->setUiReadOnly(false);
-                        if (transScalingInitialWBHP == RicExportFractureCompletionsImpl::FROM_PRODUCTION_START_W_MIN)
-                        {
-                            transScalingWBHP.uiCapability()->setUiName("  PDD Minimum Initial WBHP");
-                        }
-                        else
-                        {
-                            transScalingWBHP.uiCapability()->setUiName("  PDD Fixed Initial WBHP");
-                        }
-                    }
                 }
             }
 

ApplicationCode/Commands/CompletionExportCommands/RicExportCompletionDataSettingsUi.h

@@ -56,8 +56,7 @@ public:
     };
     typedef caf::AppEnum<CombinationMode> CombinationModeType;
 
-    typedef caf::AppEnum<RicExportFractureCompletionsImpl::PressureDepletionTransScaling> TransScalingType;
+    typedef caf::AppEnum<RicExportFractureCompletionsImpl::PressureDepletionWBHPSource>   TransScalingWBHPSource;
-    typedef caf::AppEnum<RicExportFractureCompletionsImpl::PressureDepletionInitialWBHP>  TransScalingInitialWBHP;
 
     RicExportCompletionDataSettingsUi();
 
@@ -66,9 +65,9 @@ public:
     caf::PdmField<ExportSplitType>          fileSplit;
     caf::PdmField<CompdatExportType>        compdatExport;
 
-    caf::PdmField<TransScalingType>         transScalingType;
+    caf::PdmField<bool>                     performTransScaling;
     caf::PdmField<int>                      transScalingTimeStep;
-    caf::PdmField<TransScalingInitialWBHP>  transScalingInitialWBHP;
+    caf::PdmField<TransScalingWBHPSource>   transScalingWBHPSource;
     caf::PdmField<double>                   transScalingWBHP;
 
     caf::PdmField<bool>                     includeMsw;

ApplicationCode/Commands/CompletionExportCommands/RicExportFractureCompletionsImpl.cpp

@@ -184,7 +184,7 @@ std::vector<RigCompletionData>
         caseToApply->loadStaticResultsByName(resultNames);
     }
 
-    if (pdParams.pressureDropScaling != NO_SCALING)
+    if (pdParams.performScaling)
     {
         RigCaseCellResultsData* results = caseToApply->results(RiaDefines::MATRIX_MODEL);
         results->findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "PRESSURE");
@@ -225,15 +225,14 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
     size_t                        pressureResultIndex = results->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "PRESSURE");
     const RigActiveCellInfo*      actCellInfo         = caseToApply->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL);
 
-    PressureDepletionTransScaling currentPressureDropScaling = pdParams.pressureDropScaling;
+    bool performPressureDepletionScaling = pdParams.performScaling;
 
     int    initialWellProductionTimeStep = 0;
-    double initialWellPressure           = 0;
     double currentWellPressure           = 0;
 
-    if (currentPressureDropScaling != NO_SCALING)
+    if (performPressureDepletionScaling)
     {
-        double minimumWBHP = pdParams.pressureScalingWBHP;
+        double userWBHP = pdParams.userWBHP;
 
         double initialWBHPFromSummary = 0.0;
         double currentWBHPFromSummary = 0.0;
@@ -245,49 +244,27 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
                                                                     &initialWBHPFromSummary,
                                                                     &currentWBHPFromSummary);
 
-        currentWellPressure = currentWBHPFromSummary;
+        if (pdParams.wbhpSource == WBHP_FROM_SUMMARY)
-        if (pdParams.initialWbhpSource == FROM_PRODUCTION_START)
         {
-            initialWellPressure = initialWBHPFromSummary;
+            currentWellPressure = currentWBHPFromSummary;
-        }
-        else if (pdParams.initialWbhpSource == FROM_PRODUCTION_START_W_MIN)
-        {
-            initialWellPressure = initialWBHPFromSummary;
             if (pdParams.pressureScalingTimeStep <= initialWellProductionTimeStep)
             {
-                initialWellPressure = minimumWBHP;
+                currentWellPressure = userWBHP;
             }
         }
         else
         {
-            initialWellPressure = minimumWBHP;
+            currentWellPressure = userWBHP;
-        }
-
-        // Final check for initial vs current pressure to see if scaling is valid
-        if (std::fabs(initialWellPressure - currentWellPressure) < 1.0e-6)
-        {
-            // Don't perform scaling if current pressure is equal to initial.
-            currentPressureDropScaling = NO_SCALING;
         }
     }
 
     const std::vector<std::vector<double>>* pressureResultVector   = nullptr;
-    const std::vector<double>*              initialMatrixPressures = nullptr;
     const std::vector<double>*              currentMatrixPressures = nullptr;
-    if (currentPressureDropScaling != NO_SCALING)
+    if (performPressureDepletionScaling)
     {
         pressureResultVector = &results->cellScalarResults(pressureResultIndex);
         CVF_ASSERT(!pressureResultVector->empty());
 
-        if (initialWellProductionTimeStep < static_cast<int>(pressureResultVector->size()))
-        {
-            initialMatrixPressures = &pressureResultVector->at(initialWellProductionTimeStep);
-        }
-        else
-        {
-            // Don't perform scaling if the initial well production time step is beyond the case range.
-            currentPressureDropScaling = NO_SCALING;
-        }
         if (pdParams.pressureScalingTimeStep < static_cast<int>(pressureResultVector->size()))
         {
             currentMatrixPressures = &pressureResultVector->at(pdParams.pressureScalingTimeStep);
@@ -295,7 +272,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
         else
         {
             // Don't perform scaling if the current pressure time step is beyond the case range.
-            currentPressureDropScaling = NO_SCALING;
+            performPressureDepletionScaling = false;
         }
     }
 
@@ -349,25 +326,15 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
         // Insert total transmissibility from eclipse-cell to well for this fracture into the map
         std::map<size_t, double> matrixToWellTrans = calculateMatrixToWellTransmissibilities(transCondenser);
 
-        ////////////////////////////////////////////////////////
+        double maxPressureDrop = 0.0, minPressureDrop = 0.0;
-        // clang-format off
+        if (performPressureDepletionScaling)
-        // WARNING!!!                                         //
-        // PROTOTYPE-CODE for Pressure Differential Depletion //
-        // MAY CHANGE A LOT                                   //
-        ////////////////////////////////////////////////////////
-       
-        if (currentPressureDropScaling == MATRIX_TO_WELL_DP_OVER_INITIAL_DP ||
-            currentPressureDropScaling == MATRIX_TO_WELL_DP_OVER_MAX_INITIAL_DP)
         {
             RigTransmissibilityCondenser scaledCondenser = transCondenser;
             // 1. Scale matrix to fracture transmissibilities by matrix to fracture pressure
             std::map<size_t, double> originalLumpedMatrixToFractureTrans = scaledCondenser.scaleMatrixToFracTransByMatrixWellDP(
                 actCellInfo,
-                initialWellPressure,
                 currentWellPressure,
-                *initialMatrixPressures,
+                *currentMatrixPressures, &minPressureDrop, &maxPressureDrop);
-                *currentMatrixPressures,
-                currentPressureDropScaling == MATRIX_TO_WELL_DP_OVER_MAX_INITIAL_DP);
             // 2: Calculate new external transmissibilities
             scaledCondenser.calculateCondensedTransmissibilities();
 
@@ -384,11 +351,6 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
             }
         }
        
-        ////////////////////////////////////////////////////////////
-        // clang-format on
-        // END PROTOTYPE CODE FOR PRESSURE DIFFERENTIAL DEPLETION //
-        ////////////////////////////////////////////////////////////
-
         std::vector<RigCompletionData> allCompletionsForOneFracture =
             generateCompdatValuesForFracture(matrixToWellTrans, wellPathName, caseToApply, fracture, fracTemplate);
 
@@ -397,7 +359,9 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
             RicWellPathFractureReportItem reportItem(
                 wellPathName, fracture->name(), fracTemplate->name(), fracture->fractureMD());
             reportItem.setUnitSystem(fracTemplate->fractureTemplateUnit());
-            reportItem.setPressureDepletionParameters(caf::AppEnum<PressureDepletionTransScaling>::uiTextFromIndex(currentPressureDropScaling), initialWellPressure, currentWellPressure);
+            reportItem.setPressureDepletionParameters(performPressureDepletionScaling ? "True" : "False",
+                caf::AppEnum<PressureDepletionWBHPSource>::uiTextFromIndex(pdParams.wbhpSource),
+                pdParams.userWBHP, minPressureDrop, maxPressureDrop);
 
             RicExportFractureCompletionsImpl::calculateAndSetReportItemData(
                 allCompletionsForOneFracture, eclToFractureCalc, reportItem);

ApplicationCode/Commands/CompletionExportCommands/RicExportFractureCompletionsImpl.h

@@ -44,18 +44,11 @@ class QString;
 class RicExportFractureCompletionsImpl
 {
 public:
-    enum PressureDepletionTransScaling
-    {
-        NO_SCALING = 0,
-        MATRIX_TO_WELL_DP_OVER_INITIAL_DP,
-        MATRIX_TO_WELL_DP_OVER_MAX_INITIAL_DP
-    };
 
-    enum PressureDepletionInitialWBHP
+    enum PressureDepletionWBHPSource
     {
-        FROM_PRODUCTION_START,
+        WBHP_FROM_SUMMARY,
-        FROM_PRODUCTION_START_W_MIN,
+        WBHP_FROM_USER_DEF
-        FIXED_INITIAL_WBHP
     };
 
     //--------------------------------------------------------------------------------------------------
@@ -63,20 +56,20 @@ public:
     //--------------------------------------------------------------------------------------------------
     struct PressureDepletionParameters
     {
-        PressureDepletionParameters(PressureDepletionTransScaling pressureDropScaling = NO_SCALING,
+        PressureDepletionParameters(bool                        performScaling = false,
-                                    int                           pressureScalingTimeStep = 0,
+                                    int                         pressureScalingTimeStep = 0,
-                                    PressureDepletionInitialWBHP  initialWbhpSource = FROM_PRODUCTION_START,
+                                    PressureDepletionWBHPSource wbhpSource = WBHP_FROM_SUMMARY,
-                                    double                        pressureScalingWBHP = 200.0)
+                                    double                      userWBHP = 200.0)
-            : pressureDropScaling(pressureDropScaling)
+            : performScaling(performScaling)
             , pressureScalingTimeStep(pressureScalingTimeStep)
-            , initialWbhpSource(initialWbhpSource)
+            , wbhpSource(wbhpSource)
-            , pressureScalingWBHP(pressureScalingWBHP)
+            , userWBHP(userWBHP)
         {}
 
-        PressureDepletionTransScaling    pressureDropScaling;
+        bool                        performScaling;
-        int                              pressureScalingTimeStep;
+        int                         pressureScalingTimeStep;
-        PressureDepletionInitialWBHP     initialWbhpSource;
+        PressureDepletionWBHPSource wbhpSource;
-        double                           pressureScalingWBHP;
+        double                      userWBHP;
     };     
 
     static std::vector<RigCompletionData> generateCompdatValuesForWellPath(RimWellPath* wellPath,

ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeatureImpl.cpp

@@ -245,9 +245,9 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompletions(const std::ve
                         exportSettings.caseToApply(),
                         reportItems,
                         fractureTransmissibilityExportInformationStream.get(),
-                        RicExportFractureCompletionsImpl::PressureDepletionParameters(exportSettings.transScalingType(),
+                        RicExportFractureCompletionsImpl::PressureDepletionParameters(exportSettings.performTransScaling(),
                                                                                       exportSettings.transScalingTimeStep(),
-                                                                                      exportSettings.transScalingInitialWBHP(),
+                                                                                      exportSettings.transScalingWBHPSource(),
                                                                                       exportSettings.transScalingWBHP()));
 
                 appendCompletionData(&completionsPerEclipseCellAllCompletionTypes, fractureCompletionData);
@@ -291,9 +291,9 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompletions(const std::ve
                     exportSettings.caseToApply(),
                     simWell,
                     fractureTransmissibilityExportInformationStream.get(),
-                    RicExportFractureCompletionsImpl::PressureDepletionParameters(exportSettings.transScalingType(),
+                    RicExportFractureCompletionsImpl::PressureDepletionParameters(exportSettings.performTransScaling(),
                                                                                   exportSettings.transScalingTimeStep(),
-                                                                                  exportSettings.transScalingInitialWBHP(),
+                                                                                  exportSettings.transScalingWBHPSource(),
                                                                                   exportSettings.transScalingWBHP()));
 
             appendCompletionData(&completionsPerEclipseCell, fractureCompletionData);
@@ -312,7 +312,6 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompletions(const std::ve
         if (exportSettings.fileSplit == RicExportCompletionDataSettingsUi::UNIFIED_FILE)
         {
             QString fileName = QString("UnifiedCompletions_%1").arg(eclipseCaseName);
-            fileName += createPressureDepletionFileNameSuffix(exportSettings);
             sortAndExportCompletionsToFile(exportSettings.caseToApply,
                                            exportSettings.folder,
                                            fileName,
@@ -337,7 +336,6 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompletions(const std::ve
                 if (wellCompletions.empty()) continue;
 
                 QString fileName = QString("%1_unifiedCompletions_%2").arg(wellPath->name()).arg(eclipseCaseName);
-                fileName += createPressureDepletionFileNameSuffix(exportSettings);
                 sortAndExportCompletionsToFile(exportSettings.caseToApply,
                                                exportSettings.folder,
                                                fileName,
@@ -379,7 +377,6 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompletions(const std::ve
                         QString fileName = QString("%1_%2_%3").arg(wellPath->name()).arg(completionTypeText).arg(eclipseCaseName);
                         if (completionType == RigCompletionData::FRACTURE)
                         {
-                            fileName += createPressureDepletionFileNameSuffix(exportSettings);
                             sortAndExportCompletionsToFile(exportSettings.caseToApply,
                                                            exportSettings.folder,
                                                            fileName,
@@ -422,7 +419,6 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompletions(const std::ve
                 if (wellCompletions.empty()) continue;
 
                 QString fileName = QString("%1_Fractures_%2").arg(simWell->name()).arg(eclipseCaseName);
-                fileName += createPressureDepletionFileNameSuffix(exportSettings);
                 sortAndExportCompletionsToFile(exportSettings.caseToApply,
                                                exportSettings.folder,
                                                fileName,
@@ -2618,50 +2614,6 @@ void RicWellPathExportCompletionDataFeatureImpl::exportWellSegments(
     RicWellPathExportCompletionDataFeatureImpl::generateCompsegTables(formatter, exportInfo);
 }
 
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-QString RicWellPathExportCompletionDataFeatureImpl::createPressureDepletionFileNameSuffix(
-    const RicExportCompletionDataSettingsUi& exportSettings)
-{
-    QString suffix;
-    if (exportSettings.transScalingType() != RicExportFractureCompletionsImpl::NO_SCALING)
-    {
-        if (exportSettings.transScalingType() == RicExportFractureCompletionsImpl::MATRIX_TO_WELL_DP_OVER_INITIAL_DP)
-        {
-            suffix += QString("_3");
-        }
-        else if (exportSettings.transScalingType() == RicExportFractureCompletionsImpl::MATRIX_TO_WELL_DP_OVER_MAX_INITIAL_DP)
-        {
-            suffix += QString("_4");
-        }
-
-        suffix += QString("B_");
-
-        if (exportSettings.transScalingInitialWBHP() == RicExportFractureCompletionsImpl::FROM_PRODUCTION_START)
-        {
-            suffix += QString("_WBHPROD_");
-        }
-        else if (exportSettings.transScalingInitialWBHP() == RicExportFractureCompletionsImpl::FROM_PRODUCTION_START_W_MIN)
-        {
-            suffix += QString("_WBHPMIN_");
-        }
-        else
-        {
-            suffix += QString("_WBHPFIX_");
-        }
-
-        RimEclipseCase* eclipseCase = exportSettings.caseToApply();
-        if (eclipseCase)
-        {
-            QString date = eclipseCase->timeStepStrings()[exportSettings.transScalingTimeStep()];
-            date.replace(QRegExp("[\\.\\s]"), "_");
-            suffix += QString("%1").arg(date);
-        }
-    }
-    return suffix;
-}
-
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeatureImpl.h

@@ -231,7 +231,6 @@ private:
                                                              QFilePtr exportFile,
                                                              const RimWellPath* wellPath,
                                                              const std::vector<const RimPerforationInterval*>& perforationIntervals);
-    static QString                        createPressureDepletionFileNameSuffix(const RicExportCompletionDataSettingsUi& exportSettings);
 
     static void                           exportCarfinForTemporaryLgrs(const RimEclipseCase* sourceCase, const QString& folder);
 

ApplicationCode/Commands/CompletionExportCommands/RicWellPathFractureReportItem.cpp

@@ -43,8 +43,8 @@ RicWellPathFractureReportItem::RicWellPathFractureReportItem(const QString& well
     , m_xf(0.0)
     , m_h(0.0)
     , m_km(0.0)
-    , m_pressureDepletionInitialWBHP(-1.0)
+    , m_pressureDepletionMinPressureDrop(-1.0)
-    , m_pressureDepletionCurrentWBHP(-1.0)
+    , m_pressureDepletionMaxPressureDrop(-1.0)
 {
 }
 
@@ -120,6 +120,14 @@ QString RicWellPathFractureReportItem::pressureDepletionScaling() const
     return m_pressureDepletionScalingString;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+QString RicWellPathFractureReportItem::pressureDepletionWBHPString() const
+{
+    return m_pressureDepletionWBHPString;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -131,11 +139,13 @@ void RicWellPathFractureReportItem::setUnitSystem(RiaEclipseUnitTools::UnitSyste
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicWellPathFractureReportItem::setPressureDepletionParameters(QString scalingString, double initialWBHP, double currentWBHP)
+void RicWellPathFractureReportItem::setPressureDepletionParameters(QString scalingString, QString wbhpString, double userWBHP, double minPressureDrop, double maxPressureDrop)
 {
-    m_pressureDepletionScalingString = scalingString;
+    m_pressureDepletionScalingString     = scalingString;
-    m_pressureDepletionInitialWBHP   = initialWBHP;
+    m_pressureDepletionWBHPString        = wbhpString;
-    m_pressureDepletionCurrentWBHP   = currentWBHP;
+    m_pressureDepletionUserWBHP          = userWBHP;
+    m_pressureDepletionMinPressureDrop   = minPressureDrop;
+    m_pressureDepletionMaxPressureDrop   = maxPressureDrop;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -245,17 +255,25 @@ double RicWellPathFractureReportItem::kmxf() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RicWellPathFractureReportItem::pressureDepletionInitialWBHP() const
+double RicWellPathFractureReportItem::pressureDepletionUserWBHP() const
 {
-    return m_pressureDepletionInitialWBHP;
+    return m_pressureDepletionUserWBHP;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RicWellPathFractureReportItem::pressureDepletionCurrentWBHP() const
+double RicWellPathFractureReportItem::pressureDepletionMinPressureDrop() const
 {
-    return m_pressureDepletionCurrentWBHP;
+    return m_pressureDepletionMinPressureDrop;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RicWellPathFractureReportItem::pressureDepletionMaxPressureDrop() const
+{
+    return m_pressureDepletionMaxPressureDrop;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/Commands/CompletionExportCommands/RicWellPathFractureReportItem.h

@@ -35,12 +35,13 @@ public:
     void setHeightAndHalfLength(double height, double halfLength);
     void setAreaWeightedTransmissibility(double transmissibility);
     void setUnitSystem(RiaEclipseUnitTools::UnitSystem unitSystem);
-    void setPressureDepletionParameters(QString scalingString, double initialWBHP, double currentWBHP);
+    void setPressureDepletionParameters(QString scalingString, QString wbhpString, double userWBHP, double minPressureDrop, double maxPressureDrop);
 
     QString wellPathNameForExport() const;
     QString fractureName() const;
     QString fractureTemplateName() const;
     QString pressureDepletionScaling() const;
+    QString pressureDepletionWBHPString() const;
 
     RiaEclipseUnitTools::UnitSystem unitSystem() const;
 
@@ -58,8 +59,9 @@ public:
     double km() const;
     double kmxf() const;
 
-    double pressureDepletionInitialWBHP() const;
+    double pressureDepletionUserWBHP() const;
-    double pressureDepletionCurrentWBHP() const;
+    double pressureDepletionMinPressureDrop() const;
+    double pressureDepletionMaxPressureDrop() const;
 
     bool operator < (const RicWellPathFractureReportItem& other) const;
 
@@ -69,6 +71,7 @@ private:
     QString                         m_wellPathFracture;
     QString                         m_wellPathFractureTemplate;
     QString                         m_pressureDepletionScalingString;
+    QString                         m_pressureDepletionWBHPString;
     double                          m_mesuredDepth;
 
     double m_transmissibility;
@@ -82,6 +85,7 @@ private:
     double m_h;
     double m_km;
     
-    double m_pressureDepletionInitialWBHP;
+    double m_pressureDepletionUserWBHP;
-    double m_pressureDepletionCurrentWBHP;
+    double m_pressureDepletionMinPressureDrop;
+    double m_pressureDepletionMaxPressureDrop;
 };

ApplicationCode/Commands/CompletionExportCommands/RicWellPathFractureTextReportFeatureImpl.cpp

@@ -710,8 +710,10 @@ QString RicWellPathFractureTextReportFeatureImpl::createFracturePressureDepletio
         RifEclipseOutputTableColumn("Well"),
         RifEclipseOutputTableColumn("Fracture"),
         RifEclipseOutputTableColumn("PDD Scaling"),
-        RifEclipseOutputTableColumn("Initial WBHP"),
+        RifEclipseOutputTableColumn("WBHP Source"),
-        RifEclipseOutputTableColumn("Current WBHP")
+        RifEclipseOutputTableColumn("User WBHP"),
+        RifEclipseOutputTableColumn("Min Pressure Drop"),
+        RifEclipseOutputTableColumn("Max Pressure Drop")
     };
 
     formatter.header(header);
@@ -722,8 +724,10 @@ QString RicWellPathFractureTextReportFeatureImpl::createFracturePressureDepletio
         formatter.add(reportItem.wellPathNameForExport());
         formatter.add(reportItem.fractureName());
         formatter.add(reportItem.pressureDepletionScaling());
-        formatter.add(reportItem.pressureDepletionInitialWBHP());
+        formatter.add(reportItem.pressureDepletionWBHPString());
-        formatter.add(reportItem.pressureDepletionCurrentWBHP());
+        formatter.add(reportItem.pressureDepletionUserWBHP());
+        formatter.add(reportItem.pressureDepletionMinPressureDrop());
+        formatter.add(reportItem.pressureDepletionMaxPressureDrop());
 
         formatter.rowCompleted();
     }

ApplicationCode/ReservoirDataModel/Completions/RigTransmissibilityCondenser.cpp

@@ -123,40 +123,37 @@ double RigTransmissibilityCondenser::condensedTransmissibility(CellAddress exter
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::map<size_t, double>
+std::map<size_t, double> RigTransmissibilityCondenser::scaleMatrixToFracTransByMatrixWellDP(
-    RigTransmissibilityCondenser::scaleMatrixToFracTransByMatrixWellDP(const RigActiveCellInfo*   actCellInfo,
+    const RigActiveCellInfo* actCellInfo, double currentWellPressure, const std::vector<double>& currentMatrixPressures,
-                                                                       double                     initialWellPressure,
+    double* minPressureDrop, double* maxPressureDrop)
-                                                                       double                     currentWellPressure,
-                                                                       const std::vector<double>& initialMatrixPressures,
-                                                                       const std::vector<double>& currentMatrixPressures,
-                                                                       bool                       normalizeByMax)
 {
-    CVF_ASSERT(initialMatrixPressures.size() == currentMatrixPressures.size());
-
     std::map<size_t, double> originalLumpedMatrixToFractureTrans; // Sum(T_mf)
 
-    double maxInitialDeltaPressure = 0.0;
+    double epsilonDeltaPressure = 1.0e-6;
-    if (normalizeByMax)
-    {
-        for (auto it = m_neighborTransmissibilities.begin(); it != m_neighborTransmissibilities.end(); ++it)
-        {
-            if (it->first.m_cellIndexSpace == CellAddress::STIMPLAN)
-            {
-                for (auto jt = it->second.begin(); jt != it->second.end(); ++jt)
-                {
-                    if (jt->first.m_cellIndexSpace == CellAddress::ECLIPSE)
-                    {
-                        size_t globalMatrixCellIdx = jt->first.m_globalCellIdx;
-                        size_t eclipseResultIndex  = actCellInfo->cellResultIndex(globalMatrixCellIdx);
-                        CVF_ASSERT(eclipseResultIndex < currentMatrixPressures.size());
 
-                        double initialDeltaPressure = initialMatrixPressures[eclipseResultIndex] - initialWellPressure;
+    double minNonZeroDeltaPressure =  std::numeric_limits<double>::infinity();
-                        maxInitialDeltaPressure     = std::max(maxInitialDeltaPressure, initialDeltaPressure);
+    double maxNonZeroDeltaPressure = -std::numeric_limits<double>::infinity();
-                    }
+
+    for (auto it = m_neighborTransmissibilities.begin(); it != m_neighborTransmissibilities.end(); ++it)
+    {
+        if (it->first.m_cellIndexSpace == CellAddress::STIMPLAN)
+        {
+            for (auto jt = it->second.begin(); jt != it->second.end(); ++jt)
+            {
+                if (jt->first.m_cellIndexSpace == CellAddress::ECLIPSE)
+                {
+                    size_t globalMatrixCellIdx = jt->first.m_globalCellIdx;
+                    size_t eclipseResultIndex  = actCellInfo->cellResultIndex(globalMatrixCellIdx);
+                    CVF_ASSERT(eclipseResultIndex < currentMatrixPressures.size());
+                    double unsignedDeltaPressure = std::abs(currentMatrixPressures[eclipseResultIndex] - currentWellPressure);
+                    double nonZeroDeltaPressure  = std::max(epsilonDeltaPressure, unsignedDeltaPressure);
+                    maxNonZeroDeltaPressure      = std::max(maxNonZeroDeltaPressure, nonZeroDeltaPressure);
+                    minNonZeroDeltaPressure      = std::min(minNonZeroDeltaPressure, nonZeroDeltaPressure);
                 }
             }
         }
     }
+
     for (auto it = m_neighborTransmissibilities.begin(); it != m_neighborTransmissibilities.end(); ++it)
     {
         if (it->first.m_cellIndexSpace == CellAddress::STIMPLAN)
@@ -171,20 +168,24 @@ std::map<size_t, double>
 
                     originalLumpedMatrixToFractureTrans[globalMatrixCellIdx] += jt->second;
 
-                    double initialDeltaPressure = initialMatrixPressures[eclipseResultIndex] - initialWellPressure;
+                    double unsignedDeltaPressure = std::abs(currentMatrixPressures[eclipseResultIndex] - currentWellPressure);
-                    double currentDeltaPressure = currentMatrixPressures[eclipseResultIndex] - currentWellPressure;
+                    double nonZeroDeltaPressure = std::max(epsilonDeltaPressure, unsignedDeltaPressure);
-                    if (normalizeByMax)
+
-                    {
+                    jt->second *= nonZeroDeltaPressure / maxNonZeroDeltaPressure;
-                        jt->second *= currentDeltaPressure / maxInitialDeltaPressure;
-                    }
-                    else
-                    {
-                        jt->second *= currentDeltaPressure / initialDeltaPressure;
-                    }
                 }
             }
         }
     }
+
+    if (minPressureDrop && minNonZeroDeltaPressure != std::numeric_limits<double>::infinity())
+    {
+        *minPressureDrop = minNonZeroDeltaPressure;
+    }
+    if (maxPressureDrop && maxNonZeroDeltaPressure != std::numeric_limits<double>::infinity())
+    {
+        *maxPressureDrop = maxNonZeroDeltaPressure;
+    }
+
     return originalLumpedMatrixToFractureTrans;
 }
 

ApplicationCode/ReservoirDataModel/Completions/RigTransmissibilityCondenser.h

@@ -95,12 +95,7 @@ public:
     std::string neighborTransDebugOutput(const RigMainGrid* mainGrid, const RigFractureGrid* fractureGrid);
     std::string condensedTransDebugOutput(const RigMainGrid* mainGrid, const RigFractureGrid* fractureGrid);
 
-    std::map<size_t, double> scaleMatrixToFracTransByMatrixWellDP(const RigActiveCellInfo*   actCellInfo,
+    std::map<size_t, double> scaleMatrixToFracTransByMatrixWellDP(const RigActiveCellInfo* actCellInfo, double currentWellPressure, const std::vector<double>& currentMatrixPressures, double* minPressureDrop, double* maxPressureDrop);
-                                                                  double                     initialWellPressure,
-                                                                  double                     currentWellPressure,
-                                                                  const std::vector<double>& initialMatrixPressures,
-                                                                  const std::vector<double>& currentMatrixPressures,
-                                                                  bool                       normalizeByMax);
 
     std::map<size_t, double> calculateFicticiousFractureToWellTransmissibilities();
     std::map<size_t, double>