#8955 Grid Property Calculator : Add filtering support.

ApplicationLibCode/ProjectDataModel/RimGridCalculation.cpp

@@ -19,16 +19,20 @@
 #include "RimGridCalculation.h"
 
 #include "RiaDefines.h"
-#include "RimEclipseCase.h"
-#include "RimEclipseCellColors.h"
-#include "RimEclipseView.h"
-#include "RimReloadCaseTools.h"
-
 #include "RiaLogging.h"
 #include "RiaPorosityModel.h"
 
+#include "RimEclipseCase.h"
+#include "RimEclipseCellColors.h"
+#include "RimEclipseView.h"
+#include "RimGridCalculationVariable.h"
+#include "RimReloadCaseTools.h"
+
 #include "RigCaseCellResultsData.h"
 #include "RigEclipseResultAddress.h"
+#include "RigMainGrid.h"
+#include "RigResultAccessor.h"
+#include "RigResultAccessorFactory.h"
 
 #include "expressionparser/ExpressionParser.h"
 
@@ -57,78 +61,24 @@ bool RimGridCalculation::calculate()
 {
     QString leftHandSideVariableName = RimGridCalculation::findLeftHandSide( m_expression );
 
-    auto porosityModel = RiaDefines::PorosityModelType::MATRIX_MODEL;
-
     RimEclipseCase* eclipseCase = findEclipseCaseFromVariables();
     if ( !eclipseCase )
     {
         RiaLogging::errorInMessageBox( nullptr,
-                                       "Expression Parser",
+                                       "Grid Property Calculator",
                                        QString( "No case found for calculation : %1" ).arg( leftHandSideVariableName ) );
         return false;
     }
 
-    const size_t timeStepCount = eclipseCase->results( porosityModel )->maxTimeStepCount();
+    auto [isOk, errorMessage] = validateVariables();
-
+    if ( !isOk )
-    std::vector<std::vector<std::vector<double>>> values;
-    for ( size_t i = 0; i < m_variables.size(); i++ )
     {
-        RimGridCalculationVariable* v = dynamic_cast<RimGridCalculationVariable*>( m_variables[i] );
+        RiaLogging::errorInMessageBox( nullptr, "Grid Property Calculator", errorMessage );
-        CAF_ASSERT( v != nullptr );
+        return false;
-
-        if ( !v->eclipseCase() )
-        {
-            RiaLogging::errorInMessageBox( nullptr,
-                                           "Expression Parser",
-                                           QString( "No case defined for variable : %1" ).arg( v->name() ) );
-            return false;
-        }
-
-        if ( v->resultVariable().isEmpty() )
-        {
-            RiaLogging::errorInMessageBox( nullptr,
-                                           "Expression Parser",
-                                           QString( "No result variable defined for variable : %1" ).arg( v->name() ) );
-            return false;
-        }
-
-        auto                    resultCategoryType = v->resultCategoryType();
-        RigEclipseResultAddress resAddr( resultCategoryType, v->resultVariable() );
-        if ( !eclipseCase->results( porosityModel )->ensureKnownResultLoaded( resAddr ) )
-        {
-            RiaLogging::errorInMessageBox( nullptr,
-                                           "Expression Parser",
-                                           QString( "Unable to load result for variable : %1" ).arg( v->name() ) );
-            return false;
-        }
-
-        int timeStep = v->timeStep();
-
-        std::vector<std::vector<double>> inputValues = eclipseCase->results( porosityModel )->cellScalarResults( resAddr );
-        if ( resultCategoryType == RiaDefines::ResultCatType::STATIC_NATIVE )
-        {
-            // Use static data for all time steps
-            inputValues.resize( timeStepCount );
-            for ( size_t tsId = 1; tsId < timeStepCount; tsId++ )
-            {
-                inputValues[tsId] = inputValues[0];
-            }
-        }
-        else if ( timeStep != RimGridCalculationVariable::allTimeStepsValue() )
-        {
-            // Use data from a specific time step for this variable for all result time steps
-            for ( size_t tsId = 0; tsId < timeStepCount; tsId++ )
-            {
-                if ( static_cast<int>( tsId ) != timeStep )
-                {
-                    inputValues[tsId] = inputValues[timeStep];
-                }
-            }
-        }
-
-        values.push_back( inputValues );
     }
 
+    auto porosityModel = RiaDefines::PorosityModelType::MATRIX_MODEL;
+
     RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::GENERATED, leftHandSideVariableName );
 
     if ( !eclipseCase->results( porosityModel )->ensureKnownResultLoaded( resAddr ) )
@@ -138,22 +88,32 @@ bool RimGridCalculation::calculate()
 
     eclipseCase->results( porosityModel )->clearScalarResult( resAddr );
 
+    const size_t timeStepCount = eclipseCase->results( porosityModel )->maxTimeStepCount();
+
     std::vector<std::vector<double>>* scalarResultFrames =
         eclipseCase->results( porosityModel )->modifiableCellScalarResultTimesteps( resAddr );
     scalarResultFrames->resize( timeStepCount );
 
     for ( size_t tsId = 0; tsId < timeStepCount; tsId++ )
     {
+        std::vector<std::vector<double>> values;
+        for ( size_t i = 0; i < m_variables.size(); i++ )
+        {
+            RimGridCalculationVariable* v = dynamic_cast<RimGridCalculationVariable*>( m_variables[i] );
+            CAF_ASSERT( v != nullptr );
+            values.push_back( getInputVectorForVariable( v, tsId, porosityModel ) );
+        }
+
         ExpressionParser parser;
         for ( size_t i = 0; i < m_variables.size(); i++ )
         {
             RimGridCalculationVariable* v = dynamic_cast<RimGridCalculationVariable*>( m_variables[i] );
             CAF_ASSERT( v != nullptr );
-            parser.assignVector( v->name(), values[i][tsId] );
+            parser.assignVector( v->name(), values[i] );
         }
 
         std::vector<double> resultValues;
-        resultValues.resize( values[0][tsId].size() );
+        resultValues.resize( values[0].size() );
         parser.assignVector( leftHandSideVariableName, resultValues );
 
         QString errorText;
@@ -161,6 +121,14 @@ bool RimGridCalculation::calculate()
 
         if ( evaluatedOk )
         {
+            auto [cellFilterView, defaultValueConfig] = findFilterValuesFromVariables();
+
+            if ( cellFilterView )
+            {
+                auto [defaultValueType, defaultValue] = defaultValueConfig;
+                filterResults( cellFilterView, values, defaultValueType, defaultValue, resultValues );
+            }
+
             scalarResultFrames->at( tsId ) = resultValues;
 
             m_isDirty = false;
@@ -170,7 +138,7 @@ bool RimGridCalculation::calculate()
             QString s = "The following error message was received from the parser library : \n\n";
             s += errorText;
 
-            RiaLogging::errorInMessageBox( nullptr, "Expression Parser", s );
+            RiaLogging::errorInMessageBox( nullptr, "Grid Property Calculator", s );
             return false;
         }
     }
@@ -181,7 +149,7 @@ bool RimGridCalculation::calculate()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimEclipseCase* RimGridCalculation::findEclipseCaseFromVariables()
+RimEclipseCase* RimGridCalculation::findEclipseCaseFromVariables() const
 {
     for ( auto variable : m_variables )
     {
@@ -194,6 +162,150 @@ RimEclipseCase* RimGridCalculation::findEclipseCaseFromVariables()
     return nullptr;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::pair<RimGridView*, RimGridCalculationVariable::DefaultValueConfig>
+    RimGridCalculation::findFilterValuesFromVariables() const
+{
+    for ( auto variable : m_variables )
+    {
+        RimGridCalculationVariable* v = dynamic_cast<RimGridCalculationVariable*>( variable.p() );
+        CAF_ASSERT( v != nullptr );
+
+        if ( v->cellFilterView() ) return std::make_pair( v->cellFilterView(), v->defaultValueConfiguration() );
+    }
+
+    return std::pair( nullptr, std::make_pair( RimGridCalculationVariable::DefaultValueType::POSITIVE_INFINITY, HUGE_VAL ) );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+int RimGridCalculation::findFilterVariableIndex() const
+{
+    for ( size_t i = 0; i < m_variables.size(); i++ )
+    {
+        auto                        variable = m_variables[i];
+        RimGridCalculationVariable* v        = dynamic_cast<RimGridCalculationVariable*>( variable );
+        CAF_ASSERT( v != nullptr );
+
+        if ( v->cellFilterView() ) return static_cast<int>( i );
+    }
+
+    return -1;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<double> RimGridCalculation::getInputVectorForVariable( RimGridCalculationVariable*   v,
+                                                                   size_t                        tsId,
+                                                                   RiaDefines::PorosityModelType porosityModel ) const
+{
+    int timeStep = v->timeStep();
+
+    auto resultCategoryType = v->resultCategoryType();
+
+    // General case is to use the data from the given time step
+    size_t timeStepToUse = tsId;
+
+    if ( resultCategoryType == RiaDefines::ResultCatType::STATIC_NATIVE )
+    {
+        // Use the first time step for static data for all time steps
+        timeStepToUse = 0;
+    }
+    else if ( timeStep != RimGridCalculationVariable::allTimeStepsValue() )
+    {
+        // Use data from a specific time step for this variable for all result time steps
+        timeStepToUse = timeStep;
+    }
+
+    RigEclipseResultAddress resAddr( resultCategoryType, v->resultVariable() );
+
+    auto   mainGrid     = v->eclipseCase()->mainGrid();
+    size_t maxGridCount = mainGrid->gridCount();
+
+    size_t              cellCount = mainGrid->globalCellArray().size();
+    std::vector<double> inputValues( cellCount );
+    for ( size_t gridIdx = 0; gridIdx < maxGridCount; ++gridIdx )
+    {
+        auto grid = mainGrid->gridByIndex( gridIdx );
+
+        cvf::ref<RigResultAccessor> sourceResultAccessor =
+            RigResultAccessorFactory::createFromResultAddress( v->eclipseCase()->eclipseCaseData(),
+                                                               gridIdx,
+                                                               porosityModel,
+                                                               timeStepToUse,
+                                                               resAddr );
+
+#pragma omp parallel for
+        for ( int localGridCellIdx = 0; localGridCellIdx < static_cast<int>( grid->cellCount() ); localGridCellIdx++ )
+        {
+            const size_t reservoirCellIndex = grid->reservoirCellIndex( localGridCellIdx );
+            inputValues[reservoirCellIndex] = sourceResultAccessor->cellScalar( localGridCellIdx );
+        }
+    }
+
+    return inputValues;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimGridCalculation::replaceFilteredValuesWithVector( const std::vector<double>& inputValues,
+                                                          cvf::ref<cvf::UByteArray>  visibility,
+                                                          std::vector<double>&       resultValues )
+{
+#pragma omp parallel for
+    for ( int i = 0; i < static_cast<int>( resultValues.size() ); i++ )
+    {
+        if ( !visibility->val( i ) )
+        {
+            resultValues[i] = inputValues[i];
+        }
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimGridCalculation::replaceFilteredValuesWithDefaultValue( double                    defaultValue,
+                                                                cvf::ref<cvf::UByteArray> visibility,
+                                                                std::vector<double>&      resultValues )
+{
+#pragma omp parallel for
+    for ( int i = 0; i < static_cast<int>( resultValues.size() ); i++ )
+    {
+        if ( !visibility->val( i ) )
+        {
+            resultValues[i] = defaultValue;
+        }
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimGridCalculation::filterResults( RimGridView*                                 cellFilterView,
+                                        const std::vector<std::vector<double>>&      values,
+                                        RimGridCalculationVariable::DefaultValueType defaultValueType,
+                                        double                                       defaultValue,
+                                        std::vector<double>&                         resultValues ) const
+{
+    auto visibility = cellFilterView->currentTotalCellVisibility();
+
+    if ( defaultValueType == RimGridCalculationVariable::DefaultValueType::FROM_PROPERTY )
+    {
+        int filterVariableIndex = findFilterVariableIndex();
+        replaceFilteredValuesWithVector( values[filterVariableIndex], visibility, resultValues );
+    }
+    else
+    {
+        replaceFilteredValuesWithDefaultValue( defaultValue, visibility, resultValues );
+    }
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -237,3 +349,39 @@ void RimGridCalculation::removeDependentObjects()
         RimReloadCaseTools::updateAll3dViews( eclipseCase );
     }
 }
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::pair<bool, QString> RimGridCalculation::validateVariables()
+{
+    auto porosityModel = RiaDefines::PorosityModelType::MATRIX_MODEL;
+
+    for ( size_t i = 0; i < m_variables.size(); i++ )
+    {
+        RimGridCalculationVariable* v = dynamic_cast<RimGridCalculationVariable*>( m_variables[i] );
+        CAF_ASSERT( v != nullptr );
+
+        if ( !v->eclipseCase() )
+        {
+            QString errorMessage = QString( "No case defined for variable : %1" ).arg( v->name() );
+            return std::make_pair( false, errorMessage );
+        }
+
+        if ( v->resultVariable().isEmpty() )
+        {
+            QString errorMessage = QString( "No result variable defined for variable : %1" ).arg( v->name() );
+            return std::make_pair( false, errorMessage );
+        }
+
+        auto                    resultCategoryType = v->resultCategoryType();
+        RigEclipseResultAddress resAddr( resultCategoryType, v->resultVariable() );
+        if ( !v->eclipseCase()->results( porosityModel )->ensureKnownResultLoaded( resAddr ) )
+        {
+            QString errorMessage = QString( "Unable to load result for variable : %1" ).arg( v->name() );
+            return std::make_pair( false, errorMessage );
+        }
+    }
+
+    return std::make_pair( true, "" );
+}

ApplicationLibCode/ProjectDataModel/RimGridCalculation.h

@@ -18,10 +18,14 @@
 
 #pragma once
 
+#include "RiaPorosityModel.h"
 #include "RimGridCalculationVariable.h"
 #include "RimUserDefinedCalculation.h"
 
+#include "cvfArray.h"
+
 class RimEclipseCase;
+class RimGridView;
 
 //==================================================================================================
 ///
@@ -40,6 +44,29 @@ public:
 
 protected:
     RimGridCalculationVariable* createVariable() const override;
+    std::pair<bool, QString>    validateVariables();
 
-    RimEclipseCase* findEclipseCaseFromVariables();
+    RimEclipseCase* findEclipseCaseFromVariables() const;
+
+    std::vector<double> getInputVectorForVariable( RimGridCalculationVariable*   v,
+                                                   size_t                        tsId,
+                                                   RiaDefines::PorosityModelType porosityModel ) const;
+
+    void filterResults( RimGridView*                                 cellFilterView,
+                        const std::vector<std::vector<double>>&      values,
+                        RimGridCalculationVariable::DefaultValueType defaultValueType,
+                        double                                       defaultValue,
+                        std::vector<double>&                         resultValues ) const;
+
+    static void replaceFilteredValuesWithVector( const std::vector<double>& inputValues,
+                                                 cvf::ref<cvf::UByteArray>  visibility,
+                                                 std::vector<double>&       resultValues );
+
+    static void replaceFilteredValuesWithDefaultValue( double                    defaultValue,
+                                                       cvf::ref<cvf::UByteArray> visibility,
+                                                       std::vector<double>&      resultValues );
+
+    int findFilterVariableIndex() const;
+
+    std::pair<RimGridView*, RimGridCalculationVariable::DefaultValueConfig> findFilterValuesFromVariables() const;
 };

ApplicationLibCode/ProjectDataModel/RimGridCalculationVariable.cpp

@@ -29,10 +29,23 @@
 
 #include "RimEclipseCase.h"
 #include "RimEclipseResultAddress.h"
+#include "RimEclipseView.h"
 #include "RimTools.h"
 
 CAF_PDM_SOURCE_INIT( RimGridCalculationVariable, "RimGridCalculationVariable" );
 
+namespace caf
+{
+template <>
+void caf::AppEnum<RimGridCalculationVariable::DefaultValueType>::setUp()
+{
+    addItem( RimGridCalculationVariable::DefaultValueType::POSITIVE_INFINITY, "POSITIVE_INFINITY", "Inf" );
+    addItem( RimGridCalculationVariable::DefaultValueType::FROM_PROPERTY, "FROM_PROPERTY", "Property Value" );
+    addItem( RimGridCalculationVariable::DefaultValueType::USER_DEFINED, "USER_DEFINED", "User Defined" );
+    setDefault( RimGridCalculationVariable::DefaultValueType::POSITIVE_INFINITY );
+}
+}; // namespace caf
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -44,6 +57,9 @@ RimGridCalculationVariable::RimGridCalculationVariable()
     CAF_PDM_InitField( &m_resultVariable, "ResultVariable", RiaResultNames::undefinedResultName(), "Variable" );
     CAF_PDM_InitFieldNoDefault( &m_eclipseCase, "EclipseGridCase", "Grid Case" );
     CAF_PDM_InitField( &m_timeStep, "TimeStep", allTimeStepsValue(), "Time Step" );
+    CAF_PDM_InitFieldNoDefault( &m_cellFilterView, "VisibleCellView", "Filter by 3d View Visibility" );
+    CAF_PDM_InitFieldNoDefault( &m_defaultValueType, "DefaultValueType", "Default Value Type" );
+    CAF_PDM_InitField( &m_defaultValue, "DefaultValue", 0.0, "Default Value" );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -69,11 +85,19 @@ void RimGridCalculationVariable::defineUiOrdering( QString uiConfigName, caf::Pd
     uiOrdering.add( &m_resultType );
     uiOrdering.add( &m_resultVariable );
     uiOrdering.add( &m_timeStep );
+    uiOrdering.add( &m_cellFilterView );
+    uiOrdering.add( &m_defaultValueType );
+    uiOrdering.add( &m_defaultValue );
 
     uiOrdering.skipRemainingFields();
 
     m_resultType.uiCapability()->setUiReadOnly( m_eclipseCase == nullptr );
     m_timeStep.uiCapability()->setUiReadOnly( m_resultType == RiaDefines::ResultCatType::STATIC_NATIVE );
+
+    m_cellFilterView.uiCapability()->setUiReadOnly( m_eclipseCase == nullptr );
+    m_defaultValueType.uiCapability()->setUiReadOnly( m_cellFilterView == nullptr );
+    m_defaultValue.uiCapability()->setUiReadOnly(
+        m_cellFilterView == nullptr || defaultValueType() != RimGridCalculationVariable::DefaultValueType::USER_DEFINED );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -117,6 +141,18 @@ QList<caf::PdmOptionItemInfo>
 
         RimTools::timeStepsForCase( m_eclipseCase(), &options );
     }
+    else if ( fieldNeedingOptions == &m_cellFilterView )
+    {
+        if ( m_eclipseCase )
+        {
+            options.push_back( caf::PdmOptionItemInfo( "Disabled", nullptr ) );
+            for ( RimEclipseView* view : m_eclipseCase->reservoirViews.children() )
+            {
+                CVF_ASSERT( view && "Really always should have a valid view pointer in ReservoirViews" );
+                options.push_back( caf::PdmOptionItemInfo( view->name(), view, false, view->uiIconProvider() ) );
+            }
+        }
+    }
 
     return options;
 }
@@ -181,6 +217,41 @@ int RimGridCalculationVariable::allTimeStepsValue()
     return -1;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimGridView* RimGridCalculationVariable::cellFilterView() const
+{
+    return m_cellFilterView;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimGridCalculationVariable::defaultValue() const
+{
+    return m_defaultValue;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimGridCalculationVariable::DefaultValueType RimGridCalculationVariable::defaultValueType() const
+{
+    return m_defaultValueType();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimGridCalculationVariable::DefaultValueConfig RimGridCalculationVariable::defaultValueConfiguration() const
+{
+    if ( m_defaultValueType() == RimGridCalculationVariable::DefaultValueType::USER_DEFINED )
+        return std::make_pair( m_defaultValueType(), m_defaultValue() );
+
+    return std::make_pair( m_defaultValueType(), HUGE_VAL );
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimGridCalculationVariable.h

@@ -28,6 +28,7 @@
 
 class RimEclipseCase;
 class RimEclipseResultAddress;
+class RimGridView;
 class RigCaseCellResultsData;
 
 //==================================================================================================
@@ -39,6 +40,13 @@ class RimGridCalculationVariable : public RimUserDefinedCalculationVariable
     CAF_PDM_HEADER_INIT;
 
 public:
+    enum class DefaultValueType
+    {
+        POSITIVE_INFINITY,
+        FROM_PROPERTY,
+        USER_DEFINED
+    };
+
     RimGridCalculationVariable();
 
     QString displayString() const override;
@@ -47,6 +55,12 @@ public:
     RiaDefines::ResultCatType resultCategoryType() const;
     QString                   resultVariable() const;
     int                       timeStep() const;
+    RimGridView*              cellFilterView() const;
+    double                    defaultValue() const;
+    DefaultValueType          defaultValueType() const;
+
+    using DefaultValueConfig = std::pair<RimGridCalculationVariable::DefaultValueType, double>;
+    DefaultValueConfig defaultValueConfiguration() const;
 
     static int allTimeStepsValue();
 
@@ -67,4 +81,7 @@ private:
     caf::PdmField<caf::AppEnum<RiaDefines::ResultCatType>> m_resultType;
     caf::PdmField<QString>                                 m_resultVariable;
     caf::PdmField<int>                                     m_timeStep;
+    caf::PdmPtrField<RimGridView*>                         m_cellFilterView;
+    caf::PdmField<caf::AppEnum<DefaultValueType>>          m_defaultValueType;
+    caf::PdmField<double>                                  m_defaultValue;
 };