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: RigCaseCellResultsData: Remove the final result index based interface

Browse Source
This commit is contained in:
Jacob Støren 2019-01-28 16:18:28 +01:00
parent a185929826
commit dbb2a564a2
32 changed files with 271 additions and 251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ApplicationCode/CommandFileInterface/RicfExportProperty.cpp
View File

@ -85,8 +85,7 @@ void RicfExportProperty::execute()
RigCaseCellResultsData* cellResultsData = eclipseCaseData->results(RiaDefines::MATRIX_MODEL); RigCaseCellResultsData* cellResultsData = eclipseCaseData->results(RiaDefines::MATRIX_MODEL);
size_t resultIdx = cellResultsData->findOrLoadKnownScalarResult(m_propertyName); if (!cellResultsData->ensureKnownResultLoaded(RigEclipseResultAddress(m_propertyName)))
if (resultIdx == cvf::UNDEFINED_SIZE_T)
{ {
RiaLogging::error(QString("exportProperty: Could not find result property : %1").arg(m_propertyName())); RiaLogging::error(QString("exportProperty: Could not find result property : %1").arg(m_propertyName()));
return; return;

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

@ -187,7 +187,7 @@ std::vector<RigCompletionData>
if (pdParams.performScaling) if (pdParams.performScaling)
{ {
RigCaseCellResultsData* results = caseToApply->results(RiaDefines::MATRIX_MODEL); RigCaseCellResultsData* results = caseToApply->results(RiaDefines::MATRIX_MODEL);
results->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "PRESSURE"); results->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "PRESSURE"));
} }
return generateCompdatValuesConst(caseToApply, return generateCompdatValuesConst(caseToApply,

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

@ -1230,13 +1230,13 @@ CellDirection RicWellPathExportCompletionDataFeatureImpl::calculateCellMainDirec
{ {
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData(); RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "DX"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "DX"));
cvf::ref<RigResultAccessor> dxAccessObject = cvf::ref<RigResultAccessor> dxAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DX"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DX");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "DY"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "DY"));
cvf::ref<RigResultAccessor> dyAccessObject = cvf::ref<RigResultAccessor> dyAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DY"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DY");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "DZ"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "DZ"));
cvf::ref<RigResultAccessor> dzAccessObject = cvf::ref<RigResultAccessor> dzAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DZ"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DZ");
@ -1274,23 +1274,23 @@ TransmissibilityData
{ {
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData(); RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "DX"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "DX"));
cvf::ref<RigResultAccessor> dxAccessObject = cvf::ref<RigResultAccessor> dxAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DX"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DX");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "DY"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "DY"));
cvf::ref<RigResultAccessor> dyAccessObject = cvf::ref<RigResultAccessor> dyAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DY"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DY");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "DZ"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "DZ"));
cvf::ref<RigResultAccessor> dzAccessObject = cvf::ref<RigResultAccessor> dzAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DZ"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DZ");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "PERMX"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "PERMX"));
cvf::ref<RigResultAccessor> permxAccessObject = cvf::ref<RigResultAccessor> permxAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMX"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMX");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "PERMY"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "PERMY"));
cvf::ref<RigResultAccessor> permyAccessObject = cvf::ref<RigResultAccessor> permyAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMY"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMY");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "PERMZ"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "PERMZ"));
cvf::ref<RigResultAccessor> permzAccessObject = cvf::ref<RigResultAccessor> permzAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMZ"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMZ");
@ -1303,7 +1303,7 @@ TransmissibilityData
double ntg = 1.0; double ntg = 1.0;
{ {
// Trigger loading from file // Trigger loading from file
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "NTG"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "NTG"));
cvf::ref<RigResultAccessor> ntgAccessObject = cvf::ref<RigResultAccessor> ntgAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "NTG"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "NTG");
@ -1370,7 +1370,7 @@ double RicWellPathExportCompletionDataFeatureImpl::calculateDFactor(RimEclipseCa
double porosity = 0.0; double porosity = 0.0;
{ {
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "PORO"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "PORO"));
cvf::ref<RigResultAccessor> poroAccessObject = cvf::ref<RigResultAccessor> poroAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PORO"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PORO");
@ -1408,29 +1408,28 @@ double RicWellPathExportCompletionDataFeatureImpl::calculateTransmissibilityAsEc
{ {
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData(); RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "DX"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "DX"));
cvf::ref<RigResultAccessor> dxAccessObject = cvf::ref<RigResultAccessor> dxAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DX"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DX");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "DY"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "DY"));
cvf::ref<RigResultAccessor> dyAccessObject = cvf::ref<RigResultAccessor> dyAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DY"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DY");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "DZ"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "DZ"));
cvf::ref<RigResultAccessor> dzAccessObject = cvf::ref<RigResultAccessor> dzAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DZ"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DZ");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "PERMX"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "PERMX"));
cvf::ref<RigResultAccessor> permxAccessObject = cvf::ref<RigResultAccessor> permxAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMX"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMX");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "PERMY"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "PERMY"));
cvf::ref<RigResultAccessor> permyAccessObject = cvf::ref<RigResultAccessor> permyAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMY"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMY");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "PERMZ"); eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "PERMZ"));
cvf::ref<RigResultAccessor> permzAccessObject = cvf::ref<RigResultAccessor> permzAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMZ"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMZ");
double ntg = 1.0; double ntg = 1.0;
size_t ntgResIdx = eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "NTG"); if (eclipseCase->results(RiaDefines::MATRIX_MODEL)->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "NTG")))
if (ntgResIdx != cvf::UNDEFINED_SIZE_T)
{ {
cvf::ref<RigResultAccessor> ntgAccessObject = cvf::ref<RigResultAccessor> ntgAccessObject =
RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "NTG"); RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "NTG");

9
ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp
View File

@ -318,13 +318,10 @@ bool RifEclipseInputFileTools::readDataFromKeyword(ecl_kw_type* eclipseKeywordDa
if (!mathingItemCount) return false; if (!mathingItemCount) return false;
size_t resultIndex = caseData->results(RiaDefines::MATRIX_MODEL)->findScalarResultIndex(resultName); // Todo : Is it neccessary to search without type first ? RigEclipseResultAddress resAddr( RiaDefines::INPUT_PROPERTY, resultName);
if (resultIndex == cvf::UNDEFINED_SIZE_T) caseData->results(RiaDefines::MATRIX_MODEL)->createResultEntry( resAddr, false);
{
caseData->results(RiaDefines::MATRIX_MODEL)->findOrCreateScalarResultIndex(RiaDefines::INPUT_PROPERTY, resultName, false);
}
std::vector< std::vector<double> >& newPropertyData = caseData->results(RiaDefines::MATRIX_MODEL)->cellScalarResults(RigEclipseResultAddress(resultName)); std::vector< std::vector<double> >& newPropertyData = caseData->results(RiaDefines::MATRIX_MODEL)->cellScalarResults(resAddr);
newPropertyData.push_back(std::vector<double>()); newPropertyData.push_back(std::vector<double>());
newPropertyData[0].resize(ecl_kw_get_size(eclipseKeywordData), HUGE_VAL); newPropertyData[0].resize(ecl_kw_get_size(eclipseKeywordData), HUGE_VAL);

26
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -573,10 +573,12 @@ void RifReaderEclipseOutput::setHdf5FileName(const QString& fileName)
} }
QStringList resultNames = hdf5ReaderInterface->propertyNames(); QStringList resultNames = hdf5ReaderInterface->propertyNames();
for (int i = 0; i < resultNames.size(); ++i) for (int i = 0; i < resultNames.size(); ++i)
{ {
matrixModelResults->findOrCreateScalarResultIndex(RiaDefines::SOURSIMRL, resultNames[i], false); RigEclipseResultAddress resAddr(RiaDefines::SOURSIMRL, resultNames[i]);
matrixModelResults->setTimeStepInfos(RigEclipseResultAddress(RiaDefines::SOURSIMRL, resultNames[i]), timeStepInfos); matrixModelResults->createResultEntry(resAddr, false);
matrixModelResults->setTimeStepInfos(resAddr, timeStepInfos);
} }
m_hdfReaderInterface = std::move(hdf5ReaderInterface); m_hdfReaderInterface = std::move(hdf5ReaderInterface);
@ -855,8 +857,9 @@ void RifReaderEclipseOutput::buildMetaData(ecl_grid_type* grid)
for (int i = 0; i < matrixResultNames.size(); ++i) for (int i = 0; i < matrixResultNames.size(); ++i)
{ {
matrixModelResults->findOrCreateScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, matrixResultNames[i], false); RigEclipseResultAddress resAddr(RiaDefines::DYNAMIC_NATIVE, matrixResultNames[i]);
matrixModelResults->setTimeStepInfos(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, matrixResultNames[i]), timeStepInfos); matrixModelResults->createResultEntry(resAddr, false);
matrixModelResults->setTimeStepInfos(resAddr, timeStepInfos);
} }
} }
@ -868,8 +871,9 @@ void RifReaderEclipseOutput::buildMetaData(ecl_grid_type* grid)
for (int i = 0; i < fractureResultNames.size(); ++i) for (int i = 0; i < fractureResultNames.size(); ++i)
{ {
fractureModelResults->findOrCreateScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, fractureResultNames[i], false); RigEclipseResultAddress resAddr(RiaDefines::DYNAMIC_NATIVE, fractureResultNames[i]);
fractureModelResults->setTimeStepInfos(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, fractureResultNames[i]), timeStepInfos); fractureModelResults->createResultEntry(resAddr, false);
fractureModelResults->setTimeStepInfos(resAddr, timeStepInfos);
} }
} }
} }
@ -939,8 +943,9 @@ void RifReaderEclipseOutput::buildMetaData(ecl_grid_type* grid)
for (int i = 0; i < matrixResultNames.size(); ++i) for (int i = 0; i < matrixResultNames.size(); ++i)
{ {
matrixModelResults->findOrCreateScalarResultIndex(RiaDefines::STATIC_NATIVE, matrixResultNames[i], false); RigEclipseResultAddress resAddr(RiaDefines::STATIC_NATIVE, matrixResultNames[i]);
matrixModelResults->setTimeStepInfos(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, matrixResultNames[i]), staticTimeStepInfo); matrixModelResults->createResultEntry(resAddr, false);
matrixModelResults->setTimeStepInfos(resAddr, staticTimeStepInfo);
} }
} }
@ -954,8 +959,9 @@ void RifReaderEclipseOutput::buildMetaData(ecl_grid_type* grid)
for (int i = 0; i < fractureResultNames.size(); ++i) for (int i = 0; i < fractureResultNames.size(); ++i)
{ {
fractureModelResults->findOrCreateScalarResultIndex(RiaDefines::STATIC_NATIVE, fractureResultNames[i], false); RigEclipseResultAddress resAddr(RiaDefines::STATIC_NATIVE, fractureResultNames[i]);
fractureModelResults->setTimeStepInfos(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, fractureResultNames[i]), staticTimeStepInfo); fractureModelResults->createResultEntry(resAddr, false);
fractureModelResults->setTimeStepInfos(resAddr, staticTimeStepInfo);
} }
} }
} }

