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

Improve encapsulation of RigEclipseResultInfo

Browse Source 
* To make it more suitable for looking up results.
This commit is contained in:
Gaute Lindkvist 2018-06-19 13:20:15 +02:00
parent 51631fda6e
commit e3e4e79340
6 changed files with 175 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

@ -251,10 +251,10 @@ void RimIdenticalGridCaseGroup::loadMainCaseAndActiveCellInfo()
for (size_t resIdx = 0; resIdx < resultInfos.size(); resIdx++)
{
RiaDefines::ResultCatType resultType = resultInfos[resIdx].m_resultType;
QString resultName = resultInfos[resIdx].m_resultName;
bool needsToBeStored = resultInfos[resIdx].m_needsToBeStored;
bool mustBeCalculated = resultInfos[resIdx].m_mustBeCalculated;
RiaDefines::ResultCatType resultType = resultInfos[resIdx].resultType();
QString resultName = resultInfos[resIdx].resultName();
bool needsToBeStored = resultInfos[resIdx].needsToBeStored();
bool mustBeCalculated = resultInfos[resIdx].mustBeCalculated();
size_t scalarResultIndex = cellResultsStorage->findScalarResultIndex(resultType, resultName);
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)

16
ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp
View File

@ -96,7 +96,7 @@ void RimReservoirCellResultsStorage::setupBeforeSave()
bool hasResultsToStore = false;
for (size_t rIdx = 0; rIdx < resInfo.size(); ++rIdx)
{
if (resInfo[rIdx].m_needsToBeStored)
if (resInfo[rIdx].needsToBeStored())
{
hasResultsToStore = true;
break;
@ -128,18 +128,18 @@ void RimReservoirCellResultsStorage::setupBeforeSave()
{
// If there is no data, we do not store anything for the current result variable
// (Even not the metadata, of cause)
size_t timestepCount = m_cellResults->cellScalarResults(resInfo[rIdx].m_gridScalarResultIndex).size();
size_t timestepCount = m_cellResults->cellScalarResults(resInfo[rIdx].gridScalarResultIndex()).size();
if (timestepCount && resInfo[rIdx].m_needsToBeStored)
if (timestepCount && resInfo[rIdx].needsToBeStored())
{
progInfo.setProgressDescription(resInfo[rIdx].m_resultName);
progInfo.setProgressDescription(resInfo[rIdx].resultName());
// Create and setup the cache information for this result
RimReservoirCellResultsStorageEntryInfo* cacheEntry = new RimReservoirCellResultsStorageEntryInfo;
m_resultCacheMetaData.push_back(cacheEntry);
cacheEntry->m_resultType = resInfo[rIdx].m_resultType;
cacheEntry->m_resultName = resInfo[rIdx].m_resultName;
cacheEntry->m_resultType = resInfo[rIdx].resultType();
cacheEntry->m_resultName = resInfo[rIdx].resultName();
cacheEntry->m_timeStepDates = resInfo[rIdx].dates();
cacheEntry->m_daysSinceSimulationStart = resInfo[rIdx].daysSinceSimulationStarts();
@ -153,7 +153,7 @@ void RimReservoirCellResultsStorage::setupBeforeSave()
const std::vector<double>* data = nullptr;
if (tsIdx < timestepCount)
{
data = &(m_cellResults->cellScalarResults(resInfo[rIdx].m_gridScalarResultIndex, tsIdx));
data = &(m_cellResults->cellScalarResults(resInfo[rIdx].gridScalarResultIndex(), tsIdx));
}
if (data && data->size())
@ -271,7 +271,7 @@ void RimReservoirCellResultsStorage::setCellResults(RigCaseCellResultsData* cell
for (size_t rIdx = 0; rIdx < m_resultCacheMetaData.size(); ++rIdx)
{
RimReservoirCellResultsStorageEntryInfo* resInfo = m_resultCacheMetaData[rIdx];
size_t resultIndex = m_cellResults->findOrCreateScalarResultIndex(resInfo->m_resultType(), resInfo->m_resultName(), true);
size_t resultIndex = m_cellResults->findOrCreateScalarResultIndex(resInfo->m_resultType(), resInfo->m_resultName, true);
std::vector<int> reportNumbers; // Hack: Using no report step numbers. Not really used except for Flow Diagnostics...
reportNumbers.resize(resInfo->m_timeStepDates().size());

69
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@ -238,9 +238,9 @@ size_t RigCaseCellResultsData::findScalarResultIndex(RiaDefines::ResultCatType t
std::vector<RigEclipseResultInfo>::const_iterator it;
for (it = m_resultInfos.begin(); it != m_resultInfos.end(); ++it)
{
if (it->m_resultType == type && it->m_resultName == resultName)
if (it->resultType() == type && it->resultName() == resultName)
{
return it->m_gridScalarResultIndex;
return it->gridScalarResultIndex();
}
}
@ -301,7 +301,7 @@ size_t RigCaseCellResultsData::findOrCreateScalarResultIndex(RiaDefines::ResultC
scalarResultIndex = this->resultCount();
m_cellScalarResults.push_back(std::vector<std::vector<double> >());
RigEclipseResultInfo resInfo(type, needsToBeStored, false, resultName, scalarResultIndex);
RigEclipseResultInfo resInfo(type, resultName, needsToBeStored, false, scalarResultIndex);
m_resultInfos.push_back(resInfo);
// Create statistics calculator and add statistics cache object
@ -409,9 +409,9 @@ QStringList RigCaseCellResultsData::resultNames(RiaDefines::ResultCatType resTyp
std::vector<RigEclipseResultInfo>::const_iterator it;
for (it = m_resultInfos.begin(); it != m_resultInfos.end(); ++it)
{
if (it->m_resultType == resType )
if (it->resultType() == resType )
{
varList.push_back(it->m_resultName);
varList.push_back(it->resultName());
}
}
return varList;
@ -475,8 +475,8 @@ std::vector<QDateTime> RigCaseCellResultsData::allTimeStepDatesFromEclipseReader
//--------------------------------------------------------------------------------------------------
QDateTime RigCaseCellResultsData::timeStepDate(size_t scalarResultIndex, size_t timeStepIndex) const
{
if (scalarResultIndex < m_resultInfos.size() && m_resultInfos[scalarResultIndex].m_timeStepInfos.size() > timeStepIndex)
return m_resultInfos[scalarResultIndex].m_timeStepInfos[timeStepIndex].m_date;
if (scalarResultIndex < m_resultInfos.size() && m_resultInfos[scalarResultIndex].timeStepInfos().size() > timeStepIndex)
return m_resultInfos[scalarResultIndex].timeStepInfos()[timeStepIndex].m_date;
else
return QDateTime();
}
@ -536,8 +536,8 @@ std::vector<double> RigCaseCellResultsData::daysSinceSimulationStart(size_t scal
//--------------------------------------------------------------------------------------------------
int RigCaseCellResultsData::reportStepNumber(size_t scalarResultIndex, size_t timeStepIndex) const
{
if (scalarResultIndex < m_resultInfos.size() && m_resultInfos[scalarResultIndex].m_timeStepInfos.size() > timeStepIndex)
return m_resultInfos[scalarResultIndex].m_timeStepInfos[timeStepIndex].m_reportNumber;
if (scalarResultIndex < m_resultInfos.size() && m_resultInfos[scalarResultIndex].timeStepInfos().size() > timeStepIndex)
return m_resultInfos[scalarResultIndex].timeStepInfos()[timeStepIndex].m_reportNumber;
else
return -1;
}
@ -559,7 +559,7 @@ std::vector<int> RigCaseCellResultsData::reportStepNumbers(size_t scalarResultIn
std::vector<RigEclipseTimeStepInfo> RigCaseCellResultsData::timeStepInfos(size_t scalarResultIndex) const
{
if (scalarResultIndex < m_resultInfos.size())
return m_resultInfos[scalarResultIndex].m_timeStepInfos;
return m_resultInfos[scalarResultIndex].timeStepInfos();
else
return std::vector<RigEclipseTimeStepInfo>();
}
@ -571,7 +571,7 @@ void RigCaseCellResultsData::setTimeStepInfos(size_t scalarResultIndex, const st
{
CVF_ASSERT(scalarResultIndex < m_resultInfos.size() );
m_resultInfos[scalarResultIndex].m_timeStepInfos = timeStepInfos;
m_resultInfos[scalarResultIndex].setTimeStepInfos(timeStepInfos);
std::vector< std::vector<double> >& dataValues = this->cellScalarResults(scalarResultIndex);
dataValues.resize(timeStepInfos.size());
@ -587,9 +587,9 @@ size_t RigCaseCellResultsData::maxTimeStepCount(size_t* scalarResultIndexWithMos
for (size_t i = 0; i < m_resultInfos.size(); i++)
{
if (m_resultInfos[i].m_timeStepInfos.size() > maxTsCount)
if (m_resultInfos[i].timeStepInfos().size() > maxTsCount)
{
maxTsCount = m_resultInfos[i].m_timeStepInfos.size();
maxTsCount = m_resultInfos[i].timeStepInfos().size();
scalarResultIndexWithMaxTsCount = i;
}
}
@ -632,10 +632,19 @@ void RigCaseCellResultsData::clearScalarResult(RiaDefines::ResultCatType type, c
size_t scalarResultIndex = this->findScalarResultIndex(type, resultName);
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T) return;
m_cellScalarResults[scalarResultIndex].clear();
std::vector<std::vector<double>> empty;
m_cellScalarResults[scalarResultIndex].swap(empty);
recalculateStatistics(scalarResultIndex);
//m_resultInfos[scalarResultIndex].m_resultType = RiaDefines::REMOVED;
//m_resultInfos[scalarResultIndex].type() = RiaDefines::REMOVED;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseCellResultsData::clearScalarResult(const RigEclipseResultInfo& resultInfo)
{
clearScalarResult(resultInfo.resultType(), resultInfo.resultName());
}
//--------------------------------------------------------------------------------------------------
@ -688,10 +697,10 @@ bool RigCaseCellResultsData::updateResultName(RiaDefines::ResultCatType resultTy
for (auto& it : m_resultInfos)
{
if (it.m_resultType == resultType && it.m_resultName == oldName)
if (it.resultType() == resultType && it.resultName() == oldName)
{
anyNameUpdated = true;
it.m_resultName = newName;
it.setResultName(newName);
}
}
@ -742,9 +751,9 @@ bool RigCaseCellResultsData::mustBeCalculated(size_t scalarResultIndex) const
std::vector<RigEclipseResultInfo>::const_iterator it;
for (it = m_resultInfos.begin(); it != m_resultInfos.end(); ++it)
{
if (it->m_gridScalarResultIndex == scalarResultIndex)
if (it->gridScalarResultIndex() == scalarResultIndex)
{
return it->m_mustBeCalculated;
return it->mustBeCalculated();
}
}
@ -759,9 +768,9 @@ void RigCaseCellResultsData::setMustBeCalculated(size_t scalarResultIndex)
std::vector<RigEclipseResultInfo>::iterator it;
for (it = m_resultInfos.begin(); it != m_resultInfos.end(); ++it)
{
if (it->m_gridScalarResultIndex == scalarResultIndex)
if (it->gridScalarResultIndex() == scalarResultIndex)
{
it->m_mustBeCalculated = true;
it->setMustBeCalculated(true);
}
}
}
@ -774,9 +783,9 @@ void RigCaseCellResultsData::eraseAllSourSimData()
for (size_t i = 0; i < m_resultInfos.size(); i++)
{
RigEclipseResultInfo& ri = m_resultInfos[i];
if (ri.m_resultType == RiaDefines::SOURSIMRL)
if (ri.resultType() == RiaDefines::SOURSIMRL)
{
ri.m_resultType = RiaDefines::REMOVED;
ri.setResultType(RiaDefines::REMOVED);
}
}
}
@ -1102,7 +1111,7 @@ size_t RigCaseCellResultsData::findOrLoadScalarResult(RiaDefines::ResultCatType
if (m_readerInterface.notNull())
{
// Add one more result to result container
size_t timeStepCount = this->infoForEachResultIndex()[scalarResultIndex].m_timeStepInfos.size();
size_t timeStepCount = this->infoForEachResultIndex()[scalarResultIndex].timeStepInfos().size();
bool resultLoadingSucess = true;
@ -1145,7 +1154,7 @@ size_t RigCaseCellResultsData::findOrLoadScalarResult(RiaDefines::ResultCatType
RifReaderEclipseOutput* eclReader = dynamic_cast<RifReaderEclipseOutput*>(m_readerInterface.p());
if (eclReader)
{
size_t timeStepCount = this->infoForEachResultIndex()[scalarResultIndex].m_timeStepInfos.size();
size_t timeStepCount = this->infoForEachResultIndex()[scalarResultIndex].timeStepInfos().size();
this->cellScalarResults(scalarResultIndex).resize(timeStepCount);
@ -1202,7 +1211,7 @@ size_t RigCaseCellResultsData::findOrLoadScalarResultForTimeStep(RiaDefines::Res
if (m_readerInterface.notNull())
{
size_t timeStepCount = this->infoForEachResultIndex()[scalarResultIndex].m_timeStepInfos.size();
size_t timeStepCount = this->infoForEachResultIndex()[scalarResultIndex].timeStepInfos().size();
bool resultLoadingSucess = true;
@ -1244,7 +1253,7 @@ size_t RigCaseCellResultsData::findOrLoadScalarResultForTimeStep(RiaDefines::Res
RifReaderEclipseOutput* eclReader = dynamic_cast<RifReaderEclipseOutput*>(m_readerInterface.p());
if (eclReader)
{
size_t timeStepCount = this->infoForEachResultIndex()[scalarResultIndex].m_timeStepInfos.size();
size_t timeStepCount = this->infoForEachResultIndex()[scalarResultIndex].timeStepInfos().size();
this->cellScalarResults(scalarResultIndex).resize(timeStepCount);
@ -1289,7 +1298,7 @@ void RigCaseCellResultsData::computeSOILForTimeStep(size_t timeStepIndex)
if (swatForTimeStep.size() > 0)
{
soilResultValueCount = swatForTimeStep.size();
soilTimeStepCount = this->infoForEachResultIndex()[scalarIndexSWAT].m_timeStepInfos.size();
soilTimeStepCount = this->infoForEachResultIndex()[scalarIndexSWAT].timeStepInfos().size();
}
}
@ -1300,7 +1309,7 @@ void RigCaseCellResultsData::computeSOILForTimeStep(size_t timeStepIndex)
{
soilResultValueCount = qMax(soilResultValueCount, sgasForTimeStep.size());
size_t sgasTimeStepCount = this->infoForEachResultIndex()[scalarIndexSGAS].m_timeStepInfos.size();
size_t sgasTimeStepCount = this->infoForEachResultIndex()[scalarIndexSGAS].timeStepInfos().size();
soilTimeStepCount = qMax(soilTimeStepCount, sgasTimeStepCount);
}
}
@ -1409,7 +1418,7 @@ void RigCaseCellResultsData::testAndComputeSgasForTimeStep(size_t timeStepIndex)
if (swatForTimeStep.size() > 0)
{
swatResultValueCount = swatForTimeStep.size();
swatTimeStepCount = this->infoForEachResultIndex()[scalarIndexSWAT].m_timeStepInfos.size();
swatTimeStepCount = this->infoForEachResultIndex()[scalarIndexSWAT].timeStepInfos().size();
}
}

1
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.h
View File

@ -107,6 +107,7 @@ public:
void computeDepthRelatedResults();
void clearScalarResult(RiaDefines::ResultCatType type, const QString & resultName);
void clearScalarResult(const RigEclipseResultInfo& resultInfo);
void clearAllResults();
void freeAllocatedResultsData();

104
ApplicationCode/ReservoirDataModel/RigEclipseResultInfo.cpp
View File

@ -53,9 +53,8 @@ std::vector<RigEclipseTimeStepInfo> RigEclipseTimeStepInfo::createTimeStepInfos(
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigEclipseResultInfo::RigEclipseResultInfo(RiaDefines::ResultCatType resultType, bool needsToBeStored, bool mustBeCalculated,
QString resultName, size_t gridScalarResultIndex)
: m_resultType(resultType),
RigEclipseResultInfo::RigEclipseResultInfo(RiaDefines::ResultCatType resultType,
QString resultName, bool needsToBeStored, bool mustBeCalculated, size_t gridScalarResultIndex) : m_resultType(resultType),
m_needsToBeStored(needsToBeStored),
m_mustBeCalculated(mustBeCalculated),
m_resultName(resultName),
@ -63,6 +62,104 @@ RigEclipseResultInfo::RigEclipseResultInfo(RiaDefines::ResultCatType resultType,
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaDefines::ResultCatType RigEclipseResultInfo::resultType() const
{
return m_resultType;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseResultInfo::setResultType(RiaDefines::ResultCatType newType)
{
m_resultType = newType;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const QString& RigEclipseResultInfo::resultName() const
{
return m_resultName;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseResultInfo::setResultName(const QString& name)
{
m_resultName = name;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigEclipseResultInfo::needsToBeStored() const
{
return m_needsToBeStored;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseResultInfo::setNeedsToBeStored(bool store)
{
m_needsToBeStored = store;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigEclipseResultInfo::mustBeCalculated() const
{
return m_mustBeCalculated;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseResultInfo::setMustBeCalculated(bool mustCalculate)
{
m_mustBeCalculated = mustCalculate;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigEclipseResultInfo::gridScalarResultIndex() const
{
return m_gridScalarResultIndex;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseResultInfo::setGridScalarResultIndex(size_t index)
{
m_gridScalarResultIndex = index;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<RigEclipseTimeStepInfo>& RigEclipseResultInfo::timeStepInfos() const
{
return m_timeStepInfos;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseResultInfo::setTimeStepInfos(const std::vector<RigEclipseTimeStepInfo>& timeSteps)
{
m_timeStepInfos = timeSteps;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -107,4 +204,3 @@ std::vector<int> RigEclipseResultInfo::reportNumbers() const
return values;
}

29
ApplicationCode/ReservoirDataModel/RigEclipseResultInfo.h
View File

@ -49,14 +49,31 @@ public:
class RigEclipseResultInfo
{
public:
RigEclipseResultInfo(RiaDefines::ResultCatType resultType, bool needsToBeStored, bool mustBeCalculated,
QString resultName, size_t gridScalarResultIndex);
RigEclipseResultInfo(RiaDefines::ResultCatType resultType,
QString resultName,
bool needsToBeStored = false,
bool mustBeCalculated = false,
size_t gridScalarResultIndex = 0u);
std::vector<QDateTime> dates() const;
std::vector<double> daysSinceSimulationStarts() const;
std::vector<int> reportNumbers() const;
RiaDefines::ResultCatType resultType() const;
void setResultType(RiaDefines::ResultCatType newType);
const QString& resultName() const;
void setResultName(const QString& name);
bool needsToBeStored() const;
void setNeedsToBeStored(bool store);
bool mustBeCalculated() const;
void setMustBeCalculated(bool mustCalculate);
size_t gridScalarResultIndex() const;
void setGridScalarResultIndex(size_t index);
const std::vector<RigEclipseTimeStepInfo>& timeStepInfos() const;
void setTimeStepInfos(const std::vector<RigEclipseTimeStepInfo>& timeSteps);
public:
std::vector<QDateTime> dates() const;
std::vector<double> daysSinceSimulationStarts() const;
std::vector<int> reportNumbers() const;
private:
RiaDefines::ResultCatType m_resultType;
bool m_needsToBeStored;
bool m_mustBeCalculated;