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;
} }

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

@ -18,7 +18,6 @@
#pragma once #pragma once
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -57,17 +56,17 @@ public:
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,
double scaledMatrixToWellTrans);
static double effectiveInternalFractureToWellTrans(double scaledMatrixToFractureTrans, static double effectiveMatrixToWellTransPDDHC(double sumOriginalMatrixToFractureTrans,
double scaledMatrixToWellTrans); double effectiveInternalFractureToWellTrans);
static double effectiveMatrixToWellTrans(double originalMatrixToFractureTrans,
double effectiveInternalFractureToWellTrans);
private: private:
static double centerToEdgeFractureCellTrans(double conductivity, static double centerToEdgeFractureCellTrans(double conductivity,
@ -77,5 +76,4 @@ private:
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;

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

@ -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;
@ -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;
}; };