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

Merge pull request #6225 from OPM/fracture-model-plot-pressure-curves

Browse Source 
Fracture model plot pressure curves
This commit is contained in:
Kristian Bendiksen 2020-07-10 12:34:10 +02:00 committed by GitHub
commit e05dc5ff79
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 213 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ApplicationCode/Application/RiaFractureModelDefines.cpp
View File

@ -23,6 +23,7 @@ namespace caf
template <>
void AppEnum<RiaDefines::CurveProperty>::setUp()
{
addItem( RiaDefines::CurveProperty::UNDEFINED, "UNDEFINED", "Undefined" );
addItem( RiaDefines::CurveProperty::FACIES, "FACIES", "Facies" );
addItem( RiaDefines::CurveProperty::LAYERS, "LAYERS", "Layers" );
addItem( RiaDefines::CurveProperty::POROSITY, "POROSITY", "Porosity" );
@ -40,6 +41,6 @@ void AppEnum<RiaDefines::CurveProperty>::setUp()
addItem( RiaDefines::CurveProperty::K0, "K0", "k0" );
addItem( RiaDefines::CurveProperty::FLUID_LOSS_COEFFICIENT, "FLUID_LOSS_COEFFICIENT", "Fluid Loss Coefficient" );
addItem( RiaDefines::CurveProperty::SPURT_LOSS, "SPURT_LOSS", "Spurt Loss" );
setDefault( RiaDefines::CurveProperty::FACIES );
setDefault( RiaDefines::CurveProperty::UNDEFINED );
}
}; // namespace caf

1
ApplicationCode/Application/RiaFractureModelDefines.h
View File

@ -26,6 +26,7 @@ namespace RiaDefines
{
enum class CurveProperty
{
UNDEFINED,
FACIES,
LAYERS,
POROSITY,

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

@ -101,13 +101,13 @@ RimFractureModelPlot*
plots["Pressure"] = {std::make_tuple( "PRESSURE",
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::LINEAR_INTERPOLATION,
false,
RiaDefines::CurveProperty::PRESSURE ),
true,
RiaDefines::CurveProperty::INITIAL_PRESSURE ),
std::make_tuple( "PRESSURE",
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::LINEAR_INTERPOLATION,
true,
RiaDefines::CurveProperty::INITIAL_PRESSURE )};
RimFractureModelCurve::MissingValueStrategy::OTHER_CURVE_PROPERTY,
false,
RiaDefines::CurveProperty::PRESSURE )};
plots["Permeability"] = {std::make_tuple( "PERMX",
RiaDefines::ResultCatType::STATIC_NATIVE,
@ -383,6 +383,11 @@ void RicNewFractureModelPlotFeature::createParametersTrack( RimFractureModelPlot
curve->setCurrentTimeStep( timeStep );
}
if ( curveProperty == RiaDefines::CurveProperty::INITIAL_PRESSURE )
{
curve->setBurdenStrategy( RimFractureModelCurve::BurdenStrategy::GRADIENT );
}
plotTrack->addCurve( curve );
curve->loadDataAndUpdate( true );

2
ApplicationCode/Commands/RicExportFractureModelPlotToFileFeature.cpp
View File

@ -72,6 +72,6 @@ void RicExportFractureModelPlotToFileFeature::onActionTriggered( bool isChecked
//--------------------------------------------------------------------------------------------------
void RicExportFractureModelPlotToFileFeature::setupActionLook( QAction* actionToSetup )
{
actionToSetup->setText( "Export Fracture Model Plot to File" );
actionToSetup->setText( "Export Fracture Model to File" );
actionToSetup->setIcon( QIcon( ":/Save.png" ) );
}

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

@ -22,6 +22,7 @@
#include "RiaCompletionTypeCalculationScheduler.h"
#include "RiaEclipseUnitTools.h"
#include "RiaFractureDefines.h"
#include "RiaFractureModelDefines.h"
#include "RiaLogging.h"
#include "Riu3DMainWindowTools.h"
@ -125,12 +126,20 @@ RimFractureModel::RimFractureModel()
CAF_PDM_InitFieldNoDefault( &m_overburdenFacies, "OverburdenFacies", "Overburden Facies", "", "", "" );
CAF_PDM_InitField( &m_overburdenPorosity, "OverburdenPorosity", 0.0, "Overburden Porosity", "", "", "" );
CAF_PDM_InitField( &m_overburdenPermeability, "OverburdenPermeability", 10.0e-6, "Overburden Permeability", "", "", "" );
CAF_PDM_InitField( &m_overburdenFluidDensity, "OverburdenFluidDensity", 1.03, "Overburden Fluid Density [g/cm^3]", "", "", "" );
CAF_PDM_InitField( &m_underburdenHeight, "UnderburdenHeight", 50.0, "Underburden Height", "", "", "" );
CAF_PDM_InitFieldNoDefault( &m_underburdenFormation, "UnderburdenFormation", "Underburden Formation", "", "", "" );
CAF_PDM_InitFieldNoDefault( &m_underburdenFacies, "UnderburdenFacies", "Underburden Facies", "", "", "" );
CAF_PDM_InitField( &m_underburdenPorosity, "UnderburdenPorosity", 0.0, "Underburden Porosity", "", "", "" );
CAF_PDM_InitField( &m_underburdenPermeability, "UnderburdenPermeability", 10.0e-6, "Underburden Permeability", "", "", "" );
CAF_PDM_InitField( &m_underburdenFluidDensity,
"UnderburdenFluidDensity",
1.03,
"Underburden Fluid Density [g/cm^3]",
"",
"",
"" );
CAF_PDM_InitFieldNoDefault( &m_elasticProperties, "ElasticProperties", "Elastic Properties", "", "", "" );
m_elasticProperties.uiCapability()->setUiHidden( true );
@ -591,6 +600,19 @@ double RimFractureModel::getDefaultForMissingValue( const QString& keyword ) con
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaDefines::CurveProperty RimFractureModel::getDefaultPropertyForMissingValues( const QString& keyword ) const
{
if ( keyword == QString( "PRESSURE" ) )
{
return RiaDefines::CurveProperty::INITIAL_PRESSURE;
}
return RiaDefines::CurveProperty::UNDEFINED;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -631,6 +653,38 @@ double RimFractureModel::getDefaultForMissingUnderburdenValue( const QString& ke
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFractureModel::getOverburdenGradient( const QString& keyword ) const
{
if ( keyword == QString( "PRESSURE" ) )
{
return m_overburdenFluidDensity * 9.81 * 1000.0 / 1.0e6;
}
else
{
RiaLogging::error( QString( "Missing overburden gradient for %1." ).arg( keyword ) );
return std::numeric_limits<double>::infinity();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFractureModel::getUnderburdenGradient( const QString& keyword ) const
{
if ( keyword == QString( "PRESSURE" ) )
{
return m_underburdenFluidDensity * 9.81 * 1000.0 / 1.0e6;
}
else
{
RiaLogging::error( QString( "Missing underburden gradient for %1." ).arg( keyword ) );
return std::numeric_limits<double>::infinity();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

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

@ -19,6 +19,7 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaFractureModelDefines.h"
#include "RimCheckableNamedObject.h"
#include "RimWellPathComponentInterface.h"
@ -100,10 +101,14 @@ public:
void setElasticProperties( RimElasticProperties* elasticProperties );
RimElasticProperties* elasticProperties() const;
double getDefaultForMissingOverburdenValue( const QString& keyword ) const;
double getDefaultForMissingUnderburdenValue( const QString& keyword ) const;
double getDefaultForMissingValue( const QString& keyword ) const;
void updateReferringPlots();
RiaDefines::CurveProperty getDefaultPropertyForMissingValues( const QString& keyword ) const;
double getDefaultForMissingOverburdenValue( const QString& keyword ) const;
double getDefaultForMissingUnderburdenValue( const QString& keyword ) const;
double getDefaultForMissingValue( const QString& keyword ) const;
double getOverburdenGradient( const QString& keyword ) const;
double getUnderburdenGradient( const QString& keyword ) const;
void updateReferringPlots();
protected:
void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
@ -137,9 +142,11 @@ protected:
caf::PdmField<double> m_overburdenPermeability;
caf::PdmField<QString> m_overburdenFormation;
caf::PdmField<QString> m_overburdenFacies;
caf::PdmField<double> m_overburdenFluidDensity;
caf::PdmField<double> m_underburdenHeight;
caf::PdmField<double> m_underburdenPorosity;
caf::PdmField<double> m_underburdenPermeability;
caf::PdmField<QString> m_underburdenFormation;
caf::PdmField<QString> m_underburdenFacies;
caf::PdmField<double> m_underburdenFluidDensity;
};

138
ApplicationCode/ProjectDataModel/RimFractureModelCurve.cpp
View File

@ -18,6 +18,7 @@
#include "RimFractureModelCurve.h"
#include "RiaFractureModelDefines.h"
#include "RigEclipseCaseData.h"
#include "RigEclipseWellLogExtractor.h"
#include "RigResultAccessorFactory.h"
@ -61,9 +62,21 @@ void caf::AppEnum<RimFractureModelCurve::MissingValueStrategy>::setUp()
addItem( RimFractureModelCurve::MissingValueStrategy::LINEAR_INTERPOLATION,
"LINEAR_INTERPOLATION",
"Linear interpolation" );
addItem( RimFractureModelCurve::MissingValueStrategy::OTHER_CURVE_PROPERTY,
"OTHER_CURVE_PROPERTY",
"Other Curve Property" );
setDefault( RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE );
}
template <>
void caf::AppEnum<RimFractureModelCurve::BurdenStrategy>::setUp()
{
addItem( RimFractureModelCurve::BurdenStrategy::DEFAULT_VALUE, "DEFAULT_VALUE", "Default value" );
addItem( RimFractureModelCurve::BurdenStrategy::GRADIENT, "GRADIENT", "Gradient" );
setDefault( RimFractureModelCurve::BurdenStrategy::DEFAULT_VALUE );
}
}; // namespace caf
//--------------------------------------------------------------------------------------------------
@ -82,6 +95,11 @@ RimFractureModelCurve::RimFractureModelCurve()
CAF_PDM_InitField( &m_missingValueStrategy, "MissingValueStrategy", defaultValue, "Missing Value Strategy", "", "", "" );
m_missingValueStrategy.uiCapability()->setUiHidden( true );
caf::AppEnum<RimFractureModelCurve::BurdenStrategy> defaultBurdenValue =
RimFractureModelCurve::BurdenStrategy::DEFAULT_VALUE;
CAF_PDM_InitField( &m_burdenStrategy, "BurdenStrategy", defaultBurdenValue, "Burden Strategy", "", "", "" );
m_burdenStrategy.uiCapability()->setUiHidden( true );
CAF_PDM_InitFieldNoDefault( &m_curveProperty, "CurveProperty", "Curve Property", "", "", "" );
m_curveProperty.uiCapability()->setUiHidden( true );
@ -193,27 +211,13 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
double overburdenHeight = m_fractureModel->overburdenHeight();
if ( overburdenHeight > 0.0 )
{
double defaultOverburdenValue = std::numeric_limits<double>::infinity();
if ( m_missingValueStrategy() == RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE )
{
defaultOverburdenValue =
m_fractureModel->getDefaultForMissingOverburdenValue( m_eclipseResultDefinition()->resultVariable() );
}
addOverburden( tvDepthValues, measuredDepthValues, values, overburdenHeight, defaultOverburdenValue );
addOverburden( tvDepthValues, measuredDepthValues, values );
}
double underburdenHeight = m_fractureModel->underburdenHeight();
if ( underburdenHeight > 0.0 )
{
double defaultUnderburdenValue = std::numeric_limits<double>::infinity();
if ( m_missingValueStrategy() == RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE )
{
defaultUnderburdenValue =
m_fractureModel->getDefaultForMissingUnderburdenValue( m_eclipseResultDefinition()->resultVariable() );
}
addUnderburden( tvDepthValues, measuredDepthValues, values, underburdenHeight, defaultUnderburdenValue );
addUnderburden( tvDepthValues, measuredDepthValues, values );
}
if ( hasMissingValues( values ) )
@ -239,7 +243,7 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
if ( overburdenHeight > 0.0 )
{
double defaultOverburdenValue = std::numeric_limits<double>::infinity();
if ( m_missingValueStrategy() == RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE )
if ( m_burdenStrategy() == RimFractureModelCurve::BurdenStrategy::DEFAULT_VALUE )
{
defaultOverburdenValue = m_fractureModel->getDefaultForMissingOverburdenValue(
m_eclipseResultDefinition()->resultVariable() );
@ -253,7 +257,7 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
if ( underburdenHeight > 0.0 )
{
double defaultUnderburdenValue = std::numeric_limits<double>::infinity();
if ( m_missingValueStrategy() == RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE )
if ( m_burdenStrategy() == RimFractureModelCurve::BurdenStrategy::DEFAULT_VALUE )
{
defaultUnderburdenValue = m_fractureModel->getDefaultForMissingUnderburdenValue(
m_eclipseResultDefinition()->resultVariable() );
@ -279,12 +283,36 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
replaceMissingValues( values, defaultValue );
}
}
else
else if ( m_missingValueStrategy() == RimFractureModelCurve::MissingValueStrategy::LINEAR_INTERPOLATION )
{
RiaLogging::info(
QString( "Interpolating missing values for %1" ).arg( m_eclipseResultDefinition()->resultVariable() ) );
RiaInterpolationTools::interpolateMissingValues( measuredDepthValues, values );
}
else
{
// Get the missing data from other curve
RimFractureModelPlot* fractureModelPlot;
firstAncestorOrThisOfType( fractureModelPlot );
if ( !fractureModelPlot )
{
RiaLogging::error( QString( "No replacement data found for fracture model curve." ) );
return;
}
RiaDefines::CurveProperty replacementProperty = m_fractureModel->getDefaultPropertyForMissingValues(
m_eclipseResultDefinition.value()->resultVariable() );
std::vector<double> initialValues;
fractureModelPlot->getCurvePropertyValues( replacementProperty, initialValues );
if ( initialValues.empty() )
{
RiaLogging::error( QString( "Empty replacement data found for fracture model curve." ) );
return;
}
replaceMissingValues( values, initialValues );
}
}
RiaEclipseUnitTools::UnitSystem eclipseUnitsType = eclipseCase->eclipseCaseData()->unitsType();
@ -322,6 +350,14 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFractureModelCurve::setBurdenStrategy( BurdenStrategy strategy )
{
m_burdenStrategy = strategy;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -416,24 +452,40 @@ cvf::ref<RigResultAccessor>
//--------------------------------------------------------------------------------------------------
void RimFractureModelCurve::addOverburden( std::vector<double>& tvDepthValues,
std::vector<double>& measuredDepthValues,
std::vector<double>& values,
double overburdenHeight,
double defaultOverburdenValue )
std::vector<double>& values ) const
{
if ( !values.empty() )
{
double overburdenHeight = m_fractureModel->overburdenHeight();
double tvdOverburdenBottom = tvDepthValues[0];
double tvdOverburdenTop = tvdOverburdenBottom - overburdenHeight;
double overburdenTopValue = std::numeric_limits<double>::infinity();
double overburdenBottomValue = std::numeric_limits<double>::infinity();
if ( m_burdenStrategy() == RimFractureModelCurve::BurdenStrategy::DEFAULT_VALUE )
{
overburdenTopValue =
m_fractureModel->getDefaultForMissingOverburdenValue( m_eclipseResultDefinition()->resultVariable() );
overburdenBottomValue = overburdenTopValue;
}
else
{
double gradient = m_fractureModel->getOverburdenGradient( m_eclipseResultDefinition()->resultVariable() );
overburdenBottomValue = values[0];
overburdenTopValue = overburdenBottomValue + gradient * -overburdenHeight;
}
// Prepend the new "fake" depth for start of overburden
double tvdTop = tvDepthValues[0];
tvDepthValues.insert( tvDepthValues.begin(), tvdTop );
tvDepthValues.insert( tvDepthValues.begin(), tvdTop - overburdenHeight );
tvDepthValues.insert( tvDepthValues.begin(), tvdOverburdenBottom );
tvDepthValues.insert( tvDepthValues.begin(), tvdOverburdenTop );
// TODO: this is not always correct
double mdTop = measuredDepthValues[0];
measuredDepthValues.insert( measuredDepthValues.begin(), mdTop );
measuredDepthValues.insert( measuredDepthValues.begin(), mdTop - overburdenHeight );
values.insert( values.begin(), defaultOverburdenValue );
values.insert( values.begin(), defaultOverburdenValue );
values.insert( values.begin(), overburdenBottomValue );
values.insert( values.begin(), overburdenTopValue );
}
}
@ -442,18 +494,34 @@ void RimFractureModelCurve::addOverburden( std::vector<double>& tvDepthValues,
//--------------------------------------------------------------------------------------------------
void RimFractureModelCurve::addUnderburden( std::vector<double>& tvDepthValues,
std::vector<double>& measuredDepthValues,
std::vector<double>& values,
double underburdenHeight,
double defaultUnderburdenValue )
std::vector<double>& values ) const
{
if ( !values.empty() )
{
size_t lastIndex = tvDepthValues.size() - 1;
double underburdenHeight = m_fractureModel->underburdenHeight();
double tvdUnderburdenTop = tvDepthValues[lastIndex];
double tvdUnderburdenBottom = tvdUnderburdenTop + underburdenHeight;
double underburdenTopValue = std::numeric_limits<double>::infinity();
double underburdenBottomValue = std::numeric_limits<double>::infinity();
if ( m_burdenStrategy() == RimFractureModelCurve::BurdenStrategy::DEFAULT_VALUE )
{
underburdenTopValue =
m_fractureModel->getDefaultForMissingUnderburdenValue( m_eclipseResultDefinition()->resultVariable() );
underburdenBottomValue = underburdenTopValue;
}
else
{
double gradient = m_fractureModel->getUnderburdenGradient( m_eclipseResultDefinition()->resultVariable() );
underburdenTopValue = values[lastIndex];
underburdenBottomValue = underburdenTopValue + gradient * underburdenHeight;
}
// Append the new "fake" depth for start of underburden
double tvdBottom = tvDepthValues[lastIndex];
tvDepthValues.push_back( tvdBottom );
tvDepthValues.push_back( tvdBottom + underburdenHeight );
tvDepthValues.push_back( tvdUnderburdenTop );
tvDepthValues.push_back( tvdUnderburdenBottom );
// Append the new "fake" md
// TODO: check if this is correct???
@ -461,7 +529,7 @@ void RimFractureModelCurve::addUnderburden( std::vector<double>& tvDepthValues,
measuredDepthValues.push_back( mdBottom );
measuredDepthValues.push_back( mdBottom + underburdenHeight );
values.push_back( defaultUnderburdenValue );
values.push_back( defaultUnderburdenValue );
values.push_back( underburdenTopValue );
values.push_back( underburdenBottomValue );
}
}

28
ApplicationCode/ProjectDataModel/RimFractureModelCurve.h
View File

@ -46,7 +46,14 @@ public:
enum class MissingValueStrategy
{
DEFAULT_VALUE,
LINEAR_INTERPOLATION
LINEAR_INTERPOLATION,
OTHER_CURVE_PROPERTY
};
enum class BurdenStrategy
{
DEFAULT_VALUE,
GRADIENT
};
RimFractureModelCurve();
@ -58,6 +65,8 @@ public:
void setMissingValueStrategy( MissingValueStrategy strategy );
void setBurdenStrategy( BurdenStrategy strategy );
void setCurveProperty( RiaDefines::CurveProperty ) override;
RiaDefines::CurveProperty curveProperty() const override;
@ -75,19 +84,16 @@ protected:
int timeStepIndex,
RimEclipseResultDefinition* eclipseResultDefinition );
static void addOverburden( std::vector<double>& tvDepthValues,
std::vector<double>& measuredDepthValues,
std::vector<double>& values,
double overburdenHeight,
double defaultOverburdenValue );
void addOverburden( std::vector<double>& tvDepthValues,
std::vector<double>& measuredDepthValues,
std::vector<double>& values ) const;
static void addUnderburden( std::vector<double>& tvDepthValues,
std::vector<double>& measuredDepthValues,
std::vector<double>& values,
double underburdenHeight,
double defaultUnderburdenValue );
void addUnderburden( std::vector<double>& tvDepthValues,
std::vector<double>& measuredDepthValues,
std::vector<double>& values ) const;
caf::PdmPtrField<RimFractureModel*> m_fractureModel;
caf::PdmField<caf::AppEnum<MissingValueStrategy>> m_missingValueStrategy;
caf::PdmField<caf::AppEnum<BurdenStrategy>> m_burdenStrategy;
caf::PdmField<caf::AppEnum<RiaDefines::CurveProperty>> m_curveProperty;
};

20
ApplicationCode/ProjectDataModel/RimFractureModelPlot.cpp
View File

@ -47,6 +47,8 @@ RimFractureModelPlot::RimFractureModelPlot()
CAF_PDM_InitFieldNoDefault( &m_fractureModel, "FractureModel", "Fracture Model", "", "", "" );
m_fractureModel.uiCapability()->setUiTreeChildrenHidden( true );
m_fractureModel.uiCapability()->setUiHidden( true );
setDeletable( true );
}
//--------------------------------------------------------------------------------------------------
@ -93,25 +95,29 @@ void RimFractureModelPlot::applyDataSource()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFractureModelPlot::getPorosityValues( std::vector<double>& values ) const
void RimFractureModelPlot::getCurvePropertyValues( RiaDefines::CurveProperty curveProperty, std::vector<double>& values ) const
{
RimWellLogExtractionCurve* curve = findCurveByProperty( RiaDefines::CurveProperty::POROSITY );
RimWellLogExtractionCurve* curve = findCurveByProperty( curveProperty );
if ( curve )
{
values = curve->curveData()->xValues();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFractureModelPlot::getPorosityValues( std::vector<double>& values ) const
{
getCurvePropertyValues( RiaDefines::CurveProperty::POROSITY, values );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFractureModelPlot::getFaciesValues( std::vector<double>& values ) const
{
RimWellLogExtractionCurve* curve = findCurveByProperty( RiaDefines::CurveProperty::FACIES );
if ( curve )
{
values = curve->curveData()->xValues();
}
getCurvePropertyValues( RiaDefines::CurveProperty::FACIES, values );
}
//--------------------------------------------------------------------------------------------------

1
ApplicationCode/ProjectDataModel/RimFractureModelPlot.h
View File

@ -60,6 +60,7 @@ public:
void getPorosityValues( std::vector<double>& values ) const;
void getFaciesValues( std::vector<double>& values ) const;
void getCurvePropertyValues( RiaDefines::CurveProperty curveProperty, std::vector<double>& values ) const;
std::vector<double> calculateTrueVerticalDepth() const;
std::vector<double> calculatePorosity() const;