mirror of
https://github.com/OPM/ResInsight.git
synced 2025-01-27 00:36:53 -06:00
640 lines
24 KiB
C++
640 lines
24 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) Statoil ASA
|
|
//
|
|
// ResInsight is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
// FITNESS FOR A PARTICULAR PURPOSE.
|
|
//
|
|
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
|
|
// for more details.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "RifReaderEclipseSummary.h"
|
|
#include "RiaFilePathTools.h"
|
|
#include "RiaStringEncodingTools.h"
|
|
#include "RifEclipseSummaryTools.h"
|
|
#include "RifReaderEclipseOutput.h"
|
|
|
|
#include <cassert>
|
|
#include <string>
|
|
|
|
#include <QDateTime>
|
|
#include <QDir>
|
|
#include <QString>
|
|
#include <QStringList>
|
|
|
|
#include "ert/ecl/ecl_file.h"
|
|
#include "ert/ecl/ecl_kw.h"
|
|
#include "ert/ecl/ecl_kw_magic.h"
|
|
#include "ert/ecl/ecl_sum.h"
|
|
#include "ert/ecl/smspec_node.hpp"
|
|
|
|
std::vector<time_t> getTimeSteps(ecl_sum_type* ecl_sum)
|
|
{
|
|
std::vector<time_t> timeSteps;
|
|
|
|
if (ecl_sum)
|
|
{
|
|
time_t_vector_type* steps = ecl_sum_alloc_time_vector(ecl_sum, false);
|
|
|
|
if (steps)
|
|
{
|
|
for (int i = 0; i < time_t_vector_size(steps); i++)
|
|
{
|
|
timeSteps.push_back(time_t_vector_iget(steps, i));
|
|
}
|
|
|
|
time_t_vector_free(steps);
|
|
}
|
|
}
|
|
return timeSteps;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
ecl_sum_type* openEclSum(const QString& inHeaderFileName, bool includeRestartFiles)
|
|
{
|
|
QString headerFileName;
|
|
QStringList dataFileNames;
|
|
QString nativeHeaderFileName = QDir::toNativeSeparators(inHeaderFileName);
|
|
RifEclipseSummaryTools::findSummaryFiles(nativeHeaderFileName, &headerFileName, &dataFileNames);
|
|
|
|
if (headerFileName.isEmpty() || dataFileNames.size() == 0) return nullptr;
|
|
|
|
assert(!headerFileName.isEmpty());
|
|
assert(dataFileNames.size() > 0);
|
|
|
|
stringlist_type* dataFiles = stringlist_alloc_new();
|
|
for (int i = 0; i < dataFileNames.size(); i++)
|
|
{
|
|
stringlist_append_copy(dataFiles, RiaStringEncodingTools::toNativeEncoded(dataFileNames[i]).data());
|
|
}
|
|
|
|
bool lazyLoad = true;
|
|
std::string itemSeparatorInVariableNames = ":";
|
|
ecl_sum_type* ecl_sum = ecl_sum_fread_alloc(RiaStringEncodingTools::toNativeEncoded(headerFileName).data(),
|
|
dataFiles,
|
|
itemSeparatorInVariableNames.data(),
|
|
includeRestartFiles,
|
|
lazyLoad,
|
|
ECL_FILE_CLOSE_STREAM);
|
|
|
|
stringlist_free(dataFiles);
|
|
|
|
return ecl_sum;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void closeEclSum(ecl_sum_type* ecl_sum)
|
|
{
|
|
if (ecl_sum) ecl_sum_free(ecl_sum);
|
|
}
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RifReaderEclipseSummary::RifReaderEclipseSummary()
|
|
: m_ecl_sum(nullptr)
|
|
, m_ecl_SmSpec(nullptr)
|
|
{
|
|
m_valuesCache.reset(new ValuesCache());
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RifReaderEclipseSummary::~RifReaderEclipseSummary()
|
|
{
|
|
if (m_ecl_sum)
|
|
{
|
|
ecl_sum_free(m_ecl_sum);
|
|
m_ecl_sum = nullptr;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RifReaderEclipseSummary::open(const QString& headerFileName, bool includeRestartFiles)
|
|
{
|
|
assert(m_ecl_sum == nullptr);
|
|
|
|
m_ecl_sum = openEclSum(headerFileName, includeRestartFiles);
|
|
|
|
if (m_ecl_sum)
|
|
{
|
|
m_timeSteps.clear();
|
|
m_ecl_SmSpec = ecl_sum_get_smspec(m_ecl_sum);
|
|
m_timeSteps = getTimeSteps(m_ecl_sum);
|
|
|
|
buildMetaData();
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RifRestartFileInfo> RifReaderEclipseSummary::getRestartFiles(const QString& headerFileName, bool* hasWarnings)
|
|
{
|
|
CVF_ASSERT(hasWarnings);
|
|
|
|
std::vector<RifRestartFileInfo> restartFiles;
|
|
m_warnings.clear();
|
|
*hasWarnings = false;
|
|
|
|
RifRestartFileInfo currFile;
|
|
currFile.fileName = headerFileName;
|
|
while (!currFile.fileName.isEmpty())
|
|
{
|
|
// Due to a weakness in libecl regarding restart summary header file selection,
|
|
// do some extra checking
|
|
{
|
|
QString formattedHeaderExtension = ".FSMSPEC";
|
|
QString nonformattedHeaderExtension = ".SMSPEC";
|
|
QString formattedDataFileExtension = ".FUNSMRY";
|
|
|
|
if (currFile.fileName.endsWith(nonformattedHeaderExtension, Qt::CaseInsensitive))
|
|
{
|
|
QString formattedHeaderFile = currFile.fileName;
|
|
formattedHeaderFile.replace(nonformattedHeaderExtension, formattedHeaderExtension, Qt::CaseInsensitive);
|
|
QString formattedDateFile = currFile.fileName;
|
|
formattedDateFile.replace(nonformattedHeaderExtension, formattedDataFileExtension, Qt::CaseInsensitive);
|
|
|
|
QFileInfo nonformattedHeaderFileInfo = QFileInfo(currFile.fileName);
|
|
QFileInfo formattedHeaderFileInfo = QFileInfo(formattedHeaderFile);
|
|
QFileInfo formattedDateFileInfo = QFileInfo(formattedDateFile);
|
|
if (formattedHeaderFileInfo.lastModified() < nonformattedHeaderFileInfo.lastModified() &&
|
|
formattedHeaderFileInfo.exists() && !formattedDateFileInfo.exists())
|
|
{
|
|
m_warnings.push_back(QString("RifReaderEclipseSummary: Formatted summary header file without an\n") +
|
|
QString("associated data file detected.\n") +
|
|
QString("This may cause a failure reading summary origin data.\n") +
|
|
QString("To avoid this problem, please delete or rename the.FSMSPEC file."));
|
|
*hasWarnings = true;
|
|
break;
|
|
}
|
|
}
|
|
QString prevFile = currFile.fileName;
|
|
currFile = getRestartFile(currFile.fileName);
|
|
|
|
// Fix to stop potential infinite loop
|
|
if (currFile.fileName == prevFile)
|
|
{
|
|
m_warnings.push_back("RifReaderEclipseSummary: Restart file reference loop detected");
|
|
*hasWarnings = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!currFile.fileName.isEmpty()) restartFiles.push_back(currFile);
|
|
}
|
|
return restartFiles;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RifRestartFileInfo RifReaderEclipseSummary::getFileInfo(const QString& headerFileName)
|
|
{
|
|
RifRestartFileInfo fileInfo;
|
|
ecl_sum_type* ecl_sum = openEclSum(headerFileName, false);
|
|
std::vector<time_t> timeSteps = getTimeSteps(ecl_sum);
|
|
if (timeSteps.size() > 0)
|
|
{
|
|
fileInfo.fileName = headerFileName;
|
|
fileInfo.startDate = timeSteps.front();
|
|
fileInfo.endDate = timeSteps.back();
|
|
}
|
|
closeEclSum(ecl_sum);
|
|
return fileInfo;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::string stringFromPointer(const char* pointerToChar)
|
|
{
|
|
std::string myString;
|
|
|
|
// NB! Assigning a null pointer to a std::string causes runtime crash
|
|
if (pointerToChar)
|
|
{
|
|
myString = pointerToChar;
|
|
}
|
|
|
|
return myString;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::string wellNameFromNode(const ecl::smspec_node* ertSumVarNode)
|
|
{
|
|
return stringFromPointer(smspec_node_get_wgname(ertSumVarNode));
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::string lgrNameFromNode(const ecl::smspec_node* ertSumVarNode)
|
|
{
|
|
return stringFromPointer(smspec_node_get_lgr_name(ertSumVarNode));
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RifEclipseSummaryAddress addressFromErtSmSpecNode(const ecl::smspec_node& ertSumVarNode)
|
|
{
|
|
if (ertSumVarNode.get_var_type() == ECL_SMSPEC_INVALID_VAR)
|
|
{
|
|
return RifEclipseSummaryAddress();
|
|
}
|
|
|
|
RifEclipseSummaryAddress::SummaryVarCategory sumCategory(RifEclipseSummaryAddress::SUMMARY_INVALID);
|
|
std::string quantityName;
|
|
int regionNumber(-1);
|
|
int regionNumber2(-1);
|
|
std::string wellGroupName;
|
|
std::string wellName;
|
|
int wellSegmentNumber(-1);
|
|
std::string lgrName;
|
|
int cellI(-1);
|
|
int cellJ(-1);
|
|
int cellK(-1);
|
|
int aquiferNumber(-1);
|
|
bool isErrorResult(false);
|
|
|
|
quantityName = stringFromPointer(ertSumVarNode.get_keyword());
|
|
|
|
switch (ertSumVarNode.get_var_type())
|
|
{
|
|
case ECL_SMSPEC_AQUIFER_VAR: {
|
|
sumCategory = RifEclipseSummaryAddress::SUMMARY_AQUIFER;
|
|
aquiferNumber = ertSumVarNode.get_num();
|
|
}
|
|
break;
|
|
case ECL_SMSPEC_WELL_VAR: {
|
|
sumCategory = RifEclipseSummaryAddress::SUMMARY_WELL;
|
|
wellName = stringFromPointer(ertSumVarNode.get_wgname());
|
|
}
|
|
break;
|
|
case ECL_SMSPEC_REGION_VAR: {
|
|
sumCategory = RifEclipseSummaryAddress::SUMMARY_REGION;
|
|
regionNumber = ertSumVarNode.get_num();
|
|
}
|
|
break;
|
|
case ECL_SMSPEC_FIELD_VAR: {
|
|
sumCategory = RifEclipseSummaryAddress::SUMMARY_FIELD;
|
|
}
|
|
break;
|
|
case ECL_SMSPEC_GROUP_VAR: {
|
|
sumCategory = RifEclipseSummaryAddress::SUMMARY_WELL_GROUP;
|
|
wellGroupName = stringFromPointer(ertSumVarNode.get_wgname());
|
|
}
|
|
break;
|
|
case ECL_SMSPEC_BLOCK_VAR: {
|
|
sumCategory = RifEclipseSummaryAddress::SUMMARY_BLOCK;
|
|
|
|
auto ijk = ertSumVarNode.get_ijk();
|
|
cellI = ijk[0];
|
|
cellJ = ijk[1];
|
|
cellK = ijk[2];
|
|
}
|
|
break;
|
|
case ECL_SMSPEC_COMPLETION_VAR: {
|
|
sumCategory = RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION;
|
|
wellName = stringFromPointer(ertSumVarNode.get_wgname());
|
|
|
|
auto ijk = ertSumVarNode.get_ijk();
|
|
cellI = ijk[0];
|
|
cellJ = ijk[1];
|
|
cellK = ijk[2];
|
|
}
|
|
break;
|
|
case ECL_SMSPEC_LOCAL_BLOCK_VAR: {
|
|
sumCategory = RifEclipseSummaryAddress::SUMMARY_BLOCK_LGR;
|
|
lgrName = stringFromPointer(ertSumVarNode.get_lgr_name());
|
|
|
|
auto ijk = ertSumVarNode.get_lgr_ijk();
|
|
cellI = ijk[0];
|
|
cellJ = ijk[1];
|
|
cellK = ijk[2];
|
|
}
|
|
break;
|
|
case ECL_SMSPEC_LOCAL_COMPLETION_VAR: {
|
|
sumCategory = RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION_LGR;
|
|
wellName = stringFromPointer(ertSumVarNode.get_wgname());
|
|
lgrName = stringFromPointer(ertSumVarNode.get_lgr_name());
|
|
|
|
auto ijk = ertSumVarNode.get_lgr_ijk();
|
|
cellI = ijk[0];
|
|
cellJ = ijk[1];
|
|
cellK = ijk[2];
|
|
}
|
|
break;
|
|
case ECL_SMSPEC_LOCAL_WELL_VAR: {
|
|
sumCategory = RifEclipseSummaryAddress::SUMMARY_WELL_LGR;
|
|
wellName = stringFromPointer(ertSumVarNode.get_wgname());
|
|
lgrName = stringFromPointer(ertSumVarNode.get_lgr_name());
|
|
}
|
|
break;
|
|
case ECL_SMSPEC_NETWORK_VAR: {
|
|
sumCategory = RifEclipseSummaryAddress::SUMMARY_NETWORK;
|
|
}
|
|
break;
|
|
case ECL_SMSPEC_REGION_2_REGION_VAR: {
|
|
sumCategory = RifEclipseSummaryAddress::SUMMARY_REGION_2_REGION;
|
|
regionNumber = ertSumVarNode.get_R1();
|
|
regionNumber2 = ertSumVarNode.get_R2();
|
|
}
|
|
break;
|
|
case ECL_SMSPEC_SEGMENT_VAR: {
|
|
sumCategory = RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT;
|
|
wellName = stringFromPointer(ertSumVarNode.get_wgname());
|
|
wellSegmentNumber = ertSumVarNode.get_num();
|
|
}
|
|
break;
|
|
case ECL_SMSPEC_MISC_VAR: {
|
|
sumCategory = RifEclipseSummaryAddress::SUMMARY_MISC;
|
|
}
|
|
break;
|
|
default:
|
|
CVF_ASSERT(false);
|
|
break;
|
|
}
|
|
|
|
return RifEclipseSummaryAddress(sumCategory,
|
|
quantityName,
|
|
regionNumber,
|
|
regionNumber2,
|
|
wellGroupName,
|
|
wellName,
|
|
wellSegmentNumber,
|
|
lgrName,
|
|
cellI,
|
|
cellJ,
|
|
cellK,
|
|
aquiferNumber,
|
|
isErrorResult);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RifReaderEclipseSummary::values(const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values) const
|
|
{
|
|
assert(m_ecl_sum != nullptr);
|
|
|
|
int variableIndex = indexFromAddress(resultAddress);
|
|
|
|
if (variableIndex < 0) return false;
|
|
|
|
values->clear();
|
|
values->reserve(timeStepCount());
|
|
|
|
const std::vector<double>& cachedValues = m_valuesCache->getValues(resultAddress);
|
|
if (!cachedValues.empty())
|
|
{
|
|
values->insert(values->begin(), cachedValues.begin(), cachedValues.end());
|
|
}
|
|
else if (m_ecl_SmSpec)
|
|
{
|
|
const ecl::smspec_node& ertSumVarNode = ecl_smspec_iget_node_w_node_index(m_ecl_SmSpec, variableIndex);
|
|
int paramsIndex = ertSumVarNode.get_params_index();
|
|
|
|
double_vector_type* dataValues = ecl_sum_alloc_data_vector(m_ecl_sum, paramsIndex, false);
|
|
|
|
if (dataValues)
|
|
{
|
|
int dataSize = double_vector_size(dataValues);
|
|
const double* dataPtr = double_vector_get_const_ptr(dataValues);
|
|
values->insert(values->end(), dataPtr, dataPtr + dataSize);
|
|
double_vector_free(dataValues);
|
|
|
|
m_valuesCache->insertValues(resultAddress, *values);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
int RifReaderEclipseSummary::timeStepCount() const
|
|
{
|
|
assert(m_ecl_sum != nullptr);
|
|
|
|
if (m_ecl_SmSpec == nullptr) return 0;
|
|
|
|
return ecl_sum_get_data_length(m_ecl_sum);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
const std::vector<time_t>& RifReaderEclipseSummary::timeSteps(const RifEclipseSummaryAddress& resultAddress) const
|
|
{
|
|
assert(m_ecl_sum != nullptr);
|
|
|
|
return m_timeSteps;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
int RifReaderEclipseSummary::indexFromAddress(const RifEclipseSummaryAddress& resultAddress) const
|
|
{
|
|
auto it = m_resultAddressToErtNodeIdx.find(resultAddress);
|
|
if (it != m_resultAddressToErtNodeIdx.end())
|
|
{
|
|
return it->second;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RifReaderEclipseSummary::buildMetaData()
|
|
{
|
|
m_allResultAddresses.clear();
|
|
m_resultAddressToErtNodeIdx.clear();
|
|
|
|
if (m_ecl_SmSpec)
|
|
{
|
|
int varCount = ecl_smspec_num_nodes(m_ecl_SmSpec);
|
|
for (int i = 0; i < varCount; i++)
|
|
{
|
|
const ecl::smspec_node& ertSumVarNode = ecl_smspec_iget_node_w_node_index(m_ecl_SmSpec, i);
|
|
RifEclipseSummaryAddress addr = addressFromErtSmSpecNode(ertSumVarNode);
|
|
m_allResultAddresses.insert(addr);
|
|
m_resultAddressToErtNodeIdx[addr] = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RifRestartFileInfo RifReaderEclipseSummary::getRestartFile(const QString& headerFileName)
|
|
{
|
|
ecl_sum_type* ecl_sum = openEclSum(headerFileName, true);
|
|
|
|
const ecl_smspec_type* smspec = ecl_sum ? ecl_sum_get_smspec(ecl_sum) : nullptr;
|
|
const char* rstCase = smspec ? ecl_smspec_get_restart_case(smspec) : nullptr;
|
|
QString restartCase = rstCase ? RiaFilePathTools::canonicalPath(RiaStringEncodingTools::fromNativeEncoded(rstCase)) : "";
|
|
closeEclSum(ecl_sum);
|
|
|
|
if (!restartCase.isEmpty())
|
|
{
|
|
QString path = QFileInfo(restartCase).dir().path();
|
|
QString restartBase = QDir(restartCase).dirName();
|
|
|
|
char* smspec_header = ecl_util_alloc_exfilename(
|
|
path.toStdString().data(), restartBase.toStdString().data(), ECL_SUMMARY_HEADER_FILE, false /*unformatted*/, 0);
|
|
QString restartFileName = RiaFilePathTools::toInternalSeparator(RiaStringEncodingTools::fromNativeEncoded(smspec_header));
|
|
free(smspec_header);
|
|
|
|
return getFileInfo(restartFileName);
|
|
}
|
|
return RifRestartFileInfo();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::string RifReaderEclipseSummary::unitName(const RifEclipseSummaryAddress& resultAddress) const
|
|
{
|
|
if (!m_ecl_SmSpec) return "";
|
|
|
|
int variableIndex = indexFromAddress(resultAddress);
|
|
|
|
if (variableIndex < 0) return "";
|
|
|
|
const ecl::smspec_node& ertSumVarNode = ecl_smspec_iget_node_w_node_index(m_ecl_SmSpec, variableIndex);
|
|
return ertSumVarNode.get_unit();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RifReaderEclipseSummary::markForCachePurge(const RifEclipseSummaryAddress& address)
|
|
{
|
|
m_valuesCache->markAddressForPurge(address);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RifReaderEclipseSummary::purgeCache()
|
|
{
|
|
ValuesCache::purge();
|
|
}
|
|
|
|
#if 0
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RifReaderEclipseSummary::populateVectorFromStringList(stringlist_type* stringList, std::vector<std::string>* strings)
|
|
{
|
|
assert(stringList && strings);
|
|
|
|
for (int i = 0; i < stringlist_get_size(stringList); i++)
|
|
{
|
|
strings->push_back(stringlist_iget(stringList, i));
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
const std::vector<double> RifReaderEclipseSummary::ValuesCache::EMPTY_VECTOR;
|
|
std::set<RifReaderEclipseSummary::ValuesCache*> RifReaderEclipseSummary::ValuesCache::m_instances;
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RifReaderEclipseSummary::ValuesCache::ValuesCache()
|
|
{
|
|
// Register instance
|
|
m_instances.insert(this);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RifReaderEclipseSummary::ValuesCache::~ValuesCache()
|
|
{
|
|
// Deregister instance
|
|
m_instances.erase(this);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RifReaderEclipseSummary::ValuesCache::insertValues(const RifEclipseSummaryAddress& address,
|
|
const std::vector<double>& values)
|
|
{
|
|
m_cachedValues[address] = values;
|
|
m_purgeList.erase(address);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
const std::vector<double>& RifReaderEclipseSummary::ValuesCache::getValues(const RifEclipseSummaryAddress& address) const
|
|
{
|
|
if (m_cachedValues.find(address) != m_cachedValues.end())
|
|
{
|
|
return m_cachedValues.at(address);
|
|
}
|
|
return EMPTY_VECTOR;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RifReaderEclipseSummary::ValuesCache::markAddressForPurge(const RifEclipseSummaryAddress& address)
|
|
{
|
|
m_purgeList.insert(address);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RifReaderEclipseSummary::ValuesCache::purge()
|
|
{
|
|
for (auto instance : m_instances)
|
|
instance->purgeData();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RifReaderEclipseSummary::ValuesCache::purgeData()
|
|
{
|
|
for (const auto purgeAddr : m_purgeList)
|
|
{
|
|
m_cachedValues.erase(purgeAddr);
|
|
}
|
|
m_purgeList.clear();
|
|
}
|