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

#3958 Refactoring: Removed result index from NNC data

Browse Source
This commit is contained in:
Jacob Støren 2019-01-23 16:08:25 +01:00
parent 09011862cd
commit d8eded7d49
10 changed files with 75 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ApplicationCode/ModelVisualization/RivFaultPartMgr.cpp
View File

@ -691,9 +691,9 @@ void RivFaultPartMgr::updateNNCColors(size_t timeStepIndex, RimEclipseCellColors
if (cellResultColors) if (cellResultColors)
{ {
RigEclipseResultAddress scalarSetIndex = cellResultColors->eclipseResultAddress(); RigEclipseResultAddress eclResAddr = cellResultColors->eclipseResultAddress();
if (m_grid->mainGrid()->nncData()->hasScalarValues(scalarSetIndex.scalarResultIndex)) if (m_grid->mainGrid()->nncData()->hasScalarValues(eclResAddr))
{ {
showNncsWithScalarMappedColor = true; showNncsWithScalarMappedColor = true;
} }
@ -702,8 +702,8 @@ void RivFaultPartMgr::updateNNCColors(size_t timeStepIndex, RimEclipseCellColors
if (showNncsWithScalarMappedColor) if (showNncsWithScalarMappedColor)
{ {
RigEclipseResultAddress scalarSetIndex = cellResultColors->eclipseResultAddress(); RigEclipseResultAddress eclResAddr = cellResultColors->eclipseResultAddress();
RiaDefines::ResultCatType resultType = cellResultColors->resultType(); RiaDefines::ResultCatType resultType = cellResultColors->resultType();
const cvf::ScalarMapper* mapper = cellResultColors->legendConfig()->scalarMapper(); const cvf::ScalarMapper* mapper = cellResultColors->legendConfig()->scalarMapper();
@ -714,7 +714,7 @@ void RivFaultPartMgr::updateNNCColors(size_t timeStepIndex, RimEclipseCellColors
{ {
size_t nativeTimeStepIndex = eclipseCase->uiToNativeTimeStepIndex(timeStepIndex); size_t nativeTimeStepIndex = eclipseCase->uiToNativeTimeStepIndex(timeStepIndex);
m_NNCGenerator->textureCoordinates( m_NNCGenerator->textureCoordinates(
m_NNCTextureCoords.p(), mapper, resultType, scalarSetIndex.scalarResultIndex, nativeTimeStepIndex); m_NNCTextureCoords.p(), mapper, resultType, eclResAddr, nativeTimeStepIndex);
} }
} }

8
ApplicationCode/ModelVisualization/RivNNCGeometryGenerator.cpp
View File

@ -148,7 +148,7 @@ void RivNNCGeometryGenerator::computeArrays()
void RivNNCGeometryGenerator::textureCoordinates(cvf::Vec2fArray* textureCoords, void RivNNCGeometryGenerator::textureCoordinates(cvf::Vec2fArray* textureCoords,
const cvf::ScalarMapper* mapper, const cvf::ScalarMapper* mapper,
RiaDefines::ResultCatType resultType, RiaDefines::ResultCatType resultType,
size_t scalarResultIndex, const RigEclipseResultAddress& resVarAddr,
size_t nativeTimeStepIndex) const size_t nativeTimeStepIndex) const
{ {
size_t numVertices = m_vertices->size(); size_t numVertices = m_vertices->size();
@ -158,15 +158,15 @@ void RivNNCGeometryGenerator::textureCoordinates(cvf::Vec2fArray* textureCoords,
const std::vector<double>* nncResultVals = nullptr; const std::vector<double>* nncResultVals = nullptr;
if (resultType == RiaDefines::STATIC_NATIVE) if (resultType == RiaDefines::STATIC_NATIVE)
{ {
nncResultVals = m_nncData->staticConnectionScalarResult(scalarResultIndex); nncResultVals = m_nncData->staticConnectionScalarResult(resVarAddr);
} }
else if (resultType == RiaDefines::DYNAMIC_NATIVE) else if (resultType == RiaDefines::DYNAMIC_NATIVE)
{ {
nncResultVals = m_nncData->dynamicConnectionScalarResult(scalarResultIndex, nativeTimeStepIndex); nncResultVals = m_nncData->dynamicConnectionScalarResult(resVarAddr, nativeTimeStepIndex);
} }
else if (resultType == RiaDefines::GENERATED) else if (resultType == RiaDefines::GENERATED)
{ {
nncResultVals = m_nncData->generatedConnectionScalarResult(scalarResultIndex, nativeTimeStepIndex); nncResultVals = m_nncData->generatedConnectionScalarResult(resVarAddr, nativeTimeStepIndex);
} }
if (!nncResultVals || nncResultVals->size() == 0) if (!nncResultVals || nncResultVals->size() == 0)

3
ApplicationCode/ModelVisualization/RivNNCGeometryGenerator.h
View File

@ -33,6 +33,7 @@ namespace cvf
class RigNNCData; class RigNNCData;
class RigGridBase; class RigGridBase;
class RigEclipseResultAddress;
//================================================================================================== //==================================================================================================
/// ///
@ -50,7 +51,7 @@ public:
void textureCoordinates(cvf::Vec2fArray* textureCoords, void textureCoordinates(cvf::Vec2fArray* textureCoords,
const cvf::ScalarMapper* mapper, const cvf::ScalarMapper* mapper,
RiaDefines::ResultCatType resultType, RiaDefines::ResultCatType resultType,
size_t scalarResultIndex, const RigEclipseResultAddress& resVarAddr,
size_t nativeTimeStepIndex) const; size_t nativeTimeStepIndex) const;
// Mapping between cells and geometry // Mapping between cells and geometry

8
ApplicationCode/ModelVisualization/RivReservoirFaultsPartMgr.cpp
View File

@ -159,18 +159,18 @@ void RivReservoirFaultsPartMgr::appendPartsToModel(cvf::ModelBasicList* model)
bool showNncs = true; bool showNncs = true;
if (faultCollection->hideNncsWhenNoResultIsAvailable()) if (faultCollection->hideNncsWhenNoResultIsAvailable())
{ {
RigEclipseResultAddress scalarResultIndex; RigEclipseResultAddress eclipseResultAddress;
if (faultResultColors->showCustomFaultResult()) if (faultResultColors->showCustomFaultResult())
{ {
scalarResultIndex = faultResultColors->customFaultResult()->eclipseResultAddress(); eclipseResultAddress = faultResultColors->customFaultResult()->eclipseResultAddress();
} }
else else
{ {
scalarResultIndex = cellResultColors->eclipseResultAddress(); eclipseResultAddress = cellResultColors->eclipseResultAddress();
} }
RigMainGrid* mainGrid = m_reservoirView->mainGrid(); RigMainGrid* mainGrid = m_reservoirView->mainGrid();
if (!(mainGrid && mainGrid->nncData()->hasScalarValues(scalarResultIndex.scalarResultIndex))) if (!(mainGrid && mainGrid->nncData()->hasScalarValues(eclipseResultAddress)))
{ {
showNncs = false; showNncs = false;
} }

8
ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
View File

@ -794,28 +794,28 @@ bool RimEclipseCase::openReserviorCase()
if (combinedTransResIdx != cvf::UNDEFINED_SIZE_T) if (combinedTransResIdx != cvf::UNDEFINED_SIZE_T)
{ {
eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::propertyNameCombTrans(), eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::propertyNameCombTrans(),
combinedTransResIdx); RigEclipseResultAddress(combinedTransResIdx));
} }
size_t combinedWatFluxResIdx = size_t combinedWatFluxResIdx =
results->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedWaterFluxResultName()); results->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedWaterFluxResultName());
if (combinedWatFluxResIdx != cvf::UNDEFINED_SIZE_T) if (combinedWatFluxResIdx != cvf::UNDEFINED_SIZE_T)
{ {
eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::propertyNameFluxWat(), eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::propertyNameFluxWat(),
combinedWatFluxResIdx); RigEclipseResultAddress(combinedWatFluxResIdx));
} }
size_t combinedOilFluxResIdx = size_t combinedOilFluxResIdx =
results->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedOilFluxResultName()); results->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedOilFluxResultName());
if (combinedOilFluxResIdx != cvf::UNDEFINED_SIZE_T) if (combinedOilFluxResIdx != cvf::UNDEFINED_SIZE_T)
{ {
eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::propertyNameFluxOil(), eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::propertyNameFluxOil(),
combinedOilFluxResIdx); RigEclipseResultAddress(combinedOilFluxResIdx));
} }
size_t combinedGasFluxResIdx = size_t combinedGasFluxResIdx =
results->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedGasFluxResultName()); results->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedGasFluxResultName());
if (combinedGasFluxResIdx != cvf::UNDEFINED_SIZE_T) if (combinedGasFluxResIdx != cvf::UNDEFINED_SIZE_T)
{ {
eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::propertyNameFluxGas(), eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::propertyNameFluxGas(),
combinedGasFluxResIdx); RigEclipseResultAddress(combinedGasFluxResIdx));
} }
} }
} }

