Fault Reactivation: extract density, youngs modulus and poissons number geo mech model.

ApplicationLibCode/FileInterface/RifFaultReactivationModelExporter.cpp

@@ -321,6 +321,7 @@ std::pair<bool, std::string>
         RifInpExportTools::printHeading( stream, "Material, name=" + mat.name );
         RifInpExportTools::printHeading( stream, "Density" );
         RifInpExportTools::printNumber( stream, mat.density );
+
         RifInpExportTools::printHeading( stream, "Elastic" );
         RifInpExportTools::printNumbers( stream, { mat.youngsModulus, mat.poissonNumber } );
 
@@ -555,6 +556,8 @@ bool RifFaultReactivationModelExporter::writePropertyToFile( const RigFaultReact
 
         const std::vector<cvf::Vec3d>& nodes  = grid->globalNodes();
         const std::vector<double>      values = dataAccess.propertyValues( part, property, outputTimeStep );
+        if ( values.size() != nodes.size() ) return false;
+
         for ( size_t i = 0; i < nodes.size(); i++ )
         {
             std::string line = partName + "." + std::to_string( i + 1 ) + ", " + additionalData + std::to_string( values[i] );

ApplicationLibCode/ProjectDataModel/Faults/CMakeLists_files.cmake

@@ -9,6 +9,7 @@ set(SOURCE_GROUP_HEADER_FILES
     ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessorPorePressure.h
     ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessorVoidRatio.h
     ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessorTemperature.h
+    ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessorGeoMech.h
     ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationEnums.h
 )
 
@@ -23,6 +24,7 @@ set(SOURCE_GROUP_SOURCE_FILES
     ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessorPorePressure.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessorVoidRatio.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessorTemperature.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/RimFaultReactivationDataAccessorGeoMech.cpp
 )
 
 list(APPEND CODE_HEADER_FILES ${SOURCE_GROUP_HEADER_FILES})

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccess.cpp

@@ -32,6 +32,7 @@
 
 #include "RimEclipseCase.h"
 #include "RimFaultReactivationDataAccessor.h"
+#include "RimFaultReactivationDataAccessorGeoMech.h"
 #include "RimFaultReactivationDataAccessorPorePressure.h"
 #include "RimFaultReactivationDataAccessorTemperature.h"
 #include "RimFaultReactivationDataAccessorVoidRatio.h"
@@ -40,14 +41,26 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFaultReactivationDataAccess::RimFaultReactivationDataAccess( RimEclipseCase* thecase, const std::vector<size_t>& timeSteps )
-
+RimFaultReactivationDataAccess::RimFaultReactivationDataAccess( RimEclipseCase*            thecase,
+                                                                RimGeoMechCase*            geoMechCase,
+                                                                const std::vector<size_t>& timeSteps )
     : m_timeSteps( timeSteps )
 {
     // 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 ) );
+    if ( geoMechCase )
+    {
+        std::vector<RimFaultReactivation::Property> properties = { RimFaultReactivation::Property::YoungsModulus,
+                                                                   RimFaultReactivation::Property::PoissonsRatio,
+                                                                   RimFaultReactivation::Property::Density };
+
+        for ( auto property : properties )
+        {
+            m_accessors.push_back( std::make_shared<RimFaultReactivationDataAccessorGeoMech>( geoMechCase, property ) );
+        }
+    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -112,7 +125,10 @@ void RimFaultReactivationDataAccess::extractModelData( const RigFaultReactivatio
 {
     auto properties = { RimFaultReactivation::Property::PorePressure,
                         RimFaultReactivation::Property::VoidRatio,
-                        RimFaultReactivation::Property::Temperature };
+                        RimFaultReactivation::Property::Temperature,
+                        RimFaultReactivation::Property::YoungsModulus,
+                        RimFaultReactivation::Property::PoissonsRatio,
+                        RimFaultReactivation::Property::Density };
 
     for ( auto property : properties )
     {

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccess.h

@@ -29,6 +29,7 @@
 #include <vector>
 
 class RimEclipseCase;
+class RimGeoMechCase;
 class RimFaultReactivationDataAccessor;
 class RigFaultReactivationModel;
 
@@ -39,7 +40,7 @@ class RigFaultReactivationModel;
 class RimFaultReactivationDataAccess
 {
 public:
-    RimFaultReactivationDataAccess( RimEclipseCase* eclipseCase, const std::vector<size_t>& timeSteps );
+    RimFaultReactivationDataAccess( RimEclipseCase* eclipseCase, RimGeoMechCase* geoMechCase, const std::vector<size_t>& timeSteps );
     ~RimFaultReactivationDataAccess();
 
     void extractModelData( const RigFaultReactivationModel& model );

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorGeoMech.cpp

@@ -0,0 +1,162 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "RimFaultReactivationDataAccessorGeoMech.h"
+
+#include "RigFemPartCollection.h"
+#include "RigFemPartResultsCollection.h"
+#include "RigFemResultAddress.h"
+#include "RigFemScalarResultFrames.h"
+#include "RigGeoMechCaseData.h"
+#include "RigHexIntersectionTools.h"
+#include "RigMainGrid.h"
+#include "RigResultAccessorFactory.h"
+
+#include "RimFaultReactivationEnums.h"
+#include "RimGeoMechCase.h"
+
+#include <cmath>
+#include <limits>
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimFaultReactivationDataAccessorGeoMech::RimFaultReactivationDataAccessorGeoMech( RimGeoMechCase*                geoMechCase,
+                                                                                  RimFaultReactivation::Property property )
+    : m_geoMechCase( geoMechCase )
+    , m_property( property )
+{
+    m_geoMechCaseData = geoMechCase->geoMechData();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimFaultReactivationDataAccessorGeoMech::~RimFaultReactivationDataAccessorGeoMech()
+{
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimFaultReactivationDataAccessorGeoMech::updateResultAccessor()
+{
+    const int partIndex = 0;
+
+    auto loadFrameLambda = [&]( auto femParts, RigFemResultAddress addr ) -> RigFemScalarResultFrames*
+    {
+        auto result = femParts->findOrLoadScalarResult( partIndex, addr );
+        if ( result->frameData( 0, 0 ).empty() )
+        {
+            return nullptr;
+        }
+        return result;
+    };
+
+    auto femParts  = m_geoMechCaseData->femPartResults();
+    m_resultFrames = loadFrameLambda( femParts, getResultAddress( m_property ) );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RigFemResultAddress RimFaultReactivationDataAccessorGeoMech::getResultAddress( RimFaultReactivation::Property property )
+{
+    if ( property == RimFaultReactivation::Property::YoungsModulus ) return RigFemResultAddress( RIG_ELEMENT, "MODULUS", "" );
+    if ( property == RimFaultReactivation::Property::PoissonsRatio ) return RigFemResultAddress( RIG_ELEMENT, "RATIO", "" );
+    CAF_ASSERT( property == RimFaultReactivation::Property::Density );
+    return RigFemResultAddress( RIG_ELEMENT, "DENSITY", "" );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimFaultReactivationDataAccessorGeoMech::isMatching( RimFaultReactivation::Property property ) const
+{
+    return property == m_property;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimFaultReactivationDataAccessorGeoMech::valueAtPosition( const cvf::Vec3d& position ) const
+{
+    if ( !m_resultFrames ) return std::numeric_limits<double>::infinity();
+
+    auto findCloseCells = [this]( const cvf::BoundingBox& bb, int partId ) -> std::vector<size_t>
+    {
+        std::vector<size_t> closeCells;
+
+        if ( m_geoMechCaseData->femParts()->partCount() )
+        {
+            m_geoMechCaseData->femParts()->part( partId )->findIntersectingElementIndices( bb, &closeCells );
+        }
+        return closeCells;
+    };
+
+    const int                      partId     = 0;
+    const RigFemPart*              femPart    = m_geoMechCaseData->femParts()->part( partId );
+    const std::vector<cvf::Vec3f>& nodeCoords = femPart->nodes().coordinates;
+
+    cvf::BoundingBox bb;
+    bb.add( position );
+
+    std::vector<size_t> closeCells = findCloseCells( bb, partId );
+
+    cvf::Vec3d hexCorners[8];
+    for ( size_t ccIdx = 0; ccIdx < closeCells.size(); ++ccIdx )
+    {
+        size_t elementIdx = closeCells[ccIdx];
+
+        RigElementType elmType = femPart->elementType( elementIdx );
+        if ( elmType != HEX8 && elmType != HEX8P ) continue;
+
+        const int* cornerIndices = femPart->connectivities( elementIdx );
+
+        hexCorners[0] = cvf::Vec3d( nodeCoords[cornerIndices[0]] );
+        hexCorners[1] = cvf::Vec3d( nodeCoords[cornerIndices[1]] );
+        hexCorners[2] = cvf::Vec3d( nodeCoords[cornerIndices[2]] );
+        hexCorners[3] = cvf::Vec3d( nodeCoords[cornerIndices[3]] );
+        hexCorners[4] = cvf::Vec3d( nodeCoords[cornerIndices[4]] );
+        hexCorners[5] = cvf::Vec3d( nodeCoords[cornerIndices[5]] );
+        hexCorners[6] = cvf::Vec3d( nodeCoords[cornerIndices[6]] );
+        hexCorners[7] = cvf::Vec3d( nodeCoords[cornerIndices[7]] );
+
+        if ( RigHexIntersectionTools::isPointInCell( position, hexCorners ) )
+        {
+            int timeStepIndex = 0;
+            int frameIndex    = 0;
+
+            const std::vector<float>& data = m_resultFrames->frameData( timeStepIndex, frameIndex );
+            if ( elementIdx >= data.size() ) return std::numeric_limits<double>::infinity();
+
+            return data[elementIdx];
+        }
+    }
+
+    return std::numeric_limits<double>::infinity();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimFaultReactivationDataAccessorGeoMech::hasValidDataAtPosition( const cvf::Vec3d& position ) const
+{
+    double value = valueAtPosition( position );
+    return !std::isinf( value );
+}

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorGeoMech.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 "RimFaultReactivationDataAccessor.h"
+#include "RimFaultReactivationEnums.h"
+
+#include "RigFemResultAddress.h"
+
+class RigFemPartResultsCollection;
+class RimGeoMechCase;
+class RigGeoMechCaseData;
+class RigFemScalarResultFrames;
+
+//==================================================================================================
+///
+///
+//==================================================================================================
+class RimFaultReactivationDataAccessorGeoMech : public RimFaultReactivationDataAccessor
+{
+public:
+    RimFaultReactivationDataAccessorGeoMech( RimGeoMechCase* geoMechCase, RimFaultReactivation::Property property );
+    ~RimFaultReactivationDataAccessorGeoMech();
+
+    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 RigFemResultAddress getResultAddress( RimFaultReactivation::Property property );
+
+    RimGeoMechCase*                m_geoMechCase;
+    RimFaultReactivation::Property m_property;
+    RigGeoMechCaseData*            m_geoMechCaseData;
+    RigFemScalarResultFrames*      m_resultFrames;
+};

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationEnums.h

@@ -62,7 +62,10 @@ enum class Property
 {
     PorePressure,
     VoidRatio,
-    Temperature
+    Temperature,
+    Density,
+    YoungsModulus,
+    PoissonsRatio
 };
 
 } // namespace RimFaultReactivation

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationModel.cpp

@@ -731,7 +731,7 @@ bool RimFaultReactivationModel::extractAndExportModelData()
     auto grid = eCase->mainGrid();
 
     // extract data for each timestep
-    m_dataAccess = std::make_shared<RimFaultReactivationDataAccess>( eCase, selectedTimeStepIndexes );
+    m_dataAccess = std::make_shared<RimFaultReactivationDataAccess>( eCase, geoMechCase(), selectedTimeStepIndexes );
     model()->generateElementSets( m_dataAccess.get(), grid );
     m_dataAccess->extractModelData( *model() );