13
ApplicationCode/FileInterface/RifReaderMockModel.cpp
View File

@ -53,8 +53,9 @@ bool RifReaderMockModel::open(const QString& fileName, RigEclipseCaseData* eclip
for (size_t i = 0; i < m_reservoirBuilder.resultCount(); i++) for (size_t i = 0; i < m_reservoirBuilder.resultCount(); i++)
{ {
cellResults->findOrCreateScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, QString("Dynamic_Result_%1").arg(i), false); RigEclipseResultAddress resAddr(RiaDefines::DYNAMIC_NATIVE, QString("Dynamic_Result_%1").arg(i));
cellResults->setTimeStepInfos(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, QString("Dynamic_Result_%1").arg(i)), timeStepInfos); cellResults->createResultEntry(resAddr, false);
cellResults->setTimeStepInfos(resAddr, timeStepInfos);
} }
if (m_reservoirBuilder.timeStepCount() == 0) return true; if (m_reservoirBuilder.timeStepCount() == 0) return true;
@ -69,9 +70,11 @@ bool RifReaderMockModel::open(const QString& fileName, RigEclipseCaseData* eclip
if (i == 1) varEnd = "Y"; if (i == 1) varEnd = "Y";
int resIndex = 0; int resIndex = 0;
if (i > 1) resIndex = i; if (i > 1) resIndex = i;
RigEclipseResultAddress resAddr(RiaDefines::STATIC_NATIVE, QString("Static_Result_%1%2").arg(resIndex).arg(varEnd));
cellResults->findOrCreateScalarResultIndex(RiaDefines::STATIC_NATIVE, QString("Static_Result_%1%2").arg(resIndex).arg(varEnd), false); cellResults->createResultEntry(resAddr, false);
cellResults->setTimeStepInfos(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, QString("Static_Result_%1%2").arg(resIndex).arg(varEnd)), staticResultTimeStepInfos); cellResults->setTimeStepInfos(resAddr, staticResultTimeStepInfos);
} }
@ -79,7 +82,7 @@ bool RifReaderMockModel::open(const QString& fileName, RigEclipseCaseData* eclip
{ \ { \
QString resultName(Name); \ QString resultName(Name); \
RigEclipseResultAddress resAddr(RiaDefines::INPUT_PROPERTY, resultName);\ RigEclipseResultAddress resAddr(RiaDefines::INPUT_PROPERTY, resultName);\
cellResults->findOrCreateScalarResultIndex(RiaDefines::INPUT_PROPERTY, resultName, false); \ cellResults->createResultEntry(resAddr, false); \
cellResults->setTimeStepInfos(resAddr, staticResultTimeStepInfos); \ cellResults->setTimeStepInfos(resAddr, staticResultTimeStepInfos); \
cellResults->cellScalarResults(resAddr).resize(1); \ cellResults->cellScalarResults(resAddr).resize(1); \
std::vector<double>& values = cellResults->cellScalarResults(resAddr)[0]; \ std::vector<double>& values = cellResults->cellScalarResults(resAddr)[0]; \

2
ApplicationCode/ModelVisualization/RivCellEdgeGeometryUtils.cpp
View File

@ -326,7 +326,7 @@ cvf::ref<RigResultAccessor> RivCellEdgeGeometryUtils::createCellEdgeResultAccess
} }
RiaDefines::PorosityModelType porosityModel = cellResultColors->porosityModel(); RiaDefines::PorosityModelType porosityModel = cellResultColors->porosityModel();
cvf::ref<RigResultAccessor> daObj = RigResultAccessorFactory::createFromResultIdx(eclipseCase, grid->gridIndex(), porosityModel, adjustedTimeStep, resultIndices[cubeFaceIdx]); cvf::ref<RigResultAccessor> daObj = RigResultAccessorFactory::createFromResultAddress(eclipseCase, grid->gridIndex(), porosityModel, adjustedTimeStep, resultIndices[cubeFaceIdx]);
cellEdgeResultAccessor->setDataAccessObjectForFace(static_cast<cvf::StructGridInterface::FaceType>(cubeFaceIdx), daObj.p()); cellEdgeResultAccessor->setDataAccessObjectForFace(static_cast<cvf::StructGridInterface::FaceType>(cubeFaceIdx), daObj.p());
} }
} }

11
ApplicationCode/ProjectDataModel/Flow/RimWellPlotTools.cpp
View File

@ -111,9 +111,8 @@ std::pair<RigEclipseResultAddress, QString> RimWellPlotTools::pressureResultData
{ {
for (const auto& pressureDataName : PRESSURE_DATA_NAMES) for (const auto& pressureDataName : PRESSURE_DATA_NAMES)
{ {
size_t index = eclipseCaseData->results(RiaDefines::MATRIX_MODEL) if (eclipseCaseData->results(RiaDefines::MATRIX_MODEL)
->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, pressureDataName); ->hasResultEntry(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, pressureDataName)))
if (index != cvf::UNDEFINED_SIZE_T)
{ {
return std::make_pair(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, pressureDataName), pressureDataName); return std::make_pair(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, pressureDataName), pressureDataName);
} }
@ -228,10 +227,8 @@ bool RimWellPlotTools::hasFlowData(RimEclipseResultCase* gridCase)
for (const QString& channelName : FLOW_DATA_NAMES) for (const QString& channelName : FLOW_DATA_NAMES)
{ {
size_t resultIndex = return eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->hasResultEntry(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE,
eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, channelName); channelName));
if (resultIndex != cvf::UNDEFINED_SIZE_T) return true;
} }
return false; return false;
} }

2
ApplicationCode/ProjectDataModel/RimCellEdgeColors.cpp
View File