42
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@ -2024,9 +2024,9 @@ void RigCaseCellResultsData::computeRiTransComponent(const QString& riTransCompo
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigCaseCellResultsData::computeNncCombRiTrans() void RigCaseCellResultsData::computeNncCombRiTrans()
{ {
size_t riCombTransScalarResultIndex = RigEclipseResultAddress riCombTransEclResAddr = RigEclipseResultAddress(
this->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiTranResultName()); this->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiTranResultName()));
if (m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombTransScalarResultIndex)) return; if (m_ownerMainGrid->nncData()->staticConnectionScalarResult( riCombTransEclResAddr )) return;
double cdarchy = darchysValue(); double cdarchy = darchysValue();
@ -2047,7 +2047,7 @@ void RigCaseCellResultsData::computeNncCombRiTrans()
std::vector<double>& permZResults = m_cellScalarResults[permZResultIdx][0]; std::vector<double>& permZResults = m_cellScalarResults[permZResultIdx][0];
std::vector<double>& riCombTransResults = std::vector<double>& riCombTransResults =
m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombTrans()); m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombTrans());
m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::propertyNameRiCombTrans(), riCombTransScalarResultIndex); m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::propertyNameRiCombTrans(), riCombTransEclResAddr);
std::vector<double>* ntgResults = nullptr; std::vector<double>* ntgResults = nullptr;
if (hasNTGResults) if (hasNTGResults)
@ -2277,22 +2277,22 @@ void RigCaseCellResultsData::computeRiMULTComponent(const QString& riMultCompNam
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigCaseCellResultsData::computeNncCombRiMULT() void RigCaseCellResultsData::computeNncCombRiMULT()
{ {
size_t riCombMultScalarResultIndex = auto riCombMultEclResAddr =
this->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiMultResultName()); RigEclipseResultAddress(this->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiMultResultName()));
size_t riCombTransScalarResultIndex = auto riCombTransEclResAddr =
this->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiTranResultName()); RigEclipseResultAddress(this->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiTranResultName()));
size_t combTransScalarResultIndex = auto combTransEclResAddr =
this->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedTransmissibilityResultName()); RigEclipseResultAddress(this->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedTransmissibilityResultName()));
if (m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombMultScalarResultIndex)) return; if (m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombMultEclResAddr)) return;
std::vector<double>& riMultResults = std::vector<double>& riMultResults =
m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombMult()); m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombMult());
const std::vector<double>* riTransResults = const std::vector<double>* riTransResults =
m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombTransScalarResultIndex); m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombTransEclResAddr);
const std::vector<double>* transResults = const std::vector<double>* transResults =
m_ownerMainGrid->nncData()->staticConnectionScalarResult(combTransScalarResultIndex); m_ownerMainGrid->nncData()->staticConnectionScalarResult(combTransEclResAddr);
m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::propertyNameRiCombMult(), riCombMultScalarResultIndex); m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::propertyNameRiCombMult(), riCombMultEclResAddr);
for (size_t nncConIdx = 0; nncConIdx < riMultResults.size(); ++nncConIdx) for (size_t nncConIdx = 0; nncConIdx < riMultResults.size(); ++nncConIdx)
{ {
@ -2413,18 +2413,18 @@ void RigCaseCellResultsData::computeRiTRANSbyAreaComponent(const QString& riTran
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigCaseCellResultsData::computeNncCombRiTRANSbyArea() void RigCaseCellResultsData::computeNncCombRiTRANSbyArea()
{ {
size_t riCombTransByAreaScResIdx = auto riCombTransByAreaEclResAddr =
this->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiAreaNormTranResultName()); RigEclipseResultAddress(this->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiAreaNormTranResultName()));
size_t combTransScalarResultIndex = auto combTransEclResAddr =
this->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedTransmissibilityResultName()); RigEclipseResultAddress(this->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedTransmissibilityResultName()));
if (m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombTransByAreaScResIdx)) return; if (m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombTransByAreaEclResAddr)) return;
std::vector<double>& riAreaNormTransResults = std::vector<double>& riAreaNormTransResults =
m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombTransByArea()); m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombTransByArea());
m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::propertyNameRiCombTransByArea(), riCombTransByAreaScResIdx); m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::propertyNameRiCombTransByArea(), riCombTransByAreaEclResAddr);
const std::vector<double>* transResults = const std::vector<double>* transResults =
m_ownerMainGrid->nncData()->staticConnectionScalarResult(combTransScalarResultIndex); m_ownerMainGrid->nncData()->staticConnectionScalarResult(combTransEclResAddr);
const std::vector<RigConnection>& connections = m_ownerMainGrid->nncData()->connections(); const std::vector<RigConnection>& connections = m_ownerMainGrid->nncData()->connections();

