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

#6173 Improve pressure extrapolation in overburden and underburden.

Browse Source 
Use gradient derived from fluid density.
This commit is contained in:
Kristian Bendiksen 2020-07-10 11:59:33 +02:00
parent 709da35a3e
commit cb9e3fe30d
5 changed files with 146 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -99,15 +99,15 @@ RimFractureModelPlot*
RiaDefines::CurveProperty::POROSITY )};
plots["Pressure"] = {std::make_tuple( "PRESSURE",
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::OTHER_CURVE_PROPERTY,
false,
RiaDefines::CurveProperty::PRESSURE ),
std::make_tuple( "PRESSURE",
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::LINEAR_INTERPOLATION,
true,
RiaDefines::CurveProperty::INITIAL_PRESSURE )};
RiaDefines::CurveProperty::INITIAL_PRESSURE ),
std::make_tuple( "PRESSURE",
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
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 );

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

@ -126,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 );
@ -645,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();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

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

@ -105,7 +105,10 @@ public:
double getDefaultForMissingOverburdenValue( const QString& keyword ) const;
double getDefaultForMissingUnderburdenValue( const QString& keyword ) const;
double getDefaultForMissingValue( const QString& keyword ) const;
void updateReferringPlots();
double getOverburdenGradient( const QString& keyword ) const;
double getUnderburdenGradient( const QString& keyword ) const;
void updateReferringPlots();
protected:
void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
@ -139,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;
};

108
ApplicationCode/ProjectDataModel/RimFractureModelCurve.cpp
View File

@ -68,6 +68,15 @@ void caf::AppEnum<RimFractureModelCurve::MissingValueStrategy>::setUp()
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
//--------------------------------------------------------------------------------------------------
@ -86,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 );
@ -197,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 ) )
@ -243,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() );
@ -257,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() );
@ -350,6 +350,14 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFractureModelCurve::setBurdenStrategy( BurdenStrategy strategy )
{
m_burdenStrategy = strategy;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -444,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 );
}
}
@ -470,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???
@ -489,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 );
}
}

25
ApplicationCode/ProjectDataModel/RimFractureModelCurve.h
View File

@ -50,6 +50,12 @@ public:
OTHER_CURVE_PROPERTY
};
enum class BurdenStrategy
{
DEFAULT_VALUE,
GRADIENT
};
RimFractureModelCurve();
~RimFractureModelCurve() override;
@ -59,6 +65,8 @@ public:
void setMissingValueStrategy( MissingValueStrategy strategy );
void setBurdenStrategy( BurdenStrategy strategy );
void setCurveProperty( RiaDefines::CurveProperty ) override;
RiaDefines::CurveProperty curveProperty() const override;
@ -76,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;
};