@ -120,7 +120,7 @@ void RimCellEdgeColors::loadResult()
int i; int i;
for (i = 0; i < vars.size(); ++i) for (i = 0; i < vars.size(); ++i)
{ {
m_reservoirView->currentGridCellResults()->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, vars[i]); m_reservoirView->currentGridCellResults()->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, vars[i]));
int cubeFaceIdx; int cubeFaceIdx;
for (cubeFaceIdx = 0; cubeFaceIdx < 6; ++cubeFaceIdx) for (cubeFaceIdx = 0; cubeFaceIdx < 6; ++cubeFaceIdx)
{ {

35
ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
View File

@ -691,8 +691,7 @@ bool RimEclipseCase::loadStaticResultsByName(const std::vector<QString>& resultN
{ {
for (const auto& resultName : resultNames) for (const auto& resultName : resultNames)
{ {
size_t resultIdx = cellResultsData->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, resultName); if (!cellResultsData->ensureKnownResultLoaded(RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, resultName)))
if (resultIdx == cvf::UNDEFINED_SIZE_T)
{ {
foundDataForAllResults = false; foundDataForAllResults = false;
} }
@ -789,33 +788,33 @@ bool RimEclipseCase::openReserviorCase()
results->createPlaceholderResultEntries(); results->createPlaceholderResultEntries();
// After the placeholder result for combined transmissibility is created, // After the placeholder result for combined transmissibility is created,
// make sure the nnc transmissibilities can be addressed by this scalarResultIndex as well // make sure the nnc transmissibilities can be addressed by this scalarResultIndex as well
size_t combinedTransResIdx =
results->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedTransmissibilityResultName()); RigEclipseResultAddress combinedTransmissibilityResAddr(RiaDefines::STATIC_NATIVE, RiaDefines::combinedTransmissibilityResultName());
if (combinedTransResIdx != cvf::UNDEFINED_SIZE_T) if (results->hasResultEntry(combinedTransmissibilityResAddr))
{ {
eclipseCaseData()->mainGrid()->nncData()->setEclResultAddress(RigNNCData::propertyNameCombTrans(), eclipseCaseData()->mainGrid()->nncData()->setEclResultAddress(RigNNCData::propertyNameCombTrans(),
RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, RiaDefines::combinedTransmissibilityResultName())); combinedTransmissibilityResAddr);
} }
size_t combinedWatFluxResIdx =
results->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedWaterFluxResultName()); RigEclipseResultAddress combinedWaterFluxResAddr(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedWaterFluxResultName());
if (combinedWatFluxResIdx != cvf::UNDEFINED_SIZE_T) if (results->hasResultEntry(combinedWaterFluxResAddr))
{ {
eclipseCaseData()->mainGrid()->nncData()->setEclResultAddress(RigNNCData::propertyNameFluxWat(), eclipseCaseData()->mainGrid()->nncData()->setEclResultAddress(RigNNCData::propertyNameFluxWat(),
RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedWaterFluxResultName())); combinedWaterFluxResAddr);
} }
size_t combinedOilFluxResIdx =
results->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedOilFluxResultName()); RigEclipseResultAddress combinedOilFluxResAddr(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedOilFluxResultName());
if (combinedOilFluxResIdx != cvf::UNDEFINED_SIZE_T) if (results->hasResultEntry(combinedOilFluxResAddr))
{ {
eclipseCaseData()->mainGrid()->nncData()->setEclResultAddress(RigNNCData::propertyNameFluxOil(), eclipseCaseData()->mainGrid()->nncData()->setEclResultAddress(RigNNCData::propertyNameFluxOil(),
RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedOilFluxResultName())); combinedOilFluxResAddr);
} }
size_t combinedGasFluxResIdx = RigEclipseResultAddress combinedGasFluxResAddr(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedGasFluxResultName());
results->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedGasFluxResultName());
if (combinedGasFluxResIdx != cvf::UNDEFINED_SIZE_T) if (results->hasResultEntry(combinedGasFluxResAddr))
{ {
eclipseCaseData()->mainGrid()->nncData()->setEclResultAddress(RigNNCData::propertyNameFluxGas(), eclipseCaseData()->mainGrid()->nncData()->setEclResultAddress(RigNNCData::propertyNameFluxGas(),
RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedGasFluxResultName())); combinedGasFluxResAddr);
} }
} }
} }

11
ApplicationCode/ProjectDataModel/RimEclipseCellColors.cpp
View File

@ -441,10 +441,9 @@ void RimEclipseCellColors::updateLegendData(size_t currentTimeStep,
{ {
RigCaseCellResultsData* gridCellResults = this->currentGridCellResults(); RigCaseCellResultsData* gridCellResults = this->currentGridCellResults();
{ {
size_t scalarSetIndex = gridCellResults->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "SOIL");
RigEclipseResultAddress resAddr(RiaDefines::DYNAMIC_NATIVE, "SOIL"); RigEclipseResultAddress resAddr(RiaDefines::DYNAMIC_NATIVE, "SOIL");
if ( scalarSetIndex != cvf::UNDEFINED_SIZE_T ) if ( gridCellResults->ensureKnownResultLoaded(resAddr) )
{ {
double globalMin = 0.0; double globalMin = 0.0;
double globalMax = 1.0; double globalMax = 1.0;
@ -459,9 +458,9 @@ void RimEclipseCellColors::updateLegendData(size_t currentTimeStep,
} }
{ {
size_t scalarSetIndex = gridCellResults->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "SGAS");
RigEclipseResultAddress resAddr(RiaDefines::DYNAMIC_NATIVE, "SGAS"); RigEclipseResultAddress resAddr(RiaDefines::DYNAMIC_NATIVE, "SGAS");
if ( scalarSetIndex != cvf::UNDEFINED_SIZE_T )
if ( gridCellResults->ensureKnownResultLoaded(resAddr) )
{ {
double globalMin = 0.0; double globalMin = 0.0;
double globalMax = 1.0; double globalMax = 1.0;
@ -476,9 +475,9 @@ void RimEclipseCellColors::updateLegendData(size_t currentTimeStep,
} }
{ {
size_t scalarSetIndex = gridCellResults->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "SWAT");
RigEclipseResultAddress resAddr(RiaDefines::DYNAMIC_NATIVE, "SWAT"); RigEclipseResultAddress resAddr(RiaDefines::DYNAMIC_NATIVE, "SWAT");
if ( scalarSetIndex != cvf::UNDEFINED_SIZE_T )
if ( gridCellResults->ensureKnownResultLoaded(resAddr) )
{ {
double globalMin = 0.0; double globalMin = 0.0;
double globalMax = 1.0; double globalMax = 1.0;

20
ApplicationCode/ProjectDataModel/RimEclipseContourMapProjection.cpp
View File

@ -186,16 +186,16 @@ std::vector<double> RimEclipseContourMapProjection::generateResults(int timeStep
if (isColumnResult()) if (isColumnResult())
{ {
m_currentResultName = ""; m_currentResultName = "";
resultData->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "PORO"); resultData->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "PORO"));
resultData->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "NTG"); resultData->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "NTG"));
resultData->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "DZ"); resultData->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "DZ"));
if (m_resultAggregation == RESULTS_OIL_COLUMN || m_resultAggregation == RESULTS_HC_COLUMN) if (m_resultAggregation == RESULTS_OIL_COLUMN || m_resultAggregation == RESULTS_HC_COLUMN)
{ {
resultData->findOrLoadKnownScalarResultForTimeStep(RiaDefines::DYNAMIC_NATIVE, "SOIL", timeStep); resultData->ensureKnownResultLoadedForTimeStep(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SOIL"), timeStep);
} }
if (m_resultAggregation == RESULTS_GAS_COLUMN || m_resultAggregation == RESULTS_HC_COLUMN) if (m_resultAggregation == RESULTS_GAS_COLUMN || m_resultAggregation == RESULTS_HC_COLUMN)
{ {
resultData->findOrLoadKnownScalarResultForTimeStep(RiaDefines::DYNAMIC_NATIVE, "SGAS", timeStep); resultData->ensureKnownResultLoadedForTimeStep(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SGAS"), timeStep);
} }
gridResultValues = calculateColumnResult(m_resultAggregation()); gridResultValues = calculateColumnResult(m_resultAggregation());
} }
@ -249,11 +249,11 @@ void RimEclipseContourMapProjection::clearResultVariable()
std::vector<double> RimEclipseContourMapProjection::calculateColumnResult(ResultAggregation resultAggregation) const std::vector<double> RimEclipseContourMapProjection::calculateColumnResult(ResultAggregation resultAggregation) const
{ {
const RigCaseCellResultsData* resultData = eclipseCase()->results(RiaDefines::MATRIX_MODEL); const RigCaseCellResultsData* resultData = eclipseCase()->results(RiaDefines::MATRIX_MODEL);
size_t poroResultIndex = resultData->findScalarResultIndex(RiaDefines::STATIC_NATIVE, "PORO"); bool hasPoroResult = resultData->hasResultEntry(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "PORO"));
size_t ntgResultIndex = resultData->findScalarResultIndex(RiaDefines::STATIC_NATIVE, "NTG" ); bool hasNtgResult = resultData->hasResultEntry(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "NTG" ));
size_t dzResultIndex = resultData->findScalarResultIndex(RiaDefines::STATIC_NATIVE, "DZ" ); bool haDzResult = resultData->hasResultEntry(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "DZ" ));
if (poroResultIndex == cvf::UNDEFINED_SIZE_T || ntgResultIndex == cvf::UNDEFINED_SIZE_T || dzResultIndex == cvf::UNDEFINED_SIZE_T) if (! (hasPoroResult && hasNtgResult && haDzResult) )
{ {
return std::vector<double>(); return std::vector<double>();
} }
@ -276,6 +276,7 @@ std::vector<double> RimEclipseContourMapProjection::calculateColumnResult(Result
resultValues[cellResultIdx] = soilResults[cellResultIdx]; resultValues[cellResultIdx] = soilResults[cellResultIdx];
} }
} }
if (resultAggregation == RESULTS_GAS_COLUMN || resultAggregation == RESULTS_HC_COLUMN) if (resultAggregation == RESULTS_GAS_COLUMN || resultAggregation == RESULTS_HC_COLUMN)
{ {
const std::vector<double>& sgasResults = resultData->cellScalarResults(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SGAS"), timeStep); const std::vector<double>& sgasResults = resultData->cellScalarResults(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SGAS"), timeStep);
@ -285,7 +286,6 @@ std::vector<double> RimEclipseContourMapProjection::calculateColumnResult(Result
} }
} }
for (size_t cellResultIdx = 0; cellResultIdx < resultValues.size(); ++cellResultIdx) for (size_t cellResultIdx = 0; cellResultIdx < resultValues.size(); ++cellResultIdx)
{ {
resultValues[cellResultIdx] *= poroResults[cellResultIdx] * ntgResults[cellResultIdx] * dzResults[cellResultIdx]; resultValues[cellResultIdx] *= poroResults[cellResultIdx] * ntgResults[cellResultIdx] * dzResults[cellResultIdx];

6
ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp
View File

@ -772,7 +772,7 @@ void RimEclipseResultDefinition::loadResult()
RigCaseCellResultsData* gridCellResults = this->currentGridCellResults(); RigCaseCellResultsData* gridCellResults = this->currentGridCellResults();
if (gridCellResults) if (gridCellResults)
{ {
gridCellResults->findOrLoadKnownScalarResult(m_resultType(), m_resultVariable); gridCellResults->ensureKnownResultLoaded(RigEclipseResultAddress(m_resultType(), m_resultVariable));
} }
} }
@ -810,8 +810,8 @@ bool RimEclipseResultDefinition::hasResult() const
else if (this->currentGridCellResults() ) else if (this->currentGridCellResults() )
{ {
const RigCaseCellResultsData* gridCellResults = this->currentGridCellResults(); const RigCaseCellResultsData* gridCellResults = this->currentGridCellResults();
size_t gridScalarResultIndex = gridCellResults->findScalarResultIndex(m_resultType(), m_resultVariable());
return gridScalarResultIndex != cvf::UNDEFINED_SIZE_T; return gridCellResults->hasResultEntry(RigEclipseResultAddress(m_resultType(), m_resultVariable()));
} }
return false; return false;

