OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Fault reactivation: Improve POR-Bar extraction.

Browse Source
This commit is contained in:
Kristian Bendiksen
2024-02-05 17:52:32 +01:00
parent 5037473f5c
commit 5a3894b804
14 changed files with 163 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccess.cpp
View File

@@ -41,6 +41,7 @@
#include "RimFaultReactivationDataAccessorVoidRatio.h"
#include "RimFaultReactivationEnums.h"
#include "RimFaultReactivationModel.h"
#include <limits>
//--------------------------------------------------------------------------------------------------
///
@@ -179,20 +180,24 @@ std::vector<double> RimFaultReactivationDataAccess::extractModelData( const RigF
CAF_ASSERT( it != borderSurfaceElements.end() && "Sea bed border surface does not exist" );
std::set<unsigned int> seabedElements( it->second.begin(), it->second.end() );
std::vector<double> values;
if ( nodeProperties.contains( property ) )
{
for ( auto& node : grid->dataNodes() )
int numNodes = static_cast<int>( grid->dataNodes().size() );
std::vector<double> values( numNodes, std::numeric_limits<double>::infinity() );
for ( int nodeIndex = 0; nodeIndex < numNodes; nodeIndex++ )
{
double value = accessor->valueAtPosition( node, model, gridPart );
values.push_back( value );
double value = accessor->valueAtPosition( grid->dataNodes()[nodeIndex], model, gridPart );
values[nodeIndex] = value;
}
return values;
}
else
{
size_t numElements = grid->elementIndices().size();
for ( size_t elementIndex = 0; elementIndex < numElements; elementIndex++ )
int numElements = static_cast<int>( grid->elementIndices().size() );
std::vector<double> values( numElements, std::numeric_limits<double>::infinity() );
for ( int elementIndex = 0; elementIndex < numElements; elementIndex++ )
{
std::vector<cvf::Vec3d> corners = grid->elementDataCorners( elementIndex );
@@ -203,13 +208,12 @@ std::vector<double> RimFaultReactivationDataAccess::extractModelData( const RigF
double topDepth = computeAverageDepth( corners, { 0, 1, 2, 3 } ) - topDepthAdjust;
double bottomDepth = computeAverageDepth( corners, { 4, 5, 6, 7 } );
cvf::Vec3d position = RigCaseToCaseCellMapperTools::calculateCellCenter( corners.data() );
double value = accessor->valueAtPosition( position, model, gridPart, topDepth, bottomDepth, elementIndex );
values.push_back( value );
cvf::Vec3d position = RigCaseToCaseCellMapperTools::calculateCellCenter( corners.data() );
double value = accessor->valueAtPosition( position, model, gridPart, topDepth, bottomDepth, elementIndex );
values[elementIndex] = value;
}
return values;
}
return values;
}
return {};

19
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessor.cpp
View File

@@ -21,6 +21,7 @@
#include "RigFaultReactivationModel.h"
#include "RigMainGrid.h"
#include "RimFaultReactivationEnums.h"
#include "cafAssert.h"
//--------------------------------------------------------------------------------------------------
@@ -48,3 +49,21 @@ void RimFaultReactivationDataAccessor::setModelAndTimeStep( const RigFaultReacti
m_timeStep = timeStep;
updateResultAccessor();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<bool, RimFaultReactivation::ElementSets> RimFaultReactivationDataAccessor::findElementSetForElementIndex(
const std::map<RimFaultReactivation::ElementSets, std::vector<unsigned int>>& elementSets,
int elementIndex )
{
for ( auto [s, indexes] : elementSets )
{
if ( std::find( indexes.begin(), indexes.end(), elementIndex ) != indexes.end() )
{
return std::pair<bool, RimFaultReactivation::ElementSets>( true, s );
}
}
return std::pair<bool, RimFaultReactivation::ElementSets>( false, RimFaultReactivation::ElementSets::OverBurden );
}

5
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessor.h
View File

@@ -24,6 +24,7 @@
#include <limits>
#include <map>
#include <vector>
class RigMainGrid;
class RigFaultReactivationModel;
@@ -52,6 +53,10 @@ public:
protected:
virtual void updateResultAccessor() = 0;
static std::pair<bool, RimFaultReactivation::ElementSets>
findElementSetForElementIndex( const std::map<RimFaultReactivation::ElementSets, std::vector<unsigned int>>& elementSets,
int elementIndex );
const RigFaultReactivationModel* m_model;
size_t m_timeStep;
};

24
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorGeoMech.cpp
View File

@@ -61,18 +61,14 @@ void RimFaultReactivationDataAccessorGeoMech::updateResultAccessor()
{
const int partIndex = 0;
auto loadFrameLambda = [&]( auto femParts, RigFemResultAddress addr ) -> RigFemScalarResultFrames*
auto loadFrameLambda = [&]( auto femParts, RigFemResultAddress addr ) -> std::vector<float>
{
auto result = femParts->findOrLoadScalarResult( partIndex, addr );
if ( result->frameData( 0, 0 ).empty() )
{
return nullptr;
}
return result;
return result->frameData( 0, 0 );
};
auto femParts = m_geoMechCaseData->femPartResults();
m_resultFrames = loadFrameLambda( femParts, getResultAddress( m_property ) );
auto femParts = m_geoMechCaseData->femPartResults();
m_data = loadFrameLambda( femParts, getResultAddress( m_property ) );
}
//--------------------------------------------------------------------------------------------------
@@ -104,23 +100,19 @@ double RimFaultReactivationDataAccessorGeoMech::valueAtPosition( const cvf::Vec3
double bottomDepth,
size_t elementIndex ) const
{
if ( !m_resultFrames ) return std::numeric_limits<double>::infinity();
if ( !m_data.empty() ) return std::numeric_limits<double>::infinity();
RimWellIADataAccess iaDataAccess( m_geoMechCase );
int elementIdx = iaDataAccess.elementIndex( position );
if ( elementIdx != -1 )
{
int timeStepIndex = 0;
int frameIndex = 0;
const std::vector<float>& data = m_resultFrames->frameData( timeStepIndex, frameIndex );
if ( elementIdx >= static_cast<int>( data.size() ) ) return std::numeric_limits<double>::infinity();
if ( elementIdx >= static_cast<int>( m_data.size() ) ) return std::numeric_limits<double>::infinity();
if ( m_property == RimFaultReactivation::Property::YoungsModulus )
{
return RiaEclipseUnitTools::gigaPascalToPascal( data[elementIdx] );
return RiaEclipseUnitTools::gigaPascalToPascal( m_data[elementIdx] );
}
return data[elementIdx];
return m_data[elementIdx];
}
return std::numeric_limits<double>::infinity();

2
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorGeoMech.h
View File

@@ -55,5 +55,5 @@ private:
RimGeoMechCase* m_geoMechCase;
RimFaultReactivation::Property m_property;
RigGeoMechCaseData* m_geoMechCaseData;
RigFemScalarResultFrames* m_resultFrames;
std::vector<float> m_data;
};

20
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorPorePressure.cpp
View File

@@ -109,24 +109,24 @@ double RimFaultReactivationDataAccessorPorePressure::valueAtPosition( const cvf:
CAF_ASSERT( m_wellPaths.find( gridPart ) != m_wellPaths.end() );
auto wellPath = m_wellPaths.find( gridPart )->second;
auto cellIdx = m_mainGrid->findReservoirCellIndexFromPoint( position );
if ( cellIdx != cvf::UNDEFINED_SIZE_T )
{
double valueFromEclipse = m_resultAccessor->cellScalar( cellIdx );
if ( !std::isinf( valueFromEclipse ) ) return RiaEclipseUnitTools::barToPascal( valueFromEclipse );
}
auto [values, intersections] =
RimFaultReactivationDataAccessorWellLogExtraction::extractValuesAndIntersections( *m_resultAccessor.p(), *extractor.p(), *wellPath );
auto [value, pos] = RimFaultReactivationDataAccessorWellLogExtraction::calculatePorBar( model,
RimFaultReactivation::ElementSets elementSet = RimFaultReactivation::ElementSets::UnderBurden;
auto [value, pos] = RimFaultReactivationDataAccessorWellLogExtraction::calculatePorBar( model,
gridPart,
intersections,
values,
position,
elementSet,
m_defaultPorePressureGradient );
if ( pos.isUndefined() )
{
auto cellIdx = m_mainGrid->findReservoirCellIndexFromPoint( position );
if ( cellIdx != cvf::UNDEFINED_SIZE_T )
{
double valueFromEclipse = m_resultAccessor->cellScalar( cellIdx );
if ( !std::isinf( valueFromEclipse ) ) return RiaEclipseUnitTools::barToPascal( valueFromEclipse );
}
}
return RiaEclipseUnitTools::barToPascal( value );
}

23
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorStress.cpp
View File

@@ -83,19 +83,22 @@ double RimFaultReactivationDataAccessorStress::valueAtPosition( const cvf::Vec3d
cvf::Vec3d topPosition( position.x(), position.y(), topDepth );
cvf::Vec3d bottomPosition( position.x(), position.y(), bottomDepth );
auto part = model.grid( gridPart );
auto [isOk, elementSet] = findElementSetForElementIndex( part->elementSets(), static_cast<int>( elementIndex ) );
if ( isPositionValid( position, topPosition, bottomPosition, gridPart ) )
{
if ( m_property == RimFaultReactivation::Property::StressTop )
{
auto [porBar, extractionPos] = calculatePorBar( topPosition, m_gradient, gridPart );
auto [porBar, extractionPos] = calculatePorBar( topPosition, elementSet, m_gradient, gridPart );
if ( std::isinf( porBar ) ) return porBar;
double s33 = extractStressValue( StressType::S33, extractionPos, gridPart );
return -RiaEclipseUnitTools::barToPascal( s33 - porBar );
}
else if ( m_property == RimFaultReactivation::Property::StressBottom )
{
auto [porBar, extractionPos] = calculatePorBar( bottomPosition, m_gradient, gridPart );
auto [porBar, extractionPos] = calculatePorBar( bottomPosition, elementSet, m_gradient, gridPart );
if ( std::isinf( porBar ) ) return porBar;
double s33 = extractStressValue( StressType::S33, extractionPos, gridPart );
return -RiaEclipseUnitTools::barToPascal( s33 - porBar );
@@ -110,11 +113,11 @@ double RimFaultReactivationDataAccessorStress::valueAtPosition( const cvf::Vec3d
}
else if ( m_property == RimFaultReactivation::Property::LateralStressComponentX )
{
return lateralStressComponentX( position, gridPart );
return lateralStressComponentX( position, elementSet, gridPart );
}
else if ( m_property == RimFaultReactivation::Property::LateralStressComponentY )
{
return lateralStressComponentY( position, gridPart );
return lateralStressComponentY( position, elementSet, gridPart );
}
}
@@ -124,9 +127,11 @@ double RimFaultReactivationDataAccessorStress::valueAtPosition( const cvf::Vec3d
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFaultReactivationDataAccessorStress::lateralStressComponentX( const cvf::Vec3d& position, RimFaultReactivation::GridPart gridPart ) const
double RimFaultReactivationDataAccessorStress::lateralStressComponentX( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
RimFaultReactivation::GridPart gridPart ) const
{
auto [porBar, extractionPos] = calculatePorBar( position, m_gradient, gridPart );
auto [porBar, extractionPos] = calculatePorBar( position, elementSet, m_gradient, gridPart );
if ( std::isinf( porBar ) ) return porBar;
double s11 = extractStressValue( StressType::S11, extractionPos, gridPart );
double s33 = extractStressValue( StressType::S33, extractionPos, gridPart );
@@ -136,9 +141,11 @@ double RimFaultReactivationDataAccessorStress::lateralStressComponentX( const cv
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFaultReactivationDataAccessorStress::lateralStressComponentY( const cvf::Vec3d& position, RimFaultReactivation::GridPart gridPart ) const
double RimFaultReactivationDataAccessorStress::lateralStressComponentY( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
RimFaultReactivation::GridPart gridPart ) const
{
auto [porBar, extractionPos] = calculatePorBar( position, m_gradient, gridPart );
auto [porBar, extractionPos] = calculatePorBar( position, elementSet, m_gradient, gridPart );
if ( std::isinf( porBar ) ) return porBar;
double s22 = extractStressValue( StressType::S22, extractionPos, gridPart );
double s33 = extractStressValue( StressType::S33, extractionPos, gridPart );

14
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorStress.h
View File

@@ -63,16 +63,22 @@ protected:
virtual double extractStressValue( StressType stressType, const cvf::Vec3d& position, RimFaultReactivation::GridPart gridPart ) const = 0;
virtual std::pair<double, cvf::Vec3d>
calculatePorBar( const cvf::Vec3d& position, double gradient, RimFaultReactivation::GridPart gridPart ) const = 0;
virtual std::pair<double, cvf::Vec3d> calculatePorBar( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
double gradient,
RimFaultReactivation::GridPart gridPart ) const = 0;
virtual bool isPositionValid( const cvf::Vec3d& position,
const cvf::Vec3d& topPosition,
const cvf::Vec3d& bottomPosition,
RimFaultReactivation::GridPart gridPart ) const = 0;
virtual double lateralStressComponentX( const cvf::Vec3d& position, RimFaultReactivation::GridPart gridPart ) const;
virtual double lateralStressComponentY( const cvf::Vec3d& position, RimFaultReactivation::GridPart gridPart ) const;
virtual double lateralStressComponentX( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
RimFaultReactivation::GridPart gridPart ) const;
virtual double lateralStressComponentY( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
RimFaultReactivation::GridPart gridPart ) const;
RimFaultReactivation::Property m_property;
double m_gradient;

29
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorStressEclipse.cpp
View File

@@ -176,15 +176,17 @@ bool RimFaultReactivationDataAccessorStressEclipse::isPositionValid( const cvf::
const cvf::Vec3d& bottomPosition,
RimFaultReactivation::GridPart gridPart ) const
{
auto [porBar, extractionPosition] = calculatePorBar( position, m_gradient, gridPart );
return !std::isinf( porBar );
// auto [porBar, extractionPosition] = calculatePorBar( position, m_gradient, gridPart );
// return !std::isinf( porBar );
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<double, cvf::Vec3d> RimFaultReactivationDataAccessorStressEclipse::calculatePorBar( const cvf::Vec3d& position,
double gradient,
std::pair<double, cvf::Vec3d> RimFaultReactivationDataAccessorStressEclipse::calculatePorBar( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
double gradient,
RimFaultReactivation::GridPart gridPart ) const
{
if ( ( m_mainGrid != nullptr ) && m_resultAccessor.notNull() )
@@ -198,8 +200,13 @@ std::pair<double, cvf::Vec3d> RimFaultReactivationDataAccessorStressEclipse::cal
auto [values, intersections] =
RimFaultReactivationDataAccessorWellLogExtraction::extractValuesAndIntersections( *m_resultAccessor.p(), *extractor.p(), *wellPath );
auto [value, extractionPos] =
RimFaultReactivationDataAccessorWellLogExtraction::calculatePorBar( *m_model, gridPart, intersections, values, position, m_gradient );
auto [value, extractionPos] = RimFaultReactivationDataAccessorWellLogExtraction::calculatePorBar( *m_model,
gridPart,
intersections,
values,
position,
elementSet,
m_gradient );
if ( extractionPos.isUndefined() )
{
auto cellIdx = m_mainGrid->findReservoirCellIndexFromPoint( position );
@@ -269,8 +276,9 @@ std::vector<double>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFaultReactivationDataAccessorStressEclipse::lateralStressComponentX( const cvf::Vec3d& position,
RimFaultReactivation::GridPart gridPart ) const
double RimFaultReactivationDataAccessorStressEclipse::lateralStressComponentX( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
RimFaultReactivation::GridPart gridPart ) const
{
return m_lateralStressComponent;
}
@@ -278,8 +286,9 @@ double RimFaultReactivationDataAccessorStressEclipse::lateralStressComponentX( c
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFaultReactivationDataAccessorStressEclipse::lateralStressComponentY( const cvf::Vec3d& position,
RimFaultReactivation::GridPart gridPart ) const
double RimFaultReactivationDataAccessorStressEclipse::lateralStressComponentY( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
RimFaultReactivation::GridPart gridPart ) const
{
return m_lateralStressComponent;
}

14
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorStressEclipse.h
View File

@@ -59,16 +59,22 @@ private:
double extractStressValue( StressType stressType, const cvf::Vec3d& position, RimFaultReactivation::GridPart gridPart ) const override;
std::pair<double, cvf::Vec3d>
calculatePorBar( const cvf::Vec3d& position, double gradient, RimFaultReactivation::GridPart gridPart ) const override;
std::pair<double, cvf::Vec3d> calculatePorBar( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
double gradient,
RimFaultReactivation::GridPart gridPart ) const override;
bool isPositionValid( const cvf::Vec3d& position,
const cvf::Vec3d& topPosition,
const cvf::Vec3d& bottomPosition,
RimFaultReactivation::GridPart gridPart ) const override;
double lateralStressComponentX( const cvf::Vec3d& position, RimFaultReactivation::GridPart gridPart ) const override;
double lateralStressComponentY( const cvf::Vec3d& position, RimFaultReactivation::GridPart gridPart ) const override;
double lateralStressComponentX( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
RimFaultReactivation::GridPart gridPart ) const override;
double lateralStressComponentY( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
RimFaultReactivation::GridPart gridPart ) const override;
static std::vector<double> integrateVerticalStress( const RigWellPath& wellPath,
const std::vector<cvf::Vec3d>& intersections,

19
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorStressGeoMech.cpp
View File

@@ -172,13 +172,14 @@ RigFemScalarResultFrames* RimFaultReactivationDataAccessorStressGeoMech::dataFra
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<double, cvf::Vec3d> RimFaultReactivationDataAccessorStressGeoMech::calculatePorBar( const cvf::Vec3d& position,
double gradient,
std::pair<double, cvf::Vec3d> RimFaultReactivationDataAccessorStressGeoMech::calculatePorBar( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
double gradient,
RimFaultReactivation::GridPart gridPart ) const
{
int timeStepIndex = 0;
int frameIndex = m_s33Frames->frameCount( timeStepIndex ) - 1;
return calculatePorBar( position, m_gradient, gridPart, timeStepIndex, frameIndex );
return calculatePorBar( position, elementSet, m_gradient, gridPart, timeStepIndex, frameIndex );
}
//--------------------------------------------------------------------------------------------------
@@ -210,10 +211,11 @@ double RimFaultReactivationDataAccessorStressGeoMech::interpolatedResultValue( R
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<double, cvf::Vec3d> RimFaultReactivationDataAccessorStressGeoMech::calculatePorBar( const cvf::Vec3d& position,
double gradient,
RimFaultReactivation::GridPart gridPart,
int timeStepIndex,
std::pair<double, cvf::Vec3d> RimFaultReactivationDataAccessorStressGeoMech::calculatePorBar( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
double gradient,
RimFaultReactivation::GridPart gridPart,
int timeStepIndex,
int frameIndex ) const
{
CAF_ASSERT( m_extractors.find( gridPart ) != m_extractors.end() );
@@ -234,6 +236,7 @@ std::pair<double, cvf::Vec3d> RimFaultReactivationDataAccessorStressGeoMech::cal
extractor->intersections(),
values,
position,
elementSet,
gradient );
if ( extractionPos.isUndefined() )
@@ -245,7 +248,7 @@ std::pair<double, cvf::Vec3d> RimFaultReactivationDataAccessorStressGeoMech::cal
// Use data from geo mech grid if defined (only position is reservoir).
RimWellIADataAccess iaDataAccess( m_geoMechCase );
double gridValue = iaDataAccess.interpolatedResultValue( m_femPart, frameData, RIG_NODAL, position );
if ( !std::isinf( gridValue ) )
if ( !std::isinf( gridValue ) && !std::isnan( gridValue ) )
{
return { gridValue, position };
}

31
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorStressGeoMech.h
View File

@@ -62,8 +62,10 @@ private:
double extractStressValue( StressType stressType, const cvf::Vec3d& position, RimFaultReactivation::GridPart gridPart ) const override;
std::pair<double, cvf::Vec3d>
calculatePorBar( const cvf::Vec3d& position, double gradient, RimFaultReactivation::GridPart gridPart ) const override;
std::pair<double, cvf::Vec3d> calculatePorBar( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
double gradient,
RimFaultReactivation::GridPart gridPart ) const override;
bool isPositionValid( const cvf::Vec3d& position,
const cvf::Vec3d& topPosition,
@@ -77,21 +79,22 @@ private:
const cvf::Vec3d& position,
const std::vector<float>& scalarResults ) const;
std::pair<double, cvf::Vec3d> calculatePorBar( const cvf::Vec3d& position,
double gradient,
RimFaultReactivation::GridPart gridPart,
int timeStepIndex,
int frameIndex ) const;
std::pair<double, cvf::Vec3d> calculatePorBar( const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
double gradient,
RimFaultReactivation::GridPart gridPart,
int timeStepIndex,
int frameIndex ) const;
RigFemScalarResultFrames* dataFrames( StressType stressType ) const;
RimGeoMechCase* m_geoMechCase;
RigGeoMechCaseData* m_geoMechCaseData;
RigFemScalarResultFrames* m_s11Frames;
RigFemScalarResultFrames* m_s22Frames;
RigFemScalarResultFrames* m_s33Frames;
RigFemScalarResultFrames* m_porBarFrames;
const RigFemPart* m_femPart;
RimGeoMechCase* m_geoMechCase;
RigGeoMechCaseData* m_geoMechCaseData;
RigFemScalarResultFrames* m_s11Frames;
RigFemScalarResultFrames* m_s22Frames;
RigFemScalarResultFrames* m_s33Frames;
const RigFemScalarResultFrames* m_porBarFrames;
const RigFemPart* m_femPart;
std::map<RimFaultReactivation::GridPart, cvf::ref<RigWellPath>> m_wellPaths;
std::map<RimFaultReactivation::GridPart, cvf::ref<RigGeoMechWellLogExtractor>> m_extractors;

28
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorWellLogExtraction.cpp
View File

@@ -66,20 +66,13 @@ RimFaultReactivationDataAccessorWellLogExtraction::~RimFaultReactivationDataAcce
std::pair<double, cvf::Vec3d> RimFaultReactivationDataAccessorWellLogExtraction::calculatePorBar( const RigFaultReactivationModel& model,
RimFaultReactivation::GridPart gridPart,
const std::vector<cvf::Vec3d>& intersections,
std::vector<double>& values,
const cvf::Vec3d& position,
double gradient )
std::vector<double>& values,
const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
double gradient )
{
auto part = model.grid( gridPart );
CAF_ASSERT( part );
auto elementSets = part->elementSets();
auto [isOk, elementSet] = RimFaultReactivationDataAccessorWellLogExtraction::findElementSetForPoint( *part, position, elementSets );
if ( isOk && ( elementSet == RimFaultReactivation::ElementSets::OverBurden || elementSet == RimFaultReactivation::ElementSets::UnderBurden ) )
if ( elementSet == RimFaultReactivation::ElementSets::OverBurden || elementSet == RimFaultReactivation::ElementSets::UnderBurden )
{
auto calculatePorePressure = []( double depth, double gradient )
{ return RiaEclipseUnitTools::pascalToBar( gradient * 9.81 * depth * 1000.0 ); };
return { calculatePorePressure( std::abs( position.z() ), gradient ), position };
}
@@ -236,9 +229,6 @@ void RimFaultReactivationDataAccessorWellLogExtraction::fillInMissingValuesWithG
{
CAF_ASSERT( intersections.size() == values.size() );
auto calculatePorePressure = []( double depth, double gradient )
{ return RiaEclipseUnitTools::pascalToBar( gradient * 9.81 * depth * 1000.0 ); };
auto [lastOverburdenIndex, firstUnderburdenIndex] = findOverburdenAndUnderburdenIndex( values );
// Fill in overburden values using gradient
@@ -483,3 +473,11 @@ std::pair<bool, RimFaultReactivation::ElementSets> RimFaultReactivationDataAcces
return { false, RimFaultReactivation::ElementSets::OverBurden };
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFaultReactivationDataAccessorWellLogExtraction::calculatePorePressure( double depth, double gradient )
{
return RiaEclipseUnitTools::pascalToBar( gradient * 9.81 * depth * 1000.0 );
}

15
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorWellLogExtraction.h
View File

@@ -42,12 +42,13 @@ public:
RimFaultReactivationDataAccessorWellLogExtraction();
~RimFaultReactivationDataAccessorWellLogExtraction();
static std::pair<double, cvf::Vec3d> calculatePorBar( const RigFaultReactivationModel& model,
RimFaultReactivation::GridPart gridPart,
const std::vector<cvf::Vec3d>& intersections,
std::vector<double>& values,
const cvf::Vec3d& position,
double gradient );
static std::pair<double, cvf::Vec3d> calculatePorBar( const RigFaultReactivationModel& model,
RimFaultReactivation::GridPart gridPart,
const std::vector<cvf::Vec3d>& intersections,
std::vector<double>& values,
const cvf::Vec3d& position,
RimFaultReactivation::ElementSets elementSet,
double gradient );
static std::pair<double, cvf::Vec3d> calculateTemperature( const std::vector<cvf::Vec3d>& intersections,
std::vector<double>& values,
@@ -100,4 +101,6 @@ protected:
int lastOverburdenIndex,
double topValue );
static double computeMinimumDistance( const cvf::Vec3d& position, const std::vector<cvf::Vec3d>& positions );
static double calculatePorePressure( double depth, double gradient );
};