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

#6597 Use and display scaled elastic properties.

Browse Source
This commit is contained in:
Kristian Bendiksen 2020-10-02 14:33:15 +02:00
parent 7c555658ec
commit 309d9313bd
9 changed files with 200 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

129
ApplicationCode/ProjectDataModel/RimElasticProperties.cpp
View File

@ -47,6 +47,8 @@ RimElasticProperties::RimElasticProperties()
m_propertiesTable.uiCapability()->setUiReadOnly( true );
m_propertiesTable.xmlCapability()->disableIO();
CAF_PDM_InitScriptableField( &m_showScaledProperties, "ShowScaledProperties", true, "ShowScaledProperties", "", "", "" );
CAF_PDM_InitScriptableFieldNoDefault( &m_scalings, "PropertyScalingCollection", "PropertyScalingCollection", "", "", "" );
m_scalings.uiCapability()->setUiHidden( true );
m_scalings.uiCapability()->setUiTreeHidden( true );
@ -104,12 +106,26 @@ const RigElasticProperties& RimElasticProperties::propertiesForFacies( FaciesKey
return m_properties.find( key )->second;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimElasticProperties::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
const QVariant& oldValue,
const QVariant& newValue )
{
if ( changedField == &m_showScaledProperties )
{
m_propertiesTable = generatePropertiesTable();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimElasticProperties::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
{
uiOrdering.add( &m_filePath );
uiOrdering.add( &m_showScaledProperties );
uiOrdering.add( &m_propertiesTable );
}
@ -156,52 +172,43 @@ QString RimElasticProperties::generatePropertiesTable()
" </thead>"
" <tbody>" );
std::vector<RiaDefines::CurveProperty> properties = scalableProperties();
QString body;
for ( auto prop : m_properties )
{
const QString& fieldName = prop.second.fieldName();
const std::vector<double>& porosity = prop.second.porosity();
const std::vector<double>& youngsModulus = prop.second.youngsModulus();
const std::vector<double>& poissonsRatio = prop.second.poissonsRatio();
const std::vector<double>& K_Ic = prop.second.K_Ic();
const std::vector<double>& proppantEmbedment = prop.second.proppantEmbedment();
const std::vector<double>& biotCoefficient = prop.second.biotCoefficient();
const std::vector<double>& k0 = prop.second.k0();
const std::vector<double>& fluidLossCoefficient = prop.second.fluidLossCoefficient();
const std::vector<double>& spurtLoss = prop.second.spurtLoss();
const std::vector<double>& immobileFluidSaturation = prop.second.immobileFluidSaturation();
const QString& fieldName = prop.second.fieldName();
const QString& formationName = prop.second.formationName();
const QString& faciesName = prop.second.faciesName();
const std::vector<double>& porosity = prop.second.porosity();
for ( size_t i = 0; i < porosity.size(); i++ )
{
QString format( "<tr>"
" <td>%1</td>"
" <td>%2</td>"
" <td>%3</td>"
" <td align=right>%4</td>"
" <td align=right>%5</td>"
" <td align=right>%6</td>"
" <td align=right>%7</td>"
" <td align=right>%8</td>"
" <td align=right>%9</td>"
" <td align=right>%10</td>"
" <td align=right>%11</td>"
" <td align=right>%12</td>"
" <td align=right>%13</td>"
"</tr>" );
QString line = QString( "<tr>"
" <td>%1</td>"
" <td>%2</td>"
" <td>%3</td>"
" <td align=right>%4</td>" )
.arg( fieldName )
.arg( formationName )
.arg( faciesName )
.arg( porosity[i] );
QString line = format.arg( fieldName )
.arg( prop.second.formationName() )
.arg( prop.second.faciesName() )
.arg( porosity[i] )
.arg( youngsModulus[i] )
.arg( poissonsRatio[i] )
.arg( K_Ic[i] )
.arg( proppantEmbedment[i] )
.arg( biotCoefficient[i] )
.arg( k0[i] )
.arg( fluidLossCoefficient[i] )
.arg( spurtLoss[i] )
.arg( immobileFluidSaturation[i] );
for ( auto property : properties )
{
double scale = 1.0;
if ( m_showScaledProperties() )
{
scale = getPropertyScaling( formationName, faciesName, property );
}
double value = prop.second.getValue( property, i, scale );
QString propertyElement = QString( "<td align=right>%1</td>" ).arg( value );
line.append( propertyElement );
}
line.append( "</tr>" );
body.append( line );
}
@ -232,3 +239,47 @@ RimElasticPropertyScalingCollection* RimElasticProperties::scalingCollection()
{
return m_scalings.value();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RiaDefines::CurveProperty> RimElasticProperties::scalableProperties()
{
std::vector<RiaDefines::CurveProperty> properties = {
RiaDefines::CurveProperty::YOUNGS_MODULUS,
RiaDefines::CurveProperty::POISSONS_RATIO,
RiaDefines::CurveProperty::K_IC,
RiaDefines::CurveProperty::PROPPANT_EMBEDMENT,
RiaDefines::CurveProperty::BIOT_COEFFICIENT,
RiaDefines::CurveProperty::K0,
RiaDefines::CurveProperty::FLUID_LOSS_COEFFICIENT,
RiaDefines::CurveProperty::SPURT_LOSS,
RiaDefines::CurveProperty::IMMOBILE_FLUID_SATURATION,
};
return properties;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimElasticProperties::isScalableProperty( RiaDefines::CurveProperty property )
{
std::vector<RiaDefines::CurveProperty> properties = scalableProperties();
return std::find( properties.begin(), properties.end(), property ) != properties.end();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimElasticProperties::getPropertyScaling( const QString& formationName,
const QString& faciesName,
RiaDefines::CurveProperty property ) const
{
if ( m_scalings )
{
return m_scalings->getScaling( formationName, faciesName, property );
}
return 1.0;
}

9
ApplicationCode/ProjectDataModel/RimElasticProperties.h
View File

@ -55,11 +55,19 @@ public:
RimElasticPropertyScalingCollection* scalingCollection();
static std::vector<RiaDefines::CurveProperty> scalableProperties();
static bool isScalableProperty( RiaDefines::CurveProperty );
double getPropertyScaling( const QString& formationName,
const QString& faciesName,
RiaDefines::CurveProperty property ) const;
protected:
void defineEditorAttribute( const caf::PdmFieldHandle* field,
QString uiConfigName,
caf::PdmUiEditorAttribute* attribute ) override;
void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
private:
QString generatePropertiesTable();
@ -67,6 +75,7 @@ private:
caf::PdmField<caf::FilePath> m_filePath;
caf::PdmField<QString> m_propertiesTable;
caf::PdmChildField<RimElasticPropertyScalingCollection*> m_scalings;
caf::PdmField<bool> m_showScaledProperties;
std::map<FaciesKey, RigElasticProperties> m_properties;
};

48
ApplicationCode/ProjectDataModel/RimElasticPropertiesCurve.cpp
View File

@ -280,51 +280,11 @@ void RimElasticPropertiesCurve::performDataExtraction( bool* isUsingPseudoLength
FaciesKey faciesKey = std::make_tuple( fieldName, formationName, faciesName );
if ( elasticProperties->hasPropertiesForFacies( faciesKey ) )
{
const RigElasticProperties& rigElasticProperties = elasticProperties->propertiesForFacies( faciesKey );
if ( m_curveProperty() == RiaDefines::CurveProperty::YOUNGS_MODULUS )
if ( RimElasticProperties::isScalableProperty( curveProperty() ) )
{
double val = rigElasticProperties.getYoungsModulus( porosity );
values.push_back( val );
}
else if ( m_curveProperty() == RiaDefines::CurveProperty::POISSONS_RATIO )
{
double val = rigElasticProperties.getPoissonsRatio( porosity );
values.push_back( val );
}
else if ( m_curveProperty() == RiaDefines::CurveProperty::K_IC )
{
double val = rigElasticProperties.getK_Ic( porosity );
values.push_back( val );
}
else if ( m_curveProperty() == RiaDefines::CurveProperty::PROPPANT_EMBEDMENT )
{
double val = rigElasticProperties.getProppantEmbedment( porosity );
values.push_back( val );
}
else if ( m_curveProperty() == RiaDefines::CurveProperty::BIOT_COEFFICIENT )
{
double val = rigElasticProperties.getBiotCoefficient( porosity );
values.push_back( val );
}
else if ( m_curveProperty() == RiaDefines::CurveProperty::K0 )
{
double val = rigElasticProperties.getK0( porosity );
values.push_back( val );
}
else if ( m_curveProperty() == RiaDefines::CurveProperty::FLUID_LOSS_COEFFICIENT )
{
double val = rigElasticProperties.getFluidLossCoefficient( porosity );
values.push_back( val );
}
else if ( m_curveProperty() == RiaDefines::CurveProperty::SPURT_LOSS )
{
double val = rigElasticProperties.getSpurtLoss( porosity );
values.push_back( val );
}
else if ( m_curveProperty() == RiaDefines::CurveProperty::IMMOBILE_FLUID_SATURATION )
{
double val = rigElasticProperties.getImmobileFluidSaturation( porosity );
const RigElasticProperties& rigElasticProperties = elasticProperties->propertiesForFacies( faciesKey );
double scale = elasticProperties->getPropertyScaling( formationName, faciesName, curveProperty() );
double val = rigElasticProperties.getValueForPorosity( curveProperty(), porosity, scale );
values.push_back( val );
}
else if ( m_fractureModel->hasDefaultValueForProperty( curveProperty() ) )

32
ApplicationCode/ProjectDataModel/RimElasticPropertyScaling.cpp
View File

@ -138,3 +138,35 @@ RigEclipseCaseData* RimElasticPropertyScaling::getEclipseCaseData()
return eclipseCase->eclipseCaseData();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const QString& RimElasticPropertyScaling::formation() const
{
return m_formation();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const QString& RimElasticPropertyScaling::facies() const
{
return m_facies();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaDefines::CurveProperty RimElasticPropertyScaling::property() const
{
return m_property();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimElasticPropertyScaling::scale() const
{
return m_scale;
}

5
ApplicationCode/ProjectDataModel/RimElasticPropertyScaling.h
View File

@ -39,6 +39,11 @@ public:
RimElasticPropertyScaling();
~RimElasticPropertyScaling() override;
const QString& formation() const;
const QString& facies() const;
RiaDefines::CurveProperty property() const;
double scale() const;
caf::Signal<> changed;
protected:

19
ApplicationCode/ProjectDataModel/RimElasticPropertyScalingCollection.cpp
View File

@ -79,3 +79,22 @@ void RimElasticPropertyScalingCollection::onChildDeleted( caf::PdmChildArrayFiel
std::vector<caf::PdmObjectHandle*>& referringObjects )
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimElasticPropertyScalingCollection::getScaling( const QString& formationName,
const QString& faciesName,
RiaDefines::CurveProperty property ) const
{
for ( const RimElasticPropertyScaling* scaling : m_elasticPropertyScalings )
{
if ( scaling->property() == property && scaling->formation() == formationName && scaling->facies() == faciesName )
{
return scaling->scale();
}
}
// No scaling found. Default is not scaling (1.0).
return 1.0;
}

4
ApplicationCode/ProjectDataModel/RimElasticPropertyScalingCollection.h
View File

@ -22,6 +22,8 @@
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "RiaFractureModelDefines.h"
class RimElasticPropertyScaling;
//==================================================================================================
@ -42,6 +44,8 @@ public:
void onChildDeleted( caf::PdmChildArrayFieldHandle* childArray,
std::vector<caf::PdmObjectHandle*>& referringObjects ) override;
double getScaling( const QString& formationName, const QString& faciesName, RiaDefines::CurveProperty property ) const;
private:
caf::PdmChildArrayField<RimElasticPropertyScaling*> m_elasticPropertyScalings;
};

148
ApplicationCode/ReservoirDataModel/RigElasticProperties.cpp
View File

@ -20,6 +20,8 @@
#include "RiaInterpolationTools.h"
#include "cafAssert.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -62,78 +64,6 @@ const std::vector<double>& RigElasticProperties::porosity() const
return m_porosity;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>& RigElasticProperties::youngsModulus() const
{
return m_youngsModulus;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>& RigElasticProperties::poissonsRatio() const
{
return m_poissonsRatio;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>& RigElasticProperties::K_Ic() const
{
return m_K_Ic;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>& RigElasticProperties::proppantEmbedment() const
{
return m_proppantEmbedment;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>& RigElasticProperties::biotCoefficient() const
{
return m_biotCoefficient;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>& RigElasticProperties::k0() const
{
return m_k0;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>& RigElasticProperties::fluidLossCoefficient() const
{
return m_fluidLossCoefficient;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>& RigElasticProperties::spurtLoss() const
{
return m_spurtLoss;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>& RigElasticProperties::immobileFluidSaturation() const
{
return m_immobileFluidSaturation;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -163,71 +93,51 @@ void RigElasticProperties::appendValues( double porosity,
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigElasticProperties::getYoungsModulus( double porosity ) const
size_t RigElasticProperties::numValues() const
{
return RiaInterpolationTools::linear( m_porosity, m_youngsModulus, porosity );
return m_porosity.size();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigElasticProperties::getPoissonsRatio( double porosity ) const
double RigElasticProperties::getValue( RiaDefines::CurveProperty property, size_t index, double scale ) const
{
return RiaInterpolationTools::linear( m_porosity, m_poissonsRatio, porosity );
CAF_ASSERT( index < numValues() );
const std::vector<double>& unscaledValues = getVector( property );
return unscaledValues[index] * scale;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigElasticProperties::getK_Ic( double porosity ) const
const std::vector<double>& RigElasticProperties::getVector( RiaDefines::CurveProperty property ) const
{
return RiaInterpolationTools::linear( m_porosity, m_K_Ic, porosity );
if ( property == RiaDefines::CurveProperty::YOUNGS_MODULUS ) return m_youngsModulus;
if ( property == RiaDefines::CurveProperty::POISSONS_RATIO ) return m_poissonsRatio;
if ( property == RiaDefines::CurveProperty::K_IC ) return m_K_Ic;
if ( property == RiaDefines::CurveProperty::PROPPANT_EMBEDMENT ) return m_proppantEmbedment;
if ( property == RiaDefines::CurveProperty::BIOT_COEFFICIENT ) return m_biotCoefficient;
if ( property == RiaDefines::CurveProperty::K0 ) return m_k0;
if ( property == RiaDefines::CurveProperty::FLUID_LOSS_COEFFICIENT ) return m_fluidLossCoefficient;
if ( property == RiaDefines::CurveProperty::SPURT_LOSS ) return m_spurtLoss;
// Default: if we get this far only one option left
CAF_ASSERT( property == RiaDefines::CurveProperty::IMMOBILE_FLUID_SATURATION );
return m_immobileFluidSaturation;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigElasticProperties::getProppantEmbedment( double porosity ) const
double RigElasticProperties::getValueForPorosity( RiaDefines::CurveProperty property, double porosity, double scale ) const
{
return RiaInterpolationTools::linear( m_porosity, m_proppantEmbedment, porosity );
}
const std::vector<double>& unscaledValues = getVector( property );
std::vector<double> scaledValues;
for ( double unscaled : unscaledValues )
{
scaledValues.push_back( unscaled * scale );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigElasticProperties::getBiotCoefficient( double porosity ) const
{
return RiaInterpolationTools::linear( m_porosity, m_biotCoefficient, porosity );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigElasticProperties::getK0( double porosity ) const
{
return RiaInterpolationTools::linear( m_porosity, m_k0, porosity );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigElasticProperties::getFluidLossCoefficient( double porosity ) const
{
return RiaInterpolationTools::linear( m_porosity, m_fluidLossCoefficient, porosity );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigElasticProperties::getSpurtLoss( double porosity ) const
{
return RiaInterpolationTools::linear( m_porosity, m_spurtLoss, porosity );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigElasticProperties::getImmobileFluidSaturation( double porosity ) const
{
return RiaInterpolationTools::linear( m_porosity, m_immobileFluidSaturation, porosity );
return RiaInterpolationTools::linear( m_porosity, scaledValues, porosity );
}

26
ApplicationCode/ReservoirDataModel/RigElasticProperties.h
View File

@ -18,6 +18,8 @@
#pragma once
#include "RiaFractureModelDefines.h"
#include <QString>
#include <vector>
@ -43,28 +45,16 @@ public:
double fluidLossCoefficient,
double spurtLoss,
double immobileFluidSaturation );
double getYoungsModulus( double porosity ) const;
double getPoissonsRatio( double porosity ) const;
double getK_Ic( double porosity ) const;
double getProppantEmbedment( double porosity ) const;
double getBiotCoefficient( double porosity ) const;
double getK0( double porosity ) const;
double getFluidLossCoefficient( double porosity ) const;
double getSpurtLoss( double porosity ) const;
double getImmobileFluidSaturation( double porosity ) const;
size_t numValues() const;
double getValue( RiaDefines::CurveProperty property, size_t index, double scale = 1.0 ) const;
double getValueForPorosity( RiaDefines::CurveProperty property, double porosity, double scale = 1.0 ) const;
const std::vector<double>& porosity() const;
const std::vector<double>& youngsModulus() const;
const std::vector<double>& poissonsRatio() const;
const std::vector<double>& K_Ic() const;
const std::vector<double>& proppantEmbedment() const;
const std::vector<double>& biotCoefficient() const;
const std::vector<double>& k0() const;
const std::vector<double>& fluidLossCoefficient() const;
const std::vector<double>& spurtLoss() const;
const std::vector<double>& immobileFluidSaturation() const;
private:
const std::vector<double>& getVector( RiaDefines::CurveProperty property ) const;
QString m_fieldName;
QString m_formationName;
QString m_faciesName;