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

#3224 Non-Darcy longitudinal : Use geometric mean for B-factor

Browse Source
This commit is contained in:
Magne Sjaastad 2018-09-24 15:10:46 +02:00
parent 0f99ecf9e6
commit e96cc60ee7
8 changed files with 182 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ApplicationCode/ProjectDataModel/Completions/RimEllipseFractureTemplate.cpp
View File

@ -228,10 +228,10 @@ void RimEllipseFractureTemplate::createFractureGridAndAssignConductivities()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
FractureWidthAndConductivity WellFractureIntersectionData
RimEllipseFractureTemplate::widthAndConductivityAtWellPathIntersection(const RimFracture* fractureInstance) const RimEllipseFractureTemplate::wellFractureIntersectionData(const RimFracture* fractureInstance) const
{ {
FractureWidthAndConductivity values; WellFractureIntersectionData values;
values.m_width = m_width; values.m_width = m_width;
values.m_permeability = m_permeability; values.m_permeability = m_permeability;

2
ApplicationCode/ProjectDataModel/Completions/RimEllipseFractureTemplate.h
View File

@ -76,7 +76,7 @@ private:
void createFractureGridAndAssignConductivities(); void createFractureGridAndAssignConductivities();
std::vector<cvf::Vec3f> fractureBorderPolygon() const; std::vector<cvf::Vec3f> fractureBorderPolygon() const;
FractureWidthAndConductivity widthAndConductivityAtWellPathIntersection(const RimFracture* fractureInstance) const override; WellFractureIntersectionData wellFractureIntersectionData(const RimFracture* fractureInstance) const override;
private: private:
cvf::ref<RigFractureGrid> m_fractureGrid; cvf::ref<RigFractureGrid> m_fractureGrid;

1
ApplicationCode/ProjectDataModel/Completions/RimFracture.cpp
View File

@ -269,6 +269,7 @@ void RimFracture::ensureValidNonDarcyProperties()
props.dFactor = m_fractureTemplate->computeDFactor(this); props.dFactor = m_fractureTemplate->computeDFactor(this);
props.effectivePermeability = m_fractureTemplate->computeEffectivePermeability(this); props.effectivePermeability = m_fractureTemplate->computeEffectivePermeability(this);
props.eqWellRadius = m_fractureTemplate->computeWellRadiusForDFactorCalculation(this); props.eqWellRadius = m_fractureTemplate->computeWellRadiusForDFactorCalculation(this);
props.betaFactor = m_fractureTemplate->getOrComputeBetaFactor(this);
props.isDataDirty = false; props.isDataDirty = false;
} }

2
ApplicationCode/ProjectDataModel/Completions/RimFracture.h
View File

@ -50,6 +50,7 @@ public:
, effectivePermeability(std::numeric_limits<double>::infinity()) , effectivePermeability(std::numeric_limits<double>::infinity())
, dFactor(std::numeric_limits<double>::infinity()) , dFactor(std::numeric_limits<double>::infinity())
, eqWellRadius(std::numeric_limits<double>::infinity()) , eqWellRadius(std::numeric_limits<double>::infinity())
, betaFactor(std::numeric_limits<double>::infinity())
, isDataDirty(true) , isDataDirty(true)
{ {
} }
@ -64,6 +65,7 @@ public:
double conductivity; double conductivity;
double effectivePermeability; double effectivePermeability;
double dFactor; double dFactor;
double betaFactor;
bool isDataDirty; bool isDataDirty;
}; };

89
ApplicationCode/ProjectDataModel/Completions/RimFractureTemplate.cpp
View File

@ -85,6 +85,16 @@ namespace caf
setDefault(RimFractureTemplate::NON_DARCY_NONE); setDefault(RimFractureTemplate::NON_DARCY_NONE);
} }
template<>
void caf::AppEnum< RimFractureTemplate::BetaFactorEnum>::setUp()
{
addItem(RimFractureTemplate::USER_DEFINED_BETA_FACTOR, "UserDefinedBetaFactor", "User Defined");
addItem(RimFractureTemplate::BETA_FACTOR_FROM_FRACTURE, "FractureBetaFactor", "Use Fracture Beta Factor");
setDefault(RimFractureTemplate::USER_DEFINED_BETA_FACTOR);
}
} }
// TODO Move to cafPdmObject.h // TODO Move to cafPdmObject.h
@ -138,6 +148,7 @@ RimFractureTemplate::RimFractureTemplate()
CAF_PDM_InitFieldNoDefault(&m_fractureWidthType, "FractureWidthType", "Type", "", "", ""); CAF_PDM_InitFieldNoDefault(&m_fractureWidthType, "FractureWidthType", "Type", "", "", "");
CAF_PDM_InitField_Basic(&m_fractureWidth, "FractureWidth", 0.01, "Fracture Width (h)"); CAF_PDM_InitField_Basic(&m_fractureWidth, "FractureWidth", 0.01, "Fracture Width (h)");
CAF_PDM_InitFieldNoDefault(&m_betaFactorType, "BetaFactorType", "Type", "", "", "");
CAF_PDM_InitField_Basic(&m_inertialCoefficient, "InertialCoefficient", 0.006083236, "<html>Inertial Coefficient (&beta;)</html> [Forch. unit]"); CAF_PDM_InitField_Basic(&m_inertialCoefficient, "InertialCoefficient", 0.006083236, "<html>Inertial Coefficient (&beta;)</html> [Forch. unit]");
CAF_PDM_InitFieldNoDefault(&m_permeabilityType, "PermeabilityType", "Type", "", "", ""); CAF_PDM_InitFieldNoDefault(&m_permeabilityType, "PermeabilityType", "Type", "", "", "");
@ -336,7 +347,11 @@ void RimFractureTemplate::defineUiOrdering(QString uiConfigName, caf::PdmUiOrder
if (m_nonDarcyFlowType == RimFractureTemplate::NON_DARCY_COMPUTED) if (m_nonDarcyFlowType == RimFractureTemplate::NON_DARCY_COMPUTED)
{ {
nonDarcyFlowGroup->add(&m_inertialCoefficient); {
auto group = nonDarcyFlowGroup->addNewGroup("<html>Inertial Coefficient(&beta;-factor)</html>");
group->add(&m_betaFactorType);
group->add(&m_inertialCoefficient);
}
{ {
auto group = nonDarcyFlowGroup->addNewGroup("Effective Permeability"); auto group = nonDarcyFlowGroup->addNewGroup("Effective Permeability");
@ -424,6 +439,18 @@ QList<caf::PdmOptionItemInfo> RimFractureTemplate::calculateValueOptions(const c
options.push_back(caf::PdmOptionItemInfo(caf::AppEnum<WidthEnum>::uiText(WIDTH_FROM_FRACTURE), WIDTH_FROM_FRACTURE)); options.push_back(caf::PdmOptionItemInfo(caf::AppEnum<WidthEnum>::uiText(WIDTH_FROM_FRACTURE), WIDTH_FROM_FRACTURE));
} }
if (fieldNeedingOptions == &m_betaFactorType)
{
options.push_back(
caf::PdmOptionItemInfo(caf::AppEnum<BetaFactorEnum>::uiText(USER_DEFINED_BETA_FACTOR), USER_DEFINED_BETA_FACTOR));
if (isBetaFactorAvailableOnFile())
{
options.push_back(caf::PdmOptionItemInfo(caf::AppEnum<BetaFactorEnum>::uiText(BETA_FACTOR_FROM_FRACTURE),
BETA_FACTOR_FROM_FRACTURE));
}
}
return options; return options;
} }
@ -477,13 +504,24 @@ void RimFractureTemplate::prepareFieldsForUiDisplay()
// Non Darcy Flow // Non Darcy Flow
if (m_fractureWidthType == RimFractureTemplate::USER_DEFINED_WIDTH)
{ {
m_fractureWidth.uiCapability()->setUiReadOnly(false); if (m_fractureWidthType == RimFractureTemplate::USER_DEFINED_WIDTH)
} {
else m_fractureWidth.uiCapability()->setUiReadOnly(false);
{ }
m_fractureWidth.uiCapability()->setUiReadOnly(true); else
{
m_fractureWidth.uiCapability()->setUiReadOnly(true);
}
if (m_betaFactorType == RimFractureTemplate::USER_DEFINED_BETA_FACTOR)
{
m_inertialCoefficient.uiCapability()->setUiReadOnly(false);
}
else
{
m_inertialCoefficient.uiCapability()->setUiReadOnly(true);
}
} }
if (m_permeabilityType == RimFractureTemplate::USER_DEFINED_PERMEABILITY) if (m_permeabilityType == RimFractureTemplate::USER_DEFINED_PERMEABILITY)
@ -545,7 +583,7 @@ QString RimFractureTemplate::dFactorSummary() const
auto alpha = RiaDefines::nonDarcyFlowAlpha(m_fractureTemplateUnit()); auto alpha = RiaDefines::nonDarcyFlowAlpha(m_fractureTemplateUnit());
text += indentedText(QString("&alpha; : %1").arg(alpha)); text += indentedText(QString("&alpha; : %1").arg(alpha));
auto beta = m_inertialCoefficient; auto beta = getOrComputeBetaFactor(f);
text += indentedText(QString("&beta; : %1").arg(beta)); text += indentedText(QString("&beta; : %1").arg(beta));
double effPerm = f->nonDarcyProperties().effectivePermeability; double effPerm = f->nonDarcyProperties().effectivePermeability;
@ -596,7 +634,7 @@ double RimFractureTemplate::computeEffectivePermeability(const RimFracture* frac
else else
{ {
double fracPermeability = 0.0; double fracPermeability = 0.0;
auto values = widthAndConductivityAtWellPathIntersection(fractureInstance); auto values = wellFractureIntersectionData(fractureInstance);
if (values.isWidthAndPermeabilityDefined()) if (values.isWidthAndPermeabilityDefined())
{ {
fracPermeability = values.m_permeability; fracPermeability = values.m_permeability;
@ -606,7 +644,7 @@ double RimFractureTemplate::computeEffectivePermeability(const RimFracture* frac
auto conductivity = values.m_conductivity; auto conductivity = values.m_conductivity;
auto width = computeFractureWidth(fractureInstance); auto width = computeFractureWidth(fractureInstance);
if (fabs(width) < 1e-10) return HUGE_VAL; if (fabs(width) < 1e-10) return std::numeric_limits<double>::infinity();
fracPermeability = conductivity / width; fracPermeability = conductivity / width;
} }
@ -651,7 +689,7 @@ double RimFractureTemplate::computeDFactor(const RimFracture* fractureInstance)
{ {
double radius = computeWellRadiusForDFactorCalculation(fractureInstance); double radius = computeWellRadiusForDFactorCalculation(fractureInstance);
double alpha = RiaDefines::nonDarcyFlowAlpha(m_fractureTemplateUnit()); double alpha = RiaDefines::nonDarcyFlowAlpha(m_fractureTemplateUnit());
double beta = m_inertialCoefficient; double beta = getOrComputeBetaFactor(fractureInstance);
double effPerm = computeEffectivePermeability(fractureInstance); double effPerm = computeEffectivePermeability(fractureInstance);
double gamma = m_relativeGasDensity; double gamma = m_relativeGasDensity;
@ -661,7 +699,7 @@ double RimFractureTemplate::computeDFactor(const RimFracture* fractureInstance)
double numerator = alpha * beta * effPerm * gamma; double numerator = alpha * beta * effPerm * gamma;
double denumerator = h * radius * mu; double denumerator = h * radius * mu;
if (denumerator < 1e-10) return HUGE_VAL; if (denumerator < 1e-10) return std::numeric_limits<double>::infinity();
d = numerator / denumerator; d = numerator / denumerator;
@ -685,7 +723,7 @@ double RimFractureTemplate::computeKh(const RimFracture* fractureInstance) const
// kh = permeability * h // kh = permeability * h
// conductivity = permeability * h // conductivity = permeability * h
auto values = widthAndConductivityAtWellPathIntersection(fractureInstance); auto values = wellFractureIntersectionData(fractureInstance);
if (values.isConductivityDefined()) if (values.isConductivityDefined())
{ {
// If conductivity is found in stim plan file, use this directly // If conductivity is found in stim plan file, use this directly
@ -804,7 +842,7 @@ double RimFractureTemplate::computeFractureWidth(const RimFracture* fractureInst
{ {
if (m_fractureWidthType == RimFractureTemplate::WIDTH_FROM_FRACTURE) if (m_fractureWidthType == RimFractureTemplate::WIDTH_FROM_FRACTURE)
{ {
auto values = widthAndConductivityAtWellPathIntersection(fractureInstance); auto values = wellFractureIntersectionData(fractureInstance);
return values.m_width; return values.m_width;
} }
@ -812,6 +850,21 @@ double RimFractureTemplate::computeFractureWidth(const RimFracture* fractureInst
return m_fractureWidth; return m_fractureWidth;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFractureTemplate::getOrComputeBetaFactor(const RimFracture* fractureInstance) const
{
if (m_betaFactorType == RimFractureTemplate::BETA_FACTOR_FROM_FRACTURE)
{
auto values = wellFractureIntersectionData(fractureInstance);
return values.m_betaFactorInForcheimerUnits;
}
return m_inertialCoefficient;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -831,6 +884,14 @@ std::vector<RimFracture*> RimFractureTemplate::fracturesUsingThisTemplate() cons
return fractures; return fractures;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimFractureTemplate::isBetaFactorAvailableOnFile() const
{
return false;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

27
ApplicationCode/ProjectDataModel/Completions/RimFractureTemplate.h
View File

@ -32,7 +32,7 @@
#include "cvfVector3.h" #include "cvfVector3.h"
#include <vector> #include <vector>
#include <cmath> #include <limits>
class RigFractureGrid; class RigFractureGrid;
class RimFractureContainment; class RimFractureContainment;
@ -40,13 +40,14 @@ class MinMaxAccumulator;
class PosNegAccumulator; class PosNegAccumulator;
class RimFracture; class RimFracture;
class FractureWidthAndConductivity class WellFractureIntersectionData
{ {
public: public:
FractureWidthAndConductivity() WellFractureIntersectionData()
: m_width(0.0) : m_width(0.0)
, m_permeability(0.0) , m_permeability(0.0)
, m_conductivity(HUGE_VAL) , m_conductivity(std::numeric_limits<double>::infinity())
, m_betaFactorInForcheimerUnits(std::numeric_limits<double>::infinity())
{ {
} }
@ -60,7 +61,7 @@ public:
bool isConductivityDefined() const bool isConductivityDefined() const
{ {
return (m_conductivity != HUGE_VAL); return (m_conductivity != std::numeric_limits<double>::infinity());
} }
// Unit : meter or feet // Unit : meter or feet
@ -70,6 +71,9 @@ public:
double m_permeability; double m_permeability;
double m_conductivity; double m_conductivity;
// Unit : Forcheimer unit
double m_betaFactorInForcheimerUnits;
}; };
//================================================================================================== //==================================================================================================
@ -106,6 +110,12 @@ public:
WIDTH_FROM_FRACTURE, WIDTH_FROM_FRACTURE,
}; };
enum BetaFactorEnum
{
USER_DEFINED_BETA_FACTOR,
BETA_FACTOR_FROM_FRACTURE,
};
enum NonDarcyFlowEnum enum NonDarcyFlowEnum
{ {
NON_DARCY_NONE, NON_DARCY_NONE,
@ -165,6 +175,7 @@ public:
double computeEffectivePermeability(const RimFracture* fractureInstance) const; double computeEffectivePermeability(const RimFracture* fractureInstance) const;
double computeWellRadiusForDFactorCalculation(const RimFracture* fractureInstance) const; double computeWellRadiusForDFactorCalculation(const RimFracture* fractureInstance) const;
double computeFractureWidth(const RimFracture* fractureInstance) const; double computeFractureWidth(const RimFracture* fractureInstance) const;
double getOrComputeBetaFactor(const RimFracture* fractureInstance) const;
void loadDataAndUpdateGeometryHasChanged(); void loadDataAndUpdateGeometryHasChanged();
@ -177,10 +188,12 @@ protected:
std::vector<RimFracture*> fracturesUsingThisTemplate() const; std::vector<RimFracture*> fracturesUsingThisTemplate() const;
virtual void onLoadDataAndUpdateGeometryHasChanged() = 0; virtual void onLoadDataAndUpdateGeometryHasChanged() = 0;
virtual bool isBetaFactorAvailableOnFile() const;
private: private:
void prepareFieldsForUiDisplay(); void prepareFieldsForUiDisplay();
virtual FractureWidthAndConductivity widthAndConductivityAtWellPathIntersection(const RimFracture* fractureInstance) const = 0; virtual WellFractureIntersectionData wellFractureIntersectionData(const RimFracture* fractureInstance) const = 0;
QString dFactorSummary() const; QString dFactorSummary() const;
double dFactorForTemplate() const; double dFactorForTemplate() const;
@ -205,6 +218,8 @@ protected:
caf::PdmField<caf::AppEnum<WidthEnum>> m_fractureWidthType; caf::PdmField<caf::AppEnum<WidthEnum>> m_fractureWidthType;
caf::PdmField<double> m_fractureWidth; caf::PdmField<double> m_fractureWidth;
caf::PdmField<caf::AppEnum<BetaFactorEnum>> m_betaFactorType;
caf::PdmField<double> m_inertialCoefficient; caf::PdmField<double> m_inertialCoefficient;
caf::PdmField<caf::AppEnum<PermeabilityEnum>> m_permeabilityType; caf::PdmField<caf::AppEnum<PermeabilityEnum>> m_permeabilityType;

84
ApplicationCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.cpp
View File

@ -22,6 +22,7 @@
#include "RiaCompletionTypeCalculationScheduler.h" #include "RiaCompletionTypeCalculationScheduler.h"
#include "RiaFractureDefines.h" #include "RiaFractureDefines.h"
#include "RiaLogging.h" #include "RiaLogging.h"
#include "RiaWeightedGeometricMeanCalculator.h"
#include "RiaWeightedMeanCalculator.h" #include "RiaWeightedMeanCalculator.h"
#include "RifStimPlanXmlReader.h" #include "RifStimPlanXmlReader.h"
@ -439,10 +440,9 @@ std::vector<double>
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
FractureWidthAndConductivity WellFractureIntersectionData RimStimPlanFractureTemplate::wellFractureIntersectionData(const RimFracture* fractureInstance) const
RimStimPlanFractureTemplate::widthAndConductivityAtWellPathIntersection(const RimFracture* fractureInstance) const
{ {
FractureWidthAndConductivity values; WellFractureIntersectionData values;
if (m_fractureGrid.notNull()) if (m_fractureGrid.notNull())
{ {
@ -455,9 +455,11 @@ FractureWidthAndConductivity
if (rimWellPath && rimWellPath->wellPathGeometry()) if (rimWellPath && rimWellPath->wellPathGeometry())
{ {
double totalLength = 0.0; double totalLength = 0.0;
double weightedConductivity = 0.0; double weightedConductivity = 0.0;
double weightedWidth = 0.0; double weightedWidth = 0.0;
double weightedBetaFactorOnFile = 0.0;
double conversionFactorForBeta = 1.0;
{ {
std::vector<double> widthResultValues; std::vector<double> widthResultValues;
@ -474,8 +476,30 @@ FractureWidthAndConductivity
nameUnit.first, nameUnit.second, m_activeTimeStepIndex, fractureTemplateUnit()); nameUnit.first, nameUnit.second, m_activeTimeStepIndex, fractureTemplateUnit());
} }
RiaWeightedMeanCalculator<double> widthCalc; std::vector<double> betaFactorResultValues;
RiaWeightedMeanCalculator<double> conductivityCalc; {
auto nameUnit = betaFactorParameterNameAndUnit();
betaFactorResultValues = m_stimPlanFractureDefinitionData->fractureGridResults(
nameUnit.first, nameUnit.second, m_activeTimeStepIndex);
QString trimmedUnit = nameUnit.second.trimmed().toLower();
if (trimmedUnit == "/m")
{
conversionFactorForBeta = 1.01325E+08;
}
else if (trimmedUnit == "/cm")
{
conversionFactorForBeta = 1.01325E+06;
}
else if (trimmedUnit == "/ft")
{
conversionFactorForBeta = 3.088386E+07;
}
}
RiaWeightedMeanCalculator<double> widthCalc;
RiaWeightedMeanCalculator<double> conductivityCalc;
RiaWeightedGeometricMeanCalculator betaFactorCalc;
RigWellPathStimplanIntersector intersector(rimWellPath->wellPathGeometry(), fractureInstance); RigWellPathStimplanIntersector intersector(rimWellPath->wellPathGeometry(), fractureInstance);
for (const auto& v : intersector.intersections()) for (const auto& v : intersector.intersections())
@ -493,6 +517,11 @@ FractureWidthAndConductivity
conductivityCalc.addValueAndWeight(conductivityResultValues[fractureGlobalCellIndex], conductivityCalc.addValueAndWeight(conductivityResultValues[fractureGlobalCellIndex],
intersectionLength); intersectionLength);
} }
if (fractureGlobalCellIndex < betaFactorResultValues.size())
{
betaFactorCalc.addValueAndWeight(betaFactorResultValues[fractureGlobalCellIndex], intersectionLength);
}
} }
if (conductivityCalc.validAggregatedWeight()) if (conductivityCalc.validAggregatedWeight())
{ {
@ -503,12 +532,19 @@ FractureWidthAndConductivity
weightedWidth = widthCalc.weightedMean(); weightedWidth = widthCalc.weightedMean();
totalLength = widthCalc.aggregatedWeight(); totalLength = widthCalc.aggregatedWeight();
} }
if (betaFactorCalc.validAggregatedWeight())
{
weightedBetaFactorOnFile = betaFactorCalc.weightedMean();
}
} }
if (totalLength > 1e-7) if (totalLength > 1e-7)
{ {
values.m_width = weightedWidth; values.m_width = weightedWidth;
values.m_conductivity = weightedConductivity; values.m_conductivity = weightedConductivity;
double betaFactorForcheimer = weightedBetaFactorOnFile / conversionFactorForBeta;
values.m_betaFactorInForcheimerUnits = betaFactorForcheimer;
} }
if (weightedWidth > 1e-7) if (weightedWidth > 1e-7)
@ -601,6 +637,38 @@ std::pair<QString, QString> RimStimPlanFractureTemplate::conductivityParameterNa
return std::pair<QString, QString>(); return std::pair<QString, QString>();
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<QString, QString> RimStimPlanFractureTemplate::betaFactorParameterNameAndUnit() const
{
if (m_stimPlanFractureDefinitionData.notNull())
{
std::vector<std::pair<QString, QString>> propertyNamesUnitsOnFile =
m_stimPlanFractureDefinitionData->getStimPlanPropertyNamesUnits();
for (const auto& nameUnit : propertyNamesUnitsOnFile)
{
if (nameUnit.first.contains("beta", Qt::CaseInsensitive))
{
return nameUnit;
}
}
}
return std::pair<QString, QString>();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimStimPlanFractureTemplate::isBetaFactorAvailableOnFile() const
{
auto nameAndUnit = betaFactorParameterNameAndUnit();
return !nameAndUnit.first.isEmpty();
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

4
ApplicationCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.h
View File

@ -108,10 +108,12 @@ private:
std::vector<double> fractureGridResultsForUnitSystem(const QString& resultName, const QString& unitName, size_t timeStepIndex, RiaEclipseUnitTools::UnitSystem requiredUnitSystem) const; std::vector<double> fractureGridResultsForUnitSystem(const QString& resultName, const QString& unitName, size_t timeStepIndex, RiaEclipseUnitTools::UnitSystem requiredUnitSystem) const;
virtual FractureWidthAndConductivity widthAndConductivityAtWellPathIntersection(const RimFracture* fractureInstance) const override; virtual WellFractureIntersectionData wellFractureIntersectionData(const RimFracture* fractureInstance) const override;
std::pair<QString, QString> widthParameterNameAndUnit() const; std::pair<QString, QString> widthParameterNameAndUnit() const;
std::pair<QString, QString> conductivityParameterNameAndUnit() const; std::pair<QString, QString> conductivityParameterNameAndUnit() const;
std::pair<QString, QString> betaFactorParameterNameAndUnit() const;
bool isBetaFactorAvailableOnFile() const override;
private: private:
caf::PdmField<int> m_activeTimeStepIndex; caf::PdmField<int> m_activeTimeStepIndex;