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

#6035 Handle missing values in fracture model plot.

Browse Source
This commit is contained in:
Kristian Bendiksen 2020-06-05 15:58:25 +02:00
parent 3085fe22e8
commit 89473aa9bd
11 changed files with 298 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
ApplicationCode/Commands/CompletionCommands/RicNewFractureModelPlotFeature.cpp
View File

@ -82,14 +82,26 @@ RimFractureModelPlot*
{
auto task = progInfo.task( "Creating parameters track", 15 );
std::vector<std::pair<QString, RiaDefines::ResultCatType>> results =
{std::make_pair( "PORO", RiaDefines::ResultCatType::STATIC_NATIVE ),
std::make_pair( "PRESSURE", RiaDefines::ResultCatType::DYNAMIC_NATIVE ),
std::make_pair( "PERMZ", RiaDefines::ResultCatType::STATIC_NATIVE )};
std::vector<std::tuple<QString, RiaDefines::ResultCatType, RimFractureModelCurve::MissingValueStrategy>> results =
{std::make_tuple( "PORO",
RiaDefines::ResultCatType::STATIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE ),
std::make_tuple( "PRESSURE",
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::LINEAR_INTERPOLATION ),
std::make_tuple( "PERMX",
RiaDefines::ResultCatType::STATIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE )};
for ( auto result : results )
{
createParametersTrack( plot, fractureModel, eclipseCase, timeStep, result.first, result.second );
createParametersTrack( plot,
fractureModel,
eclipseCase,
timeStep,
std::get<0>( result ),
std::get<1>( result ),
std::get<2>( result ) );
}
}
@ -240,12 +252,14 @@ void RicNewFractureModelPlotFeature::createFaciesTrack( RimFractureModelPlot* pl
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicNewFractureModelPlotFeature::createParametersTrack( RimFractureModelPlot* plot,
RimFractureModel* fractureModel,
RimEclipseCase* eclipseCase,
int timeStep,
const QString& resultVariable,
RiaDefines::ResultCatType resultCategoryType )
RimFractureModelCurve*
RicNewFractureModelPlotFeature::createParametersTrack( RimFractureModelPlot* plot,
RimFractureModel* fractureModel,
RimEclipseCase* eclipseCase,
int timeStep,
const QString& resultVariable,
RiaDefines::ResultCatType resultCategoryType,
RimFractureModelCurve::MissingValueStrategy missingValueStrategy )
{
RimWellLogTrack* plotTrack = RicNewWellLogPlotFeatureImpl::createWellLogPlotTrack( false, resultVariable, plot );
plotTrack->setFormationWellPath( fractureModel->thicknessDirectionWellPath() );
@ -268,6 +282,7 @@ void RicNewFractureModelPlotFeature::createParametersTrack( RimFractureModelPlot
curve->setCase( eclipseCase );
curve->setEclipseResultVariable( resultVariable );
curve->setEclipseResultCategory( resultCategoryType );
curve->setMissingValueStrategy( missingValueStrategy );
curve->setColor( colors.cycledColor3f( 0 ) );
curve->setLineStyle( lineStyles[0] );
curve->setLineThickness( 2 );
@ -286,6 +301,8 @@ void RicNewFractureModelPlotFeature::createParametersTrack( RimFractureModelPlot
RiaGuiApplication::instance()->getOrCreateMainPlotWindow();
RiuPlotMainWindowTools::selectAsCurrentItem( curve );
RiuPlotMainWindowTools::showPlotMainWindow();
return curve;
}
//--------------------------------------------------------------------------------------------------

16
ApplicationCode/Commands/CompletionCommands/RicNewFractureModelPlotFeature.h
View File

@ -23,6 +23,7 @@
#include "RiaDefines.h"
#include "RimElasticPropertiesCurve.h"
#include "RimFractureModelCurve.h"
class RimEclipseCase;
class RimFractureModelPlot;
@ -49,13 +50,14 @@ private:
static void
createFormationTrack( RimFractureModelPlot* plot, RimFractureModel* fractureModel, RimEclipseCase* eclipseCase );
static void
createFaciesTrack( RimFractureModelPlot* plot, RimFractureModel* fractureModel, RimEclipseCase* eclipseCase );
static void createParametersTrack( RimFractureModelPlot* plot,
RimFractureModel* fractureModel,
RimEclipseCase* eclipseCase,
int timeStep,
const QString& resultVariable,
RiaDefines::ResultCatType resultCategoryType );
createFaciesTrack( RimFractureModelPlot* plot, RimFractureModel* fractureModel, RimEclipseCase* eclipseCase );
static RimFractureModelCurve* createParametersTrack( RimFractureModelPlot* plot,
RimFractureModel* fractureModel,
RimEclipseCase* eclipseCase,
int timeStep,
const QString& resultVariable,
RiaDefines::ResultCatType resultCategoryType,
RimFractureModelCurve::MissingValueStrategy missingValueStrategy );
static void createElasticPropertiesTrack( RimFractureModelPlot* plot,
RimFractureModel* fractureModel,

39
ApplicationCode/ProjectDataModel/Completions/RimFractureModel.cpp
View File

@ -105,6 +105,9 @@ RimFractureModel::RimFractureModel()
CAF_PDM_InitField( &m_boundingBoxHorizontal, "BoundingBoxHorizontal", 50.0, "Bounding Box Horizontal", "", "", "" );
CAF_PDM_InitField( &m_boundingBoxVertical, "BoundingBoxVertical", 100.0, "Bounding Box Vertical", "", "", "" );
CAF_PDM_InitField( &m_defaultPorosity, "DefaultPorosity", 0.0, "Default Porosity", "", "", "" );
CAF_PDM_InitField( &m_defaultPermeability, "DefaultPermeability", 10.0e-6, "Default Permeability", "", "", "" );
CAF_PDM_InitFieldNoDefault( &m_elasticProperties, "ElasticProperties", "Elastic Properties", "", "", "" );
m_elasticProperties.uiCapability()->setUiHidden( true );
m_elasticProperties.uiCapability()->setUiTreeHidden( true );
@ -483,3 +486,39 @@ void RimFractureModel::loadDataAndUpdate()
m_elasticProperties->loadDataAndUpdate();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFractureModel::defaultPorosity() const
{
return m_defaultPorosity();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFractureModel::defaultPermeability() const
{
return m_defaultPermeability();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFractureModel::getDefaultForMissingValue( const QString& keyword ) const
{
if ( keyword == QString( "PORO" ) )
{
return defaultPorosity();
}
else if ( keyword == QString( "PERMX" ) )
{
return defaultPermeability();
}
else
{
RiaLogging::error( QString( "Missing default value for %1." ).arg( keyword ) );
return std::numeric_limits<double>::infinity();
}
}

7
ApplicationCode/ProjectDataModel/Completions/RimFractureModel.h
View File

@ -60,6 +60,9 @@ public:
void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
cvf::Vec3d fracturePosition() const;
double defaultPorosity() const;
double defaultPermeability() const;
// RimWellPathCompletionsInterface overrides.
RiaDefines::WellPathComponentType componentType() const override;
QString componentLabel() const override;
@ -78,6 +81,8 @@ public:
void setElasticProperties( RimElasticProperties* elasticProperties );
RimElasticProperties* elasticProperties() const;
double getDefaultForMissingValue( const QString& keyword ) const;
protected:
void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
@ -98,4 +103,6 @@ protected:
caf::PdmField<double> m_boundingBoxHorizontal;
caf::PdmPtrField<RimModeledWellPath*> m_thicknessDirectionWellPath;
caf::PdmChildField<RimElasticProperties*> m_elasticProperties;
caf::PdmField<double> m_defaultPorosity;
caf::PdmField<double> m_defaultPermeability;
};

31
ApplicationCode/ProjectDataModel/RimElasticPropertiesCurve.cpp
View File

@ -195,32 +195,17 @@ void RimElasticPropertiesCurve::performDataExtraction( bool* isUsingPseudoLength
std::vector<double> faciesValues;
eclExtractor.curveData( faciesResultAccessor.p(), &faciesValues );
// Extract porosity data
// m_eclipseResultDefinition->setResultType();
cvf::ref<RigResultAccessor> poroResAcc =
RigResultAccessorFactory::createFromResultAddress( eclipseCase->eclipseCaseData(),
0,
RiaDefines::PorosityModelType::MATRIX_MODEL,
0,
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
"PORO" ) );
if ( !poroResAcc.notNull() )
// Extract porosity data: get the porosity values from parent
RimFractureModelPlot* fractureModelPlot;
firstAncestorOrThisOfType( fractureModelPlot );
if ( !fractureModelPlot )
{
std::cerr << "NO PORO RES ACCESSOR" << std::endl;
std::cerr << "NO PORO VALUES FOUND" << std::endl;
return;
}
std::vector<double> poroValues;
eclExtractor.curveData( poroResAcc.p(), &poroValues );
std::cout << "Dims: FOrmation names to plot: " << formationNamesToPlot.size() << " Y: " << yValues.size()
<< " FACIES: " << faciesValues.size() << " PORO: " << poroValues.size() << std::endl;
for ( size_t i = 0; i < yValues.size(); i++ )
{
std::cout << i << ": " << yValues[i].first << "-" << yValues[i].second << " ==> "
<< formationNamesToPlot[i].toStdString() << std::endl;
}
fractureModelPlot->getPorosityValues( poroValues );
// TODO: make this settable??
RimColorLegend* colorLegend = RimProject::current()->colorLegendCollection()->findByName( "Facies colors" );
@ -245,10 +230,6 @@ void RimElasticPropertiesCurve::performDataExtraction( bool* isUsingPseudoLength
QString formationName = findFormationNameForDepth( formationNamesToPlot, yValues, tvDepthValues[i] );
double porosity = poroValues[i];
// std::cout << i << ": Depth: " << tvDepthValues[i] << " Poro: " << poroValues[i]
// << " Facies: " << faciesValues[i] << " name: " << faciesName.toStdString()
// << " formation: " << formationName.toStdString();
FaciesKey faciesKey = std::make_tuple( fieldName, formationName, faciesName );
if ( elasticProperties->hasPropertiesForFacies( faciesKey ) )
{

157
ApplicationCode/ProjectDataModel/RimFractureModelCurve.cpp
View File

@ -26,6 +26,8 @@
#include "RimCase.h"
#include "RimEclipseCase.h"
#include "RimEclipseInputProperty.h"
#include "RimEclipseInputPropertyCollection.h"
#include "RimEclipseResultDefinition.h"
#include "RimFractureModel.h"
#include "RimFractureModelPlot.h"
@ -42,15 +44,28 @@
#include "RiuQwtPlotWidget.h"
#include "RiaApplication.h"
#include "RiaInterpolationTools.h"
#include "RiaLogging.h"
#include "RiaPreferences.h"
#include "cafPdmUiTreeOrdering.h"
#include <QFileInfo>
#include <QMessageBox>
CAF_PDM_SOURCE_INIT( RimFractureModelCurve, "FractureModelCurve" );
namespace caf
{
template <>
void caf::AppEnum<RimFractureModelCurve::MissingValueStrategy>::setUp()
{
addItem( RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE, "DEFAULT_VALUE", "Default value" );
addItem( RimFractureModelCurve::MissingValueStrategy::LINEAR_INTERPOLATION,
"LINEAR_INTERPOLATION",
"Linear interpolation" );
setDefault( RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE );
}
}; // namespace caf
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -62,6 +77,11 @@ RimFractureModelCurve::RimFractureModelCurve()
m_fractureModel.uiCapability()->setUiTreeChildrenHidden( true );
m_fractureModel.uiCapability()->setUiHidden( true );
caf::AppEnum<RimFractureModelCurve::MissingValueStrategy> defaultValue =
RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE;
CAF_PDM_InitField( &m_missingValueStrategy, "MissingValueStrategy", defaultValue, "Missing Value Strategy", "", "", "" );
m_missingValueStrategy.uiCapability()->setUiHidden( true );
m_wellPath = nullptr;
}
@ -134,6 +154,48 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
std::cerr << "RESULT ACCESSOR IS NULL" << std::endl;
}
if ( hasMissingValues( values ) )
{
if ( m_missingValueStrategy() == RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE )
{
// Try to locate a backup accessor (e.g. PORO_1 for PORO)
cvf::ref<RigResultAccessor> backupResAcc =
findMissingValuesAccessor( eclipseCase->eclipseCaseData(),
eclipseCase->inputPropertyCollection(),
0,
m_timeStep,
m_eclipseResultDefinition() );
if ( backupResAcc.notNull() )
{
RiaLogging::info( QString( "Reading missing values from input properties for %1." )
.arg( m_eclipseResultDefinition()->resultVariable() ) );
std::vector<double> replacementValues;
eclExtractor.curveData( backupResAcc.p(), &replacementValues );
replaceMissingValues( values, replacementValues );
}
// If the backup accessor is not found, or does not provide all the missing values:
// use default value from the fracture model
if ( !backupResAcc.notNull() || hasMissingValues( values ) )
{
RiaLogging::info(
QString( "Using default value for %1" ).arg( m_eclipseResultDefinition()->resultVariable() ) );
double defaultValue =
m_fractureModel->getDefaultForMissingValue( m_eclipseResultDefinition.value()->resultVariable() );
replaceMissingValues( values, defaultValue );
}
}
else
{
RiaLogging::info(
QString( "Interpolating missing values for %1" ).arg( m_eclipseResultDefinition()->resultVariable() ) );
RiaInterpolationTools::interpolateMissingValues( measuredDepthValues, values );
}
}
RiaEclipseUnitTools::UnitSystem eclipseUnitsType = eclipseCase->eclipseCaseData()->unitsType();
if ( eclipseUnitsType == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
{
@ -168,3 +230,92 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFractureModelCurve::setMissingValueStrategy( MissingValueStrategy strategy )
{
m_missingValueStrategy = strategy;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimFractureModelCurve::hasMissingValues( const std::vector<double>& values )
{
for ( double v : values )
{
if ( v == std::numeric_limits<double>::infinity() )
{
return true;
}
}
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFractureModelCurve::replaceMissingValues( std::vector<double>& values, double defaultValue )
{
for ( double& v : values )
{
if ( v == std::numeric_limits<double>::infinity() )
{
v = defaultValue;
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFractureModelCurve::replaceMissingValues( std::vector<double>& values, const std::vector<double>& replacementValues )
{
assert( values.size() == replacementValues.size() );
for ( size_t i = 0; i < values.size(); i++ )
{
if ( values[i] == std::numeric_limits<double>::infinity() )
{
values[i] = replacementValues[i];
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultAccessor>
RimFractureModelCurve::findMissingValuesAccessor( RigEclipseCaseData* caseData,
RimEclipseInputPropertyCollection* inputPropertyCollection,
int gridIndex,
int timeStepIndex,
RimEclipseResultDefinition* eclipseResultDefinition )
{
QString resultName = eclipseResultDefinition->resultVariable();
for ( RimEclipseInputProperty* inputProperty : inputPropertyCollection->inputProperties() )
{
// Look for input properties starting with the same name as result definition
if ( inputProperty && inputProperty->resultName().startsWith( resultName ) )
{
RiaLogging::info(
QString( "Found missing values result for %1: %2" ).arg( resultName ).arg( inputProperty->resultName() ) );
RigEclipseResultAddress resultAddress( RiaDefines::ResultCatType::INPUT_PROPERTY, inputProperty->resultName() );
caseData->results( eclipseResultDefinition->porosityModel() )->ensureKnownResultLoaded( resultAddress );
cvf::ref<RigResultAccessor> resAcc =
RigResultAccessorFactory::createFromResultAddress( caseData,
gridIndex,
eclipseResultDefinition->porosityModel(),
timeStepIndex,
resultAddress );
return resAcc;
}
}
return nullptr;
}

23
ApplicationCode/ProjectDataModel/RimFractureModelCurve.h
View File

@ -30,6 +30,9 @@
class RimWellPath;
class RimWellMeasurement;
class RimFractureModel;
class RimEclipseInputPropertyCollection;
class RigEclipseCaseData;
class RigResultAccessor;
//==================================================================================================
///
@ -39,6 +42,12 @@ class RimFractureModelCurve : public RimWellLogExtractionCurve
CAF_PDM_HEADER_INIT;
public:
enum class MissingValueStrategy
{
DEFAULT_VALUE,
LINEAR_INTERPOLATION
};
RimFractureModelCurve();
~RimFractureModelCurve() override;
@ -46,8 +55,20 @@ public:
void setEclipseResultCategory( RiaDefines::ResultCatType catType );
void setMissingValueStrategy( MissingValueStrategy strategy );
protected:
void performDataExtraction( bool* isUsingPseudoLength ) override;
caf::PdmPtrField<RimFractureModel*> m_fractureModel;
static bool hasMissingValues( const std::vector<double>& values );
static void replaceMissingValues( std::vector<double>& values, double defaultValue );
static void replaceMissingValues( std::vector<double>& values, const std::vector<double>& replacementValues );
cvf::ref<RigResultAccessor> findMissingValuesAccessor( RigEclipseCaseData* caseData,
RimEclipseInputPropertyCollection* inputPropertyCollection,
int gridIndex,
int timeStepIndex,
RimEclipseResultDefinition* eclipseResultDefinition );
caf::PdmPtrField<RimFractureModel*> m_fractureModel;
caf::PdmField<caf::AppEnum<MissingValueStrategy>> m_missingValueStrategy;
};

20
ApplicationCode/ProjectDataModel/RimFractureModelPlot.cpp
View File

@ -22,6 +22,9 @@
#include "RimEclipseCase.h"
#include "RimFractureModel.h"
#include "RimFractureModelCurve.h"
#include "RigWellLogCurveData.h"
#include "cafPdmBase.h"
#include "cafPdmFieldIOScriptability.h"
@ -70,3 +73,20 @@ void RimFractureModelPlot::applyDataSource()
{
this->updateConnectedEditors();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFractureModelPlot::getPorosityValues( std::vector<double>& values ) const
{
std::vector<RimFractureModelCurve*> curves;
descendantsIncludingThisOfType( curves );
for ( RimFractureModelCurve* curve : curves )
{
if ( curve->eclipseResultVariable() == "PORO" )
{
values = curve->curveData()->xValues();
}
}
}

2
ApplicationCode/ProjectDataModel/RimFractureModelPlot.h
View File

@ -29,6 +29,8 @@ class RimFractureModelPlot : public RimDepthTrackPlot
public:
RimFractureModelPlot();
void getPorosityValues( std::vector<double>& values ) const;
protected:
void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;

8
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp
View File

@ -1036,6 +1036,14 @@ void RimWellLogExtractionCurve::setEclipseResultVariable( const QString& resVarn
m_eclipseResultDefinition->setResultVariable( resVarname );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimWellLogExtractionCurve::eclipseResultVariable() const
{
return m_eclipseResultDefinition->resultVariable();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

4
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.h
View File

@ -77,7 +77,9 @@ public:
int currentTimeStep() const;
void setCurrentTimeStep( int timeStep );
void setEclipseResultVariable( const QString& resVarname );
void setEclipseResultVariable( const QString& resVarname );
QString eclipseResultVariable() const;
void setGeoMechResultAddress( const RigFemResultAddress& resAddr );
void setTrajectoryType( TrajectoryType trajectoryType );