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

Fixup after review

Browse Source
This commit is contained in:
Gaute Lindkvist 2018-09-14 16:03:33 +02:00
parent 27bc2d015c
commit c1ec5e088b
5 changed files with 113 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -302,11 +302,11 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
RigTransmissibilityCondenser scaledCondenser = transCondenser; RigTransmissibilityCondenser scaledCondenser = transCondenser;
// 1. Scale matrix to fracture transmissibilities by matrix to fracture pressure // 1. Scale matrix to fracture transmissibilities by matrix to fracture pressure
std::map<size_t, double> originalLumpedMatrixToFractureTrans = std::map<size_t, double> originalLumpedMatrixToFractureTrans =
scaledCondenser.scaleMatrixTransmissibilitiesByPressureMatrixFracture(actCellInfo, scaledCondenser.scaleMatrixToFracTransByMatrixFracDP(actCellInfo,
currentWellPressure, currentWellPressure,
*currentMatrixPressures, *currentMatrixPressures,
pressureDropScaling == pressureDropScaling ==
MATRIX_TO_FRACTURE_DP_OVER_AVG_DP); MATRIX_TO_FRACTURE_DP_OVER_AVG_DP);
// 2: Calculate new external transmissibilities // 2: Calculate new external transmissibilities
scaledCondenser.calculateCondensedTransmissibilities(); scaledCondenser.calculateCondensedTransmissibilities();
@ -333,7 +333,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
// From Høgstøl "Hydraulic Fracturing SoW 2.8 outside contract Fracture Transmissibility Calculations for Differential Depletion": // From Høgstøl "Hydraulic Fracturing SoW 2.8 outside contract Fracture Transmissibility Calculations for Differential Depletion":
// 1. Scale matrix to fracture transmissibilities by matrix to well pressure // 1. Scale matrix to fracture transmissibilities by matrix to well pressure
std::map<size_t, double> originalLumpedMatrixToFractureTrans = std::map<size_t, double> originalLumpedMatrixToFractureTrans =
scaledCondenser.scaleMatrixTransmissibilitiesByPressureMatrixWell( scaledCondenser.scaleMatrixToFracTransByMatrixWellDP(
actCellInfo, originalWellPressure, currentWellPressure, *originalMatrixPressures, *currentMatrixPressures); actCellInfo, originalWellPressure, currentWellPressure, *originalMatrixPressures, *currentMatrixPressures);
// 2: Calculate new external transmissibilities // 2: Calculate new external transmissibilities
scaledCondenser.calculateCondensedTransmissibilities(); scaledCondenser.calculateCondensedTransmissibilities();

32
ApplicationCode/ReservoirDataModel/Completions/RigFractureTransmissibilityEquations.cpp
View File

