Merge pull request #6225 from OPM/fracture-model-plot-pressure-curves

Fracture model plot pressure curves

ApplicationCode/Application/RiaFractureModelDefines.cpp

@@ -23,6 +23,7 @@ namespace caf
 template <>
 void AppEnum<RiaDefines::CurveProperty>::setUp()
 {
+    addItem( RiaDefines::CurveProperty::UNDEFINED, "UNDEFINED", "Undefined" );
     addItem( RiaDefines::CurveProperty::FACIES, "FACIES", "Facies" );
     addItem( RiaDefines::CurveProperty::LAYERS, "LAYERS", "Layers" );
     addItem( RiaDefines::CurveProperty::POROSITY, "POROSITY", "Porosity" );
@@ -40,6 +41,6 @@ void AppEnum<RiaDefines::CurveProperty>::setUp()
     addItem( RiaDefines::CurveProperty::K0, "K0", "k0" );
     addItem( RiaDefines::CurveProperty::FLUID_LOSS_COEFFICIENT, "FLUID_LOSS_COEFFICIENT", "Fluid Loss Coefficient" );
     addItem( RiaDefines::CurveProperty::SPURT_LOSS, "SPURT_LOSS", "Spurt Loss" );
-    setDefault( RiaDefines::CurveProperty::FACIES );
+    setDefault( RiaDefines::CurveProperty::UNDEFINED );
 }
 }; // namespace caf

ApplicationCode/Application/RiaFractureModelDefines.h