14
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp
View File

@ -50,10 +50,11 @@ void RimEclipseStatisticsCaseEvaluator::addNamedResult(RigCaseCellResultsData* d
std::vector<RigEclipseResultAddress> resAddresses = m_sourceCases[0]->results(RiaDefines::MATRIX_MODEL)->existingResults(); std::vector<RigEclipseResultAddress> resAddresses = m_sourceCases[0]->results(RiaDefines::MATRIX_MODEL)->existingResults();
std::vector<RigEclipseTimeStepInfo> sourceTimeStepInfos = m_sourceCases[0]->results(RiaDefines::MATRIX_MODEL)->timeStepInfos(resAddresses[0]); std::vector<RigEclipseTimeStepInfo> sourceTimeStepInfos = m_sourceCases[0]->results(RiaDefines::MATRIX_MODEL)->timeStepInfos(resAddresses[0]);
destinationCellResults->findOrCreateScalarResultIndex(resultType, resultName, true); RigEclipseResultAddress resAddr(resultType, resultName);
destinationCellResults->createResultEntry(resAddr, true);
destinationCellResults->setTimeStepInfos(RigEclipseResultAddress(resultType, resultName), sourceTimeStepInfos); destinationCellResults->setTimeStepInfos(resAddr, sourceTimeStepInfos);
std::vector< std::vector<double> >& dataValues = destinationCellResults->cellScalarResults(RigEclipseResultAddress(resultType, resultName)); std::vector< std::vector<double> >& dataValues = destinationCellResults->cellScalarResults(resAddr);
dataValues.resize(sourceTimeStepInfos.size()); dataValues.resize(sourceTimeStepInfos.size());
@ -144,8 +145,6 @@ void RimEclipseStatisticsCaseEvaluator::evaluateForResults(const QList<ResSpec>&
if (activeCellCount == 0) continue; if (activeCellCount == 0) continue;
RigCaseCellResultsData* destCellResultsData = m_destinationCase->results(poroModel);
size_t dataAccessTimeStepIndex = timeStepIdx; size_t dataAccessTimeStepIndex = timeStepIdx;
// Always evaluate statistics once, and always use time step index zero // Always evaluate statistics once, and always use time step index zero
@ -164,7 +163,8 @@ void RimEclipseStatisticsCaseEvaluator::evaluateForResults(const QList<ResSpec>&
RimEclipseCase* sourceCase = m_sourceCases.at(caseIdx); RimEclipseCase* sourceCase = m_sourceCases.at(caseIdx);
// Trigger loading of dataset // Trigger loading of dataset
sourceCase->results(poroModel)->findOrLoadKnownScalarResultForTimeStep(resultType, resultName, dataAccessTimeStepIndex); sourceCase->results(poroModel)->ensureKnownResultLoadedForTimeStep(RigEclipseResultAddress(resultType, resultName),
dataAccessTimeStepIndex);
cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromNameAndType(sourceCase->eclipseCaseData(), gridIdx, poroModel, dataAccessTimeStepIndex, resultName, resultType); cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromNameAndType(sourceCase->eclipseCaseData(), gridIdx, poroModel, dataAccessTimeStepIndex, resultName, resultType);
if (resultAccessor.notNull()) if (resultAccessor.notNull())
@ -191,8 +191,6 @@ void RimEclipseStatisticsCaseEvaluator::evaluateForResults(const QList<ResSpec>&
for (size_t stIdx = 0; stIdx < statisticalResultNames.size(); ++stIdx) for (size_t stIdx = 0; stIdx < statisticalResultNames.size(); ++stIdx)
{ {
destCellResultsData->findScalarResultIndex(resultType, statisticalResultNames[stIdx]);
cvf::ref<RigResultModifier> resultModifier = RigResultModifierFactory::createResultModifier(m_destinationCase, cvf::ref<RigResultModifier> resultModifier = RigResultModifierFactory::createResultModifier(m_destinationCase,
grid->gridIndex(), grid->gridIndex(),
poroModel, poroModel,

12
ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp
View File

@ -272,13 +272,17 @@ void RimReservoirCellResultsStorage::setCellResults(RigCaseCellResultsData* cell
for (size_t rIdx = 0; rIdx < m_resultCacheMetaData.size(); ++rIdx) for (size_t rIdx = 0; rIdx < m_resultCacheMetaData.size(); ++rIdx)
{ {
RimReservoirCellResultsStorageEntryInfo* resInfo = m_resultCacheMetaData[rIdx]; RimReservoirCellResultsStorageEntryInfo* resInfo = m_resultCacheMetaData[rIdx];
m_cellResults->findOrCreateScalarResultIndex(resInfo->m_resultType(), resInfo->m_resultName, true);
RigEclipseResultAddress resAddr(resInfo->m_resultType(), resInfo->m_resultName);
m_cellResults->createResultEntry(resAddr, true);
std::vector<int> reportNumbers; // Hack: Using no report step numbers. Not really used except for Flow Diagnostics... std::vector<int> reportNumbers; // Hack: Using no report step numbers. Not really used except for Flow Diagnostics...
reportNumbers.resize(resInfo->m_timeStepDates().size()); reportNumbers.resize(resInfo->m_timeStepDates().size());
std::vector<RigEclipseTimeStepInfo> timeStepInfos = RigEclipseTimeStepInfo::createTimeStepInfos(resInfo->m_timeStepDates(), reportNumbers, resInfo->m_daysSinceSimulationStart()); std::vector<RigEclipseTimeStepInfo> timeStepInfos = RigEclipseTimeStepInfo::createTimeStepInfos(resInfo->m_timeStepDates(),
reportNumbers,
resInfo->m_daysSinceSimulationStart());
m_cellResults->setTimeStepInfos(RigEclipseResultAddress(resInfo->m_resultType(), resInfo->m_resultName), timeStepInfos); m_cellResults->setTimeStepInfos(resAddr, timeStepInfos);
progress.setProgressDescription(resInfo->m_resultName); progress.setProgressDescription(resInfo->m_resultName);
@ -286,7 +290,7 @@ void RimReservoirCellResultsStorage::setCellResults(RigCaseCellResultsData* cell
{ {
std::vector<double>* data = nullptr; std::vector<double>* data = nullptr;
data = &(m_cellResults->cellScalarResults(RigEclipseResultAddress(resInfo->m_resultType(), resInfo->m_resultName), tsIdx)); data = &(m_cellResults->cellScalarResults(resAddr, tsIdx));
quint64 cellCount = 0; quint64 cellCount = 0;
stream >> cellCount; stream >> cellCount;

58
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@ -1304,6 +1304,64 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult(RiaDefines::ResultCat
return scalarResultIndex; return scalarResultIndex;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigCaseCellResultsData::ensureKnownResultLoaded(const RigEclipseResultAddress& resultAddress)
{
size_t resultIndex = cvf::UNDEFINED_SIZE_T;
if (resultAddress.m_resultCatType != RiaDefines::UNDEFINED)
{
resultIndex = findOrLoadKnownScalarResult(resultAddress.m_resultCatType, resultAddress.m_resultName);
}
else
{
resultIndex = findOrLoadKnownScalarResult(resultAddress.m_resultName);
}
return (resultIndex != cvf::UNDEFINED_SIZE_T);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigCaseCellResultsData::hasResultEntry(const RigEclipseResultAddress& resultAddress) const
{
size_t resultIndex = cvf::UNDEFINED_SIZE_T;
if (resultAddress.m_resultCatType != RiaDefines::UNDEFINED)
{
resultIndex = findScalarResultIndex(resultAddress.m_resultCatType, resultAddress.m_resultName);
}
else
{
resultIndex = findScalarResultIndex(resultAddress.m_resultName);
}
return (resultIndex != cvf::UNDEFINED_SIZE_T);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseCellResultsData::createResultEntry(const RigEclipseResultAddress& resultAddress, bool needsToBeStored)
{
findOrCreateScalarResultIndex(resultAddress.m_resultCatType, resultAddress.m_resultName, needsToBeStored);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseCellResultsData::ensureKnownResultLoadedForTimeStep(const RigEclipseResultAddress& resultAddress,
size_t timeStepIndex)
{
CAF_ASSERT(resultAddress.m_resultCatType != RiaDefines::UNDEFINED);
findOrLoadKnownScalarResultForTimeStep(resultAddress.m_resultCatType,
resultAddress.m_resultName,
timeStepIndex);
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// This method is intended to be used for multicase cross statistical calculations, when /// This method is intended to be used for multicase cross statistical calculations, when
/// we need process one timestep at a time, freeing memory as we go. /// we need process one timestep at a time, freeing memory as we go.

26
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.h
View File

@ -115,19 +115,10 @@ public:
bool updateResultName(RiaDefines::ResultCatType resultType, QString& oldName, const QString& newName); bool updateResultName(RiaDefines::ResultCatType resultType, QString& oldName, const QString& newName);
// Index based stuff to rewrite/hide --> void ensureKnownResultLoadedForTimeStep(const RigEclipseResultAddress& resultAddress, size_t timeStepIndex);
bool ensureKnownResultLoaded(const RigEclipseResultAddress& resultAddress);
size_t findOrLoadKnownScalarResultForTimeStep(RiaDefines::ResultCatType type, const QString& resultName, size_t timeStepIndex); bool hasResultEntry(const RigEclipseResultAddress& resultAddress) const;
size_t findOrLoadKnownScalarResult(RiaDefines::ResultCatType type, const QString& resultName); void createResultEntry(const RigEclipseResultAddress& resultAddress, bool needsToBeStored);
size_t findOrLoadKnownScalarResult(const QString& resultName); ///< Simplified search. Assumes unique names across types.
// Find or create a slot for the results
size_t findOrCreateScalarResultIndex(RiaDefines::ResultCatType type, const QString& resultName, bool needsToBeStored);
size_t findScalarResultIndex(RiaDefines::ResultCatType type, const QString& resultName) const;
size_t findScalarResultIndex(const QString& resultName) const;
// <---
// Access the results data // Access the results data
@ -148,6 +139,15 @@ public:
const RigEclipseResultInfo* resultInfo(const RigEclipseResultAddress& resVarAddr) const; const RigEclipseResultInfo* resultInfo(const RigEclipseResultAddress& resVarAddr) const;
private: private:
size_t findOrLoadKnownScalarResult(RiaDefines::ResultCatType type, const QString& resultName);
size_t findOrLoadKnownScalarResult(const QString& resultName); ///< Simplified search. Assumes unique names across types.
size_t findOrLoadKnownScalarResultForTimeStep(RiaDefines::ResultCatType type,
const QString& resultName,
size_t timeStepIndex);
size_t findOrCreateScalarResultIndex(RiaDefines::ResultCatType type, const QString& resultName, bool needsToBeStored);
size_t findScalarResultIndex(RiaDefines::ResultCatType type, const QString& resultName) const;
size_t findScalarResultIndex(const QString& resultName) const;
size_t addStaticScalarResult(RiaDefines::ResultCatType type, size_t addStaticScalarResult(RiaDefines::ResultCatType type,
const QString& resultName, const QString& resultName,
bool needsToBeStored, bool needsToBeStored,

3
ApplicationCode/ReservoirDataModel/RigEclipseCaseData.cpp
View File

@ -730,10 +730,9 @@ const std::vector<double>* RigEclipseCaseData::resultValues(RiaDefines::Porosity
size_t timeStepIndex) size_t timeStepIndex)
{ {
RigCaseCellResultsData* gridCellResults = this->results(porosityModel); RigCaseCellResultsData* gridCellResults = this->results(porosityModel);
size_t scalarResultIndex = gridCellResults->findOrLoadKnownScalarResult(type, resultName);
const std::vector<double>* swatResults = nullptr; const std::vector<double>* swatResults = nullptr;
if (scalarResultIndex != cvf::UNDEFINED_SIZE_T) if (gridCellResults->ensureKnownResultLoaded(RigEclipseResultAddress(type, resultName)))
{ {
swatResults = &(gridCellResults->cellScalarResults(RigEclipseResultAddress(type, resultName), timeStepIndex)); swatResults = &(gridCellResults->cellScalarResults(RigEclipseResultAddress(type, resultName), timeStepIndex));
} }

6
ApplicationCode/ReservoirDataModel/RigEclipseNativeStatCalc.cpp
View File

@ -101,16 +101,16 @@ size_t RigEclipseNativeStatCalc::timeStepCount()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigEclipseNativeStatCalc::mobileVolumeWeightedMean(size_t timeStepIndex, double& mean) void RigEclipseNativeStatCalc::mobileVolumeWeightedMean(size_t timeStepIndex, double& mean)
{ {
size_t mobPVResultIndex = m_resultsData->findOrLoadKnownScalarResult(RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName()); RigEclipseResultAddress mobPorvAddress(RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName());
// For statistics result cases, the pore volume is not available, as RigCaseCellResultsData::createPlaceholderResultEntries // For statistics result cases, the pore volume is not available, as RigCaseCellResultsData::createPlaceholderResultEntries
// has not been executed // has not been executed
if (mobPVResultIndex == cvf::UNDEFINED_SIZE_T) if (!m_resultsData->ensureKnownResultLoaded(mobPorvAddress))
{ {
return; return;
} }
const std::vector<double>& weights = m_resultsData->cellScalarResults(RigEclipseResultAddress(RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName()), 0); const std::vector<double>& weights = m_resultsData->cellScalarResults(mobPorvAddress, 0);
const std::vector<double>& values = m_resultsData->cellScalarResults(m_eclipseResultAddress, timeStepIndex); const std::vector<double>& values = m_resultsData->cellScalarResults(m_eclipseResultAddress, timeStepIndex);
const RigActiveCellInfo* actCellInfo = m_resultsData->activeCellInfo(); const RigActiveCellInfo* actCellInfo = m_resultsData->activeCellInfo();

6
ApplicationCode/ReservoirDataModel/RigEclipseNativeVisibleCellsStatCalc.cpp
View File

@ -105,9 +105,11 @@ size_t RigEclipseNativeVisibleCellsStatCalc::timeStepCount()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigEclipseNativeVisibleCellsStatCalc::mobileVolumeWeightedMean(size_t timeStepIndex, double &result) void RigEclipseNativeVisibleCellsStatCalc::mobileVolumeWeightedMean(size_t timeStepIndex, double &result)
{ {
m_caseData->findOrLoadKnownScalarResult(RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName()); RigEclipseResultAddress mobPorvAddress(RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName());
const std::vector<double>& weights = m_caseData->cellScalarResults(RigEclipseResultAddress(RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName()), 0); m_caseData->ensureKnownResultLoaded(mobPorvAddress);
const std::vector<double>& weights = m_caseData->cellScalarResults(mobPorvAddress, 0);
const std::vector<double>& values = m_caseData->cellScalarResults(m_resultAddress, timeStepIndex); const std::vector<double>& values = m_caseData->cellScalarResults(m_resultAddress, timeStepIndex);
const RigActiveCellInfo* actCellInfo = m_caseData->activeCellInfo(); const RigActiveCellInfo* actCellInfo = m_caseData->activeCellInfo();

5
ApplicationCode/ReservoirDataModel/RigFlowDiagStatCalc.cpp
View File

@ -119,10 +119,11 @@ void RigFlowDiagStatCalc::mobileVolumeWeightedMean(size_t timeStepIndex, double&
if (!eclCase) return; if (!eclCase) return;
RigCaseCellResultsData* caseCellResultsData = eclCase->results(RiaDefines::MATRIX_MODEL); RigCaseCellResultsData* caseCellResultsData = eclCase->results(RiaDefines::MATRIX_MODEL);
RigEclipseResultAddress mobPoreVolResAddr(RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName());
caseCellResultsData->findOrLoadKnownScalarResult(RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName()); caseCellResultsData->ensureKnownResultLoaded(mobPoreVolResAddr);
const std::vector<double>& weights = caseCellResultsData->cellScalarResults(RigEclipseResultAddress(RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName()), 0); const std::vector<double>& weights = caseCellResultsData->cellScalarResults(mobPoreVolResAddr, 0);
const std::vector<double>* values = m_resultsData->resultValues(m_resVarAddr, timeStepIndex); const std::vector<double>* values = m_resultsData->resultValues(m_resVarAddr, timeStepIndex);
const RigActiveCellInfo* actCellInfo = m_resultsData->activeCellInfo(m_resVarAddr); const RigActiveCellInfo* actCellInfo = m_resultsData->activeCellInfo(m_resVarAddr);

7
ApplicationCode/ReservoirDataModel/RigFlowDiagVisibleCellsStatCalc.cpp
View File

@ -109,9 +109,10 @@ void RigFlowDiagVisibleCellsStatCalc::mobileVolumeWeightedMean(size_t timeStepIn
RigCaseCellResultsData* caseCellResultsData = eclCase->results(RiaDefines::MATRIX_MODEL); RigCaseCellResultsData* caseCellResultsData = eclCase->results(RiaDefines::MATRIX_MODEL);
caseCellResultsData->findOrLoadKnownScalarResult(RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName()); RigEclipseResultAddress mobPorvAddr(RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName());
const std::vector<double>& weights = caseCellResultsData->cellScalarResults(RigEclipseResultAddress(RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::mobilePoreVolumeName()), 0); caseCellResultsData->ensureKnownResultLoaded(mobPorvAddr);
const std::vector<double>& weights = caseCellResultsData->cellScalarResults(mobPorvAddr, 0);
const std::vector<double>* values = m_resultsData->resultValues(m_resVarAddr, timeStepIndex); const std::vector<double>* values = m_resultsData->resultValues(m_resVarAddr, timeStepIndex);
const RigActiveCellInfo* actCellInfo = m_resultsData->activeCellInfo(m_resVarAddr); const RigActiveCellInfo* actCellInfo = m_resultsData->activeCellInfo(m_resVarAddr);

26
ApplicationCode/ReservoirDataModel/RigNumberOfFloodedPoreVolumesCalculator.cpp
View File

@ -71,21 +71,25 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
std::vector<RigEclipseResultAddress> tracerResAddrs; std::vector<RigEclipseResultAddress> tracerResAddrs;
for (QString tracerName : tracerNames) for (QString tracerName : tracerNames)
{ {
if (gridCellResults->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, tracerName) != cvf::UNDEFINED_SIZE_T) RigEclipseResultAddress tracerResAddr(RiaDefines::DYNAMIC_NATIVE, tracerName);
if (gridCellResults->ensureKnownResultLoaded(tracerResAddr) )
{ {
tracerResAddrs.push_back(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, tracerName)); tracerResAddrs.push_back(tracerResAddr);
} }
progress.incrementProgress(); progress.incrementProgress();
} }
std::vector<std::vector<double> > summedTracersAtAllTimesteps; std::vector<std::vector<double> > summedTracersAtAllTimesteps;
//TODO: Option for Oil and Gas instead of water //TODO: Option for Oil and Gas instead of water
RigEclipseResultAddress flrWatIAddr(RiaDefines::DYNAMIC_NATIVE, "FLRWATI+");
RigEclipseResultAddress flrWatJAddr(RiaDefines::DYNAMIC_NATIVE, "FLRWATJ+");
RigEclipseResultAddress flrWatKAddr(RiaDefines::DYNAMIC_NATIVE, "FLRWATK+");
size_t scalarResultIndexFlowrateI = gridCellResults->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "FLRWATI+"); bool hasFlowrateI = gridCellResults->ensureKnownResultLoaded(flrWatIAddr);
progress.incrementProgress(); progress.incrementProgress();
size_t scalarResultIndexFlowrateJ = gridCellResults->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "FLRWATJ+"); bool hasFlowrateJ = gridCellResults->ensureKnownResultLoaded(flrWatJAddr);
progress.incrementProgress(); progress.incrementProgress();
size_t scalarResultIndexFlowrateK = gridCellResults->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "FLRWATK+"); bool hasFlowrateK = gridCellResults->ensureKnownResultLoaded(flrWatKAddr);
progress.incrementProgress(); progress.incrementProgress();
std::vector<const std::vector<double>* > flowrateIatAllTimeSteps; std::vector<const std::vector<double>* > flowrateIatAllTimeSteps;
@ -110,27 +114,27 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
for (size_t timeStep = 0; timeStep < daysSinceSimulationStart.size(); timeStep++) for (size_t timeStep = 0; timeStep < daysSinceSimulationStart.size(); timeStep++)
{ {
const std::vector<double>* flowrateI = nullptr; const std::vector<double>* flowrateI = nullptr;
if (scalarResultIndexFlowrateI != cvf::UNDEFINED_SIZE_T) if (hasFlowrateI)
{ {
flowrateI = &(eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->cellScalarResults(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "FLRWATI+"), flowrateI = &(eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->cellScalarResults(flrWatIAddr,
timeStep)); timeStep));
} }
flowrateIatAllTimeSteps.push_back(flowrateI); flowrateIatAllTimeSteps.push_back(flowrateI);
const std::vector<double>* flowrateJ = nullptr; const std::vector<double>* flowrateJ = nullptr;
if (scalarResultIndexFlowrateJ != cvf::UNDEFINED_SIZE_T) if (hasFlowrateJ)
{ {
flowrateJ = &(eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->cellScalarResults(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "FLRWATJ+"), flowrateJ = &(eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->cellScalarResults(flrWatJAddr,
timeStep)); timeStep));
} }
flowrateJatAllTimeSteps.push_back(flowrateJ); flowrateJatAllTimeSteps.push_back(flowrateJ);
const std::vector<double>* flowrateK = nullptr; const std::vector<double>* flowrateK = nullptr;
if (scalarResultIndexFlowrateK != cvf::UNDEFINED_SIZE_T) if (hasFlowrateK)
{ {
flowrateK = &(eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->cellScalarResults(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "FLRWATK+"), flowrateK = &(eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->cellScalarResults(flrWatKAddr,
timeStep)); timeStep));
} }
flowrateKatAllTimeSteps.push_back(flowrateK); flowrateKatAllTimeSteps.push_back(flowrateK);

20
ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.cpp
View File

@ -71,8 +71,7 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromNameAndType(cons
return nullptr; return nullptr;
} }
size_t scalarSetIndex = eclipseCase->results(porosityModel)->findScalarResultIndex(resultType, uiResultName); if (!eclipseCase->results(porosityModel)->hasResultEntry(RigEclipseResultAddress(resultType, uiResultName)))
if (scalarSetIndex == cvf::UNDEFINED_SIZE_T)
{ {
return nullptr; return nullptr;
} }
@ -91,7 +90,7 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromNameAndType(cons
adjustedTimeStepIndex = 0; adjustedTimeStepIndex = 0;
} }
return createFromResultIdx(eclipseCase, gridIndex, porosityModel, adjustedTimeStepIndex, RigEclipseResultAddress(resultType, uiResultName)); return createFromResultAddress(eclipseCase, gridIndex, porosityModel, adjustedTimeStepIndex, RigEclipseResultAddress(resultType, uiResultName));
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -148,13 +147,12 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createNativeFromUiResultNa
return nullptr; return nullptr;
} }
size_t scalarSetIndex = eclipseCase->results(porosityModel)->findScalarResultIndex(uiResultName); if (!eclipseCase->results(porosityModel)->hasResultEntry(RigEclipseResultAddress(uiResultName)))
if (scalarSetIndex == cvf::UNDEFINED_SIZE_T)
{ {
return nullptr; return nullptr;
} }
return createFromResultIdx(eclipseCase, gridIndex, porosityModel, timeStepIndex, RigEclipseResultAddress(uiResultName)); return createFromResultAddress(eclipseCase, gridIndex, porosityModel, timeStepIndex, RigEclipseResultAddress(uiResultName));
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -302,11 +300,11 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createDerivedResultAccesso
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromResultIdx(const RigEclipseCaseData* eclipseCase, cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromResultAddress(const RigEclipseCaseData* eclipseCase,
size_t gridIndex, size_t gridIndex,
RiaDefines::PorosityModelType porosityModel, RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex, size_t timeStepIndex,
const RigEclipseResultAddress& resultAddress) const RigEclipseResultAddress& resultAddress)
{ {
if ( !resultAddress.isValid() ) if ( !resultAddress.isValid() )
{ {

10
ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.h
View File

@ -55,11 +55,11 @@ public:
RiaDefines::ResultCatType resultType); RiaDefines::ResultCatType resultType);
static cvf::ref<RigResultAccessor> static cvf::ref<RigResultAccessor>
createFromResultIdx(const RigEclipseCaseData* eclipseCase, createFromResultAddress(const RigEclipseCaseData* eclipseCase,
size_t gridIndex, size_t gridIndex,
RiaDefines::PorosityModelType porosityModel, RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex, size_t timeStepIndex,
const RigEclipseResultAddress& resultIndex); const RigEclipseResultAddress& resultIndex);

22
ApplicationCode/ReservoirDataModel/RigResultModifierFactory.cpp
View File

@ -26,28 +26,6 @@
#include <cmath> #include <cmath>
//--------------------------------------------------------------------------------------------------
/// This function must be harmonized with RigResultAccessorFactory::createNativeResultAccessor()
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultModifier> RigResultModifierFactory::createResultModifier(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex,
QString& uiResultName)
{
if (!eclipseCase) return nullptr;
if (!eclipseCase->results(porosityModel) || !eclipseCase->activeCellInfo(porosityModel))
{
return nullptr;
}
eclipseCase->results(porosityModel)->findScalarResultIndex(uiResultName);
return createResultModifier(eclipseCase, gridIndex, porosityModel, timeStepIndex, RigEclipseResultAddress(uiResultName));
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

8
ApplicationCode/ReservoirDataModel/RigResultModifierFactory.h
View File

@ -28,13 +28,7 @@ class RigEclipseResultAddress;
class RigResultModifierFactory class RigResultModifierFactory
{ {
public: public:
static cvf::ref<RigResultModifier>
createResultModifier(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex,
QString& uiResultName);
static cvf::ref<RigResultModifier> static cvf::ref<RigResultModifier>
createResultModifier(RigEclipseCaseData* eclipseCase, createResultModifier(RigEclipseCaseData* eclipseCase,
size_t gridIndex, size_t gridIndex,

29
ApplicationCode/SocketInterface/RiaNNCCommands.cpp
View File

@ -350,9 +350,9 @@ public:
server->errorMessageDialog()->showMessage(RiaSocketServer::tr("ResInsight SocketServer: \n") + RiaSocketServer::tr("Could not find the property named: \"%2\"").arg(propertyName)); server->errorMessageDialog()->showMessage(RiaSocketServer::tr("ResInsight SocketServer: \n") + RiaSocketServer::tr("Could not find the property named: \"%2\"").arg(propertyName));
return true; return true;
} }
QString totalPropName = QString("%1IJK").arg(propertyName); RigEclipseResultAddress resAddr(QString("%1IJK").arg(propertyName));
rimCase->results(m_porosityModelEnum)->findOrLoadKnownScalarResult(totalPropName); rimCase->results(m_porosityModelEnum)->ensureKnownResultLoaded(resAddr);
nncData->setEclResultAddress(propertyName, RigEclipseResultAddress(totalPropName)); nncData->setEclResultAddress(propertyName, resAddr);
} }
// Create a list of all the requested time steps // Create a list of all the requested time steps
@ -426,22 +426,19 @@ private:
static bool scalarResultExistsOrCreate(RigCaseCellResultsData* results, QString propertyName) static bool scalarResultExistsOrCreate(RigCaseCellResultsData* results, QString propertyName)
{ {
size_t scalarResultIndex = results->findOrLoadKnownScalarResult(propertyName); RigEclipseResultAddress resAddr(RiaDefines::GENERATED, propertyName);
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
if ( !results->ensureKnownResultLoaded(resAddr) )
{ {
scalarResultIndex = results->findOrCreateScalarResultIndex(RiaDefines::GENERATED, propertyName, true); results->createResultEntry(resAddr, true);
}
if (scalarResultIndex != cvf::UNDEFINED_SIZE_T)
{
std::vector< std::vector<double> >* scalarResultFrames = nullptr;
scalarResultFrames = &(results->cellScalarResults(RigEclipseResultAddress(propertyName)));
size_t timeStepCount = results->maxTimeStepCount();
scalarResultFrames->resize(timeStepCount);
return true;
} }
return false; std::vector< std::vector<double> >* scalarResultFrames = nullptr;
scalarResultFrames = &(results->cellScalarResults(resAddr));
size_t timeStepCount = results->maxTimeStepCount();
scalarResultFrames->resize(timeStepCount);
return true;
} }
public: public:
bool interpretMore(RiaSocketServer* server, QTcpSocket* currentClient) override bool interpretMore(RiaSocketServer* server, QTcpSocket* currentClient) override

53
ApplicationCode/SocketInterface/RiaPropertyDataCommands.cpp
View File

@ -73,18 +73,14 @@ public:
// Find the requested data // Find the requested data
size_t scalarResultIndex = cvf::UNDEFINED_SIZE_T;
std::vector< std::vector<double> >* scalarResultFrames = nullptr; std::vector< std::vector<double> >* scalarResultFrames = nullptr;
if (rimCase && rimCase->results(porosityModelEnum)) if (rimCase && rimCase->results(porosityModelEnum))
{ {
scalarResultIndex = rimCase->results(porosityModelEnum)->findOrLoadKnownScalarResult(propertyName); if (rimCase->results(porosityModelEnum)->ensureKnownResultLoaded(RigEclipseResultAddress(propertyName)))
if (scalarResultIndex != cvf::UNDEFINED_SIZE_T)
{ {
scalarResultFrames = &(rimCase->results(porosityModelEnum)->cellScalarResults(RigEclipseResultAddress(propertyName))); scalarResultFrames = &(rimCase->results(porosityModelEnum)->cellScalarResults(RigEclipseResultAddress(propertyName)));
} }
} }
if (scalarResultFrames == nullptr) if (scalarResultFrames == nullptr)
@ -245,7 +241,7 @@ public:
porosityModelEnum = RiaDefines::FRACTURE_MODEL; porosityModelEnum = RiaDefines::FRACTURE_MODEL;
} }
size_t scalarResultIndex = cvf::UNDEFINED_SIZE_T; bool isResultsLoaded = false;
RigEclipseResultAddress resVarAddr(propertyName); RigEclipseResultAddress resVarAddr(propertyName);
@ -259,11 +255,11 @@ public:
// Find the requested data // Find the requested data
if (rimCase && rimCase->results(porosityModelEnum)) if (rimCase && rimCase->results(porosityModelEnum))
{ {
scalarResultIndex = rimCase->results(porosityModelEnum)->findOrLoadKnownScalarResult(propertyName); isResultsLoaded = rimCase->results(porosityModelEnum)->ensureKnownResultLoaded(resVarAddr);
} }
} }
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T) if (!isResultsLoaded)
{ {
server->errorMessageDialog()->showMessage(RiaSocketServer::tr("ResInsight SocketServer: \n") + RiaSocketServer::tr("Could not find the %1 model property named: \"%2\"").arg(porosityModelName).arg(propertyName)); server->errorMessageDialog()->showMessage(RiaSocketServer::tr("ResInsight SocketServer: \n") + RiaSocketServer::tr("Could not find the %1 model property named: \"%2\"").arg(porosityModelName).arg(propertyName));
@ -414,13 +410,11 @@ public:
if (rimCase && rimCase->results(m_porosityModelEnum)) if (rimCase && rimCase->results(m_porosityModelEnum))
{ {
size_t scalarResultIndex = cvf::UNDEFINED_SIZE_T;
scalarResultIndex = rimCase->results(m_porosityModelEnum)->findOrLoadKnownScalarResult(RiaDefines::GENERATED, propertyName);
RigEclipseResultAddress eclResAddr(RiaDefines::GENERATED, propertyName); RigEclipseResultAddress eclResAddr(RiaDefines::GENERATED, propertyName);
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T) if (!rimCase->results(m_porosityModelEnum)->ensureKnownResultLoaded(eclResAddr))
{ {
scalarResultIndex = rimCase->results(m_porosityModelEnum)->findOrCreateScalarResultIndex(RiaDefines::GENERATED, propertyName, true); rimCase->results(m_porosityModelEnum)->createResultEntry(eclResAddr, true);
RigEclipseResultAddress addrToMaxTimeStepCountResult; RigEclipseResultAddress addrToMaxTimeStepCountResult;
rimCase->results(m_porosityModelEnum)->maxTimeStepCount(&addrToMaxTimeStepCountResult); rimCase->results(m_porosityModelEnum)->maxTimeStepCount(&addrToMaxTimeStepCountResult);
@ -428,15 +422,12 @@ public:
rimCase->results(m_porosityModelEnum)->setTimeStepInfos(eclResAddr, timeStepInfos); rimCase->results(m_porosityModelEnum)->setTimeStepInfos(eclResAddr, timeStepInfos);
} }
if (scalarResultIndex != cvf::UNDEFINED_SIZE_T) scalarResultFrames = &(rimCase->results(m_porosityModelEnum)->cellScalarResults(eclResAddr));
{ size_t timeStepCount = rimCase->results(m_porosityModelEnum)->maxTimeStepCount();
scalarResultFrames = &(rimCase->results(m_porosityModelEnum)->cellScalarResults(eclResAddr)); scalarResultFrames->resize(timeStepCount);
size_t timeStepCount = rimCase->results(m_porosityModelEnum)->maxTimeStepCount();
scalarResultFrames->resize(timeStepCount);
m_currentEclResultAddress = eclResAddr; m_currentEclResultAddress = eclResAddr;
m_currentPropertyName = propertyName; m_currentPropertyName = propertyName;
}
} }
if (scalarResultFrames == nullptr) if (scalarResultFrames == nullptr)
@ -804,27 +795,23 @@ public:
} }
size_t scalarResultIndex = cvf::UNDEFINED_SIZE_T;
std::vector< std::vector<double> >* scalarResultFrames = nullptr; std::vector< std::vector<double> >* scalarResultFrames = nullptr;
if (rimCase && rimCase->results(m_porosityModelEnum)) if (rimCase && rimCase->results(m_porosityModelEnum))
{ {
scalarResultIndex = rimCase->results(m_porosityModelEnum)->findOrLoadKnownScalarResult(RiaDefines::GENERATED, propertyName); RigEclipseResultAddress resAddr(RiaDefines::GENERATED, propertyName);
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T) if ( !rimCase->results(m_porosityModelEnum)->ensureKnownResultLoaded(resAddr))
{ {
scalarResultIndex = rimCase->results(m_porosityModelEnum)->findOrCreateScalarResultIndex(RiaDefines::GENERATED, propertyName, true); rimCase->results(m_porosityModelEnum)->createResultEntry(resAddr, true);
} }
if (scalarResultIndex != cvf::UNDEFINED_SIZE_T) m_currentResultAddress = resAddr;
{ scalarResultFrames = &(rimCase->results(m_porosityModelEnum)->cellScalarResults(m_currentResultAddress));
m_currentResultAddress = RigEclipseResultAddress(RiaDefines::GENERATED, propertyName); size_t timeStepCount = rimCase->results(m_porosityModelEnum)->maxTimeStepCount();
scalarResultFrames = &(rimCase->results(m_porosityModelEnum)->cellScalarResults(m_currentResultAddress)); scalarResultFrames->resize(timeStepCount);
size_t timeStepCount = rimCase->results(m_porosityModelEnum)->maxTimeStepCount();
scalarResultFrames->resize(timeStepCount);
m_currentPropertyName = propertyName; m_currentPropertyName = propertyName;
}
} }
if (scalarResultFrames == nullptr) if (scalarResultFrames == nullptr)
@ -1206,7 +1193,7 @@ public:
if (rimCase && rimCase->results(porosityModel)) if (rimCase && rimCase->results(porosityModel))
{ {
rimCase->results(porosityModel)->findOrLoadKnownScalarResult(propertyName); rimCase->results(porosityModel)->ensureKnownResultLoaded(RigEclipseResultAddress( propertyName) );
} }
std::vector<size_t> requestedTimesteps; std::vector<size_t> requestedTimesteps;

8
ApplicationCode/UserInterface/RiuPvtPlotUpdater.cpp
View File

@ -153,10 +153,10 @@ bool RiuPvtPlotUpdater::queryDataAndUpdatePlot(const RimEclipseView& eclipseView
// The following calls will read results from file in preparation for the queries below // The following calls will read results from file in preparation for the queries below
RigCaseCellResultsData* cellResultsData = eclipseCaseData->results(RiaDefines::MATRIX_MODEL); RigCaseCellResultsData* cellResultsData = eclipseCaseData->results(RiaDefines::MATRIX_MODEL);
cellResultsData->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "RS"); cellResultsData->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "RS"));
cellResultsData->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "RV"); cellResultsData->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "RV"));
cellResultsData->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "PRESSURE"); cellResultsData->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "PRESSURE"));
cellResultsData->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "PVTNUM"); cellResultsData->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "PVTNUM"));
cvf::ref<RigResultAccessor> rsAccessor = RigResultAccessorFactory::createFromNameAndType(eclipseCaseData, gridIndex, RiaDefines::MATRIX_MODEL, timeStepIndex, "RS", RiaDefines::DYNAMIC_NATIVE); cvf::ref<RigResultAccessor> rsAccessor = RigResultAccessorFactory::createFromNameAndType(eclipseCaseData, gridIndex, RiaDefines::MATRIX_MODEL, timeStepIndex, "RS", RiaDefines::DYNAMIC_NATIVE);
cvf::ref<RigResultAccessor> rvAccessor = RigResultAccessorFactory::createFromNameAndType(eclipseCaseData, gridIndex, RiaDefines::MATRIX_MODEL, timeStepIndex, "RV", RiaDefines::DYNAMIC_NATIVE); cvf::ref<RigResultAccessor> rvAccessor = RigResultAccessorFactory::createFromNameAndType(eclipseCaseData, gridIndex, RiaDefines::MATRIX_MODEL, timeStepIndex, "RV", RiaDefines::DYNAMIC_NATIVE);

6
ApplicationCode/UserInterface/RiuRelativePermeabilityPlotUpdater.cpp
View File

@ -150,9 +150,9 @@ bool RiuRelativePermeabilityPlotUpdater::queryDataAndUpdatePlot(const RimEclipse
// Make sure we load the results that we'll query below // Make sure we load the results that we'll query below
RigCaseCellResultsData* cellResultsData = eclipseCaseData->results(RiaDefines::MATRIX_MODEL); RigCaseCellResultsData* cellResultsData = eclipseCaseData->results(RiaDefines::MATRIX_MODEL);
cellResultsData->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "SWAT"); cellResultsData->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SWAT"));
cellResultsData->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "SGAS"); cellResultsData->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SGAS"));
cellResultsData->findOrLoadKnownScalarResult(RiaDefines::STATIC_NATIVE, "SATNUM"); cellResultsData->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::STATIC_NATIVE, "SATNUM"));
// Fetch SWAT and SGAS cell values for the selected cell // Fetch SWAT and SGAS cell values for the selected cell
const size_t timeStepIndex = static_cast<size_t>(eclipseView.currentTimeStep()); const size_t timeStepIndex = static_cast<size_t>(eclipseView.currentTimeStep());