@ -45,7 +45,7 @@ double RigFractureTransmissibilityEquations::centerToCenterFractureCellTrans(dou
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// T_16 ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RigFractureTransmissibilityEquations::fractureCellToWellRadialTrans(double fractureCellConductivity, double RigFractureTransmissibilityEquations::fractureCellToWellRadialTrans(double fractureCellConductivity,
double fractureCellSizeX, double fractureCellSizeX,
@ -70,7 +70,7 @@ double RigFractureTransmissibilityEquations::fractureCellToWellRadialTrans(doubl
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// T_16 ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RigFractureTransmissibilityEquations::fractureCellToWellLinearTrans(double fractureCellConductivity, double RigFractureTransmissibilityEquations::fractureCellToWellLinearTrans(double fractureCellConductivity,
double fractureCellSizeX, double fractureCellSizeX,
@ -98,7 +98,7 @@ double RigFractureTransmissibilityEquations::fractureCellToWellLinearTrans(doubl
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// T_51 ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RigFractureTransmissibilityEquations::matrixToFractureTrans(double perm, double RigFractureTransmissibilityEquations::matrixToFractureTrans(double perm,
double NTG, double NTG,
@ -123,40 +123,46 @@ double RigFractureTransmissibilityEquations::matrixToFractureTrans(double perm,
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// T'_51 ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RigFractureTransmissibilityEquations::pressureScalingMatrixToFractureTrans(double originalWellPressure, double wellPressure, double originalMatrixPressure, double matrixPressure) double RigFractureTransmissibilityEquations::pressureScalingMatrixToFractureTransPDDHC(double originalWellPressure,
double wellPressure,
double originalMatrixPressure,
double matrixPressure)
{ {
double pressureDelta = originalMatrixPressure - originalWellPressure; double pressureDelta = originalMatrixPressure - originalWellPressure;
if (cvf::Math::abs(pressureDelta) > EPSILON) if (cvf::Math::abs(pressureDelta) > EPSILON)
{ {
return (matrixPressure - wellPressure) / pressureDelta; return (matrixPressure - wellPressure) / pressureDelta;
} }
CVF_ASSERT(false);
return 0.0; return 0.0;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// T'_16 ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RigFractureTransmissibilityEquations::effectiveInternalFractureToWellTrans(double scaledMatrixToFractureTrans, double scaledMatrixToWellTrans) double RigFractureTransmissibilityEquations::effectiveInternalFractureToWellTransPDDHC(double sumScaledMatrixToFractureTrans,
double scaledMatrixToWellTrans)
{ {
double divisor = scaledMatrixToFractureTrans - scaledMatrixToWellTrans; double divisor = sumScaledMatrixToFractureTrans - scaledMatrixToWellTrans;
if (cvf::Math::abs(divisor) > EPSILON) if (cvf::Math::abs(divisor) > EPSILON)
{ {
return (scaledMatrixToFractureTrans * scaledMatrixToWellTrans) / divisor; return (sumScaledMatrixToFractureTrans * scaledMatrixToWellTrans) / divisor;
} }
return 0.0; return 0.0;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
///T^dp_56 ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RigFractureTransmissibilityEquations::effectiveMatrixToWellTrans(double originalMatrixToFractureTrans, double effectiveInternalFractureToWellTrans) double RigFractureTransmissibilityEquations::effectiveMatrixToWellTransPDDHC(double sumOriginalMatrixToFractureTrans,
double effectiveInternalFractureToWellTrans)
{ {
double divisor = originalMatrixToFractureTrans + effectiveInternalFractureToWellTrans; double divisor = sumOriginalMatrixToFractureTrans + effectiveInternalFractureToWellTrans;
if (cvf::Math::abs(divisor) > EPSILON) if (cvf::Math::abs(divisor) > EPSILON)
{ {
return (originalMatrixToFractureTrans * effectiveInternalFractureToWellTrans) / divisor; return (sumOriginalMatrixToFractureTrans * effectiveInternalFractureToWellTrans) / divisor;
} }
return 0.0; return 0.0;
} }

56
ApplicationCode/ReservoirDataModel/Completions/RigFractureTransmissibilityEquations.h
View File

@ -1,26 +1,25 @@
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
// //
// Copyright (C) 2017- Statoil ASA // Copyright (C) 2017- Statoil ASA
// //
// ResInsight is free software: you can redistribute it and/or modify // ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by // it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or // the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version. // (at your option) any later version.
// //
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY // ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or // WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. // FITNESS FOR A PARTICULAR PURPOSE.
// //
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> // See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details. // for more details.
// //
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
#pragma once #pragma once
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
class RigFractureTransmissibilityEquations class RigFractureTransmissibilityEquations
{ {
@ -33,49 +32,48 @@ public:
double sideLengthNormalTransCell2, double sideLengthNormalTransCell2,
double cDarcyForRelevantUnit); double cDarcyForRelevantUnit);
static double fractureCellToWellRadialTrans(double fractureCellConductivity, static double fractureCellToWellRadialTrans(double fractureCellConductivity,
double fractureCellSizeX, double fractureCellSizeX,
double fractureCellSizeZ, double fractureCellSizeZ,
double wellRadius, double wellRadius,
double skinFactor, double skinFactor,
double cDarcyForRelevantUnit); double cDarcyForRelevantUnit);
static double fractureCellToWellLinearTrans(double fractureConductivity, static double fractureCellToWellLinearTrans(double fractureConductivity,
double fractureCellSizeX, double fractureCellSizeX,
double fractureCellSizeZ, double fractureCellSizeZ,
double perforationLengthVertical, double perforationLengthVertical,
double perforationLengthHorizontal, double perforationLengthHorizontal,
double perforationEfficiency, double perforationEfficiency,
double skinfactor, double skinfactor,
double cDarcyForRelevantUnit); double cDarcyForRelevantUnit);
static double matrixToFractureTrans(double permX, static double matrixToFractureTrans(double permX,
double NTG, double NTG,
double Ay, double Ay,
double dx, double dx,
double skinfactor, double skinfactor,
double fractureAreaWeightedlength, double fractureAreaWeightedlength,
double cDarcy); double cDarcy);
static double pressureScalingMatrixToFractureTrans(double originalWellPressure, // Pressure Differential Depletion Høgstøl-correction (PDDHC) methods.
double wellPressure, static double pressureScalingMatrixToFractureTransPDDHC(double originalWellPressure,
double originalMatrixPressure, double wellPressure,
double matrixPressure); double originalMatrixPressure,
double matrixPressure);
static double effectiveInternalFractureToWellTransPDDHC(double sumScaledMatrixToFractureTrans,
static double effectiveInternalFractureToWellTrans(double scaledMatrixToFractureTrans, double scaledMatrixToWellTrans);
double scaledMatrixToWellTrans);
static double effectiveMatrixToWellTrans(double originalMatrixToFractureTrans, static double effectiveMatrixToWellTransPDDHC(double sumOriginalMatrixToFractureTrans,
double effectiveInternalFractureToWellTrans); double effectiveInternalFractureToWellTrans);
private: private:
static double centerToEdgeFractureCellTrans(double conductivity, static double centerToEdgeFractureCellTrans(double conductivity,
double sideLengthParallellTrans, double sideLengthParallellTrans,
double sideLengthNormalTrans, double sideLengthNormalTrans,
double cDarcyForRelevantUnit); double cDarcyForRelevantUnit);
private: private:
static const double EPSILON; static const double EPSILON;
}; };

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

@ -123,7 +123,7 @@ double RigTransmissibilityCondenser::condensedTransmissibility(CellAddress exter
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::map<size_t, double> RigTransmissibilityCondenser::scaleMatrixTransmissibilitiesByPressureMatrixWell( std::map<size_t, double> RigTransmissibilityCondenser::scaleMatrixToFracTransByMatrixWellDP(
const RigActiveCellInfo* actCellInfo, const RigActiveCellInfo* actCellInfo,
double originalWellPressure, double originalWellPressure,
double currentWellPressure, double currentWellPressure,
@ -148,7 +148,7 @@ std::map<size_t, double> RigTransmissibilityCondenser::scaleMatrixTransmissibili
originalLumpedMatrixToFractureTrans[globalMatrixCellIdx] += jt->second; originalLumpedMatrixToFractureTrans[globalMatrixCellIdx] += jt->second;
jt->second *= RigFractureTransmissibilityEquations::pressureScalingMatrixToFractureTrans( jt->second *= RigFractureTransmissibilityEquations::pressureScalingMatrixToFractureTransPDDHC(
originalWellPressure, originalWellPressure,
currentWellPressure, currentWellPressure,
originalMatrixPressures[eclipseResultIndex], originalMatrixPressures[eclipseResultIndex],
@ -164,7 +164,7 @@ std::map<size_t, double> RigTransmissibilityCondenser::scaleMatrixTransmissibili
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::map<size_t, double> RigTransmissibilityCondenser::scaleMatrixTransmissibilitiesByPressureMatrixFracture(const RigActiveCellInfo* actCellInfo, double currentWellPressure, const std::vector<double>& currentMatrixPressures, bool divideByAverageDP) std::map<size_t, double> RigTransmissibilityCondenser::scaleMatrixToFracTransByMatrixFracDP(const RigActiveCellInfo* actCellInfo, double currentWellPressure, const std::vector<double>& currentMatrixPressures, bool divideByAverageDP)
{ {
// Solve for fracture pressures // Solve for fracture pressures
Eigen::VectorXd matrixPressures(m_Tie.cols()); Eigen::VectorXd matrixPressures(m_Tie.cols());
@ -188,14 +188,14 @@ std::map<size_t, double> RigTransmissibilityCondenser::scaleMatrixTransmissibili
Eigen::VectorXd fracturePressures = m_TiiInv * (m_Tie * matrixPressures * -1.0); Eigen::VectorXd fracturePressures = m_TiiInv * (m_Tie * matrixPressures * -1.0);
// Extract fracture pressures into a map // Extract fracture pressures into a map
std::map<size_t, double> fracturePressureMap; std::map<size_t, double> fractureCellToPressureMap;
{ {
size_t rowIndex = 0u; size_t rowIndex = 0u;
for (const ConnectionTransmissibility& connectionTrans : m_neighborTransmissibilities) for (const ConnectionTransmissibility& connectionTrans : m_neighborTransmissibilities)
{ {
if (connectionTrans.first.m_cellIndexSpace == CellAddress::STIMPLAN) if (connectionTrans.first.m_cellIndexSpace == CellAddress::STIMPLAN)
{ {
fracturePressureMap[connectionTrans.first.m_globalCellIdx] = fracturePressures[rowIndex++]; fractureCellToPressureMap[connectionTrans.first.m_globalCellIdx] = fracturePressures[rowIndex++];
} }
} }
} }
@ -208,15 +208,17 @@ std::map<size_t, double> RigTransmissibilityCondenser::scaleMatrixTransmissibili
if (it->first.m_cellIndexSpace == CellAddress::STIMPLAN) if (it->first.m_cellIndexSpace == CellAddress::STIMPLAN)
{ {
size_t globalFractureCellIdx = it->first.m_globalCellIdx; size_t globalFractureCellIdx = it->first.m_globalCellIdx;
double fracturePressure = fracturePressureMap[globalFractureCellIdx]; double fracturePressure = fractureCellToPressureMap[globalFractureCellIdx];
for (auto jt = it->second.begin(); jt != it->second.end(); ++jt) for (auto jt = it->second.begin(); jt != it->second.end(); ++jt)
{ {
if (jt->first.m_cellIndexSpace == CellAddress::ECLIPSE) if (jt->first.m_cellIndexSpace == CellAddress::ECLIPSE)
{ {
size_t globalMatrixCellIdx = jt->first.m_globalCellIdx; size_t globalMatrixCellIdx = jt->first.m_globalCellIdx;
size_t eclipseResultIndex = actCellInfo->cellResultIndex(globalMatrixCellIdx); size_t eclipseResultIndex = actCellInfo->cellResultIndex(globalMatrixCellIdx);
CVF_ASSERT(eclipseResultIndex < currentMatrixPressures.size()); CVF_ASSERT(eclipseResultIndex < currentMatrixPressures.size());
double matrixPressure = currentMatrixPressures[eclipseResultIndex]; double matrixPressure = currentMatrixPressures[eclipseResultIndex];
double pressureDrop = std::abs(matrixPressure - fracturePressure); double pressureDrop = std::abs(matrixPressure - fracturePressure);
meanCalculator.addValueAndWeight(pressureDrop, 1.0); meanCalculator.addValueAndWeight(pressureDrop, 1.0);
@ -241,15 +243,17 @@ std::map<size_t, double> RigTransmissibilityCondenser::scaleMatrixTransmissibili
if (it->first.m_cellIndexSpace == CellAddress::STIMPLAN) if (it->first.m_cellIndexSpace == CellAddress::STIMPLAN)
{ {
size_t globalFractureCellIdx = it->first.m_globalCellIdx; size_t globalFractureCellIdx = it->first.m_globalCellIdx;
double fracturePressure = fracturePressureMap[globalFractureCellIdx]; double fracturePressure = fractureCellToPressureMap[globalFractureCellIdx];
for (auto jt = it->second.begin(); jt != it->second.end(); ++jt) for (auto jt = it->second.begin(); jt != it->second.end(); ++jt)
{ {
if (jt->first.m_cellIndexSpace == CellAddress::ECLIPSE) if (jt->first.m_cellIndexSpace == CellAddress::ECLIPSE)
{ {
size_t globalMatrixCellIdx = jt->first.m_globalCellIdx; size_t globalMatrixCellIdx = jt->first.m_globalCellIdx;
size_t eclipseResultIndex = actCellInfo->cellResultIndex(globalMatrixCellIdx); size_t eclipseResultIndex = actCellInfo->cellResultIndex(globalMatrixCellIdx);
CVF_ASSERT(eclipseResultIndex < currentMatrixPressures.size()); CVF_ASSERT(eclipseResultIndex < currentMatrixPressures.size());
double matrixPressure = currentMatrixPressures[eclipseResultIndex]; double matrixPressure = currentMatrixPressures[eclipseResultIndex];
double pressureDrop = std::abs(matrixPressure - fracturePressure); double pressureDrop = std::abs(matrixPressure - fracturePressure);
@ -301,7 +305,7 @@ std::map<size_t, double> RigTransmissibilityCondenser::calculateFicticiousFractu
double scaledMatrixToWellTrans = condensedTransmissibility(externalCell, { true, RigTransmissibilityCondenser::CellAddress::WELL, 1 }); double scaledMatrixToWellTrans = condensedTransmissibility(externalCell, { true, RigTransmissibilityCondenser::CellAddress::WELL, 1 });
// T'_fjw // T'_fjw
fictitiousFractureToWellTrans[globalMatrixCellIdx] = fictitiousFractureToWellTrans[globalMatrixCellIdx] =
RigFractureTransmissibilityEquations::effectiveInternalFractureToWellTrans(scaledMatrixToFractureTrans, scaledMatrixToWellTrans); RigFractureTransmissibilityEquations::effectiveInternalFractureToWellTransPDDHC(scaledMatrixToFractureTrans, scaledMatrixToWellTrans);
} }
} }
return fictitiousFractureToWellTrans; return fictitiousFractureToWellTrans;
@ -331,7 +335,7 @@ std::map<size_t, double> RigTransmissibilityCondenser::calculateEffectiveMatrixT
double fictitiousFractureToWellTrans = fictitiousFractureToWellIt->second; double fictitiousFractureToWellTrans = fictitiousFractureToWellIt->second;
// T^dp_mw // T^dp_mw
effectiveMatrixToWellTrans[globalMatrixCellIdx] = effectiveMatrixToWellTrans[globalMatrixCellIdx] =
RigFractureTransmissibilityEquations::effectiveMatrixToWellTrans(lumpedOriginalMatrixToFractureT, fictitiousFractureToWellTrans); RigFractureTransmissibilityEquations::effectiveMatrixToWellTransPDDHC(lumpedOriginalMatrixToFractureT, fictitiousFractureToWellTrans);
} }
} }
return effectiveMatrixToWellTrans; return effectiveMatrixToWellTrans;

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

@ -1,17 +1,17 @@
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
// //
// Copyright (C) 2017 - Statoil ASA // Copyright (C) 2017 - Statoil ASA
// //
// ResInsight is free software: you can redistribute it and/or modify // ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by // it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or // the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version. // (at your option) any later version.
// //
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY // ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or // WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. // FITNESS FOR A PARTICULAR PURPOSE.
// //
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> // See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details. // for more details.
// //
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
@ -23,8 +23,8 @@
#include <Eigen/Core> #include <Eigen/Core>
#include <map> #include <map>
#include <vector>
#include <set> #include <set>
#include <vector>
class RigActiveCellInfo; class RigActiveCellInfo;
class RigMainGrid; class RigMainGrid;
@ -32,7 +32,7 @@ class RimStimPlanFractureTemplate;
class RigFractureGrid; class RigFractureGrid;
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
class RigTransmissibilityCondenser class RigTransmissibilityCondenser
{ {
@ -43,38 +43,45 @@ public:
class CellAddress class CellAddress
{ {
public: public:
enum CellIndexSpace { ECLIPSE, STIMPLAN, WELL}; enum CellIndexSpace
{
ECLIPSE,
STIMPLAN,
WELL
};
CellAddress(): m_isExternal(false), CellAddress()
m_cellIndexSpace(STIMPLAN), : m_isExternal(false)
m_globalCellIdx(-1) , m_cellIndexSpace(STIMPLAN)
{} , m_globalCellIdx(-1)
CellAddress(bool isExternal, {
CellIndexSpace cellType, }
size_t globalCellIdx) CellAddress(bool isExternal, CellIndexSpace cellType, size_t globalCellIdx)
: m_isExternal(isExternal), : m_isExternal(isExternal)
m_cellIndexSpace(cellType), , m_cellIndexSpace(cellType)
m_globalCellIdx(globalCellIdx) , m_globalCellIdx(globalCellIdx)
{} {
}
bool m_isExternal; bool m_isExternal;
CellIndexSpace m_cellIndexSpace; CellIndexSpace m_cellIndexSpace;
size_t m_globalCellIdx; size_t m_globalCellIdx;
bool operator==(const CellAddress& o) bool operator==(const CellAddress& o)
{ {
return (m_isExternal == o.m_isExternal) && (m_cellIndexSpace == o.m_cellIndexSpace) && (m_globalCellIdx == o.m_globalCellIdx); return (m_isExternal == o.m_isExternal) && (m_cellIndexSpace == o.m_cellIndexSpace) &&
(m_globalCellIdx == o.m_globalCellIdx);
} }
// Ordering external after internal is important for the matrix order internally // Ordering external after internal is important for the matrix order internally
bool operator<(const CellAddress& other) const bool operator<(const CellAddress& other) const
{ {
if (m_isExternal != other.m_isExternal) return !m_isExternal; // Internal cells < External cells if (m_isExternal != other.m_isExternal) return !m_isExternal; // Internal cells < External cells
if (m_cellIndexSpace != other.m_cellIndexSpace)return m_cellIndexSpace < other.m_cellIndexSpace; // Eclipse < StimPlan if (m_cellIndexSpace != other.m_cellIndexSpace)
if (m_globalCellIdx != other.m_globalCellIdx) return m_globalCellIdx < other.m_globalCellIdx; return m_cellIndexSpace < other.m_cellIndexSpace; // Eclipse < StimPlan
if (m_globalCellIdx != other.m_globalCellIdx) return m_globalCellIdx < other.m_globalCellIdx;
return false; return false;
} }
}; };
@ -83,29 +90,36 @@ public:
std::set<CellAddress> externalCells(); std::set<CellAddress> externalCells();
double condensedTransmissibility( CellAddress externalCell1, CellAddress externalCell2); double condensedTransmissibility(CellAddress externalCell1, CellAddress externalCell2);
std::string neighborTransDebugOutput(const RigMainGrid* mainGrid, const RigFractureGrid* fractureGrid); std::string neighborTransDebugOutput(const RigMainGrid* mainGrid, const RigFractureGrid* fractureGrid);
std::string condensedTransDebugOutput(const RigMainGrid* mainGrid, const RigFractureGrid* fractureGrid); std::string condensedTransDebugOutput(const RigMainGrid* mainGrid, const RigFractureGrid* fractureGrid);
std::map<size_t, double> scaleMatrixTransmissibilitiesByPressureMatrixWell(const RigActiveCellInfo* actCellInfo, double originalWellPressure, double currentWellPressure, const std::vector<double>& originalMatrixPressures, const std::vector<double>& currentMatrixPressures); std::map<size_t, double> scaleMatrixToFracTransByMatrixWellDP(const RigActiveCellInfo* actCellInfo,
std::map<size_t, double> scaleMatrixTransmissibilitiesByPressureMatrixFracture(const RigActiveCellInfo* actCellInfo, double currentWellPressure, const std::vector<double>& currentMatrixPressures, bool divideByAverageDP); double originalWellPressure,
double currentWellPressure,
const std::vector<double>& originalMatrixPressures,
const std::vector<double>& currentMatrixPressures);
std::map<size_t, double> scaleMatrixToFracTransByMatrixFracDP(const RigActiveCellInfo* actCellInfo,
double currentWellPressure,
const std::vector<double>& currentMatrixPressures,
bool divideByAverageDP);
std::map<size_t, double> calculateFicticiousFractureToWellTransmissibilities(); std::map<size_t, double> calculateFicticiousFractureToWellTransmissibilities();
std::map<size_t, double> calculateEffectiveMatrixToWellTransmissibilities(const std::map<size_t, double>& originalLumpedMatrixToFractureTrans, std::map<size_t, double>
const std::map<size_t, double>& ficticuousFractureToWellTransMap); calculateEffectiveMatrixToWellTransmissibilities(const std::map<size_t, double>& originalLumpedMatrixToFractureTrans,
const std::map<size_t, double>& ficticuousFractureToWellTransMap);
void calculateCondensedTransmissibilities(); void calculateCondensedTransmissibilities();
protected: protected:
typedef std::pair<CellAddress, std::map<CellAddress, double>> ConnectionTransmissibility; typedef std::pair<CellAddress, std::map<CellAddress, double>> ConnectionTransmissibility;
typedef std::map<CellAddress, std::map<CellAddress, double>> ConnectionTransmissibilities; typedef std::map<CellAddress, std::map<CellAddress, double>> ConnectionTransmissibilities;
ConnectionTransmissibilities m_neighborTransmissibilities; ConnectionTransmissibilities m_neighborTransmissibilities;
ConnectionTransmissibilities m_condensedTransmissibilities; ConnectionTransmissibilities m_condensedTransmissibilities;
std::set<CellAddress> m_externalCellAddrSet; std::set<CellAddress> m_externalCellAddrSet;
Eigen::MatrixXd m_TiiInv; Eigen::MatrixXd m_TiiInv;
Eigen::MatrixXd m_Tie; Eigen::MatrixXd m_Tie;
}; };