#2402 Fracture : Add support for multiple conductivities on a template

ApplicationCode/Application/RiaFractureDefines.h

@@ -22,5 +22,5 @@
 
 namespace RiaDefines
 {
-static QString conductivityResultName();
+QString conductivityResultName();
 };

ApplicationCode/ModelVisualization/RivWellFracturePartMgr.cpp

@@ -275,7 +275,7 @@ const QString RivWellFracturePartMgr::resultInfoText(const RimEclipseView& activ
 
         // Conductivity
         text.append("Result value: ");
-        text.append(stimPlanColors->resultName() + " ");
+        text.append(stimPlanColors->uiResultName() + " ");
         text.append(condValueText + "\n");
 
         // Cell index
@@ -386,7 +386,7 @@ cvf::ref<cvf::Part> RivWellFracturePartMgr::createEllipseSurfacePart(const RimEc
         { 
             cvf::Color3ub resultColor = cvf::Color3ub(RiaColorTables::undefinedCellColor());
 
-            if (activeView.stimPlanColors->resultName().startsWith("CONDUCTIVITY", Qt::CaseInsensitive))
+            if (activeView.stimPlanColors->uiResultName().startsWith("CONDUCTIVITY", Qt::CaseInsensitive))
             {
                 RimEllipseFractureTemplate* ellipseFractureTemplate = dynamic_cast<RimEllipseFractureTemplate*>(m_rimFracture->fractureTemplate()); 
                 if (ellipseFractureTemplate)
@@ -455,7 +455,7 @@ cvf::ref<cvf::Part> RivWellFracturePartMgr::createStimPlanColorInterpolatedSurfa
         std::vector<double> perNodeResultValues(nodeCoords.size(), HUGE_VAL);
         {
             size_t idx = 0;
-            const std::vector<std::vector<double> > dataToPlot = stimPlanFracTemplate->resultValues(activeView.stimPlanColors->resultName(), activeView.stimPlanColors->unit(), stimPlanFracTemplate->activeTimeStepIndex());
+            const std::vector<std::vector<double> > dataToPlot = stimPlanFracTemplate->resultValues(activeView.stimPlanColors->uiResultName(), activeView.stimPlanColors->unit(), stimPlanFracTemplate->activeTimeStepIndex());
             for (const std::vector<double>& unmirroredDataAtDepth : dataToPlot)
             {
                 const std::vector<double> mirroredValuesAtDepth = mirrorDataAtSingleDepth(unmirroredDataAtDepth);
@@ -583,7 +583,7 @@ cvf::ref<cvf::Part> RivWellFracturePartMgr::createStimPlanElementColorSurfacePar
 
             scalarMapper = legendConfig->scalarMapper();
 
-            QString resultNameFromColors = activeView.stimPlanColors->resultName();
+            QString resultNameFromColors = activeView.stimPlanColors->uiResultName();
             QString resultUnitFromColors = activeView.stimPlanColors->unit();
 
             std::vector<double> prCellResults = stimPlanFracTemplate->fractureGridResults(resultNameFromColors,
@@ -897,7 +897,7 @@ cvf::ref<cvf::DrawableGeo> RivWellFracturePartMgr::createStimPlanMeshDrawable(Ri
     std::vector<RigFractureCell> stimPlanCells = stimPlanFracTemplate->fractureGrid()->fractureCells();
     std::vector<cvf::Vec3f> stimPlanMeshVertices;
 
-    QString resultNameFromColors = activeView.stimPlanColors->resultName();
+    QString resultNameFromColors = activeView.stimPlanColors->uiResultName();
     QString resultUnitFromColors = activeView.stimPlanColors->unit();
 
     std::vector<double> prCellResults = stimPlanFracTemplate->fractureGridResults(resultNameFromColors,

ApplicationCode/ProjectDataModel/Completions/RimFractureTemplateCollection.cpp

@@ -65,7 +65,7 @@ std::vector<std::pair<QString, QString> > RimFractureTemplateCollection::stimPla
         auto stimPlanFracture = dynamic_cast<const RimStimPlanFractureTemplate*>(f);
         if (stimPlanFracture)
         {
-            std::vector<std::pair<QString, QString> > namesAndUnits = stimPlanFracture->resultNamesWithUnit();
+            std::vector<std::pair<QString, QString> > namesAndUnits = stimPlanFracture->uiResultNamesWithUnit();
 
             for (auto nameAndUnit : namesAndUnits)
             {
@@ -82,7 +82,7 @@ std::vector<std::pair<QString, QString> > RimFractureTemplateCollection::stimPla
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimFractureTemplateCollection::computeMinMax(const QString& resultName, const QString& unit, double* minValue,
+void RimFractureTemplateCollection::computeMinMax(const QString& uiResultName, const QString& unit, double* minValue,
                                                   double* maxValue, double* posClosestToZero, double* negClosestToZero) const
 {
     MinMaxAccumulator minMaxAccumulator;
@@ -92,7 +92,7 @@ void RimFractureTemplateCollection::computeMinMax(const QString& resultName, con
     {
         if (f)
         {
-            f->appendDataToResultStatistics(resultName, unit, minMaxAccumulator, posNegAccumulator);
+            f->appendDataToResultStatistics(uiResultName, unit, minMaxAccumulator, posNegAccumulator);
         }
     }
 

ApplicationCode/ProjectDataModel/Completions/RimFractureTemplateCollection.h

@@ -42,7 +42,7 @@ public:
     caf::PdmField< RiaEclipseUnitTools::UnitSystemType >    defaultUnitsForFracTemplates;
 
     std::vector<std::pair<QString, QString> >   stimPlanResultNamesAndUnits() const;
-    void                                        computeMinMax(const QString& resultName, const QString& unit, double* minValue, double* maxValue, double* posClosestToZero, double* negClosestToZero) const;
+    void                                        computeMinMax(const QString& uiResultName, const QString& unit, double* minValue, double* maxValue, double* posClosestToZero, double* negClosestToZero) const;
 
     void                                        deleteFractureDefinitions();
     void                                        loadAndUpdateData();

ApplicationCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.cpp

@@ -19,6 +19,7 @@
 #include "RimStimPlanFractureTemplate.h"
 
 #include "RiaApplication.h"
+#include "RiaFractureDefines.h"
 #include "RiaLogging.h"
 
 #include "RifStimPlanXmlReader.h"
@@ -73,6 +74,7 @@ RimStimPlanFractureTemplate::RimStimPlanFractureTemplate(void)
     CAF_PDM_InitField(&m_activeTimeStepIndex,           "ActiveTimeStepIndex", 0, "Active TimeStep Index", "", "", "");
     CAF_PDM_InitField(&m_showStimPlanMesh,              "ShowStimPlanMesh", true, "Show StimPlan Mesh", "", "", "");
     CAF_PDM_InitField(&m_conductivityScalingFactor,     "ConductivityFactor", 1.0, "Conductivity Scaling Factor", "", "The conductivity values read from file will be scaled with this parameters", "");
+    CAF_PDM_InitField(&m_conductivityResultNameOnFile,  "ConductivityResultName", QString(""), "Active Conductivity Result Name", "", "", "");
 
     m_fractureGrid = new RigFractureGrid();
 }
@@ -130,13 +132,13 @@ void RimStimPlanFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* ch
         || &m_activeTimeStepIndex == changedField 
         || &m_showStimPlanMesh == changedField
         || &m_conductivityScalingFactor == changedField
-        || &m_stimPlanFileName == changedField)
+        || &m_stimPlanFileName == changedField
+        || &m_conductivityResultNameOnFile == changedField)
     {
         RimProject* proj;
         this->firstAncestorOrThisOfType(proj);
         if (proj)
         {
-            //Regenerate geometry
             proj->createDisplayModelAndRedrawAllViews();
         }
     }
@@ -208,7 +210,7 @@ void RimStimPlanFractureTemplate::setDefaultsBasedOnXMLfile()
 bool RimStimPlanFractureTemplate::setBorderPolygonResultNameToDefault()
 {
     // first option: Width
-    for (std::pair<QString, QString> property : resultNamesWithUnit())
+    for (std::pair<QString, QString> property : uiResultNamesWithUnit())
     {
         if (property.first == "WIDTH")
         {
@@ -225,9 +227,9 @@ bool RimStimPlanFractureTemplate::setBorderPolygonResultNameToDefault()
     }
 
     // else: Set to first property
-    if (resultNamesWithUnit().size() > 0)
+    if (uiResultNamesWithUnit().size() > 0)
     {
-        m_borderPolygonResultName = resultNamesWithUnit()[0].first;
+        m_borderPolygonResultName = uiResultNamesWithUnit()[0].first;
         return true;
     }
     return false;
@@ -269,13 +271,12 @@ QList<caf::PdmOptionItemInfo> RimStimPlanFractureTemplate::calculateValueOptions
 
     if (fieldNeedingOptions == &m_borderPolygonResultName)
     {
-        for (std::pair<QString, QString> nameUnit : resultNamesWithUnit())
+        for (std::pair<QString, QString> nameUnit : uiResultNamesWithUnit())
         {
             //options.push_back(caf::PdmOptionItemInfo(nameUnit.first + " [" + nameUnit.second + "]", nameUnit.first + " " + nameUnit.second));
             options.push_back(caf::PdmOptionItemInfo(nameUnit.first, nameUnit.first));
         }
     }
-
     else if (fieldNeedingOptions == &m_activeTimeStepIndex)
     {
         std::vector<double> timeValues = timeSteps();
@@ -287,6 +288,17 @@ QList<caf::PdmOptionItemInfo> RimStimPlanFractureTemplate::calculateValueOptions
         }
 
     }
+    else if (fieldNeedingOptions == &m_conductivityResultNameOnFile)
+    {
+        if (m_stimPlanFractureDefinitionData.notNull())
+        {
+            QStringList conductivityResultNames = m_stimPlanFractureDefinitionData->conductivityResultNames();
+            for (const auto& resultName : conductivityResultNames)
+            {
+                options.push_back(caf::PdmOptionItemInfo(resultName, resultName));
+            }
+        }
+    }
 
     return options;
 
@@ -315,7 +327,7 @@ QString RimStimPlanFractureTemplate::getUnitForStimPlanParameter(QString paramet
     bool found = false;
     bool foundMultiple = false;
 
-    for (std::pair<QString, QString> nameUnit : resultNamesWithUnit())
+    for (std::pair<QString, QString> nameUnit : uiResultNamesWithUnit())
     {
         if (nameUnit.first == parameterName)
         {
@@ -331,6 +343,25 @@ QString RimStimPlanFractureTemplate::getUnitForStimPlanParameter(QString paramet
 }
 
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+QString RimStimPlanFractureTemplate::mapUiResultNameToFileResultName(const QString& uiResultName) const
+{
+    QString fileResultName;
+
+    if (uiResultName == RiaDefines::conductivityResultName())
+    {
+        fileResultName = m_conductivityResultNameOnFile();
+    }
+    else
+    {
+        fileResultName = uiResultName;
+    }
+
+    return fileResultName;
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -347,24 +378,50 @@ std::vector<double> RimStimPlanFractureTemplate::timeSteps()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-std::vector<std::pair<QString, QString> > RimStimPlanFractureTemplate::resultNamesWithUnit() const
+std::vector<std::pair<QString, QString> > RimStimPlanFractureTemplate::uiResultNamesWithUnit() const
 {
-    std::vector<std::pair<QString, QString> >  propertyNamesUnits;
+    std::vector<std::pair<QString, QString> > propertyNamesAndUnits;
+    
     if (m_stimPlanFractureDefinitionData.notNull())
     {
-        propertyNamesUnits = m_stimPlanFractureDefinitionData->getStimPlanPropertyNamesUnits();
+        QString conductivityUnit = "mD/s";
+
+        std::vector<std::pair<QString, QString> > tmp;
+
+        std::vector<std::pair<QString, QString> > propertyNamesUnitsOnFile = m_stimPlanFractureDefinitionData->getStimPlanPropertyNamesUnits();
+        for (const auto& nameUnitPair : propertyNamesUnitsOnFile)
+        {
+            if (nameUnitPair.first.contains("conductivity", Qt::CaseInsensitive))
+            {
+                conductivityUnit = nameUnitPair.second;
             }
-    return propertyNamesUnits;
+            else
+            {
+                tmp.push_back(nameUnitPair);
+            }
+        }
+
+        propertyNamesAndUnits.push_back(std::make_pair(RiaDefines::conductivityResultName(), conductivityUnit));
+
+        for (const auto& nameUnitPair : tmp)
+        {
+            propertyNamesAndUnits.push_back(nameUnitPair);
+        }
+    }
+
+    return propertyNamesAndUnits;
 }
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-std::vector<std::vector<double>> RimStimPlanFractureTemplate::resultValues(const QString& resultName, const QString& unitName, size_t timeStepIndex) const
+std::vector<std::vector<double>> RimStimPlanFractureTemplate::resultValues(const QString& uiResultName, const QString& unitName, size_t timeStepIndex) const
 {
     if (m_stimPlanFractureDefinitionData.notNull())
     {
-        return m_stimPlanFractureDefinitionData->getDataAtTimeIndex(resultName, unitName, timeStepIndex);
+        QString fileResultName = mapUiResultNameToFileResultName(uiResultName);
+
+        return m_stimPlanFractureDefinitionData->getDataAtTimeIndex(fileResultName, unitName, timeStepIndex);
     }
 
     return std::vector<std::vector<double>>();
@@ -373,11 +430,13 @@ std::vector<std::vector<double>> RimStimPlanFractureTemplate::resultValues(const
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimStimPlanFractureTemplate::fractureGridResults(const QString& resultName, const QString& unitName, size_t timeStepIndex) const
+std::vector<double> RimStimPlanFractureTemplate::fractureGridResults(const QString& uiResultName, const QString& unitName, size_t timeStepIndex) const
 {
     if (m_stimPlanFractureDefinitionData.notNull())
     {
-        return m_stimPlanFractureDefinitionData->fractureGridResults(resultName, unitName, timeStepIndex);
+        QString fileResultName = mapUiResultNameToFileResultName(uiResultName);
+
+        return m_stimPlanFractureDefinitionData->fractureGridResults(fileResultName, unitName, timeStepIndex);
     }
 
    return std::vector<double>();
@@ -400,13 +459,15 @@ bool RimStimPlanFractureTemplate::hasConductivity() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimStimPlanFractureTemplate::appendDataToResultStatistics(const QString& resultName, const QString& unit,
+void RimStimPlanFractureTemplate::appendDataToResultStatistics(const QString& uiResultName, const QString& unit,
                                                                 MinMaxAccumulator& minMaxAccumulator,
                                                                 PosNegAccumulator& posNegAccumulator) const
 {
     if (m_stimPlanFractureDefinitionData.notNull())
     {
-        m_stimPlanFractureDefinitionData->appendDataToResultStatistics(resultName, unit, minMaxAccumulator, posNegAccumulator);
+        QString fileResultName = mapUiResultNameToFileResultName(uiResultName);
+
+        m_stimPlanFractureDefinitionData->appendDataToResultStatistics(fileResultName, unit, minMaxAccumulator, posNegAccumulator);
     }
 }
 
@@ -427,7 +488,8 @@ void RimStimPlanFractureTemplate::updateFractureGrid()
 
     if (m_stimPlanFractureDefinitionData.notNull())
     {
-        m_fractureGrid = m_stimPlanFractureDefinitionData->createFractureGrid(m_activeTimeStepIndex,
+        m_fractureGrid = m_stimPlanFractureDefinitionData->createFractureGrid(m_conductivityResultNameOnFile,
+                                                                              m_activeTimeStepIndex,
                                                                               fractureTemplateUnit,
                                                                               m_wellPathDepthAtFracture);
     }
@@ -504,6 +566,7 @@ void RimStimPlanFractureTemplate::defineUiOrdering(QString uiConfigName, caf::Pd
     m_fractureContainment()->defineUiOrdering(uiConfigName, *trGr);
 
     caf::PdmUiGroup* propertyGroup = uiOrdering.addNewGroup("Properties");
+    propertyGroup->add(&m_conductivityResultNameOnFile);
     propertyGroup->add(&m_conductivityScalingFactor);
     propertyGroup->add(&conductivityType);
     propertyGroup->add(&skinFactor);

ApplicationCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.h

@@ -77,12 +77,12 @@ public:
     // Result Access
 
     std::vector<double>                     timeSteps();
-    std::vector<std::pair<QString, QString> > resultNamesWithUnit() const;
+    std::vector<std::pair<QString, QString> > uiResultNamesWithUnit() const;
-    std::vector<std::vector<double>>        resultValues(const QString& resultName, const QString& unitName, size_t timeStepIndex) const;
+    std::vector<std::vector<double>>        resultValues(const QString& uiResultName, const QString& unitName, size_t timeStepIndex) const;
     std::vector<double>                     fractureGridResults(const QString& resultName, const QString& unitName, size_t timeStepIndex) const;
     bool                                    hasConductivity() const;
 
-    virtual void appendDataToResultStatistics(const QString& resultName, const QString& unit,
+    virtual void appendDataToResultStatistics(const QString& uiResultName, const QString& unit,
                                                MinMaxAccumulator& minMaxAccumulator,
                                                PosNegAccumulator& posNegAccumulator) const override;
 
@@ -99,7 +99,11 @@ private:
     void                                    setDepthOfWellPathAtFracture();
     QString                                 getUnitForStimPlanParameter(QString parameterName);
 
+    QString                                 mapUiResultNameToFileResultName(const QString& uiResultName) const;
+
+private:
     caf::PdmField<int>                      m_activeTimeStepIndex;
+    caf::PdmField<QString>                  m_conductivityResultNameOnFile;
     caf::PdmField<bool>                     m_showStimPlanMesh;
 
     caf::PdmField<double>                   m_wellPathDepthAtFracture;

ApplicationCode/ProjectDataModel/RimStimPlanColors.cpp

@@ -199,7 +199,7 @@ RimLegendConfig* RimStimPlanColors::activeLegend() const
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-QString RimStimPlanColors::resultName() const
+QString RimStimPlanColors::uiResultName() const
 {
     return RimStimPlanColors::toResultName(m_resultNameAndUnit());
 }
@@ -243,7 +243,7 @@ void RimStimPlanColors::updateLegendData()
 
         RimFractureTemplateCollection* fracTemplateColl = fractureTemplateCollection();
 
-        fracTemplateColl->computeMinMax(resultName(), unit(), &minValue, &maxValue, &posClosestToZero, &negClosestToZero);
+        fracTemplateColl->computeMinMax(uiResultName(), unit(), &minValue, &maxValue, &posClosestToZero, &negClosestToZero);
 
         if (minValue != HUGE_VAL)
         {

ApplicationCode/ProjectDataModel/RimStimPlanColors.h

@@ -49,7 +49,7 @@ public:
     virtual ~RimStimPlanColors();
 
     RimLegendConfig*    activeLegend() const;
-    QString             resultName() const;
+    QString             uiResultName() const;
     void                setDefaultResultNameForStimPlan();
     QString             unit() const;
     cvf::Color3f        defaultColor() const;

ApplicationCode/ReservoirDataModel/RigStimPlanFractureDefinition.cpp

@@ -147,7 +147,8 @@ std::vector<std::vector<double>> RigStimPlanFractureDefinition::getMirroredDataA
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-cvf::ref<RigFractureGrid> RigStimPlanFractureDefinition::createFractureGrid(int m_activeTimeStepIndex, 
+cvf::ref<RigFractureGrid> RigStimPlanFractureDefinition::createFractureGrid(const QString& resultName,
+                                                                            int m_activeTimeStepIndex, 
                                                                             RiaEclipseUnitTools::UnitSystemType fractureTemplateUnit, 
                                                                             double m_wellPathDepthAtFracture)
 {
@@ -159,7 +160,7 @@ cvf::ref<RigFractureGrid> RigStimPlanFractureDefinition::createFractureGrid(int
     QString condUnit;
     if ( fractureTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC ) condUnit = "md-m";
     if ( fractureTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD )  condUnit = "md-ft";
-    std::vector<std::vector<double>> conductivityValuesAtTimeStep = this->getMirroredDataAtTimeIndex(this->conductivityResultName(), 
+    std::vector<std::vector<double>> conductivityValuesAtTimeStep = this->getMirroredDataAtTimeIndex(resultName, 
                                                                                                      condUnit, 
                                                                                                      m_activeTimeStepIndex);
 
@@ -631,3 +632,21 @@ QString RigStimPlanFractureDefinition::conductivityResultName() const
     return "";
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+QStringList RigStimPlanFractureDefinition::conductivityResultNames() const
+{
+    QStringList resultNames;
+
+    for (const auto& stimPlanResult : m_stimPlanResults)
+    {
+        if (stimPlanResult.resultName.contains("conductivity", Qt::CaseInsensitive))
+        {
+            resultNames.push_back(stimPlanResult.resultName);
+        }
+    }
+
+    return resultNames;
+}
+

ApplicationCode/ReservoirDataModel/RigStimPlanFractureDefinition.h

@@ -69,12 +69,9 @@ public:
 
     std::vector<double>                       getNegAndPosXcoords() const;
     std::vector<double>                       adjustedDepthCoordsAroundWellPathPosition(double wellPathDepthAtFracture) const;
-    std::vector<std::vector<double>>          getMirroredDataAtTimeIndex(const QString& resultName,
-                                                                         const QString& unitName,
-                                                                         size_t timeStepIndex) const;
                                               
-                                              
+    cvf::ref<RigFractureGrid>                 createFractureGrid(const QString& resultName,
-    cvf::ref<RigFractureGrid>                 createFractureGrid(int m_activeTimeStepIndex,
+                                                                 int m_activeTimeStepIndex,
                                                                  RiaEclipseUnitTools::UnitSystemType fractureTemplateUnit,
                                                                  double m_wellPathDepthAtFracture);
                                               
@@ -110,15 +107,23 @@ public:
                                                                           PosNegAccumulator& posNegAccumulator) const;
 
     QString                                   conductivityResultName() const;
+    QStringList                               conductivityResultNames() const;
     
     // Setup                          
     void                                      reorderYgridToDepths();
+
 private:                                      
     bool                                      timeStepExisist(double timeStepValue);
     size_t                                    getTimeStepIndex(double timeStepValue);
     size_t                                    resultIndex(const QString& resultName, const QString& unit) const;
     size_t                                    mirroredGridXCount() const { return m_gridXs.size() ? m_gridXs.size() + m_gridXs.size() - 1  : 0 ;}
 
+    std::vector<std::vector<double>>          getMirroredDataAtTimeIndex(const QString& resultName,
+                                                                        const QString& unitName,
+                                                                        size_t timeStepIndex) const;
+                                              
+
+private:
     RiaEclipseUnitTools::UnitSystem           m_unitSet;
     std::vector<double>                       m_gridXs;
     std::vector<double>                       m_gridYs;