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

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

Browse Source 
Fixes #10743.
This commit is contained in:
Kristian Bendiksen
2023-10-23 16:04:48 +02:00
parent a91afff937
commit ea4e46b400
20 changed files with 971 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -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