26
ApplicationCode/UserInterface/RiuResultTextBuilder.cpp
View File

@ -470,13 +470,13 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigEclipseCaseData* eclips
RigCaseCellResultsData* gridCellResults = resultColors->currentGridCellResults(); RigCaseCellResultsData* gridCellResults = resultColors->currentGridCellResults();
if (gridCellResults) if (gridCellResults)
{ {
gridCellResults->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "SOIL"); gridCellResults->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SOIL"));
gridCellResults->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "SGAS"); gridCellResults->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SGAS"));
gridCellResults->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "SWAT"); gridCellResults->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SWAT"));
cvf::ref<RigResultAccessor> dataAccessObjectX = RigResultAccessorFactory::createFromResultIdx(eclipseCase, gridIndex, porosityModel, timeStepIndex, RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SOIL")); cvf::ref<RigResultAccessor> dataAccessObjectX = RigResultAccessorFactory::createFromResultAddress(eclipseCase, gridIndex, porosityModel, timeStepIndex, RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SOIL"));
cvf::ref<RigResultAccessor> dataAccessObjectY = RigResultAccessorFactory::createFromResultIdx(eclipseCase, gridIndex, porosityModel, timeStepIndex, RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SGAS")); cvf::ref<RigResultAccessor> dataAccessObjectY = RigResultAccessorFactory::createFromResultAddress(eclipseCase, gridIndex, porosityModel, timeStepIndex, RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SGAS"));
cvf::ref<RigResultAccessor> dataAccessObjectZ = RigResultAccessorFactory::createFromResultIdx(eclipseCase, gridIndex, porosityModel, timeStepIndex, RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SWAT")); cvf::ref<RigResultAccessor> dataAccessObjectZ = RigResultAccessorFactory::createFromResultAddress(eclipseCase, gridIndex, porosityModel, timeStepIndex, RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SWAT"));
double scalarValue = 0.0; double scalarValue = 0.0;
@ -628,7 +628,7 @@ QString RiuResultTextBuilder::cellEdgeResultDetails()
} }
RiaDefines::PorosityModelType porosityModel = m_reservoirView->cellResult()->porosityModel(); RiaDefines::PorosityModelType porosityModel = m_reservoirView->cellResult()->porosityModel();
cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromResultIdx(m_reservoirView->eclipseCase()->eclipseCaseData(), cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromResultAddress(m_reservoirView->eclipseCase()->eclipseCaseData(),
m_gridIndex, m_gridIndex,
porosityModel, porosityModel,
adjustedTimeStep, adjustedTimeStep,
@ -753,15 +753,15 @@ QString RiuResultTextBuilder::cellResultText(RimEclipseCellColors* resultColors)
RigCaseCellResultsData* gridCellResults = m_reservoirView->cellResult()->currentGridCellResults(); RigCaseCellResultsData* gridCellResults = m_reservoirView->cellResult()->currentGridCellResults();
if (gridCellResults) if (gridCellResults)
{ {
gridCellResults->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "SOIL"); gridCellResults->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SOIL"));
gridCellResults->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "SGAS"); gridCellResults->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SGAS"));
gridCellResults->findOrLoadKnownScalarResult(RiaDefines::DYNAMIC_NATIVE, "SWAT"); gridCellResults->ensureKnownResultLoaded(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SWAT"));
RiaDefines::PorosityModelType porosityModel = resultColors->porosityModel(); RiaDefines::PorosityModelType porosityModel = resultColors->porosityModel();
cvf::ref<RigResultAccessor> dataAccessObjectX = RigResultAccessorFactory::createFromResultIdx(eclipseCaseData, m_gridIndex, porosityModel, m_timeStepIndex, RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SOIL")); cvf::ref<RigResultAccessor> dataAccessObjectX = RigResultAccessorFactory::createFromResultAddress(eclipseCaseData, m_gridIndex, porosityModel, m_timeStepIndex, RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SOIL"));
cvf::ref<RigResultAccessor> dataAccessObjectY = RigResultAccessorFactory::createFromResultIdx(eclipseCaseData, m_gridIndex, porosityModel, m_timeStepIndex, RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SGAS")); cvf::ref<RigResultAccessor> dataAccessObjectY = RigResultAccessorFactory::createFromResultAddress(eclipseCaseData, m_gridIndex, porosityModel, m_timeStepIndex, RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SGAS"));
cvf::ref<RigResultAccessor> dataAccessObjectZ = RigResultAccessorFactory::createFromResultIdx(eclipseCaseData, m_gridIndex, porosityModel, m_timeStepIndex, RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SWAT")); cvf::ref<RigResultAccessor> dataAccessObjectZ = RigResultAccessorFactory::createFromResultAddress(eclipseCaseData, m_gridIndex, porosityModel, m_timeStepIndex, RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "SWAT"));
double scalarValue = 0.0; double scalarValue = 0.0;