#4664 Implement smoothing of WBS curves (#4809)

* Initial WIP

* Identical results with spreadsheet

* Improved and more robust smoothing by filtering points first

* Improved smoothing and more GUI

* Include mixed-label for smoothing threshold

ApplicationCode/ProjectDataModel/CMakeLists_files.cmake

@@ -83,6 +83,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFile.h
 ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFileChannel.h
 ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFileCurve.h
 ${CMAKE_CURRENT_LIST_DIR}/RimWellLogRftCurve.h
+${CMAKE_CURRENT_LIST_DIR}/RimWellLogWbsCurve.h
 ${CMAKE_CURRENT_LIST_DIR}/RimIntersection.h
 ${CMAKE_CURRENT_LIST_DIR}/RimIntersectionCollection.h
 ${CMAKE_CURRENT_LIST_DIR}/RimContextCommandBuilder.h
@@ -221,6 +222,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFile.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFileChannel.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFileCurve.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimWellLogRftCurve.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimWellLogWbsCurve.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimIntersection.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimIntersectionCollection.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimContextCommandBuilder.cpp

ApplicationCode/ProjectDataModel/RimWellLogCurveCommonDataSource.cpp

@@ -21,6 +21,7 @@
 #include "RimCase.h"
 #include "RimDataSourceSteppingTools.h"
 #include "RimEclipseCase.h"
+#include "RimGeoMechCase.h"
 #include "RimOilField.h"
 #include "RimProject.h"
 #include "RimTools.h"
@@ -29,6 +30,7 @@
 #include "RimWellLogPlot.h"
 #include "RimWellLogPlotCollection.h"
 #include "RimWellLogTrack.h"
+#include "RimWellLogWbsCurve.h"
 #include "RimWellPath.h"
 #include "RimWellPathCollection.h"
 
@@ -37,9 +39,29 @@
 
 #include "cafPdmUiCheckBoxTristateEditor.h"
 #include "cafPdmUiComboBoxEditor.h"
