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

148
ApplicationLibCode/FileInterface/RifFaultReactivationModelExporter.cpp
View File

@@ -27,6 +27,9 @@
#include "RiaVersionInfo.h"
#include "RifInpExportTools.h"
#include "RimFaultReactivationDataAccess.h"
#include "RimFaultReactivationEnums.h"
#include "RimFaultReactivationModel.h"
#include <filesystem>
#include <fstream>
@@ -71,7 +74,11 @@ std::pair<bool, std::string> RifFaultReactivationModelExporter::exportToStream(
{ RimFaultReactivation::ElementSets::UnderBurden, "UNDERBURDEN" },
};
double faultFriction = 0.0;
double faultFriction = 0.0;
bool useGridVoidRatio = rimModel.useGridVoidRatio();
bool useGridPorePressure = rimModel.useGridPorePressure();
bool useGridTemperature = rimModel.useGridTemperature();
auto dataAccess = rimModel.dataAccess();
auto model = rimModel.model();
CAF_ASSERT( !model.isNull() );
@@ -83,9 +90,12 @@ std::pair<bool, std::string> RifFaultReactivationModelExporter::exportToStream(
[&]() { return printMaterials( stream, rimModel, materialNames ); },
[&]() { return printInteractionProperties( stream, faultFriction ); },
[&]() { return printBoundaryConditions( stream, *model, partNames, boundaries ); },
[&]() { return printPredefinedFields( stream, partNames ); },
[&]() { return printPredefinedFields( stream, *model, *dataAccess, exportDirectory, partNames, useGridVoidRatio ); },
[&]() { return printInteractions( stream, partNames, borders ); },
[&]() { return printSteps( stream, *model, partNames, rimModel.selectedTimeSteps(), exportDirectory ); },
[&]()
{
return printSteps( stream, *model, *dataAccess, partNames, rimModel.selectedTimeSteps(), exportDirectory, useGridPorePressure, useGridTemperature );
},
};
for ( auto method : methods )
@@ -398,7 +408,11 @@ std::pair<bool, std::string>
//--------------------------------------------------------------------------------------------------
std::pair<bool, std::string>
RifFaultReactivationModelExporter::printPredefinedFields( std::ostream& stream,
const std::map<RimFaultReactivation::GridPart, std::string>& partNames )
const RigFaultReactivationModel& model,
const RimFaultReactivationDataAccess& dataAccess,
const std::string& exportDirectory,
const std::map<RimFaultReactivation::GridPart, std::string>& partNames,
bool voidRatioFromEclipse )
{
// PREDEFINED FIELDS
struct PredefinedField
@@ -412,7 +426,10 @@ std::pair<bool, std::string>
for ( auto [part, partName] : partNames )
{
std::string name = partName + "." + partName;
fields.push_back( PredefinedField{ .initialConditionType = "RATIO", .partName = name, .value = 0.3 } );
if ( !voidRatioFromEclipse )
{
fields.push_back( PredefinedField{ .initialConditionType = "RATIO", .partName = name, .value = 0.3 } );
}
fields.push_back( PredefinedField{ .initialConditionType = "PORE PRESSURE", .partName = name, .value = 0.0 } );
}
@@ -424,17 +441,37 @@ std::pair<bool, std::string>
RifInpExportTools::printLine( stream, field.partName + ", " + std::to_string( field.value ) );
}
if ( voidRatioFromEclipse )
{
std::string ratioName = "RATIO";
// Export the ratio to a separate inp file for each step
std::string fileName = ratioName + ".inp";
std::string filePath = createFilePath( exportDirectory, fileName );
// Use void ratio from first time step
size_t timeStep = 0;
bool isOk = writePropertyToFile( model, dataAccess, RimFaultReactivation::Property::VoidRatio, timeStep, filePath, partNames, "" );
if ( !isOk ) return { false, "Failed to create " + ratioName + " file." };
RifInpExportTools::printHeading( stream, "Initial Conditions, TYPE=" + ratioName );
RifInpExportTools::printHeading( stream, "INCLUDE, input=" + fileName );
}
return { true, "" };
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<bool, std::string> RifFaultReactivationModelExporter::printSteps( std::ostream& stream,
const RigFaultReactivationModel& model,
std::pair<bool, std::string> RifFaultReactivationModelExporter::printSteps( std::ostream& stream,
const RigFaultReactivationModel& model,
const RimFaultReactivationDataAccess& dataAccess,
const std::map<RimFaultReactivation::GridPart, std::string>& partNames,
const std::vector<QDateTime>& timeSteps,
const std::string& exportDirectory )
const std::string& exportDirectory,
bool useGridPorePressure,
bool useGridTemperature )
{
// First time step has to be selected in order to export currently
if ( timeSteps.size() < 2 ) return { false, "Failed to export fault reactivation INP: needs at least two time steps." };
@@ -453,36 +490,37 @@ std::pair<bool, std::string> RifFaultReactivationModelExporter::printSteps( std:
RifInpExportTools::printHeading( stream, stepType );
RifInpExportTools::printNumbers( stream, { 1.0, 1.0, 1e-05, 1.0 } );
RifInpExportTools::printSectionComment( stream, "BOUNDARY CONDITIONS" );
// Export the pore pressure to a separate inp file for each step
QString fileName = "PORE_PRESSURE_DATE_" + timeSteps[i].toString( "yyyyMMdd" ) + "_" + QString::fromStdString( stepName ) + ".inp";
QString filePath = QString( "%1/%2" ).arg( QString::fromStdString( exportDirectory ) ).arg( fileName );
std::ofstream ppStream( filePath.toStdString() );
if ( !ppStream.good() )
if ( useGridPorePressure )
{
return { false, "Failed to create pore pressure file." };
RifInpExportTools::printSectionComment( stream, "BOUNDARY CONDITIONS" );
// Export the pore pressure to a separate inp file for each step
std::string fileName = createFileName( "PORE_PRESSURE", timeSteps[i], stepName );
std::string filePath = createFilePath( exportDirectory, fileName );
bool isOk =
writePropertyToFile( model, dataAccess, RimFaultReactivation::Property::PorePressure, i, filePath, partNames, "8, 8, " );
if ( !isOk ) return { false, "Failed to create pore pressure file." };
RifInpExportTools::printHeading( stream, "Boundary, type=displacement" );
RifInpExportTools::printHeading( stream, "INCLUDE, input=" + fileName );
}
for ( auto [part, partName] : partNames )
if ( useGridTemperature )
{
auto grid = model.grid( part );
RifInpExportTools::printSectionComment( stream, "TEMPERATURE" );
const std::vector<cvf::Vec3d>& nodes = grid->nodes();
// Export the pore pressure to a separate inp file for each step
std::string fileName = createFileName( "TEMPERATURE", timeSteps[i], stepName );
std::string filePath = createFilePath( exportDirectory, fileName );
const std::vector<double> porePressure = grid->nodePorePressure( i );
for ( size_t i = 0; i < nodes.size(); i++ )
{
std::string line = partName + "." + std::to_string( i + 1 ) + ", 8, 8, " + std::to_string( porePressure[i] );
RifInpExportTools::printLine( ppStream, line );
}
bool isOk = writePropertyToFile( model, dataAccess, RimFaultReactivation::Property::Temperature, i, filePath, partNames, "" );
if ( !isOk ) return { false, "Failed to create temperature file." };
RifInpExportTools::printHeading( stream, "Temperature" );
RifInpExportTools::printHeading( stream, "INCLUDE, input=" + fileName );
}
RifInpExportTools::printHeading( stream, "Boundary, type=displacement" );
RifInpExportTools::printHeading( stream, "INCLUDE, input=" + fileName.toStdString() );
RifInpExportTools::printSectionComment( stream, "OUTPUT REQUESTS" );
RifInpExportTools::printHeading( stream, "Restart, write, frequency=0" );
@@ -498,6 +536,36 @@ std::pair<bool, std::string> RifFaultReactivationModelExporter::printSteps( std:
return { true, "" };
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifFaultReactivationModelExporter::writePropertyToFile( const RigFaultReactivationModel& model,
const RimFaultReactivationDataAccess& dataAccess,
RimFaultReactivation::Property property,
size_t outputTimeStep,
const std::string& filePath,
const std::map<RimFaultReactivation::GridPart, std::string>& partNames,
const std::string& additionalData )
{
std::ofstream stream( filePath );
if ( !stream.good() ) return false;
for ( auto [part, partName] : partNames )
{
auto grid = model.grid( part );
const std::vector<cvf::Vec3d>& nodes = grid->globalNodes();
const std::vector<double> values = dataAccess.propertyValues( part, property, outputTimeStep );
for ( size_t i = 0; i < nodes.size(); i++ )
{
std::string line = partName + "." + std::to_string( i + 1 ) + ", " + additionalData + std::to_string( values[i] );
RifInpExportTools::printLine( stream, line );
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -529,3 +597,23 @@ std::pair<bool, std::string>
return { true, "" };
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::string RifFaultReactivationModelExporter::createFileName( const std::string& title, const QDateTime& dateTime, const std::string& stepName )
{
return QString( "%1_DATE_%2_%3.inp" )
.arg( QString::fromStdString( title ) )
.arg( dateTime.toString( "yyyyMMdd" ) )
.arg( QString::fromStdString( stepName ) )
.toStdString();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::string RifFaultReactivationModelExporter::createFilePath( const std::string& dir, const std::string& fileName )
{
return dir + "/" + fileName;
};

23
ApplicationLibCode/FileInterface/RifFaultReactivationModelExporter.h
View File

@@ -64,15 +64,34 @@ private:
const std::map<RimFaultReactivation::GridPart, std::string>& partNames,
const std::map<RimFaultReactivation::Boundary, std::string>& boundaries );
static std::pair<bool, std::string> printPredefinedFields( std::ostream& stream,
const std::map<RimFaultReactivation::GridPart, std::string>& partNames );
const RigFaultReactivationModel& model,
const RimFaultReactivationDataAccess& dataAccess,
const std::string& exportDirectory,
const std::map<RimFaultReactivation::GridPart, std::string>& partNames,
bool useGridVoidRatio );
static std::pair<bool, std::string> printSteps( std::ostream& stream,
const RigFaultReactivationModel& model,
const RimFaultReactivationDataAccess& dataAccess,
const std::map<RimFaultReactivation::GridPart, std::string>& partNames,
const std::vector<QDateTime>& timeSteps,
const std::string& exportDirectory );
const std::string& exportDirectory,
bool useGridPorePressure,
bool useGridTemperature );
static std::pair<bool, std::string>
printInteractions( std::ostream& stream,
const std::map<RimFaultReactivation::GridPart, std::string>& partNames,
const std::vector<std::pair<RimFaultReactivation::BorderSurface, std::string>>& borders );
static bool writePropertyToFile( const RigFaultReactivationModel& model,
const RimFaultReactivationDataAccess& dataAccess,
RimFaultReactivation::Property property,
size_t outputTimeStep,
const std::string& filePath,
const std::map<RimFaultReactivation::GridPart, std::string>& partNames,
const std::string& additionalData );
static std::string createFileName( const std::string& title, const QDateTime& dateTime, const std::string& stepName );
static std::string createFilePath( const std::string& dir, const std::string& fileName );
};

8
ApplicationLibCode/ProjectDataModel/Faults/CMakeLists_files.cmake
View File

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

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

43
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccess.h
View File

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

75
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessor.cpp Normal file
View File

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

57
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessor.h Normal file
View File

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

125
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorPorePressure.cpp Normal file
View File

@@ -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 );
}

58
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorPorePressure.h Normal file
View File

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

107
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorTemperature.cpp Normal file
View File

@@ -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 );
}