41
ApplicationCode/ReservoirDataModel/RigNNCData.cpp
View File

@ -20,6 +20,7 @@
#include "RigNNCData.h" #include "RigNNCData.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "cvfGeometryTools.h" #include "cvfGeometryTools.h"
#include "RigEclipseResultAddress.h"
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -200,9 +201,9 @@ std::vector<double>& RigNNCData::makeStaticConnectionScalarResult(QString nncDat
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const std::vector<double>* RigNNCData::staticConnectionScalarResult(size_t scalarResultIndex) const const std::vector<double>* RigNNCData::staticConnectionScalarResult(const RigEclipseResultAddress& resVarAddr) const
{ {
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); QString nncDataType = getNNCDataTypeFromScalarResultIndex(resVarAddr);
if (nncDataType.isNull()) return nullptr; if (nncDataType.isNull()) return nullptr;
std::map<QString, std::vector< std::vector<double> > >::const_iterator it = m_connectionResults.find(nncDataType); std::map<QString, std::vector< std::vector<double> > >::const_iterator it = m_connectionResults.find(nncDataType);
@ -250,9 +251,9 @@ std::vector< std::vector<double> >& RigNNCData::makeDynamicConnectionScalarResul
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const std::vector< std::vector<double> >* RigNNCData::dynamicConnectionScalarResult(size_t scalarResultIndex) const const std::vector< std::vector<double> >* RigNNCData::dynamicConnectionScalarResult(const RigEclipseResultAddress& resVarAddr) const
{ {
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); QString nncDataType = getNNCDataTypeFromScalarResultIndex(resVarAddr);
if (nncDataType.isNull()) return nullptr; if (nncDataType.isNull()) return nullptr;
auto it = m_connectionResults.find(nncDataType); auto it = m_connectionResults.find(nncDataType);
@ -270,9 +271,9 @@ const std::vector< std::vector<double> >* RigNNCData::dynamicConnectionScalarRes
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const std::vector<double>* RigNNCData::dynamicConnectionScalarResult(size_t scalarResultIndex, size_t timeStep) const const std::vector<double>* RigNNCData::dynamicConnectionScalarResult(const RigEclipseResultAddress& resVarAddr, size_t timeStep) const
{ {
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); QString nncDataType = getNNCDataTypeFromScalarResultIndex(resVarAddr);
if (nncDataType.isNull()) return nullptr; if (nncDataType.isNull()) return nullptr;
auto it = m_connectionResults.find(nncDataType); auto it = m_connectionResults.find(nncDataType);
@ -329,9 +330,9 @@ std::vector< std::vector<double> >& RigNNCData::makeGeneratedConnectionScalarRes
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const std::vector< std::vector<double> >* RigNNCData::generatedConnectionScalarResult(size_t scalarResultIndex) const const std::vector< std::vector<double> >* RigNNCData::generatedConnectionScalarResult(const RigEclipseResultAddress& resVarAddr) const
{ {
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); QString nncDataType = getNNCDataTypeFromScalarResultIndex(resVarAddr);
if (nncDataType.isNull()) return nullptr; if (nncDataType.isNull()) return nullptr;
auto it = m_connectionResults.find(nncDataType); auto it = m_connectionResults.find(nncDataType);
@ -349,9 +350,9 @@ const std::vector< std::vector<double> >* RigNNCData::generatedConnectionScalarR
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const std::vector<double>* RigNNCData::generatedConnectionScalarResult(size_t scalarResultIndex, size_t timeStep) const const std::vector<double>* RigNNCData::generatedConnectionScalarResult(const RigEclipseResultAddress& resVarAddr, size_t timeStep) const
{ {
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); QString nncDataType = getNNCDataTypeFromScalarResultIndex(resVarAddr);
if (nncDataType.isNull()) return nullptr; if (nncDataType.isNull()) return nullptr;
auto it = m_connectionResults.find(nncDataType); auto it = m_connectionResults.find(nncDataType);
@ -369,9 +370,9 @@ const std::vector<double>* RigNNCData::generatedConnectionScalarResult(size_t sc
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector< std::vector<double> >* RigNNCData::generatedConnectionScalarResult(size_t scalarResultIndex) std::vector< std::vector<double> >* RigNNCData::generatedConnectionScalarResult(const RigEclipseResultAddress& resVarAddr)
{ {
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); QString nncDataType = getNNCDataTypeFromScalarResultIndex(resVarAddr);
if (nncDataType.isNull()) return nullptr; if (nncDataType.isNull()) return nullptr;
auto it = m_connectionResults.find(nncDataType); auto it = m_connectionResults.find(nncDataType);
@ -389,9 +390,9 @@ std::vector< std::vector<double> >* RigNNCData::generatedConnectionScalarResult(
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<double>* RigNNCData::generatedConnectionScalarResult(size_t scalarResultIndex, size_t timeStep) std::vector<double>* RigNNCData::generatedConnectionScalarResult(const RigEclipseResultAddress& resVarAddr, size_t timeStep)
{ {
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); QString nncDataType = getNNCDataTypeFromScalarResultIndex(resVarAddr);
if (nncDataType.isNull()) return nullptr; if (nncDataType.isNull()) return nullptr;
auto it = m_connectionResults.find(nncDataType); auto it = m_connectionResults.find(nncDataType);
@ -493,17 +494,17 @@ std::vector<QString> RigNNCData::availableProperties(NNCResultType resultType) c
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigNNCData::setScalarResultIndex(const QString& nncDataType, size_t scalarResultIndex) void RigNNCData::setScalarResultIndex(const QString& nncDataType, const RigEclipseResultAddress& resVarAddr)
{ {
m_resultIndexToNNCDataType[scalarResultIndex] = nncDataType; m_resultIndexToNNCDataType[resVarAddr.scalarResultIndex] = nncDataType;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RigNNCData::hasScalarValues(size_t scalarResultIndex) bool RigNNCData::hasScalarValues(const RigEclipseResultAddress& resVarAddr)
{ {
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); QString nncDataType = getNNCDataTypeFromScalarResultIndex(resVarAddr);
if (nncDataType.isNull()) return false; if (nncDataType.isNull()) return false;
auto it = m_connectionResults.find(nncDataType); auto it = m_connectionResults.find(nncDataType);
@ -513,9 +514,9 @@ bool RigNNCData::hasScalarValues(size_t scalarResultIndex)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const QString RigNNCData::getNNCDataTypeFromScalarResultIndex(size_t scalarResultIndex) const const QString RigNNCData::getNNCDataTypeFromScalarResultIndex(const RigEclipseResultAddress& resVarAddr) const
{ {
auto it = m_resultIndexToNNCDataType.find(scalarResultIndex); auto it = m_resultIndexToNNCDataType.find(resVarAddr.scalarResultIndex);
if (it != m_resultIndexToNNCDataType.end()) if (it != m_resultIndexToNNCDataType.end())
{ {
return it->second; return it->second;

22
ApplicationCode/ReservoirDataModel/RigNNCData.h
View File

@ -31,7 +31,7 @@
class RigMainGrid; class RigMainGrid;
class RigCell; class RigCell;
class RigEclipseResultAddress;
class RigConnection class RigConnection
{ {
@ -88,20 +88,20 @@ public:
const std::vector<RigConnection>& connections() const { return m_connections; } const std::vector<RigConnection>& connections() const { return m_connections; }
std::vector<double>& makeStaticConnectionScalarResult(QString nncDataType); std::vector<double>& makeStaticConnectionScalarResult(QString nncDataType);
const std::vector<double>* staticConnectionScalarResult(size_t scalarResultIndex) const; const std::vector<double>* staticConnectionScalarResult(const RigEclipseResultAddress& resVarAddr) const;
const std::vector<double>* staticConnectionScalarResultByName(const QString& nncDataType) const; const std::vector<double>* staticConnectionScalarResultByName(const QString& nncDataType) const;
std::vector< std::vector<double> >& makeDynamicConnectionScalarResult(QString nncDataType, size_t timeStepCount); std::vector< std::vector<double> >& makeDynamicConnectionScalarResult(QString nncDataType, size_t timeStepCount);
const std::vector< std::vector<double> >* dynamicConnectionScalarResult(size_t scalarResultIndex) const; const std::vector< std::vector<double> >* dynamicConnectionScalarResult(const RigEclipseResultAddress& resVarAddr) const;
const std::vector<double>* dynamicConnectionScalarResult(size_t scalarResultIndex, size_t timeStep) const; const std::vector<double>* dynamicConnectionScalarResult(const RigEclipseResultAddress& resVarAddr, size_t timeStep) const;
const std::vector< std::vector<double> >* dynamicConnectionScalarResultByName(const QString& nncDataType) const; const std::vector< std::vector<double> >* dynamicConnectionScalarResultByName(const QString& nncDataType) const;
const std::vector<double>* dynamicConnectionScalarResultByName(const QString& nncDataType, size_t timeStep) const; const std::vector<double>* dynamicConnectionScalarResultByName(const QString& nncDataType, size_t timeStep) const;
std::vector< std::vector<double> >& makeGeneratedConnectionScalarResult(QString nncDataType, size_t timeStepCount); std::vector< std::vector<double> >& makeGeneratedConnectionScalarResult(QString nncDataType, size_t timeStepCount);
const std::vector< std::vector<double> >* generatedConnectionScalarResult(size_t scalarResultIndex) const; const std::vector< std::vector<double> >* generatedConnectionScalarResult(const RigEclipseResultAddress& resVarAddr) const;
const std::vector<double>* generatedConnectionScalarResult(size_t scalarResultIndex, size_t timeStep) const; const std::vector<double>* generatedConnectionScalarResult(const RigEclipseResultAddress& resVarAddr, size_t timeStep) const;
std::vector< std::vector<double> >* generatedConnectionScalarResult(size_t scalarResultIndex); std::vector< std::vector<double> >* generatedConnectionScalarResult(const RigEclipseResultAddress& resVarAddr);
std::vector<double>* generatedConnectionScalarResult(size_t scalarResultIndex, size_t timeStep); std::vector<double>* generatedConnectionScalarResult(const RigEclipseResultAddress& resVarAddr, size_t timeStep);
const std::vector< std::vector<double> >* generatedConnectionScalarResultByName(const QString& nncDataType) const; const std::vector< std::vector<double> >* generatedConnectionScalarResultByName(const QString& nncDataType) const;
const std::vector<double>* generatedConnectionScalarResultByName(const QString& nncDataType, size_t timeStep) const; const std::vector<double>* generatedConnectionScalarResultByName(const QString& nncDataType, size_t timeStep) const;
std::vector< std::vector<double> >* generatedConnectionScalarResultByName(const QString& nncDataType); std::vector< std::vector<double> >* generatedConnectionScalarResultByName(const QString& nncDataType);
@ -109,12 +109,12 @@ public:
std::vector<QString> availableProperties(NNCResultType resultType) const; std::vector<QString> availableProperties(NNCResultType resultType) const;
void setScalarResultIndex(const QString& nncDataType, size_t scalarResultIndex); void setScalarResultIndex(const QString& nncDataType, const RigEclipseResultAddress& resVarAddr);
bool hasScalarValues(size_t scalarResultIndex); bool hasScalarValues(const RigEclipseResultAddress& resVarAddr);
private: private:
const QString getNNCDataTypeFromScalarResultIndex(size_t scalarResultIndex) const; const QString getNNCDataTypeFromScalarResultIndex(const RigEclipseResultAddress& resVarAddr) const;
bool isNative(QString nncDataType) const; bool isNative(QString nncDataType) const;
private: private:

2
ApplicationCode/SocketInterface/RiaNNCCommands.cpp
View File

@ -351,7 +351,7 @@ public:
return true; return true;
} }
size_t scalarResultIndex = rimCase->results(m_porosityModelEnum)->findOrLoadKnownScalarResult(QString("%1IJK").arg(propertyName)); size_t scalarResultIndex = rimCase->results(m_porosityModelEnum)->findOrLoadKnownScalarResult(QString("%1IJK").arg(propertyName));
nncData->setScalarResultIndex(propertyName, scalarResultIndex); nncData->setScalarResultIndex(propertyName, RigEclipseResultAddress(scalarResultIndex));
} }
// Create a list of all the requested time steps // Create a list of all the requested time steps

4
ApplicationCode/UserInterface/RiuResultTextBuilder.cpp
View File

@ -429,14 +429,14 @@ QString RiuResultTextBuilder::nncResultText()
const std::vector<double>* nncValues = nullptr; const std::vector<double>* nncValues = nullptr;
if (resultType == RiaDefines::STATIC_NATIVE) if (resultType == RiaDefines::STATIC_NATIVE)
{ {
nncValues = nncData->staticConnectionScalarResult(eclipseResultAddress.scalarResultIndex); nncValues = nncData->staticConnectionScalarResult(eclipseResultAddress);
} }
else if (resultType == RiaDefines::DYNAMIC_NATIVE) else if (resultType == RiaDefines::DYNAMIC_NATIVE)
{ {
if (m_reservoirView.notNull() && m_reservoirView->eclipseCase()) if (m_reservoirView.notNull() && m_reservoirView->eclipseCase())
{ {
size_t nativeTimeStep = m_reservoirView->eclipseCase()->uiToNativeTimeStepIndex(m_timeStepIndex); size_t nativeTimeStep = m_reservoirView->eclipseCase()->uiToNativeTimeStepIndex(m_timeStepIndex);
nncValues = nncData->dynamicConnectionScalarResult(eclipseResultAddress.scalarResultIndex, nativeTimeStep); nncValues = nncData->dynamicConnectionScalarResult(eclipseResultAddress, nativeTimeStep);
} }
} }
if (nncValues && (m_nncIndex < nncValues->size())) if (nncValues && (m_nncIndex < nncValues->size()))