@@ -26,6 +26,7 @@ namespace RiaDefines
 {
 enum class CurveProperty
 {
+    UNDEFINED,
     FACIES,
     LAYERS,
     POROSITY,

ApplicationCode/Commands/CompletionCommands/RicNewFractureModelPlotFeature.cpp

@@ -101,13 +101,13 @@ RimFractureModelPlot*
         plots["Pressure"] = {std::make_tuple( "PRESSURE",
                                               RiaDefines::ResultCatType::DYNAMIC_NATIVE,
                                               RimFractureModelCurve::MissingValueStrategy::LINEAR_INTERPOLATION,
-                                              false,
+                                              true,
-                                              RiaDefines::CurveProperty::PRESSURE ),
+                                              RiaDefines::CurveProperty::INITIAL_PRESSURE ),
                              std::make_tuple( "PRESSURE",
                                               RiaDefines::ResultCatType::DYNAMIC_NATIVE,
-                                              RimFractureModelCurve::MissingValueStrategy::LINEAR_INTERPOLATION,
+                                              RimFractureModelCurve::MissingValueStrategy::OTHER_CURVE_PROPERTY,
-                                              true,
+                                              false,
-                                              RiaDefines::CurveProperty::INITIAL_PRESSURE )};
+                                              RiaDefines::CurveProperty::PRESSURE )};
 
         plots["Permeability"] = {std::make_tuple( "PERMX",
                                                   RiaDefines::ResultCatType::STATIC_NATIVE,
@@ -383,6 +383,11 @@ void RicNewFractureModelPlotFeature::createParametersTrack( RimFractureModelPlot
             curve->setCurrentTimeStep( timeStep );
         }
 
+        if ( curveProperty == RiaDefines::CurveProperty::INITIAL_PRESSURE )
+        {
+            curve->setBurdenStrategy( RimFractureModelCurve::BurdenStrategy::GRADIENT );
+        }
+
         plotTrack->addCurve( curve );
         curve->loadDataAndUpdate( true );
 

ApplicationCode/Commands/RicExportFractureModelPlotToFileFeature.cpp

@@ -72,6 +72,6 @@ void RicExportFractureModelPlotToFileFeature::onActionTriggered( bool isChecked
 //--------------------------------------------------------------------------------------------------
 void RicExportFractureModelPlotToFileFeature::setupActionLook( QAction* actionToSetup )
 {
-    actionToSetup->setText( "Export Fracture Model Plot to File" );
+    actionToSetup->setText( "Export Fracture Model to File" );
     actionToSetup->setIcon( QIcon( ":/Save.png" ) );
 }

ApplicationCode/ProjectDataModel/Completions/RimFractureModel.cpp

@@ -22,6 +22,7 @@
 #include "RiaCompletionTypeCalculationScheduler.h"
 #include "RiaEclipseUnitTools.h"
 #include "RiaFractureDefines.h"
+#include "RiaFractureModelDefines.h"
 #include "RiaLogging.h"
 
 #include "Riu3DMainWindowTools.h"
@@ -125,12 +126,20 @@ RimFractureModel::RimFractureModel()
     CAF_PDM_InitFieldNoDefault( &m_overburdenFacies, "OverburdenFacies", "Overburden Facies", "", "", "" );
     CAF_PDM_InitField( &m_overburdenPorosity, "OverburdenPorosity", 0.0, "Overburden Porosity", "", "", "" );
     CAF_PDM_InitField( &m_overburdenPermeability, "OverburdenPermeability", 10.0e-6, "Overburden Permeability", "", "", "" );
+    CAF_PDM_InitField( &m_overburdenFluidDensity, "OverburdenFluidDensity", 1.03, "Overburden Fluid Density [g/cm^3]", "", "", "" );
 
     CAF_PDM_InitField( &m_underburdenHeight, "UnderburdenHeight", 50.0, "Underburden Height", "", "", "" );
     CAF_PDM_InitFieldNoDefault( &m_underburdenFormation, "UnderburdenFormation", "Underburden Formation", "", "", "" );
     CAF_PDM_InitFieldNoDefault( &m_underburdenFacies, "UnderburdenFacies", "Underburden Facies", "", "", "" );
     CAF_PDM_InitField( &m_underburdenPorosity, "UnderburdenPorosity", 0.0, "Underburden Porosity", "", "", "" );
     CAF_PDM_InitField( &m_underburdenPermeability, "UnderburdenPermeability", 10.0e-6, "Underburden Permeability", "", "", "" );
+    CAF_PDM_InitField( &m_underburdenFluidDensity,
+                       "UnderburdenFluidDensity",
+                       1.03,
+                       "Underburden Fluid Density [g/cm^3]",
+                       "",
+                       "",
+                       "" );
 
     CAF_PDM_InitFieldNoDefault( &m_elasticProperties, "ElasticProperties", "Elastic Properties", "", "", "" );
     m_elasticProperties.uiCapability()->setUiHidden( true );
@@ -591,6 +600,19 @@ double RimFractureModel::getDefaultForMissingValue( const QString& keyword ) con
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RiaDefines::CurveProperty RimFractureModel::getDefaultPropertyForMissingValues( const QString& keyword ) const
+{
+    if ( keyword == QString( "PRESSURE" ) )
+    {
+        return RiaDefines::CurveProperty::INITIAL_PRESSURE;
+    }
+
+    return RiaDefines::CurveProperty::UNDEFINED;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -631,6 +653,38 @@ double RimFractureModel::getDefaultForMissingUnderburdenValue( const QString& ke
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimFractureModel::getOverburdenGradient( const QString& keyword ) const
+{
+    if ( keyword == QString( "PRESSURE" ) )
+    {
+        return m_overburdenFluidDensity * 9.81 * 1000.0 / 1.0e6;
+    }
+    else
+    {
+        RiaLogging::error( QString( "Missing overburden gradient for %1." ).arg( keyword ) );
+        return std::numeric_limits<double>::infinity();
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimFractureModel::getUnderburdenGradient( const QString& keyword ) const
+{
+    if ( keyword == QString( "PRESSURE" ) )
+    {
+        return m_underburdenFluidDensity * 9.81 * 1000.0 / 1.0e6;
+    }
+    else
+    {
+        RiaLogging::error( QString( "Missing underburden gradient for %1." ).arg( keyword ) );
+        return std::numeric_limits<double>::infinity();
+    }
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ProjectDataModel/Completions/RimFractureModel.h

@@ -19,6 +19,7 @@
 #pragma once
 
 #include "RiaEclipseUnitTools.h"
+#include "RiaFractureModelDefines.h"
 
 #include "RimCheckableNamedObject.h"
 #include "RimWellPathComponentInterface.h"
@@ -100,10 +101,14 @@ public:
     void                  setElasticProperties( RimElasticProperties* elasticProperties );
     RimElasticProperties* elasticProperties() const;
 
-    double getDefaultForMissingOverburdenValue( const QString& keyword ) const;
+    RiaDefines::CurveProperty getDefaultPropertyForMissingValues( const QString& keyword ) const;
-    double getDefaultForMissingUnderburdenValue( const QString& keyword ) const;
+    double                    getDefaultForMissingOverburdenValue( const QString& keyword ) const;
-    double getDefaultForMissingValue( const QString& keyword ) const;
+    double                    getDefaultForMissingUnderburdenValue( const QString& keyword ) const;
-    void   updateReferringPlots();
+    double                    getDefaultForMissingValue( const QString& keyword ) const;
+    double                    getOverburdenGradient( const QString& keyword ) const;
+    double                    getUnderburdenGradient( const QString& keyword ) const;
+
+    void updateReferringPlots();
 
 protected:
     void                          defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
@@ -137,9 +142,11 @@ protected:
     caf::PdmField<double>                       m_overburdenPermeability;
     caf::PdmField<QString>                      m_overburdenFormation;
     caf::PdmField<QString>                      m_overburdenFacies;
+    caf::PdmField<double>                       m_overburdenFluidDensity;
     caf::PdmField<double>                       m_underburdenHeight;
     caf::PdmField<double>                       m_underburdenPorosity;
     caf::PdmField<double>                       m_underburdenPermeability;
     caf::PdmField<QString>                      m_underburdenFormation;
     caf::PdmField<QString>                      m_underburdenFacies;
+    caf::PdmField<double>                       m_underburdenFluidDensity;
 };

ApplicationCode/ProjectDataModel/RimFractureModelCurve.cpp

@@ -18,6 +18,7 @@
 
 #include "RimFractureModelCurve.h"
 
+#include "RiaFractureModelDefines.h"
 #include "RigEclipseCaseData.h"
 #include "RigEclipseWellLogExtractor.h"
 #include "RigResultAccessorFactory.h"
@@ -61,9 +62,21 @@ void caf::AppEnum<RimFractureModelCurve::MissingValueStrategy>::setUp()
     addItem( RimFractureModelCurve::MissingValueStrategy::LINEAR_INTERPOLATION,
              "LINEAR_INTERPOLATION",
              "Linear interpolation" );
+    addItem( RimFractureModelCurve::MissingValueStrategy::OTHER_CURVE_PROPERTY,
+             "OTHER_CURVE_PROPERTY",
+             "Other Curve Property" );
 
     setDefault( RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE );
 }
+
+template <>
+void caf::AppEnum<RimFractureModelCurve::BurdenStrategy>::setUp()
+{
+    addItem( RimFractureModelCurve::BurdenStrategy::DEFAULT_VALUE, "DEFAULT_VALUE", "Default value" );
+    addItem( RimFractureModelCurve::BurdenStrategy::GRADIENT, "GRADIENT", "Gradient" );
+
+    setDefault( RimFractureModelCurve::BurdenStrategy::DEFAULT_VALUE );
+}
 }; // namespace caf
 
 //--------------------------------------------------------------------------------------------------
@@ -82,6 +95,11 @@ RimFractureModelCurve::RimFractureModelCurve()
     CAF_PDM_InitField( &m_missingValueStrategy, "MissingValueStrategy", defaultValue, "Missing Value Strategy", "", "", "" );
     m_missingValueStrategy.uiCapability()->setUiHidden( true );
 
+    caf::AppEnum<RimFractureModelCurve::BurdenStrategy> defaultBurdenValue =
+        RimFractureModelCurve::BurdenStrategy::DEFAULT_VALUE;
+    CAF_PDM_InitField( &m_burdenStrategy, "BurdenStrategy", defaultBurdenValue, "Burden Strategy", "", "", "" );
+    m_burdenStrategy.uiCapability()->setUiHidden( true );
+
     CAF_PDM_InitFieldNoDefault( &m_curveProperty, "CurveProperty", "Curve Property", "", "", "" );
     m_curveProperty.uiCapability()->setUiHidden( true );
 
@@ -193,27 +211,13 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
         double overburdenHeight = m_fractureModel->overburdenHeight();
         if ( overburdenHeight > 0.0 )
         {
-            double defaultOverburdenValue = std::numeric_limits<double>::infinity();
+            addOverburden( tvDepthValues, measuredDepthValues, values );
-            if ( m_missingValueStrategy() == RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE )
-            {
-                defaultOverburdenValue =
-                    m_fractureModel->getDefaultForMissingOverburdenValue( m_eclipseResultDefinition()->resultVariable() );
-            }
-
-            addOverburden( tvDepthValues, measuredDepthValues, values, overburdenHeight, defaultOverburdenValue );
         }
 
         double underburdenHeight = m_fractureModel->underburdenHeight();
         if ( underburdenHeight > 0.0 )
         {
-            double defaultUnderburdenValue = std::numeric_limits<double>::infinity();
+            addUnderburden( tvDepthValues, measuredDepthValues, values );
-            if ( m_missingValueStrategy() == RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE )
-            {
-                defaultUnderburdenValue =
-                    m_fractureModel->getDefaultForMissingUnderburdenValue( m_eclipseResultDefinition()->resultVariable() );
-            }
-
-            addUnderburden( tvDepthValues, measuredDepthValues, values, underburdenHeight, defaultUnderburdenValue );
         }
 
         if ( hasMissingValues( values ) )
@@ -239,7 +243,7 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
                     if ( overburdenHeight > 0.0 )
                     {
                         double defaultOverburdenValue = std::numeric_limits<double>::infinity();
-                        if ( m_missingValueStrategy() == RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE )
+                        if ( m_burdenStrategy() == RimFractureModelCurve::BurdenStrategy::DEFAULT_VALUE )
                         {
                             defaultOverburdenValue = m_fractureModel->getDefaultForMissingOverburdenValue(
                                 m_eclipseResultDefinition()->resultVariable() );
@@ -253,7 +257,7 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
                     if ( underburdenHeight > 0.0 )
                     {
                         double defaultUnderburdenValue = std::numeric_limits<double>::infinity();
-                        if ( m_missingValueStrategy() == RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE )
+                        if ( m_burdenStrategy() == RimFractureModelCurve::BurdenStrategy::DEFAULT_VALUE )
                         {
                             defaultUnderburdenValue = m_fractureModel->getDefaultForMissingUnderburdenValue(
                                 m_eclipseResultDefinition()->resultVariable() );
@@ -279,12 +283,36 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
                     replaceMissingValues( values, defaultValue );
                 }
             }
-            else
+            else if ( m_missingValueStrategy() == RimFractureModelCurve::MissingValueStrategy::LINEAR_INTERPOLATION )
             {
                 RiaLogging::info(
                     QString( "Interpolating missing values for %1" ).arg( m_eclipseResultDefinition()->resultVariable() ) );
                 RiaInterpolationTools::interpolateMissingValues( measuredDepthValues, values );
             }
+            else
+            {
+                // Get the missing data from other curve
+                RimFractureModelPlot* fractureModelPlot;
+                firstAncestorOrThisOfType( fractureModelPlot );
+                if ( !fractureModelPlot )
+                {
+                    RiaLogging::error( QString( "No replacement data found for fracture model curve." ) );
+                    return;
+                }
+
+                RiaDefines::CurveProperty replacementProperty = m_fractureModel->getDefaultPropertyForMissingValues(
+                    m_eclipseResultDefinition.value()->resultVariable() );
+
+                std::vector<double> initialValues;
+                fractureModelPlot->getCurvePropertyValues( replacementProperty, initialValues );
+                if ( initialValues.empty() )
+                {
+                    RiaLogging::error( QString( "Empty replacement data found for fracture model curve." ) );
+                    return;
+                }
+
+                replaceMissingValues( values, initialValues );
+            }
         }
 
         RiaEclipseUnitTools::UnitSystem eclipseUnitsType = eclipseCase->eclipseCaseData()->unitsType();
@@ -322,6 +350,14 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimFractureModelCurve::setBurdenStrategy( BurdenStrategy strategy )
+{
+    m_burdenStrategy = strategy;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -416,24 +452,40 @@ cvf::ref<RigResultAccessor>
 //--------------------------------------------------------------------------------------------------
 void RimFractureModelCurve::addOverburden( std::vector<double>& tvDepthValues,
                                            std::vector<double>& measuredDepthValues,
-                                           std::vector<double>& values,
+                                           std::vector<double>& values ) const
-                                           double               overburdenHeight,
-                                           double               defaultOverburdenValue )
 {
     if ( !values.empty() )
     {
+        double overburdenHeight    = m_fractureModel->overburdenHeight();
+        double tvdOverburdenBottom = tvDepthValues[0];
+        double tvdOverburdenTop    = tvdOverburdenBottom - overburdenHeight;
+
+        double overburdenTopValue    = std::numeric_limits<double>::infinity();
+        double overburdenBottomValue = std::numeric_limits<double>::infinity();
+        if ( m_burdenStrategy() == RimFractureModelCurve::BurdenStrategy::DEFAULT_VALUE )
+        {
+            overburdenTopValue =
+                m_fractureModel->getDefaultForMissingOverburdenValue( m_eclipseResultDefinition()->resultVariable() );
+            overburdenBottomValue = overburdenTopValue;
+        }
+        else
+        {
+            double gradient = m_fractureModel->getOverburdenGradient( m_eclipseResultDefinition()->resultVariable() );
+            overburdenBottomValue = values[0];
+            overburdenTopValue    = overburdenBottomValue + gradient * -overburdenHeight;
+        }
+
         // Prepend the new "fake" depth for start of overburden
-        double tvdTop = tvDepthValues[0];
+        tvDepthValues.insert( tvDepthValues.begin(), tvdOverburdenBottom );
-        tvDepthValues.insert( tvDepthValues.begin(), tvdTop );
+        tvDepthValues.insert( tvDepthValues.begin(), tvdOverburdenTop );
-        tvDepthValues.insert( tvDepthValues.begin(), tvdTop - overburdenHeight );
 
         // TODO: this is not always correct
         double mdTop = measuredDepthValues[0];
         measuredDepthValues.insert( measuredDepthValues.begin(), mdTop );
         measuredDepthValues.insert( measuredDepthValues.begin(), mdTop - overburdenHeight );
 
-        values.insert( values.begin(), defaultOverburdenValue );
+        values.insert( values.begin(), overburdenBottomValue );
-        values.insert( values.begin(), defaultOverburdenValue );
+        values.insert( values.begin(), overburdenTopValue );
     }
 }
 
@@ -442,18 +494,34 @@ void RimFractureModelCurve::addOverburden( std::vector<double>& tvDepthValues,
 //--------------------------------------------------------------------------------------------------
 void RimFractureModelCurve::addUnderburden( std::vector<double>& tvDepthValues,
                                             std::vector<double>& measuredDepthValues,
-                                            std::vector<double>& values,
+                                            std::vector<double>& values ) const
-                                            double               underburdenHeight,
-                                            double               defaultUnderburdenValue )
 {
     if ( !values.empty() )
     {
         size_t lastIndex = tvDepthValues.size() - 1;
 
+        double underburdenHeight    = m_fractureModel->underburdenHeight();
+        double tvdUnderburdenTop    = tvDepthValues[lastIndex];
+        double tvdUnderburdenBottom = tvdUnderburdenTop + underburdenHeight;
+
+        double underburdenTopValue    = std::numeric_limits<double>::infinity();
+        double underburdenBottomValue = std::numeric_limits<double>::infinity();
+        if ( m_burdenStrategy() == RimFractureModelCurve::BurdenStrategy::DEFAULT_VALUE )
+        {
+            underburdenTopValue =
+                m_fractureModel->getDefaultForMissingUnderburdenValue( m_eclipseResultDefinition()->resultVariable() );
+            underburdenBottomValue = underburdenTopValue;
+        }
+        else
+        {
+            double gradient = m_fractureModel->getUnderburdenGradient( m_eclipseResultDefinition()->resultVariable() );
+            underburdenTopValue    = values[lastIndex];
+            underburdenBottomValue = underburdenTopValue + gradient * underburdenHeight;
+        }
+
         // Append the new "fake" depth for start of underburden
-        double tvdBottom = tvDepthValues[lastIndex];
+        tvDepthValues.push_back( tvdUnderburdenTop );
-        tvDepthValues.push_back( tvdBottom );
+        tvDepthValues.push_back( tvdUnderburdenBottom );
-        tvDepthValues.push_back( tvdBottom + underburdenHeight );
 
         // Append the new "fake" md
         // TODO: check if this is correct???
@@ -461,7 +529,7 @@ void RimFractureModelCurve::addUnderburden( std::vector<double>& tvDepthValues,
         measuredDepthValues.push_back( mdBottom );
         measuredDepthValues.push_back( mdBottom + underburdenHeight );
 
-        values.push_back( defaultUnderburdenValue );
+        values.push_back( underburdenTopValue );
-        values.push_back( defaultUnderburdenValue );
+        values.push_back( underburdenBottomValue );
     }
 }

ApplicationCode/ProjectDataModel/RimFractureModelCurve.h

@@ -46,7 +46,14 @@ public:
     enum class MissingValueStrategy
     {
         DEFAULT_VALUE,
-        LINEAR_INTERPOLATION
+        LINEAR_INTERPOLATION,
+        OTHER_CURVE_PROPERTY
+    };
+
+    enum class BurdenStrategy
+    {
+        DEFAULT_VALUE,
+        GRADIENT
     };
 
     RimFractureModelCurve();
@@ -58,6 +65,8 @@ public:
 
     void setMissingValueStrategy( MissingValueStrategy strategy );
 
+    void setBurdenStrategy( BurdenStrategy strategy );
+
     void                      setCurveProperty( RiaDefines::CurveProperty ) override;
     RiaDefines::CurveProperty curveProperty() const override;
 
@@ -75,19 +84,16 @@ protected:
                                                            int                                timeStepIndex,
                                                            RimEclipseResultDefinition*        eclipseResultDefinition );
 
-    static void addOverburden( std::vector<double>& tvDepthValues,
+    void addOverburden( std::vector<double>& tvDepthValues,
-                               std::vector<double>& measuredDepthValues,
+                        std::vector<double>& measuredDepthValues,
-                               std::vector<double>& values,
+                        std::vector<double>& values ) const;
-                               double               overburdenHeight,
-                               double               defaultOverburdenValue );
 
-    static void addUnderburden( std::vector<double>& tvDepthValues,
+    void addUnderburden( std::vector<double>& tvDepthValues,
-                                std::vector<double>& measuredDepthValues,
+                         std::vector<double>& measuredDepthValues,
-                                std::vector<double>& values,
+                         std::vector<double>& values ) const;
-                                double               underburdenHeight,
-                                double               defaultUnderburdenValue );
 
     caf::PdmPtrField<RimFractureModel*>                    m_fractureModel;
     caf::PdmField<caf::AppEnum<MissingValueStrategy>>      m_missingValueStrategy;
+    caf::PdmField<caf::AppEnum<BurdenStrategy>>            m_burdenStrategy;
     caf::PdmField<caf::AppEnum<RiaDefines::CurveProperty>> m_curveProperty;
 };

ApplicationCode/ProjectDataModel/RimFractureModelPlot.cpp

@@ -47,6 +47,8 @@ RimFractureModelPlot::RimFractureModelPlot()
     CAF_PDM_InitFieldNoDefault( &m_fractureModel, "FractureModel", "Fracture Model", "", "", "" );
     m_fractureModel.uiCapability()->setUiTreeChildrenHidden( true );
     m_fractureModel.uiCapability()->setUiHidden( true );
+
+    setDeletable( true );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -93,25 +95,29 @@ void RimFractureModelPlot::applyDataSource()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelPlot::getPorosityValues( std::vector<double>& values ) const
+void RimFractureModelPlot::getCurvePropertyValues( RiaDefines::CurveProperty curveProperty, std::vector<double>& values ) const
 {
-    RimWellLogExtractionCurve* curve = findCurveByProperty( RiaDefines::CurveProperty::POROSITY );
+    RimWellLogExtractionCurve* curve = findCurveByProperty( curveProperty );
     if ( curve )
     {
         values = curve->curveData()->xValues();
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimFractureModelPlot::getPorosityValues( std::vector<double>& values ) const
+{
+    getCurvePropertyValues( RiaDefines::CurveProperty::POROSITY, values );
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
 void RimFractureModelPlot::getFaciesValues( std::vector<double>& values ) const
 {
-    RimWellLogExtractionCurve* curve = findCurveByProperty( RiaDefines::CurveProperty::FACIES );
+    getCurvePropertyValues( RiaDefines::CurveProperty::FACIES, values );
-    if ( curve )
-    {
-        values = curve->curveData()->xValues();
-    }
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ProjectDataModel/RimFractureModelPlot.h

@@ -60,6 +60,7 @@ public:
 
     void getPorosityValues( std::vector<double>& values ) const;
     void getFaciesValues( std::vector<double>& values ) const;
+    void getCurvePropertyValues( RiaDefines::CurveProperty curveProperty, std::vector<double>& values ) const;
 
     std::vector<double> calculateTrueVerticalDepth() const;
     std::vector<double> calculatePorosity() const;