55
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorTemperature.h Normal file
View File

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

115
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorVoidRatio.cpp Normal file
View File

@@ -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 );
}

56
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorVoidRatio.h Normal file
View File

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

7
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationEnums.h
View File

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

59
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationModel.cpp
View File

@@ -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();
}

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

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

37
ApplicationLibCode/ReservoirDataModel/RigFaultReactivationModel.cpp
View File

@@ -23,6 +23,8 @@
#include "RimFaultReactivationDataAccess.h"
#include "cafAssert.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -105,17 +107,6 @@ void RigFaultReactivationModel::reset()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFaultReactivationModel::clearModelData()
{
for ( auto part : allGridParts() )
{
m_3dparts[part]->clearModelData();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -364,18 +355,6 @@ std::shared_ptr<RigGriddedPart3d> RigFaultReactivationModel::grid( RimFaultReact
return m_3dparts.at( part );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFaultReactivationModel::extractModelData( RimFaultReactivationDataAccess* dataAccess, size_t outputTimeStep )
{
for ( auto part : allGridParts() )
{
dataAccess->useCellIndexAdjustment( m_cellIndexAdjustmentMap[part] );
m_3dparts[part]->extractModelData( dataAccess, outputTimeStep );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -394,3 +373,15 @@ void RigFaultReactivationModel::generateCellIndexMapping( const RigMainGrid* gri
{
m_cellIndexAdjustmentMap.clear();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<size_t, size_t> RigFaultReactivationModel::cellIndexAdjustment( GridPart part ) const
{
auto it = m_cellIndexAdjustmentMap.find( part );
if ( it != m_cellIndexAdjustmentMap.end() )
return it->second;
else
return {};
}

3
ApplicationLibCode/ReservoirDataModel/RigFaultReactivationModel.h
View File

@@ -89,8 +89,7 @@ public:
void generateCellIndexMapping( const RigMainGrid* grid );
void generateElementSets( const RimFaultReactivationDataAccess* dataAccess, const RigMainGrid* grid );
void clearModelData();
void extractModelData( RimFaultReactivationDataAccess* dataAccess, size_t outputTimeStep );
std::map<size_t, size_t> cellIndexAdjustment( GridPart part ) const;
protected:
void generateGrids( cvf::Vec3dArray points );

37
ApplicationLibCode/ReservoirDataModel/RigGriddedPart3d.cpp
View File

@@ -21,6 +21,7 @@
#include "RigMainGrid.h"
#include "RimFaultReactivationDataAccess.h"
#include "RimFaultReactivationEnums.h"
#include "cvfBoundingBox.h"
#include "cvfTextureImage.h"
@@ -53,16 +54,6 @@ void RigGriddedPart3d::reset()
m_elementIndices.clear();
m_meshLines.clear();
m_elementSets.clear();
clearModelData();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigGriddedPart3d::clearModelData()
{
m_nodePorePressure.clear();
}
//--------------------------------------------------------------------------------------------------
@@ -379,32 +370,6 @@ const std::map<RimFaultReactivation::ElementSets, std::vector<unsigned int>>& Ri
return m_elementSets;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>& RigGriddedPart3d::nodePorePressure( size_t outputTimeStep ) const
{
if ( outputTimeStep >= m_nodePorePressure.size() ) return m_emptyData;
return m_nodePorePressure[outputTimeStep];
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigGriddedPart3d::extractModelData( RimFaultReactivationDataAccess* dataAccess, size_t outputTimeStep )
{
if ( m_nodePorePressure.size() <= outputTimeStep )
{
m_nodePorePressure.resize( outputTimeStep + 1 );
}
for ( auto& node : m_nodes )
{
double pressure = dataAccess->porePressureAtPosition( node, 1.0 );
m_nodePorePressure[outputTimeStep].push_back( pressure );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

6
ApplicationLibCode/ReservoirDataModel/RigGriddedPart3d.h
View File

@@ -44,7 +44,6 @@ public:
~RigGriddedPart3d() override;
void reset();
void clearModelData();
void generateGeometry( std::vector<cvf::Vec3d> inputPoints,
int nHorzCells,
@@ -73,8 +72,6 @@ public:
const std::map<ElementSets, std::vector<unsigned int>>& elementSets() const;
const std::vector<double>& nodePorePressure( size_t outputTimeStep ) const;
protected:
cvf::Vec3d stepVector( cvf::Vec3d start, cvf::Vec3d stop, int nSteps );
void generateMeshlines( const std::vector<cvf::Vec3d>& cornerPoints, int numHorzCells, int numVertCells );
@@ -96,8 +93,5 @@ private:
std::map<Boundary, std::vector<unsigned int>> m_boundaryNodes;
std::map<ElementSets, std::vector<unsigned int>> m_elementSets;
std::vector<std::vector<double>> m_nodePorePressure;
const std::vector<double> m_emptyData;
std::vector<cvf::Vec3d> m_reservoirRect;
};