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

Rewrite of file acces helper class

Browse Source 
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 2013-02-05 10:51:32 +01:00
parent 77b43847c7
commit cf5aa3e882
13 changed files with 406 additions and 304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/FileInterface/FileInterface_UnitTests/Ert-Test.cpp
View File

@ -101,7 +101,6 @@ TEST(RigReservoirTest, WellTestErt)
well_info_free( well_info ); well_info_free( well_info );
} }
#endif
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// This file contains test code taken from the test cases in ERT source code. /// 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 // 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()); EXPECT_EQ(size_t(1), res.mainGrid()->globalMatrixModelActiveCellCount());
} }
#endif

119
ApplicationCode/FileInterface/FileInterface_UnitTests/RifReaderEclipseOutput-Test.cpp
View File

@ -24,6 +24,121 @@
#include "RigReservoir.h" #include "RigReservoir.h"
#include "RifReaderEclipseOutput.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" //#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()); EXPECT_TRUE(mainGridWellCells->size() == reservoir->mainGrid()->cellCount());
} }
#endif #endif

168
ApplicationCode/FileInterface/RifEclipseOutputFileTools.cpp
View File

@ -21,6 +21,7 @@
#include "util.h" #include "util.h"
#include "ecl_file.h" #include "ecl_file.h"
#include "ecl_intehead.h" #include "ecl_intehead.h"
#include "ecl_kw_magic.h"
#include <QFileInfo> #include <QFileInfo>
#include "cafProgressInfo.h" #include "cafProgressInfo.h"
@ -31,10 +32,6 @@
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RifEclipseOutputFileTools::RifEclipseOutputFileTools() RifEclipseOutputFileTools::RifEclipseOutputFileTools()
{ {
m_file = NULL;
m_globalMatrixActiveCellCounts = 0;;
m_globalFractureActiveCellCounts = 0;
} }
@ -43,75 +40,25 @@ RifEclipseOutputFileTools::RifEclipseOutputFileTools()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
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) /// 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(timeSteps);
CVF_ASSERT(m_file); CVF_ASSERT(ecl_file);
const char* KW_INTEHEAD = "INTEHEAD";
// Get the number of occurrences of the INTEHEAD keyword // 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; QStringList timeStepsFound;
int i; int i;
for (i = 0; i < numINTEHEAD; 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) if (kwINTEHEAD)
{ {
// Get date info // Get date info
@ -140,21 +87,19 @@ bool RifEclipseOutputFileTools::timeStepsText(QStringList* timeSteps)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Get list of time step texts (dates) /// 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(timeSteps);
CVF_ASSERT(m_file); CVF_ASSERT(ecl_file);
const char* KW_INTEHEAD = "INTEHEAD";
// Get the number of occurrences of the INTEHEAD keyword // 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; QList<QDateTime> timeStepsFound;
int i; int i;
for (i = 0; i < numINTEHEAD; 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) if (kwINTEHEAD)
{ {
// Get date info // Get date info
@ -179,50 +124,27 @@ bool RifEclipseOutputFileTools::timeSteps(QList<QDateTime>* timeSteps)
return true; 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, bool RifEclipseOutputFileTools::keywordData(ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<double>* values)
RifReaderInterface::PorosityModelResultType matrixOrFracture,
std::vector<double>* values)
{ {
CVF_ASSERT(m_file); ecl_kw_type* kwData = ecl_file_iget_named_kw(ecl_file, keyword.toAscii().data(), static_cast<int>(fileKeywordOccurrence));
CVF_ASSERT(values); if (kwData)
size_t gridIndex = fileKeywordOccurrence % m_numMatrixActiveCellCounts.size();
if (matrixOrFracture == RifReaderInterface::MATRIX_RESULTS)
{ {
ecl_kw_type* kwData = ecl_file_iget_named_kw(m_file, keyword.toAscii().data(), static_cast<int>(fileKeywordOccurrence)); size_t numValues = ecl_kw_get_size(kwData);
if (kwData)
{
size_t numValues = ecl_kw_get_size(kwData);
std::vector<double> doubleData; std::vector<double> doubleData;
doubleData.resize(numValues); doubleData.resize(numValues);
ecl_kw_get_data_as_double(kwData, doubleData.data()); ecl_kw_get_data_as_double(kwData, doubleData.data());
values->insert(values->end(), doubleData.begin(), doubleData.begin() + m_numMatrixActiveCellCounts[gridIndex]); values->insert(values->end(), doubleData.begin(), doubleData.end());
}
}
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]);
std::vector<double> doubleData; return true;
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 false;
} }
@ -294,42 +216,29 @@ bool RifEclipseOutputFileTools::fileSet(const QString& fileName, QStringList* fi
return fileSet->count() > 0; 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); int numKeywords = ecl_file_get_num_distinct_kw(ecl_file);
CVF_ASSERT(keywords);
if (!keywords) return false;
keywords->clear();
int numKeywords = ecl_file_get_num_distinct_kw(m_file);
caf::ProgressInfo info(numKeywords, "Reading Keywords on file"); caf::ProgressInfo info(numKeywords, "Reading Keywords on file");
for (int i = 0; i < numKeywords; i++) for (int i = 0; i < numKeywords; i++)
{ {
const char* kw = ecl_file_iget_distinct_kw(m_file , i); const char* kw = ecl_file_iget_distinct_kw(ecl_file , i);
int numKeywordOccurrences = ecl_file_get_num_named_kw(m_file, kw); int numKeywordOccurrences = ecl_file_get_num_named_kw(ecl_file, kw);
bool validData = true; bool validData = true;
size_t fileResultValueCount = 0; size_t fileResultValueCount = 0;
for (int j = 0; j < numKeywordOccurrences; j++) 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 ) if (dataType != ECL_DOUBLE_TYPE && dataType != ECL_FLOAT_TYPE && dataType != ECL_INT_TYPE )
{ {
validData = false; validData = false;
@ -339,27 +248,10 @@ bool RifEclipseOutputFileTools::validKeywords(QStringList* keywords, RifReaderIn
if (validData) if (validData)
{ {
// Only report valid fracture results when total result value count equals matrix and fracture keywords->append(QString(kw));
if (matrixOrFracture == RifReaderInterface::FRACTURE_RESULTS) keywordDataItemCounts->push_back(fileResultValueCount);
{
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));
}
}
} }
info.setProgress(i); info.setProgress(i);
} }
return true;
} }

41
ApplicationCode/FileInterface/RifEclipseOutputFileTools.h
View File

@ -25,51 +25,32 @@
#include <QString> #include <QString>
#include <QStringList> #include <QStringList>
#include <QDateTime> #include <QDateTime>
#include "ecl_file.h"
#include "RifReaderInterface.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: public:
RifEclipseOutputFileTools(); RifEclipseOutputFileTools();
virtual ~RifEclipseOutputFileTools(); virtual ~RifEclipseOutputFileTools();
bool open(const QString& fileName, const std::vector<size_t>& matrixActiveCellCounts, const std::vector<size_t>& fractureActiveCellCounts); static void findKeywordsAndDataItemCounts(ecl_file_type* ecl_file, QStringList* keywords, std::vector<size_t>* keywordDataItemCounts);
void close(); static bool keywordData(ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<double>* values);
int numOccurrences(const QString& keyword); static bool timeStepsText(ecl_file_type* ecl_file, QStringList* timeSteps);
static bool timeSteps(ecl_file_type* ecl_file, QList<QDateTime>* timeSteps);
bool validKeywords(QStringList* keywords, RifReaderInterface::PorosityModelResultType matrixOrFracture);
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 bool fileSet(const QString& fileName, QStringList* fileSet);
static QString fileNameByType(const QStringList& fileSet, ecl_file_enum fileType); static QString fileNameByType(const QStringList& fileSet, ecl_file_enum fileType);
static QStringList fileNamesByType(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;
}; };

6
ApplicationCode/FileInterface/RifEclipseRestartDataAccess.h
View File

@ -42,15 +42,15 @@ public:
RifEclipseRestartDataAccess(); RifEclipseRestartDataAccess();
virtual ~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 void close() = 0;
virtual size_t numTimeSteps() = 0; virtual size_t numTimeSteps() = 0;
virtual QStringList timeStepsText() = 0; virtual QStringList timeStepsText() = 0;
virtual QList<QDateTime> timeSteps() = 0; virtual QList<QDateTime> timeSteps() = 0;
virtual QStringList resultNames(RifReaderInterface::PorosityModelResultType matrixOrFracture) = 0; virtual void resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts) = 0;
virtual bool results(const QString& resultName, RifReaderInterface::PorosityModelResultType matrixOrFracture, size_t timeStep, std::vector<double>* values) = 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; virtual void readWellData(well_info_type * well_info) = 0;
}; };

56
ApplicationCode/FileInterface/RifEclipseRestartFilesetAccess.cpp
View File

@ -39,7 +39,7 @@ RifEclipseRestartFilesetAccess::~RifEclipseRestartFilesetAccess()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Open files /// 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(); close();
@ -47,18 +47,12 @@ bool RifEclipseRestartFilesetAccess::open(const QStringList& fileSet, const std:
int i; int i;
for (i = 0; i < numFiles; i++) for (i = 0; i < numFiles; i++)
{ {
cvf::ref<RifEclipseOutputFileTools> fileAccess = new RifEclipseOutputFileTools; ecl_file_type* ecl_file = ecl_file_open(fileSet[i].toAscii().data());
if (!fileAccess->open(fileSet[i], matrixActiveCellCounts, fractureActiveCellCounts)) if (!ecl_file) return false;
{
close();
return false;
}
m_files.push_back(fileAccess); m_ecl_files.push_back(ecl_file);
} }
m_gridCount = matrixActiveCellCounts.size();
return true; return true;
} }
@ -67,7 +61,12 @@ bool RifEclipseRestartFilesetAccess::open(const QStringList& fileSet, const std:
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RifEclipseRestartFilesetAccess::close() 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() 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++) for (i = 0; i < numSteps; i++)
{ {
QStringList stepText; 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))); 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++) for (i = 0; i < numSteps; i++)
{ {
QList<QDateTime> stepTime; QList<QDateTime> stepTime;
m_files[i]->timeSteps(&stepTime);
RifEclipseOutputFileTools::timeSteps(m_ecl_files[i], &stepTime);
if (stepTime.size() == 1) if (stepTime.size() == 1)
{ {
@ -127,29 +128,31 @@ QList<QDateTime> RifEclipseRestartFilesetAccess::timeSteps()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Get list of result names /// 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); CVF_ASSERT(numTimeSteps() > 0);
// Get the results found on the first file std::vector<size_t> valueCountForOneFile;
QStringList resultsList; RifEclipseOutputFileTools::findKeywordsAndDataItemCounts(m_ecl_files[0], resultNames, &valueCountForOneFile);
m_files[0]->validKeywords(&resultsList, matrixOrFracture);
return resultsList; for (size_t i = 0; i < valueCountForOneFile.size(); i++)
{
resultDataItemCounts->push_back(valueCountForOneFile[i] * numTimeSteps());
}
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Get result values for given time step /// 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 // No results for this result variable for current time step found
if (numOccurrences == 0) return true; if (numOccurrences == 0) return true;
// Result handling depends on presents of result values for all grids // Result handling depends on presents of result values for all grids
if (m_gridCount != numOccurrences) if (gridCount != numOccurrences)
{ {
return false; return false;
} }
@ -158,7 +161,8 @@ bool RifEclipseRestartFilesetAccess::results(const QString& resultName, RifReade
for (i = 0; i < numOccurrences; i++) for (i = 0; i < numOccurrences; i++)
{ {
std::vector<double> partValues; 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; return false;
} }
@ -177,13 +181,13 @@ void RifEclipseRestartFilesetAccess::readWellData(well_info_type* well_info)
{ {
if (!well_info) return; 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); int reportNumber = ecl_util_filename_report_nr(fileName);
if(reportNumber != -1) 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);
} }
} }
} }

10
ApplicationCode/FileInterface/RifEclipseRestartFilesetAccess.h
View File

@ -35,20 +35,18 @@ public:
RifEclipseRestartFilesetAccess(); RifEclipseRestartFilesetAccess();
virtual ~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(); void close();
size_t numTimeSteps(); size_t numTimeSteps();
QStringList timeStepsText(); QStringList timeStepsText();
QList<QDateTime> timeSteps(); QList<QDateTime> timeSteps();
QStringList resultNames(RifReaderInterface::PorosityModelResultType matrixOrFracture); void resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts);
bool results(const QString& resultName, RifReaderInterface::PorosityModelResultType matrixOrFracture, size_t timeStep, std::vector<double>* values); bool results(const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values);
virtual void readWellData(well_info_type* well_info); virtual void readWellData(well_info_type* well_info);
private: private:
std::vector< cvf::ref<RifEclipseOutputFileTools> > m_files; std::vector< ecl_file_type* > m_ecl_files;
size_t m_gridCount;
}; };

64
ApplicationCode/FileInterface/RifEclipseUnifiedRestartFileAccess.cpp
View File

@ -30,7 +30,7 @@
RifEclipseUnifiedRestartFileAccess::RifEclipseUnifiedRestartFileAccess() RifEclipseUnifiedRestartFileAccess::RifEclipseUnifiedRestartFileAccess()
: RifEclipseRestartDataAccess() : RifEclipseRestartDataAccess()
{ {
m_gridCount = 0; m_ecl_file = NULL;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -38,25 +38,23 @@ RifEclipseUnifiedRestartFileAccess::RifEclipseUnifiedRestartFileAccess()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RifEclipseUnifiedRestartFileAccess::~RifEclipseUnifiedRestartFileAccess() RifEclipseUnifiedRestartFileAccess::~RifEclipseUnifiedRestartFileAccess()
{ {
close(); if (m_ecl_file)
{
ecl_file_close(m_ecl_file);
}
m_ecl_file = NULL;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Open file /// 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]; QString fileName = fileSet[0];
cvf::ref<RifEclipseOutputFileTools> fileAccess = new RifEclipseOutputFileTools; m_ecl_file = ecl_file_open(fileName.toAscii().data());
if (!fileAccess->open(fileName, matrixModelActiveCellCounts, fractureModelActiveCellCounts)) if (!m_ecl_file) return false;
{
return false;
}
m_file = fileAccess;
m_gridCount = matrixModelActiveCellCounts.size();
return true; return true;
} }
@ -66,11 +64,6 @@ bool RifEclipseUnifiedRestartFileAccess::open(const QStringList& fileSet, const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RifEclipseUnifiedRestartFileAccess::close() void RifEclipseUnifiedRestartFileAccess::close()
{ {
if (m_file.notNull())
{
m_file->close();
m_file = NULL;
}
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -87,11 +80,10 @@ size_t RifEclipseUnifiedRestartFileAccess::numTimeSteps()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QStringList RifEclipseUnifiedRestartFileAccess::timeStepsText() QStringList RifEclipseUnifiedRestartFileAccess::timeStepsText()
{ {
RifEclipseOutputFileTools* file = m_file.p(); CVF_ASSERT(m_ecl_file != NULL);
CVF_ASSERT(file != NULL);
QStringList timeSteps; QStringList timeSteps;
file->timeStepsText(&timeSteps); RifEclipseOutputFileTools::timeStepsText(m_ecl_file, &timeSteps);
return timeSteps; return timeSteps;
} }
@ -101,11 +93,10 @@ QStringList RifEclipseUnifiedRestartFileAccess::timeStepsText()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QList<QDateTime> RifEclipseUnifiedRestartFileAccess::timeSteps() QList<QDateTime> RifEclipseUnifiedRestartFileAccess::timeSteps()
{ {
RifEclipseOutputFileTools* file = m_file.p(); CVF_ASSERT(m_ecl_file != NULL);
CVF_ASSERT(file != NULL);
QList<QDateTime> timeSteps; QList<QDateTime> timeSteps;
file->timeSteps(&timeSteps); RifEclipseOutputFileTools::timeSteps(m_ecl_file, &timeSteps);
return timeSteps; return timeSteps;
} }
@ -113,32 +104,26 @@ QList<QDateTime> RifEclipseUnifiedRestartFileAccess::timeSteps()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Get list of result names /// 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 RifEclipseOutputFileTools::findKeywordsAndDataItemCounts(m_ecl_file, resultNames, resultDataItemCounts);
QStringList resultsList;
m_file->validKeywords(&resultsList, matrixOrFracture);
return resultsList;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Get result values for given time step /// 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 numOccurrences = ecl_file_get_num_named_kw(m_ecl_file, resultName.toAscii().data());
size_t startIndex = timeStep * m_gridCount;
CVF_ASSERT(startIndex + m_gridCount <= numOccurrences); size_t startIndex = timeStep * gridCount;
CVF_ASSERT(startIndex + gridCount <= numOccurrences);
size_t occurrenceIdx; size_t occurrenceIdx;
for (occurrenceIdx = startIndex; occurrenceIdx < startIndex + m_gridCount; occurrenceIdx++) for (occurrenceIdx = startIndex; occurrenceIdx < startIndex + gridCount; occurrenceIdx++)
{ {
std::vector<double> partValues; std::vector<double> partValues;
if (!m_file->keywordData(resultName, occurrenceIdx, matrixOrFracture, &partValues)) // !! don't need to append afterwards RifEclipseOutputFileTools::keywordData(m_ecl_file, resultName, occurrenceIdx, &partValues);
{
return false;
}
values->insert(values->end(), partValues.begin(), partValues.end()); 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) void RifEclipseUnifiedRestartFileAccess::readWellData(well_info_type* well_info)
{ {
if (!well_info) return; 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);
} }

12
ApplicationCode/FileInterface/RifEclipseUnifiedRestartFileAccess.h
View File

@ -22,6 +22,8 @@
class RifEclipseOutputFileTools; class RifEclipseOutputFileTools;
//typedef struct ecl_file_struct ecl_file_type;
#include "well_info.h" #include "well_info.h"
//================================================================================================== //==================================================================================================
@ -35,20 +37,18 @@ public:
RifEclipseUnifiedRestartFileAccess(); RifEclipseUnifiedRestartFileAccess();
virtual ~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(); void close();
size_t numTimeSteps(); size_t numTimeSteps();
QStringList timeStepsText(); QStringList timeStepsText();
QList<QDateTime> timeSteps(); QList<QDateTime> timeSteps();
QStringList resultNames(RifReaderInterface::PorosityModelResultType matrixOrFracture); void resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts);
bool results(const QString& resultName, RifReaderInterface::PorosityModelResultType matrixOrFracture, size_t timeStep, std::vector<double>* values); bool results(const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values);
virtual void readWellData(well_info_type * well_info); virtual void readWellData(well_info_type * well_info);
private: private:
cvf::ref<RifEclipseOutputFileTools> m_file; ecl_file_type* m_ecl_file;
size_t m_gridCount;
}; };

199
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -212,7 +212,7 @@ void RifReaderEclipseOutput::ground()
m_fileSet.clear(); m_fileSet.clear();
m_timeSteps.clear(); m_timeSteps.clear();
m_mainGrid = NULL;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -220,7 +220,7 @@ void RifReaderEclipseOutput::ground()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RifReaderEclipseOutput::close() void RifReaderEclipseOutput::close()
{ {
m_staticResultsAccess = NULL; m_ecl_file = NULL;
m_dynamicResultsAccess = NULL; m_dynamicResultsAccess = NULL;
ground(); ground();
@ -356,6 +356,11 @@ bool RifReaderEclipseOutput::open(const QString& fileName, RigReservoir* reservo
progInfo.setProgress(8); progInfo.setProgress(8);
progInfo.setProgressDescription("Reading Result index"); 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 // Build results meta data
if (!buildMetaData(reservoir)) return false; if (!buildMetaData(reservoir)) return false;
@ -363,7 +368,8 @@ bool RifReaderEclipseOutput::open(const QString& fileName, RigReservoir* reservo
progInfo.setProgressDescription("Reading Well information"); progInfo.setProgressDescription("Reading Well information");
readWellCells(reservoir); readWellCells(reservoir);
return true; return true;
} }
@ -377,19 +383,8 @@ bool RifReaderEclipseOutput::buildMetaData(RigReservoir* reservoir)
caf::ProgressInfo progInfo(2,""); 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 // Create access object for dynamic results
m_dynamicResultsAccess = dynamicResultsAccess(m_fileSet, matrixModelActiveCellCounts, fractureModelActiveCellCount); m_dynamicResultsAccess = dynamicResultsAccess(m_fileSet);
if (m_dynamicResultsAccess.isNull()) if (m_dynamicResultsAccess.isNull())
{ {
return false; return false;
@ -403,22 +398,26 @@ bool RifReaderEclipseOutput::buildMetaData(RigReservoir* reservoir)
// Get time steps // Get time steps
m_timeSteps = m_dynamicResultsAccess->timeSteps(); m_timeSteps = m_dynamicResultsAccess->timeSteps();
{ QStringList resultNames;
QStringList dynamicResultNames = m_dynamicResultsAccess->resultNames(RifReaderInterface::MATRIX_RESULTS); 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); 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); fractureModelResults->setTimeStepDates(resIndex, m_timeSteps);
} }
} }
@ -430,17 +429,15 @@ bool RifReaderEclipseOutput::buildMetaData(RigReservoir* reservoir)
QString initFileName = RifEclipseOutputFileTools::fileNameByType(m_fileSet, ECL_INIT_FILE); QString initFileName = RifEclipseOutputFileTools::fileNameByType(m_fileSet, ECL_INIT_FILE);
if (initFileName.size() > 0) if (initFileName.size() > 0)
{ {
// Open init file ecl_file_type* ecl_file = ecl_file_open(initFileName.toAscii().data());
cvf::ref<RifEclipseOutputFileTools> initFile = new RifEclipseOutputFileTools; if (!ecl_file) return false;
if (!initFile->open(initFileName, matrixModelActiveCellCounts, fractureModelActiveCellCount))
{ QStringList resultNames;
return false; std::vector<size_t> resultNamesDataItemCounts;
} RifEclipseOutputFileTools::findKeywordsAndDataItemCounts(ecl_file, &resultNames, &resultNamesDataItemCounts);
{ {
QStringList staticResults; QStringList matrixResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts, RifReaderInterface::MATRIX_RESULTS, 1);
initFile->validKeywords(&staticResults, RifReaderInterface::MATRIX_RESULTS);
QStringList staticResultNames = staticResults;
QList<QDateTime> staticDate; QList<QDateTime> staticDate;
if (m_timeSteps.size() > 0) if (m_timeSteps.size() > 0)
@ -448,17 +445,15 @@ bool RifReaderEclipseOutput::buildMetaData(RigReservoir* reservoir)
staticDate.push_back(m_timeSteps.front()); 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); matrixModelResults->setTimeStepDates(resIndex, staticDate);
} }
} }
{ {
QStringList staticResults; QStringList fractureResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts, RifReaderInterface::FRACTURE_RESULTS, 1);
initFile->validKeywords(&staticResults, RifReaderInterface::FRACTURE_RESULTS);
QStringList staticResultNames = staticResults;
QList<QDateTime> staticDate; QList<QDateTime> staticDate;
if (m_timeSteps.size() > 0) if (m_timeSteps.size() > 0)
@ -466,14 +461,14 @@ bool RifReaderEclipseOutput::buildMetaData(RigReservoir* reservoir)
staticDate.push_back(m_timeSteps.front()); 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); fractureModelResults->setTimeStepDates(resIndex, staticDate);
} }
} }
m_staticResultsAccess = initFile; m_ecl_file = ecl_file;
} }
return true; return true;
@ -482,7 +477,7 @@ bool RifReaderEclipseOutput::buildMetaData(RigReservoir* reservoir)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Create results access object (.UNRST or .X0001 ... .XNNNN) /// 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; RifEclipseRestartDataAccess* resultsAccess = NULL;
@ -491,7 +486,7 @@ RifEclipseRestartDataAccess* RifReaderEclipseOutput::dynamicResultsAccess(const
if (unrstFileName.size() > 0) if (unrstFileName.size() > 0)
{ {
resultsAccess = new RifEclipseUnifiedRestartFileAccess(); resultsAccess = new RifEclipseUnifiedRestartFileAccess();
if (!resultsAccess->open(QStringList(unrstFileName), matrixActiveCellCounts, fractureActiveCellCounts)) if (!resultsAccess->open(QStringList(unrstFileName)))
{ {
delete resultsAccess; delete resultsAccess;
return NULL; return NULL;
@ -504,7 +499,7 @@ RifEclipseRestartDataAccess* RifReaderEclipseOutput::dynamicResultsAccess(const
if (restartFiles.size() > 0) if (restartFiles.size() > 0)
{ {
resultsAccess = new RifEclipseRestartFilesetAccess(); resultsAccess = new RifEclipseRestartFilesetAccess();
if (!resultsAccess->open(restartFiles, matrixActiveCellCounts, fractureActiveCellCounts)) if (!resultsAccess->open(restartFiles))
{ {
delete resultsAccess; delete resultsAccess;
return NULL; return NULL;
@ -524,17 +519,21 @@ RifEclipseRestartDataAccess* RifReaderEclipseOutput::dynamicResultsAccess(const
bool RifReaderEclipseOutput::staticResult(const QString& result, PorosityModelResultType matrixOrFracture, std::vector<double>* values) bool RifReaderEclipseOutput::staticResult(const QString& result, PorosityModelResultType matrixOrFracture, std::vector<double>* values)
{ {
CVF_ASSERT(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; size_t i;
for (i = 0; i < numOccurrences; i++) for (i = 0; i < numOccurrences; i++)
{ {
std::vector<double> partValues; std::vector<double> partValues;
if (!m_staticResultsAccess->keywordData(result, i, matrixOrFracture, &partValues)) return false; RifEclipseOutputFileTools::keywordData(m_ecl_file, result, i, &partValues);
values->insert(values->end(), partValues.begin(), partValues.end()); fileValues.insert(fileValues.end(), partValues.begin(), partValues.end());
} }
extractResultValuesBasedOnPorosityModel(matrixOrFracture, values, fileValues);
return true; 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) bool RifReaderEclipseOutput::dynamicResult(const QString& result, PorosityModelResultType matrixOrFracture, size_t stepIndex, std::vector<double>* values)
{ {
CVF_ASSERT(m_dynamicResultsAccess.notNull()); 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; 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);
}
}
}

15
ApplicationCode/FileInterface/RifReaderEclipseOutput.h
View File

@ -25,8 +25,11 @@
class RifEclipseOutputFileTools; class RifEclipseOutputFileTools;
class RifEclipseRestartDataAccess; class RifEclipseRestartDataAccess;
class RigGridBase; class RigGridBase;
class RigMainGrid;
typedef struct ecl_grid_struct ecl_grid_type; 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); bool buildMetaData(RigReservoir* reservoir);
void readWellCells(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); 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* staticResultsAccess(const QStringList& fileSet);
static RifEclipseRestartDataAccess* dynamicResultsAccess(const QStringList& fileSet, const std::vector<size_t>& matrixModelActiveCellCounts, const std::vector<size_t>& fractureModelActiveCellCounts); static RifEclipseRestartDataAccess* dynamicResultsAccess(const QStringList& fileSet);
QStringList validKeywordsForPorosityModel(const QStringList& keywords, const std::vector<size_t>& keywordDataItemCounts, PorosityModelResultType matrixOrFracture, size_t timeStepCount) const;
private: private:
QString m_fileName; // Name of file used to start accessing Eclipse output files 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 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; 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 cvf::ref<RifEclipseRestartDataAccess> m_dynamicResultsAccess; // File access to dynamic results
}; };

12
ApplicationCode/ProjectDataModel/RimResultDefinition.cpp
View File

@ -43,7 +43,6 @@ RimResultDefinition::RimResultDefinition()
CAF_PDM_InitField(&resultVariable, "ResultVariable", RimDefines::undefinedResultName(), "Variable", "", "", "" ); CAF_PDM_InitField(&resultVariable, "ResultVariable", RimDefines::undefinedResultName(), "Variable", "", "", "" );
resultVariable.setUiEditorTypeName(caf::PdmUiListEditor::uiEditorTypeName()); resultVariable.setUiEditorTypeName(caf::PdmUiListEditor::uiEditorTypeName());
porosityModel.setUiHidden(true);
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -60,6 +59,17 @@ RimResultDefinition::~RimResultDefinition()
void RimResultDefinition::setReservoirView(RimReservoirView* ownerReservoirView) void RimResultDefinition::setReservoirView(RimReservoirView* ownerReservoirView)
{ {
m_reservoirView = 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);
}
}
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

6
ApplicationCode/ProjectDataModel/RimResultReservoir.cpp
View File

@ -56,6 +56,9 @@ bool RimResultReservoir::openEclipseGridFile()
if (caseName().contains("Result Mock Debug Model")) if (caseName().contains("Result Mock Debug Model"))
{ {
readerInterface = this->createMockModel(this->caseName()); 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 else
{ {
@ -89,9 +92,6 @@ bool RimResultReservoir::openEclipseGridFile()
CVF_ASSERT(m_rigReservoir.notNull()); CVF_ASSERT(m_rigReservoir.notNull());
CVF_ASSERT(readerInterface.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"); progInfo.setProgressDescription("Computing Faults");
m_rigReservoir->computeFaults(); m_rigReservoir->computeFaults();
progInfo.setProgressDescription("Computing Cache"); progInfo.setProgressDescription("Computing Cache");