+#include "cafPdmUiLineEditor.h"
+
+#include <algorithm>
 
 CAF_PDM_SOURCE_INIT( RimWellLogCurveCommonDataSource, "ChangeDataSourceFeatureUi" );
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimWellLogCurveCommonDataSource::DoubleComparator::DoubleComparator( double eps /*= 1.0e-8 */ )
+    : m_eps( eps )
+{
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimWellLogCurveCommonDataSource::DoubleComparator::operator()( const double& lhs, const double& rhs ) const
+{
+    double diff = lhs - rhs;
+    return diff < -m_eps;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -65,6 +87,12 @@ RimWellLogCurveCommonDataSource::RimWellLogCurveCommonDataSource()
 
     CAF_PDM_InitField( &m_timeStep, "CurveTimeStep", -1, "Time Step", "", "", "" );
 
+    CAF_PDM_InitFieldNoDefault( &m_wbsSmoothing, "WBSSmoothing", "Smooth Curves", "", "", "" );
+    m_wbsSmoothing.uiCapability()->setUiEditorTypeName( caf::PdmUiCheckBoxTristateEditor::uiEditorTypeName() );
+    m_wbsSmoothing.v() = caf::Tristate::State::PartiallyTrue;
+
+    CAF_PDM_InitField( &m_wbsSmoothingThreshold, "WBSSmoothingThreshold", -1.0, "Smoothing Threshold", "", "", "" );
+
     m_case     = nullptr;
     m_wellPath = nullptr;
 }
@@ -149,6 +177,38 @@ void RimWellLogCurveCommonDataSource::setBranchDetectionToApply( caf::Tristate::
     m_branchDetection.v() = val;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+caf::Tristate RimWellLogCurveCommonDataSource::wbsSmoothingToApply() const
+{
+    return m_wbsSmoothing();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimWellLogCurveCommonDataSource::setWbsSmoothingToApply( caf::Tristate::State val )
+{
+    m_wbsSmoothing.v() = val;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimWellLogCurveCommonDataSource::wbsSmoothingThreshold() const
+{
+    return m_wbsSmoothingThreshold;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimWellLogCurveCommonDataSource::setWbsSmoothingThreshold( double smoothingThreshold )
+{
+    m_wbsSmoothingThreshold = smoothingThreshold;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -193,6 +253,8 @@ void RimWellLogCurveCommonDataSource::resetDefaultOptions()
     setBranchDetectionToApply( caf::Tristate::State::PartiallyTrue );
     setSimWellNameToApply( QString( "" ) );
     setTimeStepToApply( -1 );
+    setWbsSmoothingToApply( caf::Tristate::State::PartiallyTrue );
+    setWbsSmoothingThreshold( -1.0 );
 
     m_uniqueCases.clear();
     m_uniqueTrajectoryTypes.clear();
@@ -201,6 +263,8 @@ void RimWellLogCurveCommonDataSource::resetDefaultOptions()
     m_uniqueTimeSteps.clear();
     m_uniqueBranchIndices.clear();
     m_uniqueBranchDetection.clear();
+    m_uniqueWbsSmoothing.clear();
+    m_uniqueWbsSmoothingThreshold.clear();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -223,6 +287,12 @@ void RimWellLogCurveCommonDataSource::updateDefaultOptions( const std::vector<Ri
         RimWellLogFileCurve*       fileCurve       = dynamic_cast<RimWellLogFileCurve*>( curve );
         if ( extractionCurve )
         {
+            RimWellLogWbsCurve* wbsCurve = dynamic_cast<RimWellLogWbsCurve*>( extractionCurve );
+            if ( wbsCurve )
+            {
+                m_uniqueWbsSmoothing.insert( wbsCurve->smoothCurve() );
+                m_uniqueWbsSmoothingThreshold.insert( wbsCurve->smoothingThreshold() );
+            }
             if ( extractionCurve->rimCase() )
             {
                 m_uniqueCases.insert( extractionCurve->rimCase() );
@@ -311,6 +381,17 @@ void RimWellLogCurveCommonDataSource::updateDefaultOptions( const std::vector<Ri
     {
         setTimeStepToApply( *m_uniqueTimeSteps.begin() );
     }
+
+    if ( m_uniqueWbsSmoothing.size() == 1u )
+    {
+        setWbsSmoothingToApply( *m_uniqueWbsSmoothing.begin() == true ? caf::Tristate::State::True
+                                                                      : caf::Tristate::State::False );
+    }
+
+    if ( m_uniqueWbsSmoothingThreshold.size() == 1u )
+    {
+        setWbsSmoothingThreshold( *m_uniqueWbsSmoothingThreshold.begin() );
+    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -411,6 +492,21 @@ void RimWellLogCurveCommonDataSource::updateCurvesAndTracks( std::vector<RimWell
                 updatedSomething = true;
             }
 
+            RimWellLogWbsCurve* wbsCurve = dynamic_cast<RimWellLogWbsCurve*>( extractionCurve );
+            if ( wbsCurve )
+            {
+                if ( !wbsSmoothingToApply().isPartiallyTrue() )
+                {
+                    wbsCurve->setSmoothCurve( wbsSmoothingToApply().isTrue() );
+                    updatedSomething = true;
+                }
+
+                if ( wbsSmoothingThreshold() != 1.0 )
+                {
+                    wbsCurve->setSmoothingThreshold( wbsSmoothingThreshold() );
+                    updatedSomething = true;
+                }
+            }
             if ( updatedSomething )
             {
                 RimWellLogPlot* parentPlot = nullptr;
@@ -603,6 +699,13 @@ void RimWellLogCurveCommonDataSource::fieldChangedByUi( const caf::PdmFieldHandl
             m_branchDetection.v() = caf::Tristate::State::True;
         }
     }
+    if ( changedField == &m_wbsSmoothing )
+    {
+        if ( m_wbsSmoothing().isPartiallyTrue() )
+        {
+            m_wbsSmoothing.v() = caf::Tristate::State::True;
+        }
+    }
 
     this->updateCurvesAndTracks();
 }
@@ -791,6 +894,13 @@ void RimWellLogCurveCommonDataSource::defineUiOrdering( QString uiConfigName, ca
         group->add( &m_wellPath );
     }
     group->add( &m_timeStep );
+
+    if ( dynamic_cast<RimGeoMechCase*>( m_case() ) )
+    {
+        group->add( &m_wbsSmoothing );
+        group->add( &m_wbsSmoothingThreshold );
+    }
+
     uiOrdering.skipRemainingFields( true );
 }
 
@@ -830,6 +940,21 @@ void RimWellLogCurveCommonDataSource::defineEditorAttribute( const caf::PdmField
             myAttr->prevButtonText = "Previous " + modifierText + "PgUp)";
         }
     }
+    caf::PdmUiLineEditorAttributeUiDisplayString* uiDisplayStringAttr =
+        dynamic_cast<caf::PdmUiLineEditorAttributeUiDisplayString*>( attribute );
+    if ( uiDisplayStringAttr && wbsSmoothingThreshold() == -1.0 )
+    {
+        QString displayString = "Mixed";
+
+        if ( m_uniqueWbsSmoothingThreshold.size() > 1u )
+        {
+            auto minmax_it = std::minmax_element( m_uniqueWbsSmoothingThreshold.begin(),
+                                                  m_uniqueWbsSmoothingThreshold.end() );
+            displayString += QString( " [%1, %2]" ).arg( *( minmax_it.first ) ).arg( *( minmax_it.second ) );
+        }
+
+        uiDisplayStringAttr->m_displayString = displayString;
+    }
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ProjectDataModel/RimWellLogCurveCommonDataSource.h

@@ -40,6 +40,16 @@ class RimWellLogCurveCommonDataSource : public caf::PdmObject
     CAF_PDM_HEADER_INIT;
 
 public:
+    class DoubleComparator
+    {
+    public:
+        DoubleComparator( double eps = 1.0e-6 );
+        bool operator()( const double& lhs, const double& rhs ) const;
+
+    private:
+        double m_eps;
+    };
+
     RimWellLogCurveCommonDataSource();
 
     RimCase*      caseToApply() const;
@@ -52,6 +62,10 @@ public:
     void          setBranchIndexToApply( int val );
     caf::Tristate branchDetectionToApply() const;
     void          setBranchDetectionToApply( caf::Tristate::State val );
+    caf::Tristate wbsSmoothingToApply() const;
+    void          setWbsSmoothingToApply( caf::Tristate::State val );
+    double        wbsSmoothingThreshold() const;
+    void          setWbsSmoothingThreshold( double smoothingThreshold );
 
     QString simWellNameToApply() const;
     void    setSimWellNameToApply( const QString& val );
@@ -93,12 +107,16 @@ private:
     caf::PdmField<int>             m_branchIndex;
     caf::PdmField<caf::Tristate>   m_branchDetection;
     caf::PdmField<int>             m_timeStep;
+    caf::PdmField<caf::Tristate>   m_wbsSmoothing;
+    caf::PdmField<double>          m_wbsSmoothingThreshold;
 
-    std::set<RimCase*>     m_uniqueCases;
-    std::set<int>          m_uniqueTrajectoryTypes;
-    std::set<RimWellPath*> m_uniqueWellPaths;
-    std::set<QString>      m_uniqueWellNames;
-    std::set<int>          m_uniqueTimeSteps;
-    std::set<bool>         m_uniqueBranchDetection;
-    std::set<int>          m_uniqueBranchIndices;
+    std::set<RimCase*>                 m_uniqueCases;
+    std::set<int>                      m_uniqueTrajectoryTypes;
+    std::set<RimWellPath*>             m_uniqueWellPaths;
+    std::set<QString>                  m_uniqueWellNames;
+    std::set<int>                      m_uniqueTimeSteps;
+    std::set<bool>                     m_uniqueBranchDetection;
+    std::set<int>                      m_uniqueBranchIndices;
+    std::set<bool>                     m_uniqueWbsSmoothing;
+    std::set<double, DoubleComparator> m_uniqueWbsSmoothingThreshold;
 };

ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp

@@ -336,7 +336,7 @@ void RimWellLogExtractionCurve::onLoadDataAndUpdate( bool updateParentPlot )
     if ( isCurveVisible() )
     {
         bool isUsingPseudoLength = false;
-        extractData( &isUsingPseudoLength );
+        performDataExtraction( &isUsingPseudoLength );
 
         RiaDefines::DepthUnitType displayUnit = RiaDefines::UNIT_METER;
 
@@ -395,7 +395,15 @@ void RimWellLogExtractionCurve::onLoadDataAndUpdate( bool updateParentPlot )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogExtractionCurve::extractData( bool* isUsingPseudoLength )
+void RimWellLogExtractionCurve::performDataExtraction( bool* isUsingPseudoLength )
+{
+    extractData( isUsingPseudoLength );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimWellLogExtractionCurve::extractData( bool* isUsingPseudoLength, bool smoothData, double smoothingThreshold )
 {
     CAF_ASSERT( isUsingPseudoLength );
 
@@ -495,17 +503,21 @@ void RimWellLogExtractionCurve::extractData( bool* isUsingPseudoLength )
 
         m_geomResultDefinition->loadResult();
         geomExtractor->curveData( m_geomResultDefinition->resultAddress(), m_timeStep, &values );
+        if ( smoothData )
+        {
+            geomExtractor->smoothCurveData( m_timeStep, &measuredDepthValues, &tvDepthValues, &values, smoothingThreshold );
+        }
     }
 
     if ( values.size() && measuredDepthValues.size() )
     {
         if ( !tvDepthValues.size() )
         {
-            this->setValuesAndMD( values, measuredDepthValues, depthUnit, true );
+            this->setValuesAndMD( values, measuredDepthValues, depthUnit, !smoothData );
         }
         else
         {
-            this->setValuesWithTVD( values, measuredDepthValues, tvDepthValues, depthUnit, true );
+            this->setValuesWithTVD( values, measuredDepthValues, tvDepthValues, depthUnit, !smoothData );
         }
     }
 }
@@ -649,7 +661,7 @@ void RimWellLogExtractionCurve::defineUiOrdering( QString uiConfigName, caf::Pdm
 {
     RimPlotCurve::updateOptionSensitivity();
 
-    caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroup( "Curve Data" );
+    caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroupWithKeyword( "Curve Data", "CurveData" );
 
     curveDataGroup->add( &m_case );
 
@@ -677,7 +689,6 @@ void RimWellLogExtractionCurve::defineUiOrdering( QString uiConfigName, caf::Pdm
     else if ( geomCase )
     {
         curveDataGroup->add( &m_wellPath );
-        m_geomResultDefinition->uiOrdering( uiConfigName, *curveDataGroup );
     }
 
     if ( ( eclipseCase && m_eclipseResultDefinition->hasDynamicResult() ) || geomCase )

ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.h

@@ -87,9 +87,10 @@ public:
                                                       RigGeoMechWellLogExtractor* geomExtractor );
 
 protected:
-    QString createCurveAutoName() override;
-    void    onLoadDataAndUpdate( bool updateParentPlot ) override;
-    void    extractData( bool* isUsingPseudoLength );
+    QString      createCurveAutoName() override;
+    void         onLoadDataAndUpdate( bool updateParentPlot ) override;
+    virtual void performDataExtraction( bool* isUsingPseudoLength );
+    void         extractData( bool* isUsingPseudoLength, bool smoothData = false, double smoothingThreshold = -1.0 );
 
     void fieldChangedByUi( const caf::PdmFieldHandle* changedField,
                            const QVariant&            oldValue,

ApplicationCode/ProjectDataModel/RimWellLogWbsCurve.cpp

@@ -0,0 +1,86 @@
+#include "RimWellLogWbsCurve.h"
+
+//==================================================================================================
+///
+///
+//==================================================================================================
+
+CAF_PDM_SOURCE_INIT( RimWellLogWbsCurve, "RimWellLogWbsCurve" );
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimWellLogWbsCurve::RimWellLogWbsCurve()
+{
+    CAF_PDM_InitObject( "Well Bore Stability Curve", "", "", "" );
+
+    CAF_PDM_InitField( &m_smoothCurve, "SmoothCurve", false, "Smooth Curve", "", "", "" );
+    CAF_PDM_InitField( &m_smoothingThreshold, "SmoothingThreshold", 0.002, "Smoothing Threshold", "", "", "" );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimWellLogWbsCurve::smoothCurve() const
+{
+    return m_smoothCurve;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimWellLogWbsCurve::smoothingThreshold() const
+{
+    return m_smoothingThreshold;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimWellLogWbsCurve::setSmoothCurve( bool smooth )
+{
+    m_smoothCurve = smooth;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimWellLogWbsCurve::setSmoothingThreshold( double threshold )
+{
+    m_smoothingThreshold = threshold;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimWellLogWbsCurve::performDataExtraction( bool* isUsingPseudoLength )
+{
+    extractData( isUsingPseudoLength, m_smoothCurve(), m_smoothingThreshold() );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimWellLogWbsCurve::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
+{
+    RimWellLogExtractionCurve::defineUiOrdering( uiConfigName, uiOrdering );
+
+    caf::PdmUiGroup* dataGroup = uiOrdering.findGroup( "CurveData" );
+    dataGroup->add( &m_smoothCurve );
+    dataGroup->add( &m_smoothingThreshold );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimWellLogWbsCurve::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
+                                           const QVariant&            oldValue,
+                                           const QVariant&            newValue )
+{
+    RimWellLogExtractionCurve::fieldChangedByUi( changedField, oldValue, newValue );
+
+    if ( changedField == &m_smoothCurve || changedField == &m_smoothingThreshold )
+    {
+        this->loadDataAndUpdate( true );
+    }
+}

ApplicationCode/ProjectDataModel/RimWellLogWbsCurve.h

@@ -0,0 +1,49 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2019-     Equinor ASA
+//
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+//
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+#pragma once
+
+#include "RimWellLogExtractionCurve.h"
+
+//==================================================================================================
+///
+///
+//==================================================================================================
+class RimWellLogWbsCurve : public RimWellLogExtractionCurve
+{
+    CAF_PDM_HEADER_INIT;
+
+public:
+    RimWellLogWbsCurve();
+
+    bool   smoothCurve() const;
+    double smoothingThreshold() const;
+
+    void setSmoothCurve( bool smooth );
+    void setSmoothingThreshold( double threshold );
+
+protected:
+    void performDataExtraction( bool* isUsingPseudoLength ) override;
+    void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
+    void fieldChangedByUi( const caf::PdmFieldHandle* changedField,
+                           const QVariant&            oldValue,
+                           const QVariant&            newValue ) override;
+
+protected:
+    caf::PdmField<bool>   m_smoothCurve;
+    caf::PdmField<double> m_smoothingThreshold;
+};