mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-25 18:55:39 -06:00
Rewrite of file acces helper class
RifEcliseOutputFileTools is now a class with only static functions Moved some application logic from file readers to RifEcliseOutput Added more tests for extracting metainfo related to results p4#: 20368
This commit is contained in:
Magne Sjaastad
parent
77b43847c7
commit
cf5aa3e882
@ -101,7 +101,6 @@ TEST(RigReservoirTest, WellTestErt)
|
||||
|
||||
well_info_free( well_info );
|
||||
}
|
||||
#endif
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// This file contains test code taken from the test cases in ERT source code.
|
||||
// There is a typedef issue (center) between ERT and QTextStream, so this file does not include any
|
||||
@ -117,3 +116,4 @@ TEST(RigReservoirTest, ElipseInputGridFile)
|
||||
EXPECT_EQ(size_t(1), res.mainGrid()->globalMatrixModelActiveCellCount());
|
||||
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -24,6 +24,121 @@
|
||||
#include "RigReservoir.h"
|
||||
|
||||
#include "RifReaderEclipseOutput.h"
|
||||
#include "ecl_file.h"
|
||||
#include "RifEclipseOutputFileTools.h"
|
||||
#include "RigReservoirCellResults.h"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#if 0
|
||||
|
||||
|
||||
TEST(RigReservoirTest, FileOutputToolsTest)
|
||||
{
|
||||
cvf::ref<RifReaderEclipseOutput> readerInterfaceEcl = new RifReaderEclipseOutput;
|
||||
cvf::ref<RigReservoir> reservoir = new RigReservoir;
|
||||
|
||||
// QString filename("d:/Models/Statoil/testcase_juli_2011/data/TEST10K_FLT_LGR_NNC.EGRID");
|
||||
QString filename("d:/Models/Statoil/testcase_juli_2011/data/TEST10K_FLT_LGR_NNC.UNRST");
|
||||
|
||||
ecl_file_type* ertFile = ecl_file_open(filename.toAscii().data());
|
||||
EXPECT_TRUE(ertFile);
|
||||
|
||||
|
||||
QStringList keywords;
|
||||
std::vector<size_t> keywordDataItemCounts;
|
||||
RifEclipseOutputFileTools::findKeywordsAndDataItemCounts(ertFile, &keywords, &keywordDataItemCounts);
|
||||
|
||||
EXPECT_TRUE(keywords.size() == keywordDataItemCounts.size());
|
||||
|
||||
|
||||
qDebug() << "Keyword - Number of data items";
|
||||
for (int i = 0; i < keywords.size(); i++)
|
||||
{
|
||||
QString paddedKeyword = QString("%1").arg(keywords[i], 8);
|
||||
qDebug() << paddedKeyword << " - " << keywordDataItemCounts[i];
|
||||
}
|
||||
|
||||
ecl_file_close(ertFile);
|
||||
ertFile = NULL;
|
||||
}
|
||||
|
||||
|
||||
void buildResultInfoString(RigReservoir* reservoir, RifReaderInterface::PorosityModelResultType porosityModel, RimDefines::ResultCatType resultType)
|
||||
{
|
||||
RigReservoirCellResults* matrixResults = reservoir->mainGrid()->results(porosityModel);
|
||||
{
|
||||
QStringList resultNames = matrixResults->resultNames(resultType);
|
||||
|
||||
for (size_t i = 0 ; i < resultNames.size(); i++)
|
||||
{
|
||||
std::vector<double> values;
|
||||
size_t scalarResultIndex = matrixResults->findOrLoadScalarResult(resultType, resultNames[i]);
|
||||
EXPECT_TRUE(scalarResultIndex != cvf::UNDEFINED_SIZE_T);
|
||||
|
||||
QString resultText = QString("%1").arg(resultNames[i], 8);
|
||||
std::vector< std::vector<double> > & resultValues = matrixResults->cellScalarResults(scalarResultIndex);
|
||||
for (size_t timeStepIdx = 0; timeStepIdx < matrixResults->timeStepCount(scalarResultIndex); timeStepIdx++)
|
||||
{
|
||||
size_t resultValueCount = resultValues[timeStepIdx].size();
|
||||
resultText += QString(" %1").arg(resultValueCount);
|
||||
}
|
||||
|
||||
qDebug() << resultText;
|
||||
}
|
||||
qDebug() << "Number of items : " << resultNames.size();
|
||||
}
|
||||
}
|
||||
|
||||
TEST(RigReservoirTest, DualPorosityTest)
|
||||
{
|
||||
cvf::ref<RifReaderEclipseOutput> readerInterfaceEcl = new RifReaderEclipseOutput;
|
||||
cvf::ref<RigReservoir> reservoir = new RigReservoir;
|
||||
|
||||
QString filename("d:/Models/Statoil/DualProperty/DUALPORO.EGRID");
|
||||
//QString filename("d:/Models/Statoil/testcase_juli_2011/data/TEST10K_FLT_LGR_NNC.EGRID");
|
||||
|
||||
|
||||
bool result = readerInterfaceEcl->open(filename, reservoir.p());
|
||||
EXPECT_TRUE(result);
|
||||
|
||||
|
||||
qDebug() << "\n\n" <<
|
||||
"Matrix porosities, DYNAMIC results" <<
|
||||
"----------------------------------";
|
||||
buildResultInfoString(reservoir.p(), RifReaderInterface::MATRIX_RESULTS, RimDefines::DYNAMIC_NATIVE);
|
||||
|
||||
qDebug() << "\n\n" <<
|
||||
"Matrix porosities, STATIC results" <<
|
||||
"----------------------------------";
|
||||
buildResultInfoString(reservoir.p(), RifReaderInterface::MATRIX_RESULTS, RimDefines::STATIC_NATIVE);
|
||||
|
||||
qDebug() << "\n\n" <<
|
||||
"Fracture porosities, DYNAMIC results" <<
|
||||
"----------------------------------";
|
||||
buildResultInfoString(reservoir.p(), RifReaderInterface::FRACTURE_RESULTS, RimDefines::DYNAMIC_NATIVE);
|
||||
|
||||
qDebug() << "\n\n" <<
|
||||
"Fracture porosities, STATIC results" <<
|
||||
"----------------------------------";
|
||||
buildResultInfoString(reservoir.p(), RifReaderInterface::FRACTURE_RESULTS, RimDefines::STATIC_NATIVE);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//#include "RifEclipseUnifiedRestartFileAccess.h"
|
||||
|
||||
/*
|
||||
@ -69,7 +184,6 @@ TEST(RigReservoirTest, UnifiedTestFile)
|
||||
}
|
||||
*/
|
||||
|
||||
#if 0
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -149,4 +263,7 @@ TEST(RigReservoirTest, WellTest)
|
||||
EXPECT_TRUE(mainGridWellCells->size() == reservoir->mainGrid()->cellCount());
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
@ -21,6 +21,7 @@
|
||||
#include "util.h"
|
||||
#include "ecl_file.h"
|
||||
#include "ecl_intehead.h"
|
||||
#include "ecl_kw_magic.h"
|
||||
|
||||
#include <QFileInfo>
|
||||
#include "cafProgressInfo.h"
|
||||
@ -31,10 +32,6 @@
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RifEclipseOutputFileTools::RifEclipseOutputFileTools()
|
||||
{
|
||||
m_file = NULL;
|
||||
|
||||
m_globalMatrixActiveCellCounts = 0;;
|
||||
m_globalFractureActiveCellCounts = 0;
|
||||
}
|
||||
|
||||
|
||||
@ -43,75 +40,25 @@ RifEclipseOutputFileTools::RifEclipseOutputFileTools()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RifEclipseOutputFileTools::~RifEclipseOutputFileTools()
|
||||
{
|
||||
close();
|
||||
}
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Open file given by name
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RifEclipseOutputFileTools::open(const QString& fileName, const std::vector<size_t>& matrixActiveCellCounts, const std::vector<size_t>& fractureActiveCellCounts)
|
||||
{
|
||||
// Close current file if any
|
||||
close();
|
||||
|
||||
m_file = ecl_file_open(fileName.toAscii().data());
|
||||
if (!m_file) return false;
|
||||
|
||||
m_numMatrixActiveCellCounts = matrixActiveCellCounts;
|
||||
m_numFractureActiveCellCount = fractureActiveCellCounts;
|
||||
|
||||
for (size_t i = 0; i < matrixActiveCellCounts.size(); i++)
|
||||
{
|
||||
m_globalMatrixActiveCellCounts += matrixActiveCellCounts[i];
|
||||
m_globalFractureActiveCellCounts += fractureActiveCellCounts[i];
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Close file
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RifEclipseOutputFileTools::close()
|
||||
{
|
||||
if (m_file)
|
||||
{
|
||||
ecl_file_close(m_file);
|
||||
m_file = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Get the number of occurrences of the given keyword
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
int RifEclipseOutputFileTools::numOccurrences(const QString& keyword)
|
||||
{
|
||||
CVF_ASSERT(m_file);
|
||||
return ecl_file_get_num_named_kw(m_file, keyword.toAscii().data());
|
||||
}
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Get list of time step texts (dates)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RifEclipseOutputFileTools::timeStepsText(QStringList* timeSteps)
|
||||
bool RifEclipseOutputFileTools::timeStepsText(ecl_file_type* ecl_file, QStringList* timeSteps)
|
||||
{
|
||||
CVF_ASSERT(timeSteps);
|
||||
CVF_ASSERT(m_file);
|
||||
|
||||
const char* KW_INTEHEAD = "INTEHEAD";
|
||||
CVF_ASSERT(ecl_file);
|
||||
|
||||
// Get the number of occurrences of the INTEHEAD keyword
|
||||
int numINTEHEAD = numOccurrences(KW_INTEHEAD);
|
||||
int numINTEHEAD = ecl_file_get_num_named_kw(ecl_file, INTEHEAD_KW);
|
||||
|
||||
QStringList timeStepsFound;
|
||||
int i;
|
||||
for (i = 0; i < numINTEHEAD; i++)
|
||||
{
|
||||
ecl_kw_type* kwINTEHEAD = ecl_file_iget_named_kw(m_file, KW_INTEHEAD, i);
|
||||
ecl_kw_type* kwINTEHEAD = ecl_file_iget_named_kw(ecl_file, INTEHEAD_KW, i);
|
||||
if (kwINTEHEAD)
|
||||
{
|
||||
// Get date info
|
||||
@ -140,21 +87,19 @@ bool RifEclipseOutputFileTools::timeStepsText(QStringList* timeSteps)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Get list of time step texts (dates)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RifEclipseOutputFileTools::timeSteps(QList<QDateTime>* timeSteps)
|
||||
bool RifEclipseOutputFileTools::timeSteps(ecl_file_type* ecl_file, QList<QDateTime>* timeSteps)
|
||||
{
|
||||
CVF_ASSERT(timeSteps);
|
||||
CVF_ASSERT(m_file);
|
||||
|
||||
const char* KW_INTEHEAD = "INTEHEAD";
|
||||
CVF_ASSERT(ecl_file);
|
||||
|
||||
// Get the number of occurrences of the INTEHEAD keyword
|
||||
int numINTEHEAD = numOccurrences(KW_INTEHEAD);
|
||||
int numINTEHEAD = ecl_file_get_num_named_kw(ecl_file, INTEHEAD_KW);
|
||||
|
||||
QList<QDateTime> timeStepsFound;
|
||||
int i;
|
||||
for (i = 0; i < numINTEHEAD; i++)
|
||||
{
|
||||
ecl_kw_type* kwINTEHEAD = ecl_file_iget_named_kw(m_file, KW_INTEHEAD, i);
|
||||
ecl_kw_type* kwINTEHEAD = ecl_file_iget_named_kw(ecl_file, INTEHEAD_KW, i);
|
||||
if (kwINTEHEAD)
|
||||
{
|
||||
// Get date info
|
||||
@ -179,50 +124,27 @@ bool RifEclipseOutputFileTools::timeSteps(QList<QDateTime>* timeSteps)
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Get first occurrence of file of given type in given list of filenames, as filename or NULL if not found
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RifEclipseOutputFileTools::keywordData(const QString& keyword, size_t fileKeywordOccurrence,
|
||||
RifReaderInterface::PorosityModelResultType matrixOrFracture,
|
||||
std::vector<double>* values)
|
||||
bool RifEclipseOutputFileTools::keywordData(ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<double>* values)
|
||||
{
|
||||
CVF_ASSERT(m_file);
|
||||
CVF_ASSERT(values);
|
||||
|
||||
size_t gridIndex = fileKeywordOccurrence % m_numMatrixActiveCellCounts.size();
|
||||
|
||||
if (matrixOrFracture == RifReaderInterface::MATRIX_RESULTS)
|
||||
ecl_kw_type* kwData = ecl_file_iget_named_kw(ecl_file, keyword.toAscii().data(), static_cast<int>(fileKeywordOccurrence));
|
||||
if (kwData)
|
||||
{
|
||||
ecl_kw_type* kwData = ecl_file_iget_named_kw(m_file, keyword.toAscii().data(), static_cast<int>(fileKeywordOccurrence));
|
||||
if (kwData)
|
||||
{
|
||||
size_t numValues = ecl_kw_get_size(kwData);
|
||||
size_t numValues = ecl_kw_get_size(kwData);
|
||||
|
||||
std::vector<double> doubleData;
|
||||
doubleData.resize(numValues);
|
||||
std::vector<double> doubleData;
|
||||
doubleData.resize(numValues);
|
||||
|
||||
ecl_kw_get_data_as_double(kwData, doubleData.data());
|
||||
values->insert(values->end(), doubleData.begin(), doubleData.begin() + m_numMatrixActiveCellCounts[gridIndex]);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ecl_kw_type* kwData = ecl_file_iget_named_kw(m_file, keyword.toAscii().data(), static_cast<int>(fileKeywordOccurrence));
|
||||
if (kwData)
|
||||
{
|
||||
size_t numValues = ecl_kw_get_size(kwData);
|
||||
CVF_ASSERT(numValues == m_numMatrixActiveCellCounts[gridIndex] + m_numFractureActiveCellCount[gridIndex]);
|
||||
ecl_kw_get_data_as_double(kwData, doubleData.data());
|
||||
values->insert(values->end(), doubleData.begin(), doubleData.end());
|
||||
|
||||
std::vector<double> doubleData;
|
||||
doubleData.resize(numValues);
|
||||
|
||||
ecl_kw_get_data_as_double(kwData, doubleData.data());
|
||||
|
||||
values->insert(values->end(), doubleData.begin() + m_numMatrixActiveCellCounts[gridIndex], doubleData.end());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@ -294,42 +216,29 @@ bool RifEclipseOutputFileTools::fileSet(const QString& fileName, QStringList* fi
|
||||
return fileSet->count() > 0;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
ecl_file_type* RifEclipseOutputFileTools::filePointer()
|
||||
{
|
||||
return m_file;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RifEclipseOutputFileTools::validKeywords(QStringList* keywords, RifReaderInterface::PorosityModelResultType matrixOrFracture)
|
||||
void RifEclipseOutputFileTools::findKeywordsAndDataItemCounts(ecl_file_type* ecl_file, QStringList* keywords, std::vector<size_t>* keywordDataItemCounts)
|
||||
{
|
||||
if (m_globalMatrixActiveCellCounts == 0) return true;
|
||||
if (!ecl_file || !keywords || !keywordDataItemCounts) return;
|
||||
|
||||
CVF_ASSERT(m_file);
|
||||
CVF_ASSERT(keywords);
|
||||
|
||||
if (!keywords) return false;
|
||||
keywords->clear();
|
||||
|
||||
int numKeywords = ecl_file_get_num_distinct_kw(m_file);
|
||||
int numKeywords = ecl_file_get_num_distinct_kw(ecl_file);
|
||||
|
||||
caf::ProgressInfo info(numKeywords, "Reading Keywords on file");
|
||||
|
||||
for (int i = 0; i < numKeywords; i++)
|
||||
{
|
||||
const char* kw = ecl_file_iget_distinct_kw(m_file , i);
|
||||
int numKeywordOccurrences = ecl_file_get_num_named_kw(m_file, kw);
|
||||
const char* kw = ecl_file_iget_distinct_kw(ecl_file , i);
|
||||
int numKeywordOccurrences = ecl_file_get_num_named_kw(ecl_file, kw);
|
||||
bool validData = true;
|
||||
size_t fileResultValueCount = 0;
|
||||
for (int j = 0; j < numKeywordOccurrences; j++)
|
||||
{
|
||||
fileResultValueCount += ecl_file_iget_named_size(m_file, kw, j);
|
||||
fileResultValueCount += ecl_file_iget_named_size(ecl_file, kw, j);
|
||||
|
||||
ecl_type_enum dataType = ecl_file_iget_named_type(m_file, kw, j);
|
||||
ecl_type_enum dataType = ecl_file_iget_named_type(ecl_file, kw, j);
|
||||
if (dataType != ECL_DOUBLE_TYPE && dataType != ECL_FLOAT_TYPE && dataType != ECL_INT_TYPE )
|
||||
{
|
||||
validData = false;
|
||||
@ -339,27 +248,10 @@ bool RifEclipseOutputFileTools::validKeywords(QStringList* keywords, RifReaderIn
|
||||
|
||||
if (validData)
|
||||
{
|
||||
// Only report valid fracture results when total result value count equals matrix and fracture
|
||||
if (matrixOrFracture == RifReaderInterface::FRACTURE_RESULTS)
|
||||
{
|
||||
size_t rest = fileResultValueCount % (m_globalMatrixActiveCellCounts + m_globalFractureActiveCellCounts);
|
||||
if (rest == 0)
|
||||
{
|
||||
keywords->append(QString(kw));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
size_t rest = fileResultValueCount % (m_globalMatrixActiveCellCounts);
|
||||
if (rest == 0)
|
||||
{
|
||||
keywords->append(QString(kw));
|
||||
}
|
||||
}
|
||||
keywords->append(QString(kw));
|
||||
keywordDataItemCounts->push_back(fileResultValueCount);
|
||||
}
|
||||
|
||||
info.setProgress(i);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -25,51 +25,32 @@
|
||||
#include <QString>
|
||||
#include <QStringList>
|
||||
#include <QDateTime>
|
||||
|
||||
#include "ecl_file.h"
|
||||
|
||||
#include "RifReaderInterface.h"
|
||||
|
||||
#include "ecl_util.h"
|
||||
|
||||
typedef struct ecl_file_struct ecl_file_type;
|
||||
|
||||
|
||||
//==================================================================================================
|
||||
//
|
||||
// Class for access to Eclipse "keyword" files using libecl
|
||||
//
|
||||
//
|
||||
//==================================================================================================
|
||||
class RifEclipseOutputFileTools : public cvf::Object
|
||||
class RifEclipseOutputFileTools
|
||||
{
|
||||
public:
|
||||
RifEclipseOutputFileTools();
|
||||
virtual ~RifEclipseOutputFileTools();
|
||||
|
||||
bool open(const QString& fileName, const std::vector<size_t>& matrixActiveCellCounts, const std::vector<size_t>& fractureActiveCellCounts);
|
||||
void close();
|
||||
static void findKeywordsAndDataItemCounts(ecl_file_type* ecl_file, QStringList* keywords, std::vector<size_t>* keywordDataItemCounts);
|
||||
static bool keywordData(ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<double>* values);
|
||||
|
||||
int numOccurrences(const QString& keyword);
|
||||
|
||||
bool validKeywords(QStringList* keywords, RifReaderInterface::PorosityModelResultType matrixOrFracture);
|
||||
static bool timeStepsText(ecl_file_type* ecl_file, QStringList* timeSteps);
|
||||
static bool timeSteps(ecl_file_type* ecl_file, QList<QDateTime>* timeSteps);
|
||||
|
||||
bool timeStepsText(QStringList* timeSteps);
|
||||
bool timeSteps(QList<QDateTime>* timeSteps);
|
||||
|
||||
bool keywordData(const QString& keyword, size_t fileKeywordOccurrence,
|
||||
RifReaderInterface::PorosityModelResultType matrixOrFracture,
|
||||
std::vector<double>* values);
|
||||
|
||||
ecl_file_type* filePointer();
|
||||
|
||||
// Static methods
|
||||
static bool fileSet(const QString& fileName, QStringList* fileSet);
|
||||
|
||||
static QString fileNameByType(const QStringList& fileSet, ecl_file_enum fileType);
|
||||
static QStringList fileNamesByType(const QStringList& fileSet, ecl_file_enum fileType);
|
||||
|
||||
protected:
|
||||
ecl_file_type* m_file;
|
||||
|
||||
private:
|
||||
std::vector<size_t> m_numMatrixActiveCellCounts;
|
||||
std::vector<size_t> m_numFractureActiveCellCount;
|
||||
|
||||
size_t m_globalMatrixActiveCellCounts;
|
||||
size_t m_globalFractureActiveCellCounts;
|
||||
};
|
||||
|
||||
@ -42,15 +42,15 @@ public:
|
||||
RifEclipseRestartDataAccess();
|
||||
virtual ~RifEclipseRestartDataAccess();
|
||||
|
||||
virtual bool open(const QStringList& fileSet, const std::vector<size_t>& matrixModelActiveCellCounts, const std::vector<size_t>& fractureModelActiveCellCounts) = 0;
|
||||
virtual bool open(const QStringList& fileSet) = 0;
|
||||
virtual void close() = 0;
|
||||
|
||||
virtual size_t numTimeSteps() = 0;
|
||||
virtual QStringList timeStepsText() = 0;
|
||||
virtual QList<QDateTime> timeSteps() = 0;
|
||||
|
||||
virtual QStringList resultNames(RifReaderInterface::PorosityModelResultType matrixOrFracture) = 0;
|
||||
virtual bool results(const QString& resultName, RifReaderInterface::PorosityModelResultType matrixOrFracture, size_t timeStep, std::vector<double>* values) = 0;
|
||||
virtual void resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts) = 0;
|
||||
virtual bool results(const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values) = 0;
|
||||
|
||||
virtual void readWellData(well_info_type * well_info) = 0;
|
||||
};
|
||||
|
||||
@ -39,7 +39,7 @@ RifEclipseRestartFilesetAccess::~RifEclipseRestartFilesetAccess()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Open files
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RifEclipseRestartFilesetAccess::open(const QStringList& fileSet, const std::vector<size_t>& matrixActiveCellCounts, const std::vector<size_t>& fractureActiveCellCounts)
|
||||
bool RifEclipseRestartFilesetAccess::open(const QStringList& fileSet)
|
||||
{
|
||||
close();
|
||||
|
||||
@ -47,18 +47,12 @@ bool RifEclipseRestartFilesetAccess::open(const QStringList& fileSet, const std:
|
||||
int i;
|
||||
for (i = 0; i < numFiles; i++)
|
||||
{
|
||||
cvf::ref<RifEclipseOutputFileTools> fileAccess = new RifEclipseOutputFileTools;
|
||||
if (!fileAccess->open(fileSet[i], matrixActiveCellCounts, fractureActiveCellCounts))
|
||||
{
|
||||
close();
|
||||
return false;
|
||||
}
|
||||
ecl_file_type* ecl_file = ecl_file_open(fileSet[i].toAscii().data());
|
||||
if (!ecl_file) return false;
|
||||
|
||||
m_files.push_back(fileAccess);
|
||||
m_ecl_files.push_back(ecl_file);
|
||||
}
|
||||
|
||||
m_gridCount = matrixActiveCellCounts.size();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -67,7 +61,12 @@ bool RifEclipseRestartFilesetAccess::open(const QStringList& fileSet, const std:
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RifEclipseRestartFilesetAccess::close()
|
||||
{
|
||||
m_files.clear();
|
||||
for (size_t i = 0; i < m_ecl_files.size(); i++)
|
||||
{
|
||||
ecl_file_close(m_ecl_files[i]);
|
||||
}
|
||||
m_ecl_files.clear();
|
||||
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -75,7 +74,7 @@ void RifEclipseRestartFilesetAccess::close()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
size_t RifEclipseRestartFilesetAccess::numTimeSteps()
|
||||
{
|
||||
return m_files.size();
|
||||
return m_ecl_files.size();
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -90,7 +89,8 @@ QStringList RifEclipseRestartFilesetAccess::timeStepsText()
|
||||
for (i = 0; i < numSteps; i++)
|
||||
{
|
||||
QStringList stepText;
|
||||
m_files[i]->timeStepsText(&stepText);
|
||||
RifEclipseOutputFileTools::timeStepsText(m_ecl_files[i], &stepText);
|
||||
|
||||
timeSteps.append(stepText.size() == 1 ? stepText : QStringList(QString("Step %1").arg(i+1)));
|
||||
}
|
||||
|
||||
@ -109,7 +109,8 @@ QList<QDateTime> RifEclipseRestartFilesetAccess::timeSteps()
|
||||
for (i = 0; i < numSteps; i++)
|
||||
{
|
||||
QList<QDateTime> stepTime;
|
||||
m_files[i]->timeSteps(&stepTime);
|
||||
|
||||
RifEclipseOutputFileTools::timeSteps(m_ecl_files[i], &stepTime);
|
||||
|
||||
if (stepTime.size() == 1)
|
||||
{
|
||||
@ -127,29 +128,31 @@ QList<QDateTime> RifEclipseRestartFilesetAccess::timeSteps()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Get list of result names
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
QStringList RifEclipseRestartFilesetAccess::resultNames(RifReaderInterface::PorosityModelResultType matrixOrFracture)
|
||||
void RifEclipseRestartFilesetAccess::resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts)
|
||||
{
|
||||
CVF_ASSERT(numTimeSteps() > 0);
|
||||
|
||||
// Get the results found on the first file
|
||||
QStringList resultsList;
|
||||
m_files[0]->validKeywords(&resultsList, matrixOrFracture);
|
||||
std::vector<size_t> valueCountForOneFile;
|
||||
RifEclipseOutputFileTools::findKeywordsAndDataItemCounts(m_ecl_files[0], resultNames, &valueCountForOneFile);
|
||||
|
||||
return resultsList;
|
||||
for (size_t i = 0; i < valueCountForOneFile.size(); i++)
|
||||
{
|
||||
resultDataItemCounts->push_back(valueCountForOneFile[i] * numTimeSteps());
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Get result values for given time step
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RifEclipseRestartFilesetAccess::results(const QString& resultName, RifReaderInterface::PorosityModelResultType matrixOrFracture, size_t timeStep, std::vector<double>* values)
|
||||
bool RifEclipseRestartFilesetAccess::results(const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values)
|
||||
{
|
||||
size_t numOccurrences = m_files[timeStep]->numOccurrences(resultName);
|
||||
size_t numOccurrences = ecl_file_get_num_named_kw(m_ecl_files[timeStep], resultName.toAscii().data());
|
||||
|
||||
// No results for this result variable for current time step found
|
||||
if (numOccurrences == 0) return true;
|
||||
|
||||
// Result handling depends on presents of result values for all grids
|
||||
if (m_gridCount != numOccurrences)
|
||||
if (gridCount != numOccurrences)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
@ -158,7 +161,8 @@ bool RifEclipseRestartFilesetAccess::results(const QString& resultName, RifReade
|
||||
for (i = 0; i < numOccurrences; i++)
|
||||
{
|
||||
std::vector<double> partValues;
|
||||
if (!m_files[timeStep]->keywordData(resultName, i, matrixOrFracture, &partValues)) // !! don't need to append afterwards
|
||||
|
||||
if (!RifEclipseOutputFileTools::keywordData(m_ecl_files[timeStep], resultName, i, &partValues))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
@ -177,13 +181,13 @@ void RifEclipseRestartFilesetAccess::readWellData(well_info_type* well_info)
|
||||
{
|
||||
if (!well_info) return;
|
||||
|
||||
for (size_t i = 0; i < m_files.size(); i++)
|
||||
for (size_t i = 0; i < m_ecl_files.size(); i++)
|
||||
{
|
||||
const char* fileName = ecl_file_get_src_file(m_files[i]->filePointer());
|
||||
const char* fileName = ecl_file_get_src_file(m_ecl_files[i]);
|
||||
int reportNumber = ecl_util_filename_report_nr(fileName);
|
||||
if(reportNumber != -1)
|
||||
{
|
||||
well_info_add_wells(well_info, m_files[i]->filePointer(), reportNumber);
|
||||
well_info_add_wells(well_info, m_ecl_files[i], reportNumber);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -35,20 +35,18 @@ public:
|
||||
RifEclipseRestartFilesetAccess();
|
||||
virtual ~RifEclipseRestartFilesetAccess();
|
||||
|
||||
bool open(const QStringList& fileSet, const std::vector<size_t>& matrixActiveCellCounts, const std::vector<size_t>& fractureActiveCellCounts);
|
||||
bool open(const QStringList& fileSet);
|
||||
void close();
|
||||
|
||||
size_t numTimeSteps();
|
||||
QStringList timeStepsText();
|
||||
QList<QDateTime> timeSteps();
|
||||
|
||||
QStringList resultNames(RifReaderInterface::PorosityModelResultType matrixOrFracture);
|
||||
bool results(const QString& resultName, RifReaderInterface::PorosityModelResultType matrixOrFracture, size_t timeStep, std::vector<double>* values);
|
||||
void resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts);
|
||||
bool results(const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values);
|
||||
|
||||
virtual void readWellData(well_info_type* well_info);
|
||||
|
||||
private:
|
||||
std::vector< cvf::ref<RifEclipseOutputFileTools> > m_files;
|
||||
|
||||
size_t m_gridCount;
|
||||
std::vector< ecl_file_type* > m_ecl_files;
|
||||
};
|
||||
|
||||
@ -30,7 +30,7 @@
|
||||
RifEclipseUnifiedRestartFileAccess::RifEclipseUnifiedRestartFileAccess()
|
||||
: RifEclipseRestartDataAccess()
|
||||
{
|
||||
m_gridCount = 0;
|
||||
m_ecl_file = NULL;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -38,25 +38,23 @@ RifEclipseUnifiedRestartFileAccess::RifEclipseUnifiedRestartFileAccess()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RifEclipseUnifiedRestartFileAccess::~RifEclipseUnifiedRestartFileAccess()
|
||||
{
|
||||
close();
|
||||
if (m_ecl_file)
|
||||
{
|
||||
ecl_file_close(m_ecl_file);
|
||||
}
|
||||
|
||||
m_ecl_file = NULL;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Open file
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RifEclipseUnifiedRestartFileAccess::open(const QStringList& fileSet, const std::vector<size_t>& matrixModelActiveCellCounts, const std::vector<size_t>& fractureModelActiveCellCounts)
|
||||
bool RifEclipseUnifiedRestartFileAccess::open(const QStringList& fileSet)
|
||||
{
|
||||
QString fileName = fileSet[0];
|
||||
|
||||
cvf::ref<RifEclipseOutputFileTools> fileAccess = new RifEclipseOutputFileTools;
|
||||
if (!fileAccess->open(fileName, matrixModelActiveCellCounts, fractureModelActiveCellCounts))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
m_file = fileAccess;
|
||||
|
||||
m_gridCount = matrixModelActiveCellCounts.size();
|
||||
m_ecl_file = ecl_file_open(fileName.toAscii().data());
|
||||
if (!m_ecl_file) return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -66,11 +64,6 @@ bool RifEclipseUnifiedRestartFileAccess::open(const QStringList& fileSet, const
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RifEclipseUnifiedRestartFileAccess::close()
|
||||
{
|
||||
if (m_file.notNull())
|
||||
{
|
||||
m_file->close();
|
||||
m_file = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -87,11 +80,10 @@ size_t RifEclipseUnifiedRestartFileAccess::numTimeSteps()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
QStringList RifEclipseUnifiedRestartFileAccess::timeStepsText()
|
||||
{
|
||||
RifEclipseOutputFileTools* file = m_file.p();
|
||||
CVF_ASSERT(file != NULL);
|
||||
CVF_ASSERT(m_ecl_file != NULL);
|
||||
|
||||
QStringList timeSteps;
|
||||
file->timeStepsText(&timeSteps);
|
||||
RifEclipseOutputFileTools::timeStepsText(m_ecl_file, &timeSteps);
|
||||
|
||||
return timeSteps;
|
||||
}
|
||||
@ -101,11 +93,10 @@ QStringList RifEclipseUnifiedRestartFileAccess::timeStepsText()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
QList<QDateTime> RifEclipseUnifiedRestartFileAccess::timeSteps()
|
||||
{
|
||||
RifEclipseOutputFileTools* file = m_file.p();
|
||||
CVF_ASSERT(file != NULL);
|
||||
CVF_ASSERT(m_ecl_file != NULL);
|
||||
|
||||
QList<QDateTime> timeSteps;
|
||||
file->timeSteps(&timeSteps);
|
||||
RifEclipseOutputFileTools::timeSteps(m_ecl_file, &timeSteps);
|
||||
|
||||
return timeSteps;
|
||||
}
|
||||
@ -113,32 +104,26 @@ QList<QDateTime> RifEclipseUnifiedRestartFileAccess::timeSteps()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Get list of result names
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
QStringList RifEclipseUnifiedRestartFileAccess::resultNames(RifReaderInterface::PorosityModelResultType matrixOrFracture)
|
||||
void RifEclipseUnifiedRestartFileAccess::resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts)
|
||||
{
|
||||
// Get the results found on the UNRST file
|
||||
QStringList resultsList;
|
||||
m_file->validKeywords(&resultsList, matrixOrFracture);
|
||||
|
||||
return resultsList;
|
||||
RifEclipseOutputFileTools::findKeywordsAndDataItemCounts(m_ecl_file, resultNames, resultDataItemCounts);
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Get result values for given time step
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RifEclipseUnifiedRestartFileAccess::results(const QString& resultName, RifReaderInterface::PorosityModelResultType matrixOrFracture, size_t timeStep, std::vector<double>* values)
|
||||
bool RifEclipseUnifiedRestartFileAccess::results(const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values)
|
||||
{
|
||||
size_t numOccurrences = m_file->numOccurrences(resultName);
|
||||
size_t startIndex = timeStep * m_gridCount;
|
||||
CVF_ASSERT(startIndex + m_gridCount <= numOccurrences);
|
||||
size_t numOccurrences = ecl_file_get_num_named_kw(m_ecl_file, resultName.toAscii().data());
|
||||
|
||||
size_t startIndex = timeStep * gridCount;
|
||||
CVF_ASSERT(startIndex + gridCount <= numOccurrences);
|
||||
|
||||
size_t occurrenceIdx;
|
||||
for (occurrenceIdx = startIndex; occurrenceIdx < startIndex + m_gridCount; occurrenceIdx++)
|
||||
for (occurrenceIdx = startIndex; occurrenceIdx < startIndex + gridCount; occurrenceIdx++)
|
||||
{
|
||||
std::vector<double> partValues;
|
||||
if (!m_file->keywordData(resultName, occurrenceIdx, matrixOrFracture, &partValues)) // !! don't need to append afterwards
|
||||
{
|
||||
return false;
|
||||
}
|
||||
RifEclipseOutputFileTools::keywordData(m_ecl_file, resultName, occurrenceIdx, &partValues);
|
||||
|
||||
values->insert(values->end(), partValues.begin(), partValues.end());
|
||||
}
|
||||
@ -153,7 +138,8 @@ bool RifEclipseUnifiedRestartFileAccess::results(const QString& resultName, RifR
|
||||
void RifEclipseUnifiedRestartFileAccess::readWellData(well_info_type* well_info)
|
||||
{
|
||||
if (!well_info) return;
|
||||
CVF_ASSERT(m_ecl_file);
|
||||
|
||||
well_info_add_UNRST_wells(well_info, m_file->filePointer());
|
||||
well_info_add_UNRST_wells(well_info, m_ecl_file);
|
||||
}
|
||||
|
||||
|
||||
@ -22,6 +22,8 @@
|
||||
|
||||
class RifEclipseOutputFileTools;
|
||||
|
||||
//typedef struct ecl_file_struct ecl_file_type;
|
||||
|
||||
#include "well_info.h"
|
||||
|
||||
//==================================================================================================
|
||||
@ -35,20 +37,18 @@ public:
|
||||
RifEclipseUnifiedRestartFileAccess();
|
||||
virtual ~RifEclipseUnifiedRestartFileAccess();
|
||||
|
||||
bool open(const QStringList& fileSet, const std::vector<size_t>& matrixModelActiveCellCounts, const std::vector<size_t>& fractureModelActiveCellCounts);
|
||||
bool open(const QStringList& fileSet);
|
||||
void close();
|
||||
|
||||
size_t numTimeSteps();
|
||||
QStringList timeStepsText();
|
||||
QList<QDateTime> timeSteps();
|
||||
|
||||
QStringList resultNames(RifReaderInterface::PorosityModelResultType matrixOrFracture);
|
||||
bool results(const QString& resultName, RifReaderInterface::PorosityModelResultType matrixOrFracture, size_t timeStep, std::vector<double>* values);
|
||||
void resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts);
|
||||
bool results(const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values);
|
||||
|
||||
virtual void readWellData(well_info_type * well_info);
|
||||
|
||||
private:
|
||||
cvf::ref<RifEclipseOutputFileTools> m_file;
|
||||
|
||||
size_t m_gridCount;
|
||||
ecl_file_type* m_ecl_file;
|
||||
};
|
||||
|
||||
@ -212,7 +212,7 @@ void RifReaderEclipseOutput::ground()
|
||||
m_fileSet.clear();
|
||||
|
||||
m_timeSteps.clear();
|
||||
|
||||
m_mainGrid = NULL;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -220,7 +220,7 @@ void RifReaderEclipseOutput::ground()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RifReaderEclipseOutput::close()
|
||||
{
|
||||
m_staticResultsAccess = NULL;
|
||||
m_ecl_file = NULL;
|
||||
m_dynamicResultsAccess = NULL;
|
||||
|
||||
ground();
|
||||
@ -356,6 +356,11 @@ bool RifReaderEclipseOutput::open(const QString& fileName, RigReservoir* reservo
|
||||
progInfo.setProgress(8);
|
||||
progInfo.setProgressDescription("Reading Result index");
|
||||
|
||||
m_mainGrid = reservoir->mainGrid();
|
||||
|
||||
reservoir->mainGrid()->results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(this);
|
||||
reservoir->mainGrid()->results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(this);
|
||||
|
||||
// Build results meta data
|
||||
if (!buildMetaData(reservoir)) return false;
|
||||
|
||||
@ -363,7 +368,8 @@ bool RifReaderEclipseOutput::open(const QString& fileName, RigReservoir* reservo
|
||||
progInfo.setProgressDescription("Reading Well information");
|
||||
|
||||
readWellCells(reservoir);
|
||||
|
||||
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -377,19 +383,8 @@ bool RifReaderEclipseOutput::buildMetaData(RigReservoir* reservoir)
|
||||
|
||||
caf::ProgressInfo progInfo(2,"");
|
||||
|
||||
std::vector<size_t> matrixModelActiveCellCounts;
|
||||
std::vector<size_t> fractureModelActiveCellCount;
|
||||
|
||||
std::vector<RigGridBase*> grids;
|
||||
reservoir->allGrids(&grids);
|
||||
for (size_t i = 0; i < grids.size(); i++)
|
||||
{
|
||||
matrixModelActiveCellCounts.push_back(grids[i]->matrixModelActiveCellCount());
|
||||
fractureModelActiveCellCount.push_back(grids[i]->fractureModelActiveCellCount());
|
||||
}
|
||||
|
||||
// Create access object for dynamic results
|
||||
m_dynamicResultsAccess = dynamicResultsAccess(m_fileSet, matrixModelActiveCellCounts, fractureModelActiveCellCount);
|
||||
m_dynamicResultsAccess = dynamicResultsAccess(m_fileSet);
|
||||
if (m_dynamicResultsAccess.isNull())
|
||||
{
|
||||
return false;
|
||||
@ -403,22 +398,26 @@ bool RifReaderEclipseOutput::buildMetaData(RigReservoir* reservoir)
|
||||
// Get time steps
|
||||
m_timeSteps = m_dynamicResultsAccess->timeSteps();
|
||||
|
||||
{
|
||||
QStringList dynamicResultNames = m_dynamicResultsAccess->resultNames(RifReaderInterface::MATRIX_RESULTS);
|
||||
QStringList resultNames;
|
||||
std::vector<size_t> resultNamesDataItemCounts;
|
||||
m_dynamicResultsAccess->resultNames(&resultNames, &resultNamesDataItemCounts);
|
||||
|
||||
for (int i = 0; i < dynamicResultNames.size(); ++i)
|
||||
{
|
||||
QStringList matrixResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts, RifReaderInterface::MATRIX_RESULTS, m_dynamicResultsAccess->numTimeSteps());
|
||||
|
||||
for (int i = 0; i < matrixResultNames.size(); ++i)
|
||||
{
|
||||
size_t resIndex = matrixModelResults->addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, dynamicResultNames[i]);
|
||||
size_t resIndex = matrixModelResults->addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, matrixResultNames[i]);
|
||||
matrixModelResults->setTimeStepDates(resIndex, m_timeSteps);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
QStringList dynamicResultNames = m_dynamicResultsAccess->resultNames(RifReaderInterface::FRACTURE_RESULTS);
|
||||
QStringList fractureResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts, RifReaderInterface::FRACTURE_RESULTS, m_dynamicResultsAccess->numTimeSteps());
|
||||
|
||||
for (int i = 0; i < dynamicResultNames.size(); ++i)
|
||||
for (int i = 0; i < fractureResultNames.size(); ++i)
|
||||
{
|
||||
size_t resIndex = fractureModelResults->addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, dynamicResultNames[i]);
|
||||
size_t resIndex = fractureModelResults->addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, fractureResultNames[i]);
|
||||
fractureModelResults->setTimeStepDates(resIndex, m_timeSteps);
|
||||
}
|
||||
}
|
||||
@ -430,17 +429,15 @@ bool RifReaderEclipseOutput::buildMetaData(RigReservoir* reservoir)
|
||||
QString initFileName = RifEclipseOutputFileTools::fileNameByType(m_fileSet, ECL_INIT_FILE);
|
||||
if (initFileName.size() > 0)
|
||||
{
|
||||
// Open init file
|
||||
cvf::ref<RifEclipseOutputFileTools> initFile = new RifEclipseOutputFileTools;
|
||||
if (!initFile->open(initFileName, matrixModelActiveCellCounts, fractureModelActiveCellCount))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
ecl_file_type* ecl_file = ecl_file_open(initFileName.toAscii().data());
|
||||
if (!ecl_file) return false;
|
||||
|
||||
QStringList resultNames;
|
||||
std::vector<size_t> resultNamesDataItemCounts;
|
||||
RifEclipseOutputFileTools::findKeywordsAndDataItemCounts(ecl_file, &resultNames, &resultNamesDataItemCounts);
|
||||
|
||||
{
|
||||
QStringList staticResults;
|
||||
initFile->validKeywords(&staticResults, RifReaderInterface::MATRIX_RESULTS);
|
||||
QStringList staticResultNames = staticResults;
|
||||
QStringList matrixResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts, RifReaderInterface::MATRIX_RESULTS, 1);
|
||||
|
||||
QList<QDateTime> staticDate;
|
||||
if (m_timeSteps.size() > 0)
|
||||
@ -448,17 +445,15 @@ bool RifReaderEclipseOutput::buildMetaData(RigReservoir* reservoir)
|
||||
staticDate.push_back(m_timeSteps.front());
|
||||
}
|
||||
|
||||
for (int i = 0; i < staticResultNames.size(); ++i)
|
||||
for (int i = 0; i < matrixResultNames.size(); ++i)
|
||||
{
|
||||
size_t resIndex = matrixModelResults->addEmptyScalarResult(RimDefines::STATIC_NATIVE, staticResultNames[i]);
|
||||
size_t resIndex = matrixModelResults->addEmptyScalarResult(RimDefines::STATIC_NATIVE, matrixResultNames[i]);
|
||||
matrixModelResults->setTimeStepDates(resIndex, staticDate);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
QStringList staticResults;
|
||||
initFile->validKeywords(&staticResults, RifReaderInterface::FRACTURE_RESULTS);
|
||||
QStringList staticResultNames = staticResults;
|
||||
QStringList fractureResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts, RifReaderInterface::FRACTURE_RESULTS, 1);
|
||||
|
||||
QList<QDateTime> staticDate;
|
||||
if (m_timeSteps.size() > 0)
|
||||
@ -466,14 +461,14 @@ bool RifReaderEclipseOutput::buildMetaData(RigReservoir* reservoir)
|
||||
staticDate.push_back(m_timeSteps.front());
|
||||
}
|
||||
|
||||
for (int i = 0; i < staticResultNames.size(); ++i)
|
||||
for (int i = 0; i < fractureResultNames.size(); ++i)
|
||||
{
|
||||
size_t resIndex = fractureModelResults->addEmptyScalarResult(RimDefines::STATIC_NATIVE, staticResultNames[i]);
|
||||
size_t resIndex = fractureModelResults->addEmptyScalarResult(RimDefines::STATIC_NATIVE, fractureResultNames[i]);
|
||||
fractureModelResults->setTimeStepDates(resIndex, staticDate);
|
||||
}
|
||||
}
|
||||
|
||||
m_staticResultsAccess = initFile;
|
||||
m_ecl_file = ecl_file;
|
||||
}
|
||||
|
||||
return true;
|
||||
@ -482,7 +477,7 @@ bool RifReaderEclipseOutput::buildMetaData(RigReservoir* reservoir)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Create results access object (.UNRST or .X0001 ... .XNNNN)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RifEclipseRestartDataAccess* RifReaderEclipseOutput::dynamicResultsAccess(const QStringList& fileSet, const std::vector<size_t>& matrixActiveCellCounts, const std::vector<size_t>& fractureActiveCellCounts)
|
||||
RifEclipseRestartDataAccess* RifReaderEclipseOutput::dynamicResultsAccess(const QStringList& fileSet)
|
||||
{
|
||||
RifEclipseRestartDataAccess* resultsAccess = NULL;
|
||||
|
||||
@ -491,7 +486,7 @@ RifEclipseRestartDataAccess* RifReaderEclipseOutput::dynamicResultsAccess(const
|
||||
if (unrstFileName.size() > 0)
|
||||
{
|
||||
resultsAccess = new RifEclipseUnifiedRestartFileAccess();
|
||||
if (!resultsAccess->open(QStringList(unrstFileName), matrixActiveCellCounts, fractureActiveCellCounts))
|
||||
if (!resultsAccess->open(QStringList(unrstFileName)))
|
||||
{
|
||||
delete resultsAccess;
|
||||
return NULL;
|
||||
@ -504,7 +499,7 @@ RifEclipseRestartDataAccess* RifReaderEclipseOutput::dynamicResultsAccess(const
|
||||
if (restartFiles.size() > 0)
|
||||
{
|
||||
resultsAccess = new RifEclipseRestartFilesetAccess();
|
||||
if (!resultsAccess->open(restartFiles, matrixActiveCellCounts, fractureActiveCellCounts))
|
||||
if (!resultsAccess->open(restartFiles))
|
||||
{
|
||||
delete resultsAccess;
|
||||
return NULL;
|
||||
@ -524,17 +519,21 @@ RifEclipseRestartDataAccess* RifReaderEclipseOutput::dynamicResultsAccess(const
|
||||
bool RifReaderEclipseOutput::staticResult(const QString& result, PorosityModelResultType matrixOrFracture, std::vector<double>* values)
|
||||
{
|
||||
CVF_ASSERT(values);
|
||||
CVF_ASSERT(m_staticResultsAccess.notNull());
|
||||
CVF_ASSERT(m_ecl_file);
|
||||
|
||||
size_t numOccurrences = m_staticResultsAccess->numOccurrences(result);
|
||||
std::vector<double> fileValues;
|
||||
|
||||
size_t numOccurrences = ecl_file_get_num_named_kw(m_ecl_file, result.toAscii().data());
|
||||
size_t i;
|
||||
for (i = 0; i < numOccurrences; i++)
|
||||
{
|
||||
std::vector<double> partValues;
|
||||
if (!m_staticResultsAccess->keywordData(result, i, matrixOrFracture, &partValues)) return false;
|
||||
values->insert(values->end(), partValues.begin(), partValues.end());
|
||||
RifEclipseOutputFileTools::keywordData(m_ecl_file, result, i, &partValues);
|
||||
fileValues.insert(fileValues.end(), partValues.begin(), partValues.end());
|
||||
}
|
||||
|
||||
extractResultValuesBasedOnPorosityModel(matrixOrFracture, values, fileValues);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -544,7 +543,16 @@ bool RifReaderEclipseOutput::staticResult(const QString& result, PorosityModelRe
|
||||
bool RifReaderEclipseOutput::dynamicResult(const QString& result, PorosityModelResultType matrixOrFracture, size_t stepIndex, std::vector<double>* values)
|
||||
{
|
||||
CVF_ASSERT(m_dynamicResultsAccess.notNull());
|
||||
return m_dynamicResultsAccess->results(result, matrixOrFracture, stepIndex, values);
|
||||
|
||||
std::vector<double> fileValues;
|
||||
if (!m_dynamicResultsAccess->results(result, stepIndex, m_mainGrid->gridCount(), &fileValues))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
extractResultValuesBasedOnPorosityModel(matrixOrFracture, values, fileValues);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -756,3 +764,100 @@ int RifReaderEclipseOutput::findSmallestActiveCellIndexK(const RigGridBase* grid
|
||||
return -1;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel(const QStringList& keywords, const std::vector<size_t>& keywordDataItemCounts, PorosityModelResultType matrixOrFracture, size_t timeStepCount) const
|
||||
{
|
||||
if (keywords.size() != keywordDataItemCounts.size())
|
||||
{
|
||||
return QStringList();
|
||||
}
|
||||
|
||||
if (matrixOrFracture == RifReaderInterface::FRACTURE_RESULTS)
|
||||
{
|
||||
if (m_mainGrid->globalFractureModelActiveCellCount() == 0)
|
||||
{
|
||||
return QStringList();
|
||||
}
|
||||
}
|
||||
|
||||
QStringList keywordsWithCorrectNumberOfDataItems;
|
||||
|
||||
for (int i = 0; i < keywords.size(); i++)
|
||||
{
|
||||
QString keyword = keywords[i];
|
||||
size_t keywordDataCount = keywordDataItemCounts[i];
|
||||
|
||||
size_t timeStepsMatrix = keywordDataItemCounts[i] / m_mainGrid->globalMatrixModelActiveCellCount();
|
||||
size_t timeStepsMatrixRest = keywordDataItemCounts[i] % m_mainGrid->globalMatrixModelActiveCellCount();
|
||||
|
||||
size_t timeStepsMatrixAndFracture = keywordDataItemCounts[i] / (m_mainGrid->globalMatrixModelActiveCellCount() + m_mainGrid->globalFractureModelActiveCellCount());
|
||||
size_t timeStepsMatrixAndFractureRest = keywordDataItemCounts[i] % (m_mainGrid->globalMatrixModelActiveCellCount() + m_mainGrid->globalFractureModelActiveCellCount());
|
||||
|
||||
if (matrixOrFracture == RifReaderInterface::MATRIX_RESULTS)
|
||||
{
|
||||
if (timeStepsMatrixRest == 0 || timeStepsMatrixAndFractureRest == 0)
|
||||
{
|
||||
if (timeStepCount == timeStepsMatrix || timeStepCount == timeStepsMatrixAndFracture)
|
||||
{
|
||||
keywordsWithCorrectNumberOfDataItems.push_back(keywords[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (timeStepsMatrixAndFractureRest == 0 && timeStepCount == timeStepsMatrixAndFracture)
|
||||
{
|
||||
keywordsWithCorrectNumberOfDataItems.push_back(keywords[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return keywordsWithCorrectNumberOfDataItems;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel(PorosityModelResultType matrixOrFracture, std::vector<double>* destinationResultValues, const std::vector<double>& sourceResultValues)
|
||||
{
|
||||
if (matrixOrFracture == RifReaderInterface::MATRIX_RESULTS)
|
||||
{
|
||||
if (m_mainGrid->globalFractureModelActiveCellCount() == 0)
|
||||
{
|
||||
destinationResultValues->insert(destinationResultValues->end(), sourceResultValues.begin(), sourceResultValues.end());
|
||||
}
|
||||
else
|
||||
{
|
||||
size_t dataItemCount = 0;
|
||||
size_t sourceStartPosition = 0;
|
||||
|
||||
for (size_t i = 0; i < m_mainGrid->gridCount(); i++)
|
||||
{
|
||||
size_t matrixActiveCellCount = m_mainGrid->gridByIndex(i)->matrixModelActiveCellCount();
|
||||
size_t fractureActiveCellCount = m_mainGrid->gridByIndex(i)->matrixModelActiveCellCount();
|
||||
|
||||
destinationResultValues->insert(destinationResultValues->end(), sourceResultValues.begin() + sourceStartPosition, sourceResultValues.begin() + sourceStartPosition + matrixActiveCellCount);
|
||||
|
||||
sourceStartPosition += (matrixActiveCellCount + fractureActiveCellCount);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
size_t dataItemCount = 0;
|
||||
size_t sourceStartPosition = 0;
|
||||
|
||||
for (size_t i = 0; i < m_mainGrid->gridCount(); i++)
|
||||
{
|
||||
size_t matrixActiveCellCount = m_mainGrid->gridByIndex(i)->matrixModelActiveCellCount();
|
||||
size_t fractureActiveCellCount = m_mainGrid->gridByIndex(i)->matrixModelActiveCellCount();
|
||||
|
||||
destinationResultValues->insert(destinationResultValues->end(), sourceResultValues.begin() + sourceStartPosition + matrixActiveCellCount, sourceResultValues.begin() + sourceStartPosition + matrixActiveCellCount + fractureActiveCellCount);
|
||||
|
||||
sourceStartPosition += (matrixActiveCellCount + fractureActiveCellCount);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -25,8 +25,11 @@
|
||||
class RifEclipseOutputFileTools;
|
||||
class RifEclipseRestartDataAccess;
|
||||
class RigGridBase;
|
||||
class RigMainGrid;
|
||||
|
||||
typedef struct ecl_grid_struct ecl_grid_type;
|
||||
typedef struct ecl_file_struct ecl_file_type;
|
||||
|
||||
|
||||
//==================================================================================================
|
||||
//
|
||||
@ -52,17 +55,23 @@ private:
|
||||
bool buildMetaData(RigReservoir* reservoir);
|
||||
void readWellCells(RigReservoir* reservoir);
|
||||
|
||||
void extractResultValuesBasedOnPorosityModel(PorosityModelResultType matrixOrFracture, std::vector<double>* values, const std::vector<double>& fileValues);
|
||||
|
||||
int findSmallestActiveCellIndexK( const RigGridBase* grid, int cellI, int cellJ);
|
||||
|
||||
static RifEclipseRestartDataAccess* staticResultsAccess(const QStringList& fileSet, const std::vector<size_t>& matrixModelActiveCellCounts, const std::vector<size_t>& fractureModelActiveCellCounts);
|
||||
static RifEclipseRestartDataAccess* dynamicResultsAccess(const QStringList& fileSet, const std::vector<size_t>& matrixModelActiveCellCounts, const std::vector<size_t>& fractureModelActiveCellCounts);
|
||||
static RifEclipseRestartDataAccess* staticResultsAccess(const QStringList& fileSet);
|
||||
static RifEclipseRestartDataAccess* dynamicResultsAccess(const QStringList& fileSet);
|
||||
|
||||
QStringList validKeywordsForPorosityModel(const QStringList& keywords, const std::vector<size_t>& keywordDataItemCounts, PorosityModelResultType matrixOrFracture, size_t timeStepCount) const;
|
||||
|
||||
private:
|
||||
QString m_fileName; // Name of file used to start accessing Eclipse output files
|
||||
QStringList m_fileSet; // Set of files in filename's path with same base name as filename
|
||||
|
||||
cvf::cref<RigMainGrid> m_mainGrid;
|
||||
|
||||
QList<QDateTime> m_timeSteps;
|
||||
|
||||
cvf::ref<RifEclipseOutputFileTools> m_staticResultsAccess; // File access to static results
|
||||
ecl_file_type* m_ecl_file; // File access to static results
|
||||
cvf::ref<RifEclipseRestartDataAccess> m_dynamicResultsAccess; // File access to dynamic results
|
||||
};
|
||||
|
||||
@ -43,7 +43,6 @@ RimResultDefinition::RimResultDefinition()
|
||||
CAF_PDM_InitField(&resultVariable, "ResultVariable", RimDefines::undefinedResultName(), "Variable", "", "", "" );
|
||||
|
||||
resultVariable.setUiEditorTypeName(caf::PdmUiListEditor::uiEditorTypeName());
|
||||
porosityModel.setUiHidden(true);
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -60,6 +59,17 @@ RimResultDefinition::~RimResultDefinition()
|
||||
void RimResultDefinition::setReservoirView(RimReservoirView* ownerReservoirView)
|
||||
{
|
||||
m_reservoirView = ownerReservoirView;
|
||||
|
||||
// TODO: This code is executed before reservoir is read, and then porosity model is never set to zero
|
||||
if (m_reservoirView->eclipseCase() &&
|
||||
m_reservoirView->eclipseCase()->reservoirData() &&
|
||||
m_reservoirView->eclipseCase()->reservoirData()->mainGrid() )
|
||||
{
|
||||
if (m_reservoirView->eclipseCase()->reservoirData()->mainGrid()->globalFractureModelActiveCellCount() == 0)
|
||||
{
|
||||
porosityModel.setUiHidden(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
|
||||
@ -56,6 +56,9 @@ bool RimResultReservoir::openEclipseGridFile()
|
||||
if (caseName().contains("Result Mock Debug Model"))
|
||||
{
|
||||
readerInterface = this->createMockModel(this->caseName());
|
||||
|
||||
m_rigReservoir->mainGrid()->results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(readerInterface.p());
|
||||
m_rigReservoir->mainGrid()->results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(readerInterface.p());
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -89,9 +92,6 @@ bool RimResultReservoir::openEclipseGridFile()
|
||||
CVF_ASSERT(m_rigReservoir.notNull());
|
||||
CVF_ASSERT(readerInterface.notNull());
|
||||
|
||||
m_rigReservoir->mainGrid()->results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(readerInterface.p());
|
||||
m_rigReservoir->mainGrid()->results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(readerInterface.p());
|
||||
|
||||
progInfo.setProgressDescription("Computing Faults");
|
||||
m_rigReservoir->computeFaults();
|
||||
progInfo.setProgressDescription("Computing Cache");
|
||||
|
||||
Loading…
Reference in New Issue
Block a user