OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-03 12:10:57 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch '2018.01.01-patch' into dev. #2086

Browse Source
This commit is contained in:
Bjørn Erik Jensen 2018-02-05 08:29:24 +01:00
commit c09dd0522b
17 changed files with 169 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/Application/Tools/CMakeLists_files.cmake
View File

@ -24,6 +24,7 @@ ${CEE_CURRENT_LIST_DIR}RiaStdStringTools.h
${CEE_CURRENT_LIST_DIR}RiaSummaryCurveAnalyzer.h
${CEE_CURRENT_LIST_DIR}RiaSimWellBranchTools.h
${CEE_CURRENT_LIST_DIR}RiaProjectFileVersionTools.h
${CEE_CURRENT_LIST_DIR}RiaStringEncodingTools.h
)
set (SOURCE_GROUP_SOURCE_FILES
@ -45,6 +46,7 @@ ${CEE_CURRENT_LIST_DIR}RiaStdStringTools.cpp
${CEE_CURRENT_LIST_DIR}RiaSummaryCurveAnalyzer.cpp
${CEE_CURRENT_LIST_DIR}RiaSimWellBranchTools.cpp
${CEE_CURRENT_LIST_DIR}RiaProjectFileVersionTools.cpp
${CEE_CURRENT_LIST_DIR}RiaStringEncodingTools.cpp
)
list(APPEND CODE_HEADER_FILES

43
ApplicationCode/Application/Tools/RiaStringEncodingTools.cpp Normal file
View File

@ -0,0 +1,43 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2011- Statoil ASA
// Copyright (C) 2013- Ceetron Solutions AS
// Copyright (C) 2011-2012 Ceetron AS
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RiaStringEncodingTools.h"
const std::string RiaStringEncodingTools::toNativeEncoded(const QString& qstring)
{
#ifdef WIN32
return std::string(qstring.toLatin1().data());
#else
return std::string(qstring.toUtf8().data());
#endif
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const QString RiaStringEncodingTools::fromNativeEncoded(const char* native)
{
#ifdef WIN32
return QString::fromLatin1(native);
#else
return QString::fromUtf8(native);
#endif
}

38
ApplicationCode/Application/Tools/RiaStringEncodingTools.h Normal file
View File

@ -0,0 +1,38 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2011- Statoil ASA
// Copyright (C) 2013- Ceetron Solutions AS
// Copyright (C) 2011-2012 Ceetron AS
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include <QString>
#include <QByteArray>
#include <string>
//==================================================================================================
//
//
//
//==================================================================================================
class RiaStringEncodingTools
{
public:
static const std::string toNativeEncoded(const QString& qstring);
static const QString fromNativeEncoded(const char* native);
};

15
ApplicationCode/FileInterface/RifEclipseOutputFileTools.cpp
View File

@ -22,6 +22,7 @@
#include "RifEclipseRestartFilesetAccess.h"
#include "RifEclipseUnifiedRestartFileAccess.h"
#include "RiaStringEncodingTools.h"
#include "RiaQDateTimeTools.h"
#include "ert/ecl/ecl_file.h"
@ -183,7 +184,7 @@ void RifEclipseOutputFileTools::timeSteps(ecl_file_type* ecl_file, std::vector<Q
//--------------------------------------------------------------------------------------------------
bool RifEclipseOutputFileTools::keywordData(ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<double>* values)
{
ecl_kw_type* kwData = ecl_file_iget_named_kw(ecl_file, keyword.toAscii().data(), static_cast<int>(fileKeywordOccurrence));
ecl_kw_type* kwData = ecl_file_iget_named_kw(ecl_file, RiaStringEncodingTools::toNativeEncoded(keyword).data(), static_cast<int>(fileKeywordOccurrence));
if (kwData)
{
size_t numValues = ecl_kw_get_size(kwData);
@ -205,7 +206,7 @@ bool RifEclipseOutputFileTools::keywordData(ecl_file_type* ecl_file, const QStri
//--------------------------------------------------------------------------------------------------
bool RifEclipseOutputFileTools::keywordData(ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<int>* values)
{
ecl_kw_type* kwData = ecl_file_iget_named_kw(ecl_file, keyword.toAscii().data(), static_cast<int>(fileKeywordOccurrence));
ecl_kw_type* kwData = ecl_file_iget_named_kw(ecl_file, RiaStringEncodingTools::toNativeEncoded(keyword).data(), static_cast<int>(fileKeywordOccurrence));
if (kwData)
{
size_t numValues = ecl_kw_get_size(kwData);
@ -232,7 +233,7 @@ QString RifEclipseOutputFileTools::firstFileNameOfType(const QStringList& fileSe
{
bool formatted = false;
int reportNumber = -1;
if (ecl_util_get_file_type(fileSet.at(i).toAscii().data(), &formatted, &reportNumber) == fileType)
if (ecl_util_get_file_type(RiaStringEncodingTools::toNativeEncoded(fileSet.at(i)).data(), &formatted, &reportNumber) == fileType)
{
return fileSet.at(i);
}
@ -253,7 +254,7 @@ QStringList RifEclipseOutputFileTools::filterFileNamesOfType(const QStringList&
{
bool formatted = false;
int reportNumber = -1;
if (ecl_util_get_file_type(fileSet.at(i).toAscii().data(), &formatted, &reportNumber) == fileType)
if (ecl_util_get_file_type(RiaStringEncodingTools::toNativeEncoded(fileSet.at(i)).data(), &formatted, &reportNumber) == fileType)
{
fileNames.append(fileSet.at(i));
}
@ -276,12 +277,12 @@ bool RifEclipseOutputFileTools::findSiblingFilesWithSameBaseName(const QString&
QString fileNameBase = QFileInfo(fullPathFileName).baseName();
stringlist_type* eclipseFiles = stringlist_alloc_new();
ecl_util_select_filelist(filePath.toAscii().data(), fileNameBase.toAscii().data(), ECL_OTHER_FILE, false, eclipseFiles);
ecl_util_select_filelist(RiaStringEncodingTools::toNativeEncoded(filePath).data(), RiaStringEncodingTools::toNativeEncoded(fileNameBase).data(), ECL_OTHER_FILE, false, eclipseFiles);
int i;
for (i = 0; i < stringlist_get_size(eclipseFiles); i++)
{
baseNameFiles->append(stringlist_safe_iget(eclipseFiles, i));
baseNameFiles->append(RiaStringEncodingTools::fromNativeEncoded(stringlist_safe_iget(eclipseFiles, i)));
}
stringlist_free(eclipseFiles);
@ -294,7 +295,7 @@ bool RifEclipseOutputFileTools::findSiblingFilesWithSameBaseName(const QString&
//--------------------------------------------------------------------------------------------------
void RifEclipseOutputFileTools::readGridDimensions(const QString& gridFileName, std::vector< std::vector<int> >& gridDimensions)
{
ecl_grid_type * grid = ecl_grid_alloc(gridFileName.toAscii().data()); // bootstrap ecl_grid instance
ecl_grid_type * grid = ecl_grid_alloc(RiaStringEncodingTools::toNativeEncoded(gridFileName).data()); // bootstrap ecl_grid instance
stringlist_type * lgr_names = ecl_grid_alloc_lgr_name_list( grid ); // get a list of all the lgr names.
//printf("grid:%s has %d a total of %d lgr's \n", grid_filename , stringlist_get_size( lgr_names ));

6
ApplicationCode/FileInterface/RifEclipseRestartFilesetAccess.cpp
View File

@ -20,6 +20,8 @@
#include "RifEclipseRestartFilesetAccess.h"
#include "RifEclipseOutputFileTools.h"
#include "RiaStringEncodingTools.h"
#include "cafProgressInfo.h"
#include "ert/ecl/ecl_file.h"
@ -270,7 +272,7 @@ void RifEclipseRestartFilesetAccess::openTimeStep(size_t timeStep)
if (m_ecl_files[timeStep] == NULL)
{
int index = static_cast<int>(timeStep);
ecl_file_type* ecl_file = ecl_file_open(m_fileNames[index].toAscii().data(), ECL_FILE_CLOSE_STREAM);
ecl_file_type* ecl_file = ecl_file_open(RiaStringEncodingTools::toNativeEncoded(m_fileNames[index]).data(), ECL_FILE_CLOSE_STREAM);
m_ecl_files[timeStep] = ecl_file;
@ -295,7 +297,7 @@ int RifEclipseRestartFilesetAccess::reportNumber(const ecl_file_type* ecl_file)
fileNameUpper = fileNameUpper.toUpper();
// Convert to upper case, as ecl_util_filename_report_nr does not handle lower case file extensions
int reportNumber = ecl_util_filename_report_nr(fileNameUpper.toAscii().data());
int reportNumber = ecl_util_filename_report_nr(RiaStringEncodingTools::toNativeEncoded(fileNameUpper).data());
return reportNumber;
}

52
ApplicationCode/FileInterface/RifEclipseSummaryTools.cpp
View File

@ -20,17 +20,21 @@
#include "RiaSummaryCurveAnalyzer.h"
#include "RifReaderEclipseSummary.h"
#include "RiaStringEncodingTools.h"
#include "cafAppEnum.h"
#include "ert/ecl/ecl_util.h"
#include <QString>
#include <QStringList>
#include <iostream>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifEclipseSummaryTools::findSummaryHeaderFile(const std::string& inputFile, std::string* headerFile, bool* isFormatted)
void RifEclipseSummaryTools::findSummaryHeaderFile(const QString& inputFile, QString* headerFile, bool* isFormatted)
{
findSummaryHeaderFileInfo(inputFile, headerFile, NULL, NULL, isFormatted);
}
@ -38,9 +42,9 @@ void RifEclipseSummaryTools::findSummaryHeaderFile(const std::string& inputFile,
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifEclipseSummaryTools::findSummaryFiles(const std::string& inputFile,
std::string* headerFile,
std::vector<std::string>* dataFiles)
void RifEclipseSummaryTools::findSummaryFiles(const QString& inputFile,
QString* headerFile,
QStringList* dataFiles)
{
dataFiles->clear();
headerFile->clear();
@ -49,21 +53,21 @@ void RifEclipseSummaryTools::findSummaryFiles(const std::string& inputFile,
char* myBase = NULL;
char* myExtention = NULL;
util_alloc_file_components(inputFile.data(), &myPath, &myBase, &myExtention);
util_alloc_file_components(RiaStringEncodingTools::toNativeEncoded(inputFile).data(), &myPath, &myBase, &myExtention);
std::string path; if(myPath) path = myPath;
std::string base; if(myBase) base = myBase;
QString path; if(myPath) path = RiaStringEncodingTools::fromNativeEncoded(myPath);
QString base; if(myBase) base = RiaStringEncodingTools::fromNativeEncoded(myBase);
std::string extention; if(myExtention) extention = myExtention;
if(path.empty() || base.empty()) return ;
if(path.isEmpty() || base.isEmpty()) return ;
char* myHeaderFile = NULL;
stringlist_type* summary_file_list = stringlist_alloc_new();
ecl_util_alloc_summary_files(path.data(), base.data(), extention.data(), &myHeaderFile, summary_file_list);
ecl_util_alloc_summary_files(RiaStringEncodingTools::toNativeEncoded(path).data(), RiaStringEncodingTools::toNativeEncoded(base).data(), extention.data(), &myHeaderFile, summary_file_list);
if(myHeaderFile)
{
(*headerFile) = myHeaderFile;
(*headerFile) = RiaStringEncodingTools::fromNativeEncoded(myHeaderFile);
util_safe_free(myHeaderFile);
}
@ -71,7 +75,7 @@ void RifEclipseSummaryTools::findSummaryFiles(const std::string& inputFile,
{
for(int i = 0; i < stringlist_get_size(summary_file_list); i++)
{
dataFiles->push_back(stringlist_iget(summary_file_list,i));
dataFiles->push_back(RiaStringEncodingTools::fromNativeEncoded(stringlist_iget(summary_file_list,i)));
}
}
stringlist_free(summary_file_list);
@ -83,12 +87,12 @@ void RifEclipseSummaryTools::findSummaryFiles(const std::string& inputFile,
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseSummaryTools::hasSummaryFiles(const std::string& gridFileName)
bool RifEclipseSummaryTools::hasSummaryFiles(const QString& gridFileName)
{
std::string headerFileName;
std::vector<std::string> dataFileNames;
QString headerFileName;
QStringList dataFileNames;
RifEclipseSummaryTools::findSummaryFiles(gridFileName, &headerFileName, &dataFileNames);
if (!headerFileName.empty() && dataFileNames.size()) return true;
if (!headerFileName.isEmpty() && dataFileNames.size()) return true;
return false;
}
@ -96,25 +100,25 @@ bool RifEclipseSummaryTools::hasSummaryFiles(const std::string& gridFileName)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<std::string> RifEclipseSummaryTools::findSummaryDataFiles(const std::string& caseFile)
QStringList RifEclipseSummaryTools::findSummaryDataFiles(const QString& caseFile)
{
std::vector<std::string> fileNames;
QStringList fileNames;
std::string path;
std::string base;
QString path;
QString base;
findSummaryHeaderFileInfo(caseFile, NULL, &path, &base, NULL);
if (path.empty() || base.empty()) return fileNames;
if (path.isEmpty() || base.isEmpty()) return fileNames;
char* header_file = NULL;
stringlist_type* summary_file_list = stringlist_alloc_new();
ecl_util_alloc_summary_files(path.data(), base.data(), NULL, &header_file, summary_file_list);
ecl_util_alloc_summary_files(RiaStringEncodingTools::toNativeEncoded(path).data(), RiaStringEncodingTools::toNativeEncoded(base).data(), NULL, &header_file, summary_file_list);
if (stringlist_get_size( summary_file_list ) > 0)
{
for (int i = 0; i < stringlist_get_size(summary_file_list); i++)
{
fileNames.push_back(stringlist_iget(summary_file_list, i));
fileNames.push_back(RiaStringEncodingTools::fromNativeEncoded(stringlist_iget(summary_file_list, i)));
}
}
@ -163,13 +167,13 @@ void RifEclipseSummaryTools::dumpMetaData(RifSummaryReaderInterface* readerEclip
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifEclipseSummaryTools::findSummaryHeaderFileInfo(const std::string& inputFile, std::string* headerFile, std::string* path, std::string* base, bool* isFormatted)
void RifEclipseSummaryTools::findSummaryHeaderFileInfo(const QString& inputFile, QString* headerFile, QString* path, QString* base, bool* isFormatted)
{
char* myPath = NULL;
char* myBase = NULL;
bool formattedFile = true;
util_alloc_file_components(inputFile.data(), &myPath, &myBase, NULL);
util_alloc_file_components(RiaStringEncodingTools::toNativeEncoded(inputFile).data(), &myPath, &myBase, NULL);
char* myHeaderFile = ecl_util_alloc_exfilename(myPath, myBase, ECL_SUMMARY_HEADER_FILE, true, -1);
if (!myHeaderFile)

12
ApplicationCode/FileInterface/RifEclipseSummaryTools.h
View File

@ -24,6 +24,8 @@
#include <vector>
class RifSummaryReaderInterface;
class QStringList;
class QString;
//==================================================================================================
//
@ -33,13 +35,13 @@ class RifSummaryReaderInterface;
class RifEclipseSummaryTools
{
public:
static void findSummaryHeaderFile(const std::string& inputFile, std::string* headerFile, bool* isFormatted);
static std::vector<std::string> findSummaryDataFiles(const std::string& caseFile);
static void findSummaryHeaderFile(const QString& inputFile, QString* headerFile, bool* isFormatted);
static QStringList findSummaryDataFiles(const QString& caseFile);
static void findSummaryFiles(const std::string& inputFile, std::string* headerFile, std::vector<std::string>* dataFiles);
static bool hasSummaryFiles(const std::string& gridFileName);
static void findSummaryFiles(const QString& inputFile, QString* headerFile, QStringList* dataFiles);
static bool hasSummaryFiles(const QString& gridFileName);
static void dumpMetaData(RifSummaryReaderInterface* readerEclipseSummary);
private:
static void findSummaryHeaderFileInfo(const std::string& inputFile, std::string* headerFile, std::string* path, std::string* base, bool* isFormatted);
static void findSummaryHeaderFileInfo(const QString& inputFile, QString* headerFile, QString* path, QString* base, bool* isFormatted);
};

7
ApplicationCode/FileInterface/RifEclipseUnifiedRestartFileAccess.cpp
View File

@ -26,6 +26,7 @@
#include "RifEclipseOutputFileTools.h"
#include "RifReaderSettings.h"
#include "RiaStringEncodingTools.h"
#include "ert/ecl/ecl_file.h"
#include "ert/ecl/ecl_kw_magic.h"
@ -83,7 +84,7 @@ bool RifEclipseUnifiedRestartFileAccess::openFile()
if (resultFileInfo.lastModified() < indexFileInfo.lastModified())
{
m_ecl_file = ecl_file_fast_open(m_filename.toAscii().data(), indexFileName.toAscii().data(), ECL_FILE_CLOSE_STREAM);
m_ecl_file = ecl_file_fast_open(RiaStringEncodingTools::toNativeEncoded(m_filename).data(), RiaStringEncodingTools::toNativeEncoded(indexFileName).data(), ECL_FILE_CLOSE_STREAM);
if (!m_ecl_file)
{
RiaLogging::error(QString("Failed to open file %1 using index file.").arg(m_filename));
@ -99,7 +100,7 @@ bool RifEclipseUnifiedRestartFileAccess::openFile()
if (!m_ecl_file)
{
m_ecl_file = ecl_file_open(m_filename.toAscii().data(), ECL_FILE_CLOSE_STREAM);
m_ecl_file = ecl_file_open(RiaStringEncodingTools::toNativeEncoded(m_filename).data(), ECL_FILE_CLOSE_STREAM);
if (!m_ecl_file)
{
RiaLogging::error(QString("Failed to open file %1").arg(m_filename));
@ -112,7 +113,7 @@ bool RifEclipseUnifiedRestartFileAccess::openFile()
QString resultPath = fi.absolutePath();
if (caf::Utils::isFolderWritable(resultPath))
{
bool success = ecl_file_write_index(m_ecl_file, indexFileName.toAscii().data());
bool success = ecl_file_write_index(m_ecl_file, RiaStringEncodingTools::toNativeEncoded(indexFileName).data());
if (success)
{

7
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -28,6 +28,7 @@
#include "RifEclipseOutputFileTools.h"
#include "RifHdf5ReaderInterface.h"
#include "RifReaderSettings.h"
#include "RiaStringEncodingTools.h"
#ifdef USE_HDF5
#include "RifHdf5Reader.h"
@ -374,7 +375,7 @@ bool RifReaderEclipseOutput::open(const QString& fileName, RigEclipseCaseData* e
// Read geometry
// Todo: Needs to check existence of file before calling ert, else it will abort
ecl_grid_type * mainEclGrid = ecl_grid_alloc( fileName.toAscii().data() );
ecl_grid_type * mainEclGrid = ecl_grid_alloc( RiaStringEncodingTools::toNativeEncoded(fileName).data() );
progInfo.incrementProgress();
@ -722,7 +723,7 @@ bool RifReaderEclipseOutput::readActiveCellInfo()
QString egridFileName = RifEclipseOutputFileTools::firstFileNameOfType(m_filesWithSameBaseName, ECL_EGRID_FILE);
if (egridFileName.size() > 0)
{
ecl_file_type* ecl_file = ecl_file_open(egridFileName.toAscii().data(), ECL_FILE_CLOSE_STREAM);
ecl_file_type* ecl_file = ecl_file_open(RiaStringEncodingTools::toNativeEncoded(egridFileName).data(), ECL_FILE_CLOSE_STREAM);
if (!ecl_file) return false;
int actnumKeywordCount = ecl_file_get_num_named_kw(ecl_file, ACTNUM_KW);
@ -2213,7 +2214,7 @@ void RifReaderEclipseOutput::openInitFile()
QString initFileName = RifEclipseOutputFileTools::firstFileNameOfType(m_filesWithSameBaseName, ECL_INIT_FILE);
if (initFileName.size() > 0)
{
m_ecl_init_file = ecl_file_open(initFileName.toAscii().data(), ECL_FILE_CLOSE_STREAM);
m_ecl_init_file = ecl_file_open(RiaStringEncodingTools::toNativeEncoded(initFileName).data(), ECL_FILE_CLOSE_STREAM);
}
}

12
ApplicationCode/FileInterface/RifReaderEclipseRft.cpp
View File

@ -21,6 +21,8 @@
#include "RiaLogging.h"
#include "RiaQDateTimeTools.h"
#include "RiaStringEncodingTools.h"
#include "cafVecIjk.h"
#include "ert/ecl/ecl_rft_file.h"
@ -28,7 +30,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifReaderEclipseRft::RifReaderEclipseRft(const std::string& fileName):
RifReaderEclipseRft::RifReaderEclipseRft(const QString& fileName):
m_fileName(fileName), m_ecl_rft_file(nullptr)
{
}
@ -45,15 +47,15 @@ RifReaderEclipseRft::~RifReaderEclipseRft()
//--------------------------------------------------------------------------------------------------
void RifReaderEclipseRft::open()
{
if (m_fileName.empty()) return;
if (m_fileName.isEmpty()) return;
RiaLogging::info(QString("Opening file '%1'").arg(m_fileName.c_str()));
RiaLogging::info(QString("Opening file '%1'").arg( m_fileName));
m_ecl_rft_file = ecl_rft_file_alloc_case(m_fileName.data());
m_ecl_rft_file = ecl_rft_file_alloc_case(RiaStringEncodingTools::toNativeEncoded(m_fileName).data());
if (m_ecl_rft_file == NULL)
{
RiaLogging::warning(QString("Libecl could not find/open file '%'").arg(m_fileName.c_str()));
RiaLogging::warning(QString("Libecl could not find/open file '%'").arg( m_fileName));
return;
}

4
ApplicationCode/FileInterface/RifReaderEclipseRft.h
View File

@ -41,7 +41,7 @@ namespace caf
class RifReaderEclipseRft : public cvf::Object
{
public:
RifReaderEclipseRft(const std::string& fileName);
RifReaderEclipseRft(const QString& fileName);
~RifReaderEclipseRft();
const std::vector<RifEclipseRftAddress>& eclipseRftAddresses();
@ -63,7 +63,7 @@ private:
// Taken from ecl_rft_file.h and ecl_rft_node.h
typedef struct ecl_rft_file_struct ecl_rft_file_type;
std::string m_fileName;
QString m_fileName;
ecl_rft_file_type* m_ecl_rft_file;
std::vector<RifEclipseRftAddress> m_eclipseRftAddresses;
std::set<QString> m_wellNames;

15
ApplicationCode/FileInterface/RifReaderEclipseSummary.cpp
View File

@ -17,6 +17,7 @@
/////////////////////////////////////////////////////////////////////////////////
#include "RifReaderEclipseSummary.h"
#include "RiaStringEncodingTools.h"
#include "ert/ecl/ecl_sum.h"
@ -24,6 +25,8 @@
#include <assert.h>
#include <QDateTime>
#include <QString>
#include <QStringList>
#include "ert/ecl/smspec_node.h"
//--------------------------------------------------------------------------------------------------
@ -51,23 +54,23 @@ RifReaderEclipseSummary::~RifReaderEclipseSummary()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifReaderEclipseSummary::open(const std::string& headerFileName, const std::vector<std::string>& dataFileNames)
bool RifReaderEclipseSummary::open(const QString& headerFileName, const QStringList& dataFileNames)
{
assert(m_ecl_sum == NULL);
if (headerFileName.empty() || dataFileNames.size() == 0) return false;
if (headerFileName.isEmpty() || dataFileNames.size() == 0) return false;
assert(!headerFileName.empty());
assert(!headerFileName.isEmpty());
assert(dataFileNames.size() > 0);
stringlist_type* dataFiles = stringlist_alloc_new();
for (size_t i = 0; i < dataFileNames.size(); i++)
for (int i = 0; i < dataFileNames.size(); i++)
{
stringlist_append_copy(dataFiles, dataFileNames[i].data());
stringlist_append_copy(dataFiles, RiaStringEncodingTools::toNativeEncoded(dataFileNames[i]).data());
}
std::string itemSeparatorInVariableNames = ":";
m_ecl_sum = ecl_sum_fread_alloc(headerFileName.data(), dataFiles, itemSeparatorInVariableNames.data(), false);
m_ecl_sum = ecl_sum_fread_alloc(RiaStringEncodingTools::toNativeEncoded(headerFileName).data(), dataFiles, itemSeparatorInVariableNames.data(), false);
stringlist_free(dataFiles);

4
ApplicationCode/FileInterface/RifReaderEclipseSummary.h
View File

@ -25,6 +25,8 @@
#include <vector>
#include <map>
class QString;
class QStringList;
//==================================================================================================
//
@ -36,7 +38,7 @@ public:
RifReaderEclipseSummary();
~RifReaderEclipseSummary();
bool open(const std::string& headerFileName, const std::vector<std::string>& dataFileNames);
bool open(const QString& headerFileName, const QStringList& dataFileNames);
virtual const std::vector<time_t>& timeSteps(const RifEclipseSummaryAddress& resultAddress) const override;

2
ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp
View File

@ -208,7 +208,7 @@ bool RimEclipseResultCase::importGridAndResultMetaData(bool showTimeStepFilter)
if (rftFileInfo.exists())
{
RiaLogging::info(QString("RFT file found"));
m_readerEclipseRft = new RifReaderEclipseRft(rftFileInfo.filePath().toStdString());
m_readerEclipseRft = new RifReaderEclipseRft(rftFileInfo.filePath());
}

6
ApplicationCode/ProjectDataModel/Summary/RimFileSummaryCase.cpp
View File

@ -91,9 +91,9 @@ void RimFileSummaryCase::createSummaryReaderInterface()
//--------------------------------------------------------------------------------------------------
RifReaderEclipseSummary* RimFileSummaryCase::findRelatedFilesAndCreateReader(const QString& headerFileName)
{
std::string headerFileNameStd;
std::vector<std::string> dataFileNames;
std::string nativeSumHeadFileName = QDir::toNativeSeparators(headerFileName).toStdString();
QString headerFileNameStd;
QStringList dataFileNames;
QString nativeSumHeadFileName = QDir::toNativeSeparators(headerFileName);
RifEclipseSummaryTools::findSummaryFiles(nativeSumHeadFileName, &headerFileNameStd, &dataFileNames);
RifReaderEclipseSummary* summaryFileReader = new RifReaderEclipseSummary;

2
ApplicationCode/ProjectDataModel/Summary/RimSummaryCaseMainCollection.cpp
View File

@ -267,7 +267,7 @@ void RimSummaryCaseMainCollection::loadAllSummaryCaseData()
RimSummaryCase* RimSummaryCaseMainCollection::createAndAddSummaryCaseFromEclipseResultCase(RimEclipseResultCase* eclResCase)
{
QString gridFileName = eclResCase->gridFileName();
if(RifEclipseSummaryTools::hasSummaryFiles(QDir::toNativeSeparators(gridFileName).toStdString()))
if(RifEclipseSummaryTools::hasSummaryFiles(QDir::toNativeSeparators(gridFileName)))
{
RimGridSummaryCase* newSumCase = new RimGridSummaryCase();
this->m_cases.push_back(newSumCase);

11
ApplicationCode/ReservoirDataModel/RigWellLogFile.cpp
View File

@ -21,6 +21,8 @@
#include "RigWellLogCurveData.h"
#include "RiaStringEncodingTools.h"
#include "RimWellLogCurve.h"
#include "well.hpp"
@ -80,11 +82,8 @@ bool RigWellLogFile::open(const QString& fileName, QString* errorMessage)
try
{
int wellFormat = NRLib::Well::LAS;
#ifdef _WINDOWS
well = NRLib::Well::ReadWell(fileName.toStdString(), wellFormat);
#else
well = NRLib::Well::ReadWell(fileName.toUtf8().data(), wellFormat);
#endif
well = NRLib::Well::ReadWell(RiaStringEncodingTools::toNativeEncoded(fileName).data(), wellFormat);
if (!well)
{
return false;
@ -152,7 +151,7 @@ void RigWellLogFile::close()
QString RigWellLogFile::wellName() const
{
CVF_ASSERT(m_wellLogFile);
return QString::fromStdString(m_wellLogFile->GetWellName());
return RiaStringEncodingTools::fromNativeEncoded(m_wellLogFile->GetWellName().data());
}
//--------------------------------------------------------------------------------------------------