#10743 Fault Reactivation: export temperature and void ratio per node.

Fixes #10743.

ApplicationLibCode/ProjectDataModel/Faults/CMakeLists_files.cmake

@@ -5,6 +5,10 @@ set(SOURCE_GROUP_HEADER_FILES
     ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationModelCollection.h
     ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationTools.h
     ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccess.h
+    ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessor.h
+    ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessorPorePressure.h
+    ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessorVoidRatio.h
+    ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessorTemperature.h
     ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationEnums.h
 )
 
@@ -15,6 +19,10 @@ set(SOURCE_GROUP_SOURCE_FILES
     ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationModelCollection.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationTools.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccess.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessor.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessorPorePressure.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessorVoidRatio.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessorTemperature.cpp
 )
 
 list(APPEND CODE_HEADER_FILES ${SOURCE_GROUP_HEADER_FILES})

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccess.cpp

@@ -18,43 +18,36 @@
 
 #include "RimFaultReactivationDataAccess.h"
 
+#include "RiaDefines.h"
 #include "RiaPorosityModel.h"
 
 #include "RigCaseCellResultsData.h"
 #include "RigEclipseCaseData.h"
 #include "RigEclipseResultAddress.h"
 #include "RigFault.h"
+#include "RigFaultReactivationModel.h"
+#include "RigGriddedPart3d.h"
 #include "RigMainGrid.h"
 #include "RigResultAccessorFactory.h"
 
 #include "RimEclipseCase.h"
+#include "RimFaultReactivationDataAccessor.h"
+#include "RimFaultReactivationDataAccessorPorePressure.h"
+#include "RimFaultReactivationDataAccessorTemperature.h"
+#include "RimFaultReactivationDataAccessorVoidRatio.h"
+#include "RimFaultReactivationEnums.h"
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFaultReactivationDataAccess::RimFaultReactivationDataAccess( RimEclipseCase* thecase, size_t timeStepIndex )
-    : m_case( thecase )
-    , m_caseData( nullptr )
-    , m_mainGrid( nullptr )
-    , m_timeStepIndex( timeStepIndex )
+RimFaultReactivationDataAccess::RimFaultReactivationDataAccess( RimEclipseCase* thecase, const std::vector<size_t>& timeSteps )
+
+    : m_timeSteps( timeSteps )
 {
-    if ( m_case )
-    {
-        m_caseData = m_case->eclipseCaseData();
-        m_mainGrid = m_case->mainGrid();
-    }
-    if ( m_caseData )
-    {
-        RigEclipseResultAddress resVarAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "PRESSURE" );
-
-        m_case->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->ensureKnownResultLoaded( resVarAddress );
-
-        m_resultAccessor = RigResultAccessorFactory::createFromResultAddress( m_caseData,
-                                                                              0,
-                                                                              RiaDefines::PorosityModelType::MATRIX_MODEL,
-                                                                              timeStepIndex,
-                                                                              resVarAddress );
-    }
+    // TODO: correct default pore pressure gradient?
+    m_accessors.push_back( std::make_shared<RimFaultReactivationDataAccessorPorePressure>( thecase, 1.0 ) );
+    m_accessors.push_back( std::make_shared<RimFaultReactivationDataAccessorVoidRatio>( thecase, 0.0001 ) );
+    m_accessors.push_back( std::make_shared<RimFaultReactivationDataAccessorTemperature>( thecase ) );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -67,67 +60,84 @@ RimFaultReactivationDataAccess::~RimFaultReactivationDataAccess()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFaultReactivationDataAccess::useCellIndexAdjustment( std::map<size_t, size_t> adjustments )
+std::vector<double> RimFaultReactivationDataAccess::propertyValues( RimFaultReactivation::GridPart gridPart,
+                                                                    RimFaultReactivation::Property property,
+                                                                    size_t                         outputTimeStep ) const
 {
-    m_cellIndexAdjustment = adjustments;
+    const auto it = m_propertyValues.find( { gridPart, property } );
+    if ( it == m_propertyValues.end() || outputTimeStep >= it->second.size() ) return {};
+    return it->second[outputTimeStep];
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-size_t RimFaultReactivationDataAccess::findAdjustedCellIndex( const cvf::Vec3d&               position,
-                                                              const RigMainGrid*              grid,
-                                                              const std::map<size_t, size_t>& cellIndexAdjustmentMap )
+void RimFaultReactivationDataAccess::clearModelData()
 {
-    CAF_ASSERT( grid != nullptr );
+    m_accessors.clear();
+    m_propertyValues.clear();
+}
 
-    size_t cellIdx = grid->findReservoirCellIndexFromPoint( position );
-
-    // adjust cell index if present in the map
-    if ( auto search = cellIndexAdjustmentMap.find( cellIdx ); search != cellIndexAdjustmentMap.end() )
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<double> RimFaultReactivationDataAccess::extractModelData( const RigFaultReactivationModel& model,
+                                                                      RimFaultReactivation::GridPart   gridPart,
+                                                                      RimFaultReactivation::Property   property,
+                                                                      size_t                           timeStep )
+{
+    std::shared_ptr<RimFaultReactivationDataAccessor> accessor = getAccessor( property );
+    if ( accessor )
     {
-        cellIdx = search->second;
+        accessor->setTimeStep( timeStep );
+        accessor->useCellIndexAdjustment( model.cellIndexAdjustment( gridPart ) );
+
+        auto grid = model.grid( gridPart );
+
+        std::vector<double> values;
+        for ( auto& node : grid->globalNodes() )
+        {
+            double value = accessor->valueAtPosition( node );
+            values.push_back( value );
+        }
+        return values;
     }
 
-    return cellIdx;
+    return {};
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFaultReactivationDataAccess::porePressureAtPosition( const cvf::Vec3d& position, double defaultPorePressureGradient ) const
+void RimFaultReactivationDataAccess::extractModelData( const RigFaultReactivationModel& model )
 {
-    if ( ( m_mainGrid != nullptr ) && m_resultAccessor.notNull() )
-    {
-        auto cellIdx = findAdjustedCellIndex( position, m_mainGrid, m_cellIndexAdjustment );
+    auto properties = { RimFaultReactivation::Property::PorePressure,
+                        RimFaultReactivation::Property::VoidRatio,
+                        RimFaultReactivation::Property::Temperature };
 
-        if ( ( cellIdx != cvf::UNDEFINED_SIZE_T ) )
+    for ( auto property : properties )
+    {
+        for ( auto part : model.allGridParts() )
         {
-            double value = m_resultAccessor->cellScalar( cellIdx );
-            if ( !std::isinf( value ) )
+            std::vector<std::vector<double>> dataForAllTimeSteps;
+            for ( size_t timeStep : m_timeSteps )
             {
-                return 100000.0 * m_resultAccessor->cellScalar( cellIdx ); // return in pascal, not bar
+                dataForAllTimeSteps.push_back( extractModelData( model, part, property, timeStep ) );
             }
+            m_propertyValues[{ part, property }] = dataForAllTimeSteps;
         }
     }
-
-    return calculatePorePressure( std::abs( position.z() ), defaultPorePressureGradient );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFaultReactivationDataAccess::calculatePorePressure( double depth, double gradient )
+std::shared_ptr<RimFaultReactivationDataAccessor> RimFaultReactivationDataAccess::getAccessor( RimFaultReactivation::Property property ) const
 {
-    return gradient * 9.81 * depth * 1000.0;
-}
+    for ( auto accessor : m_accessors )
+        if ( accessor->isMatching( property ) ) return accessor;
 
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-size_t RimFaultReactivationDataAccess::timeStepIndex() const
-{
-    return m_timeStepIndex;
+    return nullptr;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -135,19 +145,16 @@ size_t RimFaultReactivationDataAccess::timeStepIndex() const
 //--------------------------------------------------------------------------------------------------
 bool RimFaultReactivationDataAccess::elementHasValidData( std::vector<cvf::Vec3d> elementCorners ) const
 {
+    auto accessor = getAccessor( RimFaultReactivation::Property::PorePressure );
+    if ( !accessor ) return false;
+
+    accessor->setTimeStep( 0 );
+
     int nValid = 0;
+
     for ( auto& p : elementCorners )
     {
-        auto cellIdx = findAdjustedCellIndex( p, m_mainGrid, m_cellIndexAdjustment );
-
-        if ( ( cellIdx != cvf::UNDEFINED_SIZE_T ) )
-        {
-            double value = m_resultAccessor->cellScalar( cellIdx );
-            if ( !std::isinf( value ) )
-            {
-                nValid++;
-            }
-        }
+        if ( accessor->hasValidDataAtPosition( p ) ) nValid++;
     }
 
     // if more than half of the nodes have valid data, we're ok

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccess.h

@@ -18,16 +18,19 @@
 
 #pragma once
 
-#include "cvfObject.h"
+#include "RimFaultReactivationDataAccessor.h"
+
+#include "RimFaultReactivationEnums.h"
+
 #include "cvfVector3.h"
 
 #include <map>
+#include <memory>
 #include <vector>
 
 class RimEclipseCase;
-class RigEclipseCaseData;
-class RigResultAccessor;
-class RigMainGrid;
+class RimFaultReactivationDataAccessor;
+class RigFaultReactivationModel;
 
 //==================================================================================================
 ///
@@ -36,28 +39,28 @@ class RigMainGrid;
 class RimFaultReactivationDataAccess
 {
 public:
-    RimFaultReactivationDataAccess( RimEclipseCase* thecase, size_t timeStepIndex );
+    RimFaultReactivationDataAccess( RimEclipseCase* eclipseCase, const std::vector<size_t>& timeSteps );
     ~RimFaultReactivationDataAccess();
 
-    void useCellIndexAdjustment( std::map<size_t, size_t> adjustments );
+    void extractModelData( const RigFaultReactivationModel& model );
 
-    double porePressureAtPosition( const cvf::Vec3d& position, double defaultPorePressureGradient ) const;
+    void clearModelData();
 
-    size_t timeStepIndex() const;
-
-    static size_t
-        findAdjustedCellIndex( const cvf::Vec3d& position, const RigMainGrid* grid, const std::map<size_t, size_t>& cellIndexAdjustmentMap );
+    std::vector<double>
+        propertyValues( RimFaultReactivation::GridPart gridPart, RimFaultReactivation::Property property, size_t outputTimeStep ) const;
 
     bool elementHasValidData( std::vector<cvf::Vec3d> elementCorners ) const;
 
-protected:
-    static double calculatePorePressure( double depth, double gradient );
-
 private:
-    RimEclipseCase*             m_case;
-    RigEclipseCaseData*         m_caseData;
-    const RigMainGrid*          m_mainGrid;
-    size_t                      m_timeStepIndex;
-    cvf::ref<RigResultAccessor> m_resultAccessor;
-    std::map<size_t, size_t>    m_cellIndexAdjustment;
+    std::shared_ptr<RimFaultReactivationDataAccessor> getAccessor( RimFaultReactivation::Property property ) const;
+
+    std::vector<double> extractModelData( const RigFaultReactivationModel& model,
+                                          RimFaultReactivation::GridPart   gridPart,
+                                          RimFaultReactivation::Property   property,
+                                          size_t                           timeStep );
+
+    std::vector<std::shared_ptr<RimFaultReactivationDataAccessor>> m_accessors;
+    std::vector<size_t>                                            m_timeSteps;
+
+    std::map<std::pair<RimFaultReactivation::GridPart, RimFaultReactivation::Property>, std::vector<std::vector<double>>> m_propertyValues;
 };

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessor.cpp

@@ -0,0 +1,75 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2023  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.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RimFaultReactivationDataAccessor.h"
+
+#include "RigMainGrid.h"
+
+#include "cafAssert.h"
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimFaultReactivationDataAccessor::RimFaultReactivationDataAccessor()
+{
+    m_timeStep = -1;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimFaultReactivationDataAccessor::~RimFaultReactivationDataAccessor()
+{
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimFaultReactivationDataAccessor::setTimeStep( size_t timeStep )
+{
+    m_timeStep = timeStep;
+    updateResultAccessor();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimFaultReactivationDataAccessor::useCellIndexAdjustment( const std::map<size_t, size_t>& adjustments )
+{
+    m_cellIndexAdjustment = adjustments;
+}
+
+// //--------------------------------------------------------------------------------------------------
+// ///
+// //--------------------------------------------------------------------------------------------------
+size_t RimFaultReactivationDataAccessor::findAdjustedCellIndex( const cvf::Vec3d&               position,
+                                                                const RigMainGrid*              grid,
+                                                                const std::map<size_t, size_t>& cellIndexAdjustmentMap )
+{
+    CAF_ASSERT( grid != nullptr );
+
+    size_t cellIdx = grid->findReservoirCellIndexFromPoint( position );
+
+    // adjust cell index if present in the map
+    if ( auto search = cellIndexAdjustmentMap.find( cellIdx ); search != cellIndexAdjustmentMap.end() )
+    {
+        cellIdx = search->second;
+    }
+
+    return cellIdx;
+}

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessor.h

@@ -0,0 +1,57 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2023 -    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 "cvfVector3.h"
+
+#include "RimFaultReactivationEnums.h"
+
+#include <map>
+
+class RigMainGrid;
+
+//==================================================================================================
+///
+///
+//==================================================================================================
+class RimFaultReactivationDataAccessor
+{
+public:
+    RimFaultReactivationDataAccessor();
+    ~RimFaultReactivationDataAccessor();
+
+    virtual void setTimeStep( size_t timeStep );
+
+    virtual bool isMatching( RimFaultReactivation::Property property ) const = 0;
+
+    virtual double valueAtPosition( const cvf::Vec3d& position ) const = 0;
+
+    virtual bool hasValidDataAtPosition( const cvf::Vec3d& position ) const = 0;
+
+    void useCellIndexAdjustment( const std::map<size_t, size_t>& adjustments );
+
+    static size_t
+        findAdjustedCellIndex( const cvf::Vec3d& position, const RigMainGrid* grid, const std::map<size_t, size_t>& cellIndexAdjustmentMap );
+
+protected:
+    virtual void updateResultAccessor() = 0;
+
+    std::map<size_t, size_t> m_cellIndexAdjustment;
+    size_t                   m_timeStep;
+};

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorPorePressure.cpp

@@ -0,0 +1,125 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2023  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.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RimFaultReactivationDataAccessorPorePressure.h"
+#include "RimFaciesProperties.h"
+#include "RimFaultReactivationEnums.h"
+
+#include "RiaDefines.h"
+#include "RiaPorosityModel.h"
+
+#include "RigCaseCellResultsData.h"
+#include "RigEclipseCaseData.h"
+#include "RigEclipseResultAddress.h"
+#include "RigMainGrid.h"
+#include "RigResultAccessorFactory.h"
+
+#include "RimEclipseCase.h"
+
+#include <cmath>
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimFaultReactivationDataAccessorPorePressure::RimFaultReactivationDataAccessorPorePressure( RimEclipseCase* eclipseCase,
+                                                                                            double          porePressureGradient )
+    : m_eclipseCase( eclipseCase )
+    , m_defaultPorePressureGradient( porePressureGradient )
+    , m_caseData( nullptr )
+    , m_mainGrid( nullptr )
+{
+    if ( m_eclipseCase )
+    {
+        m_caseData = m_eclipseCase->eclipseCaseData();
+        m_mainGrid = m_eclipseCase->mainGrid();
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimFaultReactivationDataAccessorPorePressure::~RimFaultReactivationDataAccessorPorePressure()
+{
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimFaultReactivationDataAccessorPorePressure::updateResultAccessor()
+{
+    if ( m_caseData )
+    {
+        RigEclipseResultAddress resVarAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "PRESSURE" );
+        m_eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->ensureKnownResultLoaded( resVarAddress );
+
+        m_resultAccessor = RigResultAccessorFactory::createFromResultAddress( m_caseData,
+                                                                              0,
+                                                                              RiaDefines::PorosityModelType::MATRIX_MODEL,
+                                                                              m_timeStep,
+                                                                              resVarAddress );
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimFaultReactivationDataAccessorPorePressure::isMatching( RimFaultReactivation::Property property ) const
+{
+    return property == RimFaultReactivation::Property::PorePressure;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimFaultReactivationDataAccessorPorePressure::valueAtPosition( const cvf::Vec3d& position ) const
+{
+    if ( ( m_mainGrid != nullptr ) && m_resultAccessor.notNull() )
+    {
+        auto cellIdx = findAdjustedCellIndex( position, m_mainGrid, m_cellIndexAdjustment );
+        if ( cellIdx != cvf::UNDEFINED_SIZE_T )
+        {
+            double value = m_resultAccessor->cellScalar( cellIdx );
+            if ( !std::isinf( value ) )
+            {
+                return 100000.0 * value; // return in pascal, not bar
+            }
+        }
+    }
+
+    return calculatePorePressure( std::abs( position.z() ), m_defaultPorePressureGradient );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimFaultReactivationDataAccessorPorePressure::calculatePorePressure( double depth, double gradient )
+{
+    return gradient * 9.81 * depth * 1000.0;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimFaultReactivationDataAccessorPorePressure::hasValidDataAtPosition( const cvf::Vec3d& position ) const
+{
+    auto cellIdx = findAdjustedCellIndex( position, m_mainGrid, m_cellIndexAdjustment );
+    if ( cellIdx == cvf::UNDEFINED_SIZE_T ) return false;
+
+    double value = m_resultAccessor->cellScalar( cellIdx );
+    return !std::isinf( value );
+}

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorPorePressure.h

@@ -0,0 +1,58 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2023 -    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 "cvfObject.h"
+#include "cvfVector3.h"
+
+#include "RimFaultReactivationDataAccessor.h"
+#include "RimFaultReactivationEnums.h"
+
+class RimEclipseCase;
+class RigEclipseCaseData;
+class RigMainGrid;
+class RigResultAccessor;
+
+//==================================================================================================
+///
+///
+//==================================================================================================
+class RimFaultReactivationDataAccessorPorePressure : public RimFaultReactivationDataAccessor
+{
+public:
+    RimFaultReactivationDataAccessorPorePressure( RimEclipseCase* eclipseCase, double porePressureGradient );
+    ~RimFaultReactivationDataAccessorPorePressure();
+
+    bool isMatching( RimFaultReactivation::Property property ) const override;
+
+    double valueAtPosition( const cvf::Vec3d& position ) const override;
+
+    bool hasValidDataAtPosition( const cvf::Vec3d& position ) const override;
+
+private:
+    void updateResultAccessor() override;
+
+    static double calculatePorePressure( double depth, double gradient );
+
+    RimEclipseCase*             m_eclipseCase;
+    RigEclipseCaseData*         m_caseData;
+    const RigMainGrid*          m_mainGrid;
+    double                      m_defaultPorePressureGradient;
+    cvf::ref<RigResultAccessor> m_resultAccessor;
+};

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorTemperature.cpp

@@ -0,0 +1,107 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2023  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.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RimFaultReactivationDataAccessorTemperature.h"
+#include "RimFaultReactivationEnums.h"
+
+#include "RiaDefines.h"
+#include "RiaPorosityModel.h"
+
+#include "RigCaseCellResultsData.h"
+#include "RigEclipseCaseData.h"
+#include "RigEclipseResultAddress.h"
+#include "RigMainGrid.h"
+#include "RigResultAccessorFactory.h"
+
+#include "RimEclipseCase.h"
+
+#include <cmath>
+#include <limits>
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimFaultReactivationDataAccessorTemperature::RimFaultReactivationDataAccessorTemperature( RimEclipseCase* eclipseCase )
+    : m_eclipseCase( eclipseCase )
+    , m_caseData( nullptr )
+    , m_mainGrid( nullptr )
+{
+    if ( m_eclipseCase )
+    {
+        m_caseData = m_eclipseCase->eclipseCaseData();
+        m_mainGrid = m_eclipseCase->mainGrid();
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimFaultReactivationDataAccessorTemperature::~RimFaultReactivationDataAccessorTemperature()
+{
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimFaultReactivationDataAccessorTemperature::updateResultAccessor()
+{
+    if ( m_caseData )
+    {
+        RigEclipseResultAddress resVarAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "TEMP" );
+        m_eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->ensureKnownResultLoaded( resVarAddress );
+        m_resultAccessor = RigResultAccessorFactory::createFromResultAddress( m_caseData,
+                                                                              0,
+                                                                              RiaDefines::PorosityModelType::MATRIX_MODEL,
+                                                                              m_timeStep,
+                                                                              resVarAddress );
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimFaultReactivationDataAccessorTemperature::isMatching( RimFaultReactivation::Property property ) const
+{
+    return property == RimFaultReactivation::Property::Temperature;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimFaultReactivationDataAccessorTemperature::valueAtPosition( const cvf::Vec3d& position ) const
+{
+    if ( ( m_mainGrid != nullptr ) && m_resultAccessor.notNull() )
+    {
+        auto cellIdx = findAdjustedCellIndex( position, m_mainGrid, m_cellIndexAdjustment );
+        if ( cellIdx != cvf::UNDEFINED_SIZE_T )
+        {
+            return m_resultAccessor->cellScalar( cellIdx );
+        }
+    }
+
+    return std::numeric_limits<double>::infinity();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimFaultReactivationDataAccessorTemperature::hasValidDataAtPosition( const cvf::Vec3d& position ) const
+{
+    auto cellIdx = findAdjustedCellIndex( position, m_mainGrid, m_cellIndexAdjustment );
+    return ( cellIdx != cvf::UNDEFINED_SIZE_T );
+}

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorTemperature.h

@@ -0,0 +1,55 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2023 -    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 "cvfObject.h"
+#include "cvfVector3.h"
+
+#include "RimFaultReactivationDataAccessor.h"
+#include "RimFaultReactivationEnums.h"
+
+class RimEclipseCase;
+class RigEclipseCaseData;
+class RigMainGrid;
+class RigResultAccessor;
+
+//==================================================================================================
+///
+///
+//==================================================================================================
+class RimFaultReactivationDataAccessorTemperature : public RimFaultReactivationDataAccessor
+{
+public:
+    RimFaultReactivationDataAccessorTemperature( RimEclipseCase* eclipseCase );
+    ~RimFaultReactivationDataAccessorTemperature();
+
+    bool isMatching( RimFaultReactivation::Property property ) const override;
+
+    double valueAtPosition( const cvf::Vec3d& position ) const override;
+
+    bool hasValidDataAtPosition( const cvf::Vec3d& position ) const override;
+
+private:
+    void updateResultAccessor() override;
+
+    RimEclipseCase*             m_eclipseCase;
+    RigEclipseCaseData*         m_caseData;
+    const RigMainGrid*          m_mainGrid;
+    cvf::ref<RigResultAccessor> m_resultAccessor;
+};

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorVoidRatio.cpp

@@ -0,0 +1,115 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2023  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.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RimFaultReactivationDataAccessorVoidRatio.h"
+#include "RimFaciesProperties.h"
+#include "RimFaultReactivationEnums.h"
+
+#include "RiaDefines.h"
+#include "RiaPorosityModel.h"
+
+#include "RigCaseCellResultsData.h"
+#include "RigEclipseCaseData.h"
+#include "RigEclipseResultAddress.h"
+#include "RigMainGrid.h"
+#include "RigResultAccessorFactory.h"
+
+#include "RimEclipseCase.h"
+
+#include <cmath>
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimFaultReactivationDataAccessorVoidRatio::RimFaultReactivationDataAccessorVoidRatio( RimEclipseCase* eclipseCase, double missingValue )
+    : m_eclipseCase( eclipseCase )
+    , m_missingValue( missingValue )
+    , m_caseData( nullptr )
+    , m_mainGrid( nullptr )
+{
+    if ( m_eclipseCase )
+    {
+        m_caseData = m_eclipseCase->eclipseCaseData();
+        m_mainGrid = m_eclipseCase->mainGrid();
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimFaultReactivationDataAccessorVoidRatio::~RimFaultReactivationDataAccessorVoidRatio()
+{
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimFaultReactivationDataAccessorVoidRatio::updateResultAccessor()
+{
+    if ( m_caseData )
+    {
+        RigEclipseResultAddress resVarAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PORO" );
+        m_eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->ensureKnownResultLoaded( resVarAddress );
+        m_resultAccessor = RigResultAccessorFactory::createFromResultAddress( m_caseData,
+                                                                              0,
+                                                                              RiaDefines::PorosityModelType::MATRIX_MODEL,
+                                                                              m_timeStep,
+                                                                              resVarAddress );
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimFaultReactivationDataAccessorVoidRatio::isMatching( RimFaultReactivation::Property property ) const
+{
+    return property == RimFaultReactivation::Property::VoidRatio;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimFaultReactivationDataAccessorVoidRatio::valueAtPosition( const cvf::Vec3d& position ) const
+{
+    if ( ( m_mainGrid != nullptr ) && m_resultAccessor.notNull() )
+    {
+        auto cellIdx = findAdjustedCellIndex( position, m_mainGrid, m_cellIndexAdjustment );
+        if ( cellIdx != cvf::UNDEFINED_SIZE_T )
+        {
+            double porosity = m_resultAccessor->cellScalar( cellIdx );
+            if ( !std::isinf( porosity ) && porosity != 1.0 )
+            {
+                return porosity / ( 1.0 - porosity );
+            }
+        }
+    }
+
+    return m_missingValue;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimFaultReactivationDataAccessorVoidRatio::hasValidDataAtPosition( const cvf::Vec3d& position ) const
+{
+    auto cellIdx = findAdjustedCellIndex( position, m_mainGrid, m_cellIndexAdjustment );
+    if ( cellIdx == cvf::UNDEFINED_SIZE_T ) return false;
+
+    double value = m_resultAccessor->cellScalar( cellIdx );
+    return !std::isinf( value );
+}

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorVoidRatio.h

@@ -0,0 +1,56 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2023 -    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 "cvfObject.h"
+#include "cvfVector3.h"
+
+#include "RimFaultReactivationDataAccessor.h"
+#include "RimFaultReactivationEnums.h"
+
+class RimEclipseCase;
+class RigEclipseCaseData;
+class RigMainGrid;
+class RigResultAccessor;
+
+//==================================================================================================
+///
+///
+//==================================================================================================
+class RimFaultReactivationDataAccessorVoidRatio : public RimFaultReactivationDataAccessor
+{
+public:
+    RimFaultReactivationDataAccessorVoidRatio( RimEclipseCase* eclipseCase, double missingValue );
+    ~RimFaultReactivationDataAccessorVoidRatio();
+
+    bool isMatching( RimFaultReactivation::Property property ) const override;
+
+    double valueAtPosition( const cvf::Vec3d& position ) const override;
+
+    bool hasValidDataAtPosition( const cvf::Vec3d& position ) const override;
+
+private:
+    void updateResultAccessor() override;
+
+    RimEclipseCase*             m_eclipseCase;
+    RigEclipseCaseData*         m_caseData;
+    const RigMainGrid*          m_mainGrid;
+    double                      m_missingValue;
+    cvf::ref<RigResultAccessor> m_resultAccessor;
+};

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationEnums.h

@@ -58,4 +58,11 @@ enum class ElementSets
     IntraReservoir
 };
 
+enum class Property
+{
+    PorePressure,
+    VoidRatio,
+    Temperature
+};
+
 } // namespace RimFaultReactivation

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationModel.cpp

@@ -44,6 +44,7 @@
 #include "RimFaultInView.h"
 #include "RimFaultInViewCollection.h"
 #include "RimFaultReactivationDataAccess.h"
+#include "RimFaultReactivationEnums.h"
 #include "RimFaultReactivationTools.h"
 #include "RimGeoMechCase.h"
 #include "RimParameterGroup.h"
@@ -114,6 +115,10 @@ RimFaultReactivationModel::RimFaultReactivationModel()
     m_selectedTimeSteps.uiCapability()->setUiEditorTypeName( caf::PdmUiTreeSelectionEditor::uiEditorTypeName() );
     m_selectedTimeSteps.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::TOP );
 
+    CAF_PDM_InitField( &m_useGridPorePressure, "UseGridPorePressure", true, "Use Grid Pore Pressure" );
+    CAF_PDM_InitField( &m_useGridVoidRatio, "UseGridVoidRatio", true, "Use Grid Void Ratio" );
+    CAF_PDM_InitField( &m_useGridTemperature, "UseGridTemperature", true, "Use Grid Temperature" );
+
     CAF_PDM_InitFieldNoDefault( &m_targets, "Targets", "Targets" );
     m_targets.uiCapability()->setUiEditorTypeName( caf::PdmUiTableViewEditor::uiEditorTypeName() );
     m_targets.uiCapability()->setUiTreeChildrenHidden( true );
@@ -491,6 +496,11 @@ void RimFaultReactivationModel::defineUiOrdering( QString uiConfigName, caf::Pdm
     timeStepGrp->add( &m_timeStepFilter );
     timeStepGrp->add( &m_selectedTimeSteps );
 
+    auto propertiesGrp = uiOrdering.addNewGroup( "Properties" );
+    propertiesGrp->add( &m_useGridPorePressure );
+    propertiesGrp->add( &m_useGridVoidRatio );
+    propertiesGrp->add( &m_useGridTemperature );
+
     auto appModelGrp = modelGrp->addNewGroup( "Appearance" );
     appModelGrp->add( &m_modelPart1Color );
     appModelGrp->add( &m_modelPart2Color );
@@ -701,7 +711,7 @@ bool RimFaultReactivationModel::exportModelSettings()
 //--------------------------------------------------------------------------------------------------
 bool RimFaultReactivationModel::extractAndExportModelData()
 {
-    model()->clearModelData();
+    if ( m_dataAccess ) m_dataAccess->clearModelData();
 
     if ( !exportModelSettings() ) return false;
 
@@ -723,19 +733,10 @@ bool RimFaultReactivationModel::extractAndExportModelData()
     // generate cell index mappings for cells that ends up at the wrong side of the fault
     model()->generateCellIndexMapping( grid );
 
-    // generate element sets for the various data parts of the model
-    {
-        RimFaultReactivationDataAccess dataAccess( eCase, 0 );
-        model()->generateElementSets( &dataAccess, grid );
-    }
-
     // extract data for each timestep
-    size_t outputTimeStepIndex = 0;
-    for ( auto timeStepIdx : selectedTimeStepIndexes )
-    {
-        RimFaultReactivationDataAccess dataAccess( eCase, timeStepIdx );
-        model()->extractModelData( &dataAccess, outputTimeStepIndex++ );
-    }
+    m_dataAccess = std::make_shared<RimFaultReactivationDataAccess>( eCase, selectedTimeStepIndexes );
+    model()->generateElementSets( m_dataAccess.get(), grid );
+    m_dataAccess->extractModelData( *model() );
 
     return true;
 }
@@ -766,3 +767,35 @@ std::array<double, 3> RimFaultReactivationModel::materialParameters( ElementSets
 
     return retVal;
 }
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::shared_ptr<RimFaultReactivationDataAccess> RimFaultReactivationModel::dataAccess() const
+{
+    return m_dataAccess;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimFaultReactivationModel::useGridVoidRatio() const
+{
+    return m_useGridVoidRatio();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimFaultReactivationModel::useGridPorePressure() const
+{
+    return m_useGridPorePressure();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimFaultReactivationModel::useGridTemperature() const
+{
+    return m_useGridTemperature();
+}

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationModel.h

@@ -18,6 +18,7 @@
 #pragma once
 
 #include "RimCheckableNamedObject.h"
+#include "RimFaultReactivationDataAccess.h"
 #include "RimFaultReactivationEnums.h"
 #include "RimPolylinePickerInterface.h"
 #include "RimPolylinesDataInterface.h"
@@ -52,6 +53,7 @@ class RimTimeStepFilter;
 class RivFaultReactivationModelPartMgr;
 class RigBasicPlane;
 class RigFaultReactivationModel;
+class RimFaultReactivationDataAccess;
 
 namespace cvf
 {
@@ -121,6 +123,12 @@ public:
 
     void updateTimeSteps();
 
+    std::shared_ptr<RimFaultReactivationDataAccess> dataAccess() const;
+
+    bool useGridVoidRatio() const;
+    bool useGridPorePressure() const;
+    bool useGridTemperature() const;
+
 protected:
     caf::PdmFieldHandle*          userDescriptionField() override;
     QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions ) override;
@@ -170,6 +178,10 @@ private:
     caf::PdmField<int>    m_numberOfCellsVertLow;
     caf::PdmField<bool>   m_useLocalCoordinates;
 
+    caf::PdmField<bool> m_useGridPorePressure;
+    caf::PdmField<bool> m_useGridVoidRatio;
+    caf::PdmField<bool> m_useGridTemperature;
+
     cvf::ref<RigBasicPlane>             m_faultPlane;
     cvf::ref<RigFaultReactivationModel> m_modelPlane;
 
@@ -179,4 +191,6 @@ private:
     caf::PdmChildArrayField<RimParameterGroup*> m_materialParameters;
 
     std::vector<QDateTime> m_availableTimeSteps;
+
+    std::shared_ptr<RimFaultReactivationDataAccess> m_dataAccess;
 };