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

#3670 Implement new Pressure Depletion behaviour

Browse Source 
* Removed choice of different scaling
* Always use current pressure delta
* Use the maximum of an epsilon value and the absolute value of the matrix to well pressure drop as the scaling factor
* Remove file name suffixes and update information table in export file.
This commit is contained in:
Gaute Lindkvist
2018-11-13 16:47:53 +01:00
parent bfee1dfa64
commit 73b79daa09
13 changed files with 167 additions and 246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
ApplicationCode/CommandFileInterface/RicfExportWellPathCompletions.cpp
View File

@@ -56,9 +56,9 @@ RicfExportWellPathCompletions::RicfExportWellPathCompletions()
RICF_InitField(&m_excludeMainBoreForFishbones, "excludeMainBoreForFishbones", false, "Exclude Main Bore for Fishbones", "", "", "");
RICF_InitField(&m_transScalingType, "transScalingType", RicExportCompletionDataSettingsUi::TransScalingType(), "Transmissibility Scaling Type", "", "", "");
RICF_InitField(&m_performTransScaling, "performTransScaling", false, "Perform Transmissibility Scaling", "", "", "");
RICF_InitField(&m_transScalingTimeStep, "transScalingTimeStep", 0, "Transmissibility Scaling Pressure Time Step", "", "", "");
RICF_InitField(&m_transScalingInitialWBHP, "transScalingWBHPFromSummary", RicExportCompletionDataSettingsUi::TransScalingInitialWBHP(), "Transmissibility Scaling WBHP from summary", "", "", "");
RICF_InitField(&m_transScalingInitialWBHP, "transScalingWBHPFromSummary", RicExportCompletionDataSettingsUi::TransScalingWBHPSource(), "Transmissibility Scaling WBHP from summary", "", "", "");
RICF_InitField(&m_transScalingWBHP, "transScalingWBHP", 200.0, "Transmissibility Scaling Constant WBHP Value", "", "", "");
}
@@ -84,9 +84,9 @@ void RicfExportWellPathCompletions::execute()
exportSettings->fileSplit = m_fileSplit;
exportSettings->compdatExport = m_compdatExport;
exportSettings->transScalingType = m_transScalingType;
exportSettings->performTransScaling = m_performTransScaling;
exportSettings->transScalingTimeStep = m_transScalingTimeStep;
exportSettings->transScalingInitialWBHP = m_transScalingInitialWBHP;
exportSettings->transScalingWBHPSource = m_transScalingInitialWBHP;
exportSettings->transScalingWBHP = m_transScalingWBHP;
exportSettings->useLateralNTG = m_useLateralNTG;

4
ApplicationCode/CommandFileInterface/RicfExportWellPathCompletions.h
View File

@@ -48,9 +48,9 @@ private:
caf::PdmField<RicExportCompletionDataSettingsUi::CompdatExportType> m_compdatExport;
caf::PdmField<RicExportCompletionDataSettingsUi::CombinationModeType> m_combinationMode;
caf::PdmField<RicExportCompletionDataSettingsUi::TransScalingType> m_transScalingType;
caf::PdmField<bool> m_performTransScaling;
caf::PdmField<int> m_transScalingTimeStep;
caf::PdmField<RicExportCompletionDataSettingsUi::TransScalingInitialWBHP> m_transScalingInitialWBHP;
caf::PdmField<RicExportCompletionDataSettingsUi::TransScalingWBHPSource> m_transScalingInitialWBHP;
caf::PdmField<double> m_transScalingWBHP;
caf::PdmField<bool> m_useLateralNTG;

70
ApplicationCode/Commands/CompletionExportCommands/RicExportCompletionDataSettingsUi.cpp
View File

@@ -57,23 +57,12 @@ namespace caf
}
template<>
void RicExportCompletionDataSettingsUi::TransScalingType::setUp()
void RicExportCompletionDataSettingsUi::TransScalingWBHPSource::setUp()
{
addItem(RicExportFractureCompletionsImpl::NO_SCALING, "NO_SCALING", "No scaling");
addItem(RicExportFractureCompletionsImpl::MATRIX_TO_WELL_DP_OVER_INITIAL_DP, "MATWELL_DP_OVER_INITIALDP", "Matrix to Well dP over initial dP");
addItem(RicExportFractureCompletionsImpl::MATRIX_TO_WELL_DP_OVER_MAX_INITIAL_DP, "MATWELL_DP_OVER_MAX_INITIALDP", "Matrix to Well dP over max initial dP");
addItem(RicExportFractureCompletionsImpl::WBHP_FROM_SUMMARY, "WBHP_SUMMARY", "WBHP From Summary Case");
addItem(RicExportFractureCompletionsImpl::WBHP_FROM_USER_DEF, "WBHP_USER_DEFINED", "Fixed User Defined WBHP");
setDefault(RicExportFractureCompletionsImpl::NO_SCALING);
}
template<>
void RicExportCompletionDataSettingsUi::TransScalingInitialWBHP::setUp()
{
addItem(RicExportFractureCompletionsImpl::FROM_PRODUCTION_START, "PROD_START", "Initial WBHP From Production Start");
addItem(RicExportFractureCompletionsImpl::FROM_PRODUCTION_START_W_MIN, "PROD_START_MIN", "Initial WBHP From Production Start With Minimum WBHP");
addItem(RicExportFractureCompletionsImpl::FIXED_INITIAL_WBHP, "FIXED_INITIAL_WBHP", "Fixed Initial WBHP");
setDefault(RicExportFractureCompletionsImpl::FROM_PRODUCTION_START);
setDefault(RicExportFractureCompletionsImpl::WBHP_FROM_SUMMARY);
}
}
// clang-format on
@@ -101,10 +90,10 @@ RicExportCompletionDataSettingsUi::RicExportCompletionDataSettingsUi()
CAF_PDM_InitField(&includeFishbones, "IncludeFishbones", true, "Fishbones", "", "", "");
CAF_PDM_InitField(&includeFractures, "IncludeFractures", true, "Fractures", "", "", "");
CAF_PDM_InitFieldNoDefault(&transScalingType, "TransScalingType", " Pressure Diff. Depletion Transmissibility Scaling", "", "", "");
CAF_PDM_InitField(&transScalingTimeStep, "TransScalingTimeStep", 0, " PDD Current WBHP Time Step", "", "", "");
CAF_PDM_InitFieldNoDefault(&transScalingInitialWBHP, "TransScalingInitialWBHP", " PDD Initial WBHP Selection", "", "", "");
CAF_PDM_InitField(&transScalingWBHP, "TransScalingWBHP", 200.0, " PDD Initial WBHP Value", "", "", "");
CAF_PDM_InitField(&performTransScaling, "TransScalingType", false, "Perform Transmissibility Scaling", "", "", "");
CAF_PDM_InitField(&transScalingTimeStep, "TransScalingTimeStep", 0, "Current Time Step", "", "", "");
CAF_PDM_InitFieldNoDefault(&transScalingWBHPSource, "TransScalingWBHPSource", "WBHP Selection", "", "", "");
CAF_PDM_InitField(&transScalingWBHP, "TransScalingWBHP", 200.0, "WBHP Before Production Start", "", "", "");
CAF_PDM_InitField(&excludeMainBoreForFishbones,
"ExcludeMainBoreForFishbones",
@@ -325,39 +314,42 @@ void RicExportCompletionDataSettingsUi::defineUiOrdering(QString uiConfigName, c
{
group->add(&includeFractures);
if (RiaApplication::enableDevelopmentFeatures())
{
group->add(&transScalingType);
group->add(&transScalingTimeStep);
group->add(&transScalingInitialWBHP);
group->add(&transScalingWBHP);
caf::PdmUiGroup* pddGroup = group->addNewGroup("Pressure Differential Depletion Scaling");
pddGroup->setUiReadOnly(!includeFractures());
if (transScalingType() == RicExportFractureCompletionsImpl::NO_SCALING)
pddGroup->add(&performTransScaling);
pddGroup->add(&transScalingTimeStep);
pddGroup->add(&transScalingWBHPSource);
pddGroup->add(&transScalingWBHP);
if (!includeFractures())
{
performTransScaling = false;
performTransScaling.uiCapability()->setUiReadOnly(true);
}
else
{
performTransScaling.uiCapability()->setUiReadOnly(false);
}
if (!performTransScaling())
{
transScalingTimeStep.uiCapability()->setUiReadOnly(true);
transScalingInitialWBHP.uiCapability()->setUiReadOnly(true);
transScalingWBHPSource.uiCapability()->setUiReadOnly(true);
transScalingWBHP.uiCapability()->setUiReadOnly(true);
}
else
{
transScalingTimeStep.uiCapability()->setUiReadOnly(false);
transScalingInitialWBHP.uiCapability()->setUiReadOnly(false);
if (transScalingInitialWBHP == RicExportFractureCompletionsImpl::FROM_PRODUCTION_START)
{
transScalingWBHP.uiCapability()->setUiReadOnly(true);
}
else
{
transScalingWBHPSource.uiCapability()->setUiReadOnly(false);
transScalingWBHP.uiCapability()->setUiReadOnly(false);
if (transScalingInitialWBHP == RicExportFractureCompletionsImpl::FROM_PRODUCTION_START_W_MIN)
if (transScalingWBHPSource == RicExportFractureCompletionsImpl::WBHP_FROM_SUMMARY)
{
transScalingWBHP.uiCapability()->setUiName(" PDD Minimum Initial WBHP");
transScalingWBHP.uiCapability()->setUiName("WBHP Before Production Start");
}
else
{
transScalingWBHP.uiCapability()->setUiName(" PDD Fixed Initial WBHP");
}
}
transScalingWBHP.uiCapability()->setUiName("User Defined WBHP");
}
}

7
ApplicationCode/Commands/CompletionExportCommands/RicExportCompletionDataSettingsUi.h
View File

@@ -56,8 +56,7 @@ public:
};
typedef caf::AppEnum<CombinationMode> CombinationModeType;
typedef caf::AppEnum<RicExportFractureCompletionsImpl::PressureDepletionTransScaling> TransScalingType;
typedef caf::AppEnum<RicExportFractureCompletionsImpl::PressureDepletionInitialWBHP> TransScalingInitialWBHP;
typedef caf::AppEnum<RicExportFractureCompletionsImpl::PressureDepletionWBHPSource> TransScalingWBHPSource;
RicExportCompletionDataSettingsUi();
@@ -66,9 +65,9 @@ public:
caf::PdmField<ExportSplitType> fileSplit;
caf::PdmField<CompdatExportType> compdatExport;
caf::PdmField<TransScalingType> transScalingType;
caf::PdmField<bool> performTransScaling;
caf::PdmField<int> transScalingTimeStep;
caf::PdmField<TransScalingInitialWBHP> transScalingInitialWBHP;
caf::PdmField<TransScalingWBHPSource> transScalingWBHPSource;
caf::PdmField<double> transScalingWBHP;
caf::PdmField<bool> includeMsw;

68
ApplicationCode/Commands/CompletionExportCommands/RicExportFractureCompletionsImpl.cpp
View File

@@ -184,7 +184,7 @@ std::vector<RigCompletionData>
caseToApply->loadStaticResultsByName(resultNames);
}
if (pdParams.pressureDropScaling != NO_SCALING)
if (pdParams.performScaling)
{
RigCaseCellResultsData* results = caseToApply->results(RiaDefines::MATRIX_MODEL);
results->findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "PRESSURE");
@@ -225,15 +225,14 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
size_t pressureResultIndex = results->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "PRESSURE");
const RigActiveCellInfo* actCellInfo = caseToApply->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL);
PressureDepletionTransScaling currentPressureDropScaling = pdParams.pressureDropScaling;
bool performPressureDepletionScaling = pdParams.performScaling;
int initialWellProductionTimeStep = 0;
double initialWellPressure = 0;
double currentWellPressure = 0;
if (currentPressureDropScaling != NO_SCALING)
if (performPressureDepletionScaling)
{
double minimumWBHP = pdParams.pressureScalingWBHP;
double userWBHP = pdParams.userWBHP;
double initialWBHPFromSummary = 0.0;
double currentWBHPFromSummary = 0.0;
@@ -245,49 +244,27 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
&initialWBHPFromSummary,
&currentWBHPFromSummary);
if (pdParams.wbhpSource == WBHP_FROM_SUMMARY)
{
currentWellPressure = currentWBHPFromSummary;
if (pdParams.initialWbhpSource == FROM_PRODUCTION_START)
{
initialWellPressure = initialWBHPFromSummary;
}
else if (pdParams.initialWbhpSource == FROM_PRODUCTION_START_W_MIN)
{
initialWellPressure = initialWBHPFromSummary;
if (pdParams.pressureScalingTimeStep <= initialWellProductionTimeStep)
{
initialWellPressure = minimumWBHP;
currentWellPressure = userWBHP;
}
}
else
{
initialWellPressure = minimumWBHP;
}
// Final check for initial vs current pressure to see if scaling is valid
if (std::fabs(initialWellPressure - currentWellPressure) < 1.0e-6)
{
// Don't perform scaling if current pressure is equal to initial.
currentPressureDropScaling = NO_SCALING;
currentWellPressure = userWBHP;
}
}
const std::vector<std::vector<double>>* pressureResultVector = nullptr;
const std::vector<double>* initialMatrixPressures = nullptr;
const std::vector<double>* currentMatrixPressures = nullptr;
if (currentPressureDropScaling != NO_SCALING)
if (performPressureDepletionScaling)
{
pressureResultVector = &results->cellScalarResults(pressureResultIndex);
CVF_ASSERT(!pressureResultVector->empty());
if (initialWellProductionTimeStep < static_cast<int>(pressureResultVector->size()))
{
initialMatrixPressures = &pressureResultVector->at(initialWellProductionTimeStep);
}
else
{
// Don't perform scaling if the initial well production time step is beyond the case range.
currentPressureDropScaling = NO_SCALING;
}
if (pdParams.pressureScalingTimeStep < static_cast<int>(pressureResultVector->size()))
{
currentMatrixPressures = &pressureResultVector->at(pdParams.pressureScalingTimeStep);
@@ -295,7 +272,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
else
{
// Don't perform scaling if the current pressure time step is beyond the case range.
currentPressureDropScaling = NO_SCALING;
performPressureDepletionScaling = false;
}
}
@@ -349,25 +326,15 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
// Insert total transmissibility from eclipse-cell to well for this fracture into the map
std::map<size_t, double> matrixToWellTrans = calculateMatrixToWellTransmissibilities(transCondenser);
////////////////////////////////////////////////////////
// clang-format off
// WARNING!!! //
// PROTOTYPE-CODE for Pressure Differential Depletion //
// MAY CHANGE A LOT //
////////////////////////////////////////////////////////
if (currentPressureDropScaling == MATRIX_TO_WELL_DP_OVER_INITIAL_DP ||
currentPressureDropScaling == MATRIX_TO_WELL_DP_OVER_MAX_INITIAL_DP)
double maxPressureDrop = 0.0, minPressureDrop = 0.0;
if (performPressureDepletionScaling)
{
RigTransmissibilityCondenser scaledCondenser = transCondenser;
// 1. Scale matrix to fracture transmissibilities by matrix to fracture pressure
std::map<size_t, double> originalLumpedMatrixToFractureTrans = scaledCondenser.scaleMatrixToFracTransByMatrixWellDP(
actCellInfo,
initialWellPressure,
currentWellPressure,
*initialMatrixPressures,
*currentMatrixPressures,
currentPressureDropScaling == MATRIX_TO_WELL_DP_OVER_MAX_INITIAL_DP);
*currentMatrixPressures, &minPressureDrop, &maxPressureDrop);
// 2: Calculate new external transmissibilities
scaledCondenser.calculateCondensedTransmissibilities();
@@ -384,11 +351,6 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
}
}
////////////////////////////////////////////////////////////
// clang-format on
// END PROTOTYPE CODE FOR PRESSURE DIFFERENTIAL DEPLETION //
////////////////////////////////////////////////////////////
std::vector<RigCompletionData> allCompletionsForOneFracture =
generateCompdatValuesForFracture(matrixToWellTrans, wellPathName, caseToApply, fracture, fracTemplate);
@@ -397,7 +359,9 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
RicWellPathFractureReportItem reportItem(
wellPathName, fracture->name(), fracTemplate->name(), fracture->fractureMD());
reportItem.setUnitSystem(fracTemplate->fractureTemplateUnit());
reportItem.setPressureDepletionParameters(caf::AppEnum<PressureDepletionTransScaling>::uiTextFromIndex(currentPressureDropScaling), initialWellPressure, currentWellPressure);
reportItem.setPressureDepletionParameters(performPressureDepletionScaling ? "True" : "False",
caf::AppEnum<PressureDepletionWBHPSource>::uiTextFromIndex(pdParams.wbhpSource),
pdParams.userWBHP, minPressureDrop, maxPressureDrop);
RicExportFractureCompletionsImpl::calculateAndSetReportItemData(
allCompletionsForOneFracture, eclToFractureCalc, reportItem);

31
ApplicationCode/Commands/CompletionExportCommands/RicExportFractureCompletionsImpl.h
View File

@@ -44,18 +44,11 @@ class QString;
class RicExportFractureCompletionsImpl
{
public:
enum PressureDepletionTransScaling
{
NO_SCALING = 0,
MATRIX_TO_WELL_DP_OVER_INITIAL_DP,
MATRIX_TO_WELL_DP_OVER_MAX_INITIAL_DP
};
enum PressureDepletionInitialWBHP
enum PressureDepletionWBHPSource
{
FROM_PRODUCTION_START,
FROM_PRODUCTION_START_W_MIN,
FIXED_INITIAL_WBHP
WBHP_FROM_SUMMARY,
WBHP_FROM_USER_DEF
};
//--------------------------------------------------------------------------------------------------
@@ -63,20 +56,20 @@ public:
//--------------------------------------------------------------------------------------------------
struct PressureDepletionParameters
{
PressureDepletionParameters(PressureDepletionTransScaling pressureDropScaling = NO_SCALING,
PressureDepletionParameters(bool performScaling = false,
int pressureScalingTimeStep = 0,
PressureDepletionInitialWBHP initialWbhpSource = FROM_PRODUCTION_START,
double pressureScalingWBHP = 200.0)
: pressureDropScaling(pressureDropScaling)
PressureDepletionWBHPSource wbhpSource = WBHP_FROM_SUMMARY,
double userWBHP = 200.0)
: performScaling(performScaling)
, pressureScalingTimeStep(pressureScalingTimeStep)
, initialWbhpSource(initialWbhpSource)
, pressureScalingWBHP(pressureScalingWBHP)
, wbhpSource(wbhpSource)
, userWBHP(userWBHP)
{}
PressureDepletionTransScaling pressureDropScaling;
bool performScaling;
int pressureScalingTimeStep;
PressureDepletionInitialWBHP initialWbhpSource;
double pressureScalingWBHP;
PressureDepletionWBHPSource wbhpSource;
double userWBHP;
};
static std::vector<RigCompletionData> generateCompdatValuesForWellPath(RimWellPath* wellPath,

56
ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeatureImpl.cpp
View File

@@ -245,9 +245,9 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompletions(const std::ve
exportSettings.caseToApply(),
reportItems,
fractureTransmissibilityExportInformationStream.get(),
RicExportFractureCompletionsImpl::PressureDepletionParameters(exportSettings.transScalingType(),
RicExportFractureCompletionsImpl::PressureDepletionParameters(exportSettings.performTransScaling(),
exportSettings.transScalingTimeStep(),
exportSettings.transScalingInitialWBHP(),
exportSettings.transScalingWBHPSource(),
exportSettings.transScalingWBHP()));
appendCompletionData(&completionsPerEclipseCellAllCompletionTypes, fractureCompletionData);
@@ -291,9 +291,9 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompletions(const std::ve
exportSettings.caseToApply(),
simWell,
fractureTransmissibilityExportInformationStream.get(),
RicExportFractureCompletionsImpl::PressureDepletionParameters(exportSettings.transScalingType(),
RicExportFractureCompletionsImpl::PressureDepletionParameters(exportSettings.performTransScaling(),
exportSettings.transScalingTimeStep(),
exportSettings.transScalingInitialWBHP(),
exportSettings.transScalingWBHPSource(),
exportSettings.transScalingWBHP()));
appendCompletionData(&completionsPerEclipseCell, fractureCompletionData);
@@ -312,7 +312,6 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompletions(const std::ve
if (exportSettings.fileSplit == RicExportCompletionDataSettingsUi::UNIFIED_FILE)
{
QString fileName = QString("UnifiedCompletions_%1").arg(eclipseCaseName);
fileName += createPressureDepletionFileNameSuffix(exportSettings);
sortAndExportCompletionsToFile(exportSettings.caseToApply,
exportSettings.folder,
fileName,
@@ -337,7 +336,6 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompletions(const std::ve
if (wellCompletions.empty()) continue;
QString fileName = QString("%1_unifiedCompletions_%2").arg(wellPath->name()).arg(eclipseCaseName);
fileName += createPressureDepletionFileNameSuffix(exportSettings);
sortAndExportCompletionsToFile(exportSettings.caseToApply,
exportSettings.folder,
fileName,
@@ -379,7 +377,6 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompletions(const std::ve
QString fileName = QString("%1_%2_%3").arg(wellPath->name()).arg(completionTypeText).arg(eclipseCaseName);
if (completionType == RigCompletionData::FRACTURE)
{
fileName += createPressureDepletionFileNameSuffix(exportSettings);
sortAndExportCompletionsToFile(exportSettings.caseToApply,
exportSettings.folder,
fileName,
@@ -422,7 +419,6 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompletions(const std::ve
if (wellCompletions.empty()) continue;
QString fileName = QString("%1_Fractures_%2").arg(simWell->name()).arg(eclipseCaseName);
fileName += createPressureDepletionFileNameSuffix(exportSettings);
sortAndExportCompletionsToFile(exportSettings.caseToApply,
exportSettings.folder,
fileName,
@@ -2618,50 +2614,6 @@ void RicWellPathExportCompletionDataFeatureImpl::exportWellSegments(
RicWellPathExportCompletionDataFeatureImpl::generateCompsegTables(formatter, exportInfo);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RicWellPathExportCompletionDataFeatureImpl::createPressureDepletionFileNameSuffix(
const RicExportCompletionDataSettingsUi& exportSettings)
{
QString suffix;
if (exportSettings.transScalingType() != RicExportFractureCompletionsImpl::NO_SCALING)
{
if (exportSettings.transScalingType() == RicExportFractureCompletionsImpl::MATRIX_TO_WELL_DP_OVER_INITIAL_DP)
{
suffix += QString("_3");
}
else if (exportSettings.transScalingType() == RicExportFractureCompletionsImpl::MATRIX_TO_WELL_DP_OVER_MAX_INITIAL_DP)
{
suffix += QString("_4");
}
suffix += QString("B_");
if (exportSettings.transScalingInitialWBHP() == RicExportFractureCompletionsImpl::FROM_PRODUCTION_START)
{
suffix += QString("_WBHPROD_");
}
else if (exportSettings.transScalingInitialWBHP() == RicExportFractureCompletionsImpl::FROM_PRODUCTION_START_W_MIN)
{
suffix += QString("_WBHPMIN_");
}
else
{
suffix += QString("_WBHPFIX_");
}
RimEclipseCase* eclipseCase = exportSettings.caseToApply();
if (eclipseCase)
{
QString date = eclipseCase->timeStepStrings()[exportSettings.transScalingTimeStep()];
date.replace(QRegExp("[\\.\\s]"), "_");
suffix += QString("%1").arg(date);
}
}
return suffix;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

1
ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeatureImpl.h
View File

@@ -231,7 +231,6 @@ private:
QFilePtr exportFile,
const RimWellPath* wellPath,
const std::vector<const RimPerforationInterval*>& perforationIntervals);
static QString createPressureDepletionFileNameSuffix(const RicExportCompletionDataSettingsUi& exportSettings);
static void exportCarfinForTemporaryLgrs(const RimEclipseCase* sourceCase, const QString& folder);

36
ApplicationCode/Commands/CompletionExportCommands/RicWellPathFractureReportItem.cpp
View File

@@ -43,8 +43,8 @@ RicWellPathFractureReportItem::RicWellPathFractureReportItem(const QString& well
, m_xf(0.0)
, m_h(0.0)
, m_km(0.0)
, m_pressureDepletionInitialWBHP(-1.0)
, m_pressureDepletionCurrentWBHP(-1.0)
, m_pressureDepletionMinPressureDrop(-1.0)
, m_pressureDepletionMaxPressureDrop(-1.0)
{
}
@@ -120,6 +120,14 @@ QString RicWellPathFractureReportItem::pressureDepletionScaling() const
return m_pressureDepletionScalingString;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RicWellPathFractureReportItem::pressureDepletionWBHPString() const
{
return m_pressureDepletionWBHPString;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -131,11 +139,13 @@ void RicWellPathFractureReportItem::setUnitSystem(RiaEclipseUnitTools::UnitSyste
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicWellPathFractureReportItem::setPressureDepletionParameters(QString scalingString, double initialWBHP, double currentWBHP)
void RicWellPathFractureReportItem::setPressureDepletionParameters(QString scalingString, QString wbhpString, double userWBHP, double minPressureDrop, double maxPressureDrop)
{
m_pressureDepletionScalingString = scalingString;
m_pressureDepletionInitialWBHP = initialWBHP;
m_pressureDepletionCurrentWBHP = currentWBHP;
m_pressureDepletionWBHPString = wbhpString;
m_pressureDepletionUserWBHP = userWBHP;
m_pressureDepletionMinPressureDrop = minPressureDrop;
m_pressureDepletionMaxPressureDrop = maxPressureDrop;
}
//--------------------------------------------------------------------------------------------------
@@ -245,17 +255,25 @@ double RicWellPathFractureReportItem::kmxf() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RicWellPathFractureReportItem::pressureDepletionInitialWBHP() const
double RicWellPathFractureReportItem::pressureDepletionUserWBHP() const
{
return m_pressureDepletionInitialWBHP;
return m_pressureDepletionUserWBHP;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RicWellPathFractureReportItem::pressureDepletionCurrentWBHP() const
double RicWellPathFractureReportItem::pressureDepletionMinPressureDrop() const
{
return m_pressureDepletionCurrentWBHP;
return m_pressureDepletionMinPressureDrop;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RicWellPathFractureReportItem::pressureDepletionMaxPressureDrop() const
{
return m_pressureDepletionMaxPressureDrop;
}
//--------------------------------------------------------------------------------------------------

14
ApplicationCode/Commands/CompletionExportCommands/RicWellPathFractureReportItem.h
View File

@@ -35,12 +35,13 @@ public:
void setHeightAndHalfLength(double height, double halfLength);
void setAreaWeightedTransmissibility(double transmissibility);
void setUnitSystem(RiaEclipseUnitTools::UnitSystem unitSystem);
void setPressureDepletionParameters(QString scalingString, double initialWBHP, double currentWBHP);
void setPressureDepletionParameters(QString scalingString, QString wbhpString, double userWBHP, double minPressureDrop, double maxPressureDrop);
QString wellPathNameForExport() const;
QString fractureName() const;
QString fractureTemplateName() const;
QString pressureDepletionScaling() const;
QString pressureDepletionWBHPString() const;
RiaEclipseUnitTools::UnitSystem unitSystem() const;
@@ -58,8 +59,9 @@ public:
double km() const;
double kmxf() const;
double pressureDepletionInitialWBHP() const;
double pressureDepletionCurrentWBHP() const;
double pressureDepletionUserWBHP() const;
double pressureDepletionMinPressureDrop() const;
double pressureDepletionMaxPressureDrop() const;
bool operator < (const RicWellPathFractureReportItem& other) const;
@@ -69,6 +71,7 @@ private:
QString m_wellPathFracture;
QString m_wellPathFractureTemplate;
QString m_pressureDepletionScalingString;
QString m_pressureDepletionWBHPString;
double m_mesuredDepth;
double m_transmissibility;
@@ -82,6 +85,7 @@ private:
double m_h;
double m_km;
double m_pressureDepletionInitialWBHP;
double m_pressureDepletionCurrentWBHP;
double m_pressureDepletionUserWBHP;
double m_pressureDepletionMinPressureDrop;
double m_pressureDepletionMaxPressureDrop;
};

12
ApplicationCode/Commands/CompletionExportCommands/RicWellPathFractureTextReportFeatureImpl.cpp
View File

@@ -710,8 +710,10 @@ QString RicWellPathFractureTextReportFeatureImpl::createFracturePressureDepletio
RifEclipseOutputTableColumn("Well"),
RifEclipseOutputTableColumn("Fracture"),
RifEclipseOutputTableColumn("PDD Scaling"),
RifEclipseOutputTableColumn("Initial WBHP"),
RifEclipseOutputTableColumn("Current WBHP")
RifEclipseOutputTableColumn("WBHP Source"),
RifEclipseOutputTableColumn("User WBHP"),
RifEclipseOutputTableColumn("Min Pressure Drop"),
RifEclipseOutputTableColumn("Max Pressure Drop")
};
formatter.header(header);
@@ -722,8 +724,10 @@ QString RicWellPathFractureTextReportFeatureImpl::createFracturePressureDepletio
formatter.add(reportItem.wellPathNameForExport());
formatter.add(reportItem.fractureName());
formatter.add(reportItem.pressureDepletionScaling());
formatter.add(reportItem.pressureDepletionInitialWBHP());
formatter.add(reportItem.pressureDepletionCurrentWBHP());
formatter.add(reportItem.pressureDepletionWBHPString());
formatter.add(reportItem.pressureDepletionUserWBHP());
formatter.add(reportItem.pressureDepletionMinPressureDrop());
formatter.add(reportItem.pressureDepletionMaxPressureDrop());
formatter.rowCompleted();
}

59
ApplicationCode/ReservoirDataModel/Completions/RigTransmissibilityCondenser.cpp
View File

@@ -123,21 +123,17 @@ double RigTransmissibilityCondenser::condensedTransmissibility(CellAddress exter
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<size_t, double>
RigTransmissibilityCondenser::scaleMatrixToFracTransByMatrixWellDP(const RigActiveCellInfo* actCellInfo,
double initialWellPressure,
double currentWellPressure,
const std::vector<double>& initialMatrixPressures,
const std::vector<double>& currentMatrixPressures,
bool normalizeByMax)
std::map<size_t, double> RigTransmissibilityCondenser::scaleMatrixToFracTransByMatrixWellDP(
const RigActiveCellInfo* actCellInfo, double currentWellPressure, const std::vector<double>& currentMatrixPressures,
double* minPressureDrop, double* maxPressureDrop)
{
CVF_ASSERT(initialMatrixPressures.size() == currentMatrixPressures.size());
std::map<size_t, double> originalLumpedMatrixToFractureTrans; // Sum(T_mf)
double maxInitialDeltaPressure = 0.0;
if (normalizeByMax)
{
double epsilonDeltaPressure = 1.0e-6;
double minNonZeroDeltaPressure = std::numeric_limits<double>::infinity();
double maxNonZeroDeltaPressure = -std::numeric_limits<double>::infinity();
for (auto it = m_neighborTransmissibilities.begin(); it != m_neighborTransmissibilities.end(); ++it)
{
if (it->first.m_cellIndexSpace == CellAddress::STIMPLAN)
@@ -149,14 +145,15 @@ std::map<size_t, double>
size_t globalMatrixCellIdx = jt->first.m_globalCellIdx;
size_t eclipseResultIndex = actCellInfo->cellResultIndex(globalMatrixCellIdx);
CVF_ASSERT(eclipseResultIndex < currentMatrixPressures.size());
double unsignedDeltaPressure = std::abs(currentMatrixPressures[eclipseResultIndex] - currentWellPressure);
double nonZeroDeltaPressure = std::max(epsilonDeltaPressure, unsignedDeltaPressure);
maxNonZeroDeltaPressure = std::max(maxNonZeroDeltaPressure, nonZeroDeltaPressure);
minNonZeroDeltaPressure = std::min(minNonZeroDeltaPressure, nonZeroDeltaPressure);
}
}
}
}
double initialDeltaPressure = initialMatrixPressures[eclipseResultIndex] - initialWellPressure;
maxInitialDeltaPressure = std::max(maxInitialDeltaPressure, initialDeltaPressure);
}
}
}
}
}
for (auto it = m_neighborTransmissibilities.begin(); it != m_neighborTransmissibilities.end(); ++it)
{
if (it->first.m_cellIndexSpace == CellAddress::STIMPLAN)
@@ -171,20 +168,24 @@ std::map<size_t, double>
originalLumpedMatrixToFractureTrans[globalMatrixCellIdx] += jt->second;
double initialDeltaPressure = initialMatrixPressures[eclipseResultIndex] - initialWellPressure;
double currentDeltaPressure = currentMatrixPressures[eclipseResultIndex] - currentWellPressure;
if (normalizeByMax)
double unsignedDeltaPressure = std::abs(currentMatrixPressures[eclipseResultIndex] - currentWellPressure);
double nonZeroDeltaPressure = std::max(epsilonDeltaPressure, unsignedDeltaPressure);
jt->second *= nonZeroDeltaPressure / maxNonZeroDeltaPressure;
}
}
}
}
if (minPressureDrop && minNonZeroDeltaPressure != std::numeric_limits<double>::infinity())
{
jt->second *= currentDeltaPressure / maxInitialDeltaPressure;
*minPressureDrop = minNonZeroDeltaPressure;
}
else
if (maxPressureDrop && maxNonZeroDeltaPressure != std::numeric_limits<double>::infinity())
{
jt->second *= currentDeltaPressure / initialDeltaPressure;
}
}
}
}
*maxPressureDrop = maxNonZeroDeltaPressure;
}
return originalLumpedMatrixToFractureTrans;
}

7
ApplicationCode/ReservoirDataModel/Completions/RigTransmissibilityCondenser.h
View File

@@ -95,12 +95,7 @@ public:
std::string neighborTransDebugOutput(const RigMainGrid* mainGrid, const RigFractureGrid* fractureGrid);
std::string condensedTransDebugOutput(const RigMainGrid* mainGrid, const RigFractureGrid* fractureGrid);
std::map<size_t, double> scaleMatrixToFracTransByMatrixWellDP(const RigActiveCellInfo* actCellInfo,
double initialWellPressure,
double currentWellPressure,
const std::vector<double>& initialMatrixPressures,
const std::vector<double>& currentMatrixPressures,
bool normalizeByMax);
std::map<size_t, double> scaleMatrixToFracTransByMatrixWellDP(const RigActiveCellInfo* actCellInfo, double currentWellPressure, const std::vector<double>& currentMatrixPressures, double* minPressureDrop, double* maxPressureDrop);
std::map<size_t, double> calculateFicticiousFractureToWellTransmissibilities();
std::map<size_t, double>