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

#2720, #2686, #2701 Origin summary and grid cases import enhancements

Browse Source
This commit is contained in:
Bjørn Erik Jensen 2018-04-13 11:11:05 +02:00
parent edf23b5265
commit d7e7c4a463
20 changed files with 381 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/Application/RiaApplication.cpp
View File

@ -1860,7 +1860,7 @@ bool RiaApplication::openFile(const QString& fileName)
}
else if (fileName.contains(".egrid", Qt::CaseInsensitive) || fileName.contains(".grid", Qt::CaseInsensitive))
{
loadingSucceded = RiaImportEclipseCaseTools::openEclipseCaseFromFile(fileName);
loadingSucceded = !RiaImportEclipseCaseTools::openEclipseCasesFromFile(QStringList({ fileName })).isEmpty();
}
else if (fileName.contains(".grdecl", Qt::CaseInsensitive))
{

1
ApplicationCode/Application/RiaPreferences.cpp
View File

@ -103,6 +103,7 @@ RiaPreferences::RiaPreferences(void)
CAF_PDM_InitFieldNoDefault(&summaryRestartFilesShowImportDialog, "summaryRestartFilesShowImportDialog", "Show Import Dialog", "", "", "");
CAF_PDM_InitFieldNoDefault(&summaryRestartFilesImportMode, "summaryRestartFilesImportMode", "Default Import Mode", "", "", "");
CAF_PDM_InitFieldNoDefault(&importRestartGridCaseFiles, "importRestartGridCaseFiles", "Import Restart Grid Cases", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_readerSettings, "readerSettings", "Reader Settings", "", "", "");
m_readerSettings = new RifReaderSettings;

1
ApplicationCode/Application/RiaPreferences.h
View File

@ -82,6 +82,7 @@ public: // Pdm Fields
caf::PdmField<bool> summaryRestartFilesShowImportDialog;
caf::PdmField<SummaryRestartFilesImportModeType> summaryRestartFilesImportMode;
caf::PdmField<bool> importRestartGridCaseFiles;
protected:
virtual void defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute);

6
ApplicationCode/Application/Tools/RiaArgumentParser.cpp
View File

@ -272,21 +272,21 @@ bool RiaArgumentParser::parseArguments()
if (caf::Utils::fileExists(caseName) &&
(fileExtension == "EGRID" || fileExtension == "GRID"))
{
RiaImportEclipseCaseTools::openEclipseCaseFromFile(caseName);
RiaImportEclipseCaseTools::openEclipseCasesFromFile(QStringList({ caseName }), true);
}
else
{
QString caseFileNameWithExt = caseName + ".EGRID";
if (caf::Utils::fileExists(caseFileNameWithExt))
{
RiaImportEclipseCaseTools::openEclipseCaseFromFile(caseFileNameWithExt);
RiaImportEclipseCaseTools::openEclipseCasesFromFile(QStringList({ caseFileNameWithExt }), true);
}
else
{
caseFileNameWithExt = caseName + ".GRID";
if (caf::Utils::fileExists(caseFileNameWithExt))
{
RiaImportEclipseCaseTools::openEclipseCaseFromFile(caseFileNameWithExt);
RiaImportEclipseCaseTools::openEclipseCasesFromFile(QStringList({ caseFileNameWithExt }), true);
}
}
}

143
ApplicationCode/Application/Tools/RiaImportEclipseCaseTools.cpp
View File

@ -23,6 +23,9 @@
#include "RiaApplication.h"
#include "RiaPreferences.h"
#include "RifEclipseSummaryTools.h"
#include "RifSummaryCaseRestartSelector.h"
#include "RigGridManager.h"
#include "RimCaseCollection.h"
@ -50,6 +53,80 @@
#include <QFileInfo>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QStringList RiaImportEclipseCaseTools::openEclipseCasesFromFile(const QStringList& fileNames, bool noDialog)
{
RiaApplication* app = RiaApplication::instance();
RimProject* project = app->project();
QStringList openedCaseFiles;
// Get list of files to import
RifSummaryCaseRestartSelector selector;
if(noDialog) selector.showDialog(false);
selector.buildGridCaseFileList(true);
std::vector<RifSummaryCaseFileInfo> summaryFileInfos = selector.getFilesToImportFromGridFiles(fileNames);
// Import eclipse case files
for (const QString& gridCaseFile : selector.gridCaseFiles())
{
if (RiaImportEclipseCaseTools::openEclipseCaseFromFile(gridCaseFile))
{
openedCaseFiles.push_back(gridCaseFile);
}
}
// Import summary cases
RimSummaryCaseMainCollection* sumCaseColl = project->activeOilField() ? project->activeOilField()->summaryCaseMainCollection() : nullptr;
std::vector<RimSummaryCase*> newSumCases = sumCaseColl->createAndAddSummaryCasesFromFileInfos(summaryFileInfos);
for (RimSummaryCase* newSumCase : newSumCases)
{
QString gridCaseFile = RifEclipseSummaryTools::findGridCaseFileFromSummaryHeaderFile(newSumCase->summaryHeaderFilename());
if (!gridCaseFile.isEmpty())
{
RimSummaryCase* existingFileSummaryCase = sumCaseColl->findSummaryCaseFromFileName(newSumCase->summaryHeaderFilename());
if (existingFileSummaryCase)
{
// Replace all occurrences of file sum with ecl sum
std::vector<caf::PdmObjectHandle*> referringObjects;
existingFileSummaryCase->objectsWithReferringPtrFields(referringObjects);
// UI settings of a curve filter is updated based
// on the new case association for the curves in the curve filter
// UI is updated by loadDataAndUpdate()
for (caf::PdmObjectHandle* objHandle : referringObjects)
{
RimSummaryCurve* summaryCurve = dynamic_cast<RimSummaryCurve*>(objHandle);
if (summaryCurve)
{
RimSummaryCurveCollection* parentCollection = nullptr;
summaryCurve->firstAncestorOrThisOfType(parentCollection);
if (parentCollection)
{
parentCollection->loadDataAndUpdate(true);
parentCollection->updateConnectedEditors();
break;
}
}
}
sumCaseColl->removeCase(existingFileSummaryCase);
delete existingFileSummaryCase;
}
sumCaseColl->updateAllRequiredEditors();
}
}
return openedCaseFiles;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -93,7 +170,11 @@ bool RiaImportEclipseCaseTools::openEclipseCaseShowTimeStepFilterImpl(const QStr
RimProject* project = app->project();
RimEclipseCaseCollection* analysisModels = project->activeOilField() ? project->activeOilField()->analysisModels() : nullptr;
if (analysisModels == nullptr) return false;
if (analysisModels == nullptr)
{
delete rimResultReservoir;
return false;
}
RiuMainWindow::instance()->show();
@ -112,66 +193,6 @@ bool RiaImportEclipseCaseTools::openEclipseCaseShowTimeStepFilterImpl(const QStr
riv->loadDataAndUpdate();
// Add a corresponding summary case if it exists
{
RimSummaryCaseMainCollection* sumCaseColl = project->activeOilField() ? project->activeOilField()->summaryCaseMainCollection() : nullptr;
if (sumCaseColl)
{
{
RiuMainPlotWindow* mainPlotWindow = app->mainPlotWindow();
if (sumCaseColl->summaryCaseCount() == 0 && mainPlotWindow)
{
mainPlotWindow->hide();
}
}
if (!sumCaseColl->findSummaryCaseFromEclipseResultCase(rimResultReservoir))
{
std::vector<RimSummaryCase*> newSumCases = sumCaseColl->createAndAddSummaryCasesFromEclipseResultCase(rimResultReservoir);
RimSummaryCase* newSumCase = !newSumCases.empty() ? newSumCases.front() : nullptr;
if (newSumCase)
{
RimSummaryCase* existingFileSummaryCase = sumCaseColl->findSummaryCaseFromFileName(newSumCase->summaryHeaderFilename());
if (existingFileSummaryCase)
{
// Replace all occurrences of file sum with ecl sum
std::vector<caf::PdmObjectHandle*> referringObjects;
existingFileSummaryCase->objectsWithReferringPtrFields(referringObjects);
// UI settings of a curve filter is updated based
// on the new case association for the curves in the curve filter
// UI is updated by loadDataAndUpdate()
for (caf::PdmObjectHandle* objHandle : referringObjects)
{
RimSummaryCurve* summaryCurve = dynamic_cast<RimSummaryCurve*>(objHandle);
if (summaryCurve)
{
RimSummaryCurveCollection* parentCollection = nullptr;
summaryCurve->firstAncestorOrThisOfType(parentCollection);
if (parentCollection)
{
parentCollection->loadDataAndUpdate(true);
parentCollection->updateConnectedEditors();
break;
}
}
}
sumCaseColl->removeCase(existingFileSummaryCase);
delete existingFileSummaryCase;
}
sumCaseColl->updateAllRequiredEditors();
}
}
}
}
if (!riv->cellResult()->hasResult())
{
riv->cellResult()->setResultVariable(RiaDefines::undefinedResultName());

3
ApplicationCode/Application/Tools/RiaImportEclipseCaseTools.h
View File

@ -27,7 +27,7 @@ class QStringList;
class RiaImportEclipseCaseTools
{
public:
static bool openEclipseCaseFromFile(const QString& fileName);
static QStringList openEclipseCasesFromFile(const QStringList& fileNames, bool noDialog = false);
static bool openEclipseCaseShowTimeStepFilter(const QString& fileName);
static bool openMockModel(const QString& name);
@ -35,6 +35,7 @@ public:
static bool addEclipseCases(const QStringList& fileNames);
private:
static bool openEclipseCaseFromFile(const QString& fileName);
static bool openEclipseCaseShowTimeStepFilterImpl(const QString& fileName, bool showTimeStepFilter);
};

6
ApplicationCode/CommandFileInterface/RicfLoadCase.cpp
View File

@ -22,6 +22,8 @@
#include "RiaLogging.h"
#include <QStringList>
CAF_PDM_SOURCE_INIT(RicfLoadCase, "loadCase");
//--------------------------------------------------------------------------------------------------
@ -37,8 +39,8 @@ RicfLoadCase::RicfLoadCase()
//--------------------------------------------------------------------------------------------------
void RicfLoadCase::execute()
{
bool ok = RiaImportEclipseCaseTools::openEclipseCaseFromFile(m_path);
if (!ok)
QStringList newCaseFiles = RiaImportEclipseCaseTools::openEclipseCasesFromFile(QStringList({m_path()}), true);
if (newCaseFiles.isEmpty())
{
RiaLogging::error(QString("loadCase: Unable to load case from %1").arg(m_path()));
}

15
ApplicationCode/Commands/EclipseCommands/RicImportEclipseCaseFeature.cpp
View File

@ -54,18 +54,11 @@ void RicImportEclipseCaseFeature::onActionTriggered(bool isChecked)
if (fileNames.size()) defaultDir = QFileInfo(fileNames.last()).absolutePath();
app->setLastUsedDialogDirectory("BINARY_GRID", defaultDir);
int i;
for (i = 0; i < fileNames.size(); i++)
{
QString fileName = fileNames[i];
QStringList newCaseFiles = RiaImportEclipseCaseTools::openEclipseCasesFromFile(fileNames);
if (!fileName.isEmpty())
{
if (RiaImportEclipseCaseTools::openEclipseCaseFromFile(fileName))
{
app->addToRecentFiles(fileName);
}
}
for (const auto newCaseFile : newCaseFiles)
{
RiaApplication::instance()->addToRecentFiles(newCaseFile);
}
}

15
ApplicationCode/Commands/EclipseCommands/RicImportEclipseCasesFeature.cpp
View File

@ -68,18 +68,11 @@ void RicImportEclipseCasesFeature::onActionTriggered(bool isChecked)
// Remember the path to next time
app->setLastUsedDialogDirectory("BINARY_GRID", QFileInfo(result.rootDir).absoluteFilePath());
int i;
for (i = 0; i < result.files.size(); i++)
{
QString fileName = result.files[i];
QStringList newCaseFiles = RiaImportEclipseCaseTools::openEclipseCasesFromFile(result.files);
if (!fileName.isEmpty())
{
if (RiaImportEclipseCaseTools::openEclipseCaseFromFile(fileName))
{
app->addToRecentFiles(fileName);
}
}
for (const auto newCaseFile : newCaseFiles)
{
RiaApplication::instance()->addToRecentFiles(newCaseFile);
}
}

7
ApplicationCode/Commands/RicImportSummaryCasesFeature.cpp
View File

@ -23,6 +23,8 @@
#include "RicFileHierarchyDialog.h"
#include "RifSummaryCaseRestartSelector.h"
#include "RimGridSummaryCase.h"
#include "RimMainPlotCollection.h"
#include "RimOilField.h"
@ -104,7 +106,10 @@ bool RicImportSummaryCasesFeature::createAndAddSummaryCasesFromFiles(const QStri
RimSummaryCaseMainCollection* sumCaseColl = proj->activeOilField() ? proj->activeOilField()->summaryCaseMainCollection() : nullptr;
if (!sumCaseColl) return false;
std::vector<RimSummaryCase*> sumCases = sumCaseColl->createAndAddSummaryCasesFromFiles(fileNames);
RifSummaryCaseRestartSelector fileSelector;
std::vector<RifSummaryCaseFileInfo> importFileInfos = fileSelector.getFilesToImportFromSummaryFiles(fileNames);
std::vector<RimSummaryCase*> sumCases = sumCaseColl->createAndAddSummaryCasesFromFileInfos(importFileInfos);
sumCaseColl->updateAllRequiredEditors();
RiuMainPlotWindow* mainPlotWindow = app->getOrCreateAndShowMainPlotWindow();

62
ApplicationCode/Commands/RicSummaryCaseRestartDialog.cpp
View File

@ -25,6 +25,7 @@
#include "RiaFilePathTools.h"
#include "RifReaderEclipseSummary.h"
#include "RifEclipseSummaryTools.h"
#include "RimEclipseView.h"
#include "Rim3dOverlayInfoConfig.h"
@ -70,6 +71,7 @@ RicSummaryCaseRestartDialog::RicSummaryCaseRestartDialog(QWidget* parent)
m_readAllRadioButton = new QRadioButton(this);
m_notReadRadionButton = new QRadioButton(this);
m_separateCasesRadionButton = new QRadioButton(this);
m_includeGridHistoryFiles = new QCheckBox(this);
m_applyToAllCheckBox = new QCheckBox(this);
m_buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
@ -82,6 +84,7 @@ RicSummaryCaseRestartDialog::RicSummaryCaseRestartDialog(QWidget* parent)
m_readAllRadioButton->setText("Import All Restart Files");
m_notReadRadionButton->setText("Do Not Import Restart Files");
m_separateCasesRadionButton->setText("Import Restart Files as Separate Cases");
m_includeGridHistoryFiles->setText("Import Historic Grid Case Files");
m_applyToAllCheckBox->setText("Apply to All Files");
// Define layout
@ -100,6 +103,7 @@ RicSummaryCaseRestartDialog::RicSummaryCaseRestartDialog(QWidget* parent)
optionsLayout->addWidget(m_readAllRadioButton);
optionsLayout->addWidget(m_notReadRadionButton);
optionsLayout->addWidget(m_separateCasesRadionButton);
optionsLayout->addWidget(m_includeGridHistoryFiles);
optionsGroup->setLayout(optionsLayout);
QHBoxLayout* buttonsLayout = new QHBoxLayout();
@ -126,6 +130,7 @@ RicSummaryCaseRestartDialog::~RicSummaryCaseRestartDialog()
//--------------------------------------------------------------------------------------------------
RicSummaryCaseRestartDialogResult RicSummaryCaseRestartDialog::openDialog(const QString& summaryHeaderFile,
bool showApplyToAllWidget,
bool buildGridCaseFileList,
ReadOptions defaultReadOption,
RicSummaryCaseRestartDialogResult *lastResult,
QWidget *parent)
@ -138,35 +143,41 @@ RicSummaryCaseRestartDialogResult RicSummaryCaseRestartDialog::openDialog(const
return RicSummaryCaseRestartDialogResult();
}
dialog.appendFileInfoToGridLayout(*dialog.m_currentFileGridLayout, currentFileInfo);
std::vector<RifRestartFileInfo> fileInfos = dialog.getRestartFiles(summaryHeaderFile);
for (const auto& fileInfo : fileInfos)
{
dialog.appendFileInfoToGridLayout(*dialog.m_filesGridLayout, fileInfo);
}
RifReaderEclipseSummary reader;
std::vector<RifRestartFileInfo> restartFileInfos = reader.getRestartFiles(summaryHeaderFile);
// If no restart files are found, do not show dialog
if (fileInfos.empty())
if (restartFileInfos.empty())
{
return RicSummaryCaseRestartDialogResult(true, NOT_IMPORT, QStringList({ summaryHeaderFile }), false);
QString gridCaseFile = RifEclipseSummaryTools::findGridCaseFileFromSummaryHeaderFile(summaryHeaderFile);
return RicSummaryCaseRestartDialogResult(true, NOT_IMPORT, QStringList({ summaryHeaderFile }), false, false, QStringList({ gridCaseFile }));
}
RicSummaryCaseRestartDialogResult dialogResult;
if (lastResult && lastResult->applyToAll)
{
dialogResult = *lastResult;
dialogResult.files.clear();
dialogResult.summaryFiles.clear();
dialogResult.restartGridFilesToImport.clear();
}
else
{
dialog.setWindowTitle("Summary Case Restart Files");
dialog.appendFileInfoToGridLayout(*dialog.m_currentFileGridLayout, currentFileInfo);
for (const auto& restartFileInfo : restartFileInfos)
{
dialog.appendFileInfoToGridLayout(*dialog.m_filesGridLayout, restartFileInfo);
}
switch (defaultReadOption)
{
case ReadOptions::IMPORT_ALL: dialog.m_readAllRadioButton->setChecked(true); break;
case ReadOptions::NOT_IMPORT: dialog.m_notReadRadionButton->setChecked(true); break;
case ReadOptions::SEPARATE_CASES: dialog.m_separateCasesRadionButton->setChecked(true); break;
}
dialog.m_includeGridHistoryFiles->setVisible(buildGridCaseFileList);
dialog.m_includeGridHistoryFiles->setChecked(lastResult->includeGridHistoryFiles);
dialog.m_applyToAllCheckBox->setVisible(showApplyToAllWidget);
dialog.resize(DEFAULT_DIALOG_WIDTH, DEFAULT_DIALOG_INIT_HEIGHT);
dialog.exec();
@ -174,20 +185,33 @@ RicSummaryCaseRestartDialogResult RicSummaryCaseRestartDialog::openDialog(const
dialogResult = RicSummaryCaseRestartDialogResult(dialog.result() == QDialog::Accepted,
dialog.selectedOption(),
{},
dialog.applyToAllSelected());
dialog.applyToAllSelected(),
dialog.includeGridHistoryFiles());
}
if (!dialogResult.ok)
{
return RicSummaryCaseRestartDialogResult(false, NOT_IMPORT, QStringList(), false);
return RicSummaryCaseRestartDialogResult(false, NOT_IMPORT, QStringList(), false, false);
}
dialogResult.files.push_back(RiaFilePathTools::toInternalSeparator(summaryHeaderFile));
dialogResult.summaryFiles.push_back(RiaFilePathTools::toInternalSeparator(summaryHeaderFile));
if (dialogResult.option == SEPARATE_CASES)
{
for (const auto& fileInfo : fileInfos)
for (const auto& restartFileInfo : restartFileInfos)
{
dialogResult.files.push_back(RiaFilePathTools::toInternalSeparator(fileInfo.fileName));
dialogResult.summaryFiles.push_back(RiaFilePathTools::toInternalSeparator(restartFileInfo.fileName));
}
}
if (dialogResult.includeGridHistoryFiles)
{
QString gridCaseFile = RifEclipseSummaryTools::findGridCaseFileFromSummaryHeaderFile(summaryHeaderFile);
dialogResult.restartGridFilesToImport.push_back(gridCaseFile);
for (const auto& restartFileInfo : restartFileInfos)
{
QString gridCaseFile = RifEclipseSummaryTools::findGridCaseFileFromSummaryHeaderFile(restartFileInfo.fileName);
if (buildGridCaseFileList && !gridCaseFile.isEmpty()) dialogResult.restartGridFilesToImport.push_back(gridCaseFile);
}
}
return dialogResult;
@ -212,6 +236,14 @@ bool RicSummaryCaseRestartDialog::applyToAllSelected() const
return m_applyToAllCheckBox->isChecked();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicSummaryCaseRestartDialog::includeGridHistoryFiles() const
{
return m_includeGridHistoryFiles->isChecked();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

22
ApplicationCode/Commands/RicSummaryCaseRestartDialog.h
View File

@ -53,12 +53,14 @@ public:
static RicSummaryCaseRestartDialogResult openDialog(const QString& summaryHeaderFile,
bool showApplyToAllWidget,
bool buildGridCaseFileList,
ReadOptions defaultReadOption,
RicSummaryCaseRestartDialogResult *lastResult = nullptr,
QWidget *parent = nullptr);
ReadOptions selectedOption() const;
bool applyToAllSelected() const;
bool includeGridHistoryFiles() const;
private:
void appendFileInfoToGridLayout(QGridLayout& gridLayout, const RifRestartFileInfo& fileInfo);
@ -78,6 +80,8 @@ private:
QRadioButton* m_notReadRadionButton;
QRadioButton* m_separateCasesRadionButton;
QCheckBox* m_includeGridHistoryFiles;
QCheckBox* m_applyToAllCheckBox;
QDialogButtonBox* m_buttons;
};
@ -94,13 +98,23 @@ public:
RicSummaryCaseRestartDialogResult(bool _ok,
RicSummaryCaseRestartDialog::ReadOptions _option,
QStringList _files,
bool _applyToAll) :
ok(_ok), option(_option), files(_files), applyToAll(_applyToAll) {
QStringList _summaryFiles,
bool _applyToAll,
bool _includeGridHistoryFiles,
QStringList _restartGridFilesToImport = {}) :
ok(_ok),
option(_option),
summaryFiles(_summaryFiles),
applyToAll(_applyToAll),
includeGridHistoryFiles(_includeGridHistoryFiles),
restartGridFilesToImport(_restartGridFilesToImport) {
}
bool ok;
RicSummaryCaseRestartDialog::ReadOptions option;
QStringList files;
QStringList summaryFiles;
bool applyToAll;
bool includeGridHistoryFiles;
QStringList restartGridFilesToImport;
};

35
ApplicationCode/FileInterface/RifEclipseSummaryTools.cpp
View File

@ -26,6 +26,7 @@
#include "ert/ecl/ecl_util.h"
#include <QDir>
#include <QString>
#include <QStringList>
@ -128,6 +129,38 @@ QStringList RifEclipseSummaryTools::findSummaryDataFiles(const QString& caseFile
return fileNames;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RifEclipseSummaryTools::findGridCaseFileFromSummaryHeaderFile(const QString& summaryHeaderFile)
{
char* myPath = nullptr;
char* myBase = nullptr;
bool formattedFile = true;
util_alloc_file_components(RiaStringEncodingTools::toNativeEncoded(QDir::toNativeSeparators(summaryHeaderFile)).data(), &myPath, &myBase, nullptr);
char* caseFile = ecl_util_alloc_exfilename(myPath, myBase, ECL_EGRID_FILE, true, -1);
if (!caseFile)
{
caseFile= ecl_util_alloc_exfilename(myPath, myBase, ECL_EGRID_FILE, false, -1);
if (caseFile)
{
formattedFile = false;
}
}
QString gridCaseFile;
if (caseFile) gridCaseFile = caseFile;
util_safe_free(caseFile);
util_safe_free(myBase);
util_safe_free(myPath);
return gridCaseFile;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -173,7 +206,7 @@ void RifEclipseSummaryTools::findSummaryHeaderFileInfo(const QString& inputFile,
char* myBase = nullptr;
bool formattedFile = true;
util_alloc_file_components(RiaStringEncodingTools::toNativeEncoded(inputFile).data(), &myPath, &myBase, nullptr);
util_alloc_file_components(RiaStringEncodingTools::toNativeEncoded(QDir::toNativeSeparators(inputFile)).data(), &myPath, &myBase, nullptr);
char* myHeaderFile = ecl_util_alloc_exfilename(myPath, myBase, ECL_SUMMARY_HEADER_FILE, true, -1);
if (!myHeaderFile)

1
ApplicationCode/FileInterface/RifEclipseSummaryTools.h
View File

@ -37,6 +37,7 @@ class RifEclipseSummaryTools
public:
static void findSummaryHeaderFile(const QString& inputFile, QString* headerFile, bool* isFormatted);
static QStringList findSummaryDataFiles(const QString& caseFile);
static QString findGridCaseFileFromSummaryHeaderFile(const QString& summaryHeaderFile);
static void findSummaryFiles(const QString& inputFile, QString* headerFile, QStringList* dataFiles);
static bool hasSummaryFiles(const QString& gridFileName);

121
ApplicationCode/FileInterface/RifSummaryCaseRestartSelector.cpp
View File

@ -24,6 +24,8 @@
#include "RicSummaryCaseRestartDialog.h"
#include "RifEclipseSummaryTools.h"
#include <string>
#include <assert.h>
@ -62,7 +64,13 @@ RicSummaryCaseRestartDialog::ReadOptions mapReadOption(RiaPreferences::SummaryRe
//--------------------------------------------------------------------------------------------------
RifSummaryCaseRestartSelector::RifSummaryCaseRestartSelector()
{
RiaPreferences* prefs = RiaApplication::instance()->preferences();
m_showDialog = prefs->summaryRestartFilesShowImportDialog();
m_defaultRestartImportMode = mapReadOption(prefs->summaryRestartFilesImportMode());
m_importRestartGridCaseFiles = prefs->importRestartGridCaseFiles();
m_buildGridCaseFileList = false;
m_gridCaseFiles.clear();
}
//--------------------------------------------------------------------------------------------------
@ -76,41 +84,53 @@ RifSummaryCaseRestartSelector::~RifSummaryCaseRestartSelector()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RifSummaryCaseFileInfo> RifSummaryCaseRestartSelector::getFilesToImport(const QStringList& selectedFiles)
std::vector<RifSummaryCaseFileInfo> RifSummaryCaseRestartSelector::getFilesToImportFromSummaryFiles(const QStringList& initialSummaryFiles)
{
RiaApplication* app = RiaApplication::instance();
RiaPreferences* prefs = app->preferences();
return getFilesToImport(initialSummaryFiles);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RifSummaryCaseFileInfo> RifSummaryCaseRestartSelector::getFilesToImportFromGridFiles(const QStringList& initialGridFiles)
{
QStringList summaryFiles = getSummaryFilesFromGridFiles(initialGridFiles);
return getFilesToImport(summaryFiles);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RifSummaryCaseFileInfo> RifSummaryCaseRestartSelector::getFilesToImport(const QStringList& initialSummaryFiles)
{
std::vector<RifSummaryCaseFileInfo> fileInfos;
if (prefs->summaryRestartFilesShowImportDialog)
if (m_showDialog)
{
bool enableApplyToAllField = selectedFiles.size() > 1;
fileInfos = getFilesToImportByAskingUser(selectedFiles, enableApplyToAllField, prefs->summaryRestartFilesImportMode);
bool enableApplyToAllField = initialSummaryFiles.size() > 1;
fileInfos = getFilesToImportByAskingUser(initialSummaryFiles, enableApplyToAllField);
}
else
{
fileInfos = getFilesToImportUsingPrefs(selectedFiles, prefs->summaryRestartFilesImportMode);
fileInfos = getFilesToImportUsingPrefs(initialSummaryFiles);
}
return fileInfos;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RifSummaryCaseFileInfo> RifSummaryCaseRestartSelector::getFilesToImportByAskingUser(const QStringList& initialFiles,
bool enableApplyToAllField,
RiaPreferences::SummaryRestartFilesImportModeType defaultSummaryRestartMode)
std::vector<RifSummaryCaseFileInfo> RifSummaryCaseRestartSelector::getFilesToImportByAskingUser(const QStringList& initialSummaryFiles,
bool enableApplyToAllField)
{
std::vector<RifSummaryCaseFileInfo> filesToImport;
RicSummaryCaseRestartDialogResult lastResult;
for (const QString& file : initialFiles)
for (const QString& summaryFile : initialSummaryFiles)
{
RicSummaryCaseRestartDialogResult result = RicSummaryCaseRestartDialog::openDialog(file, enableApplyToAllField, mapReadOption(defaultSummaryRestartMode), &lastResult);
RicSummaryCaseRestartDialogResult result = RicSummaryCaseRestartDialog::openDialog(summaryFile, enableApplyToAllField, m_buildGridCaseFileList, m_defaultRestartImportMode, &lastResult);
if (result.ok)
{
for (const QString& file : result.files)
for (const QString& file : result.summaryFiles)
{
RifSummaryCaseFileInfo fi(file, result.option == RicSummaryCaseRestartDialog::IMPORT_ALL);
if (!vectorContains(filesToImport, fi))
@ -119,6 +139,17 @@ std::vector<RifSummaryCaseFileInfo> RifSummaryCaseRestartSelector::getFilesToImp
}
}
lastResult = result;
for (const QString& gridCaseFile : result.restartGridFilesToImport)
{
m_gridCaseFiles.push_back(gridCaseFile);
}
}
else
{
// Cancel pressed, cancel everything
m_gridCaseFiles.clear();
return std::vector<RifSummaryCaseFileInfo>();
}
}
return std::vector<RifSummaryCaseFileInfo>(filesToImport.begin(), filesToImport.end());
@ -127,27 +158,40 @@ std::vector<RifSummaryCaseFileInfo> RifSummaryCaseRestartSelector::getFilesToImp
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RifSummaryCaseFileInfo> RifSummaryCaseRestartSelector::getFilesToImportUsingPrefs(const QStringList& initialFiles,
RiaPreferences::SummaryRestartFilesImportModeType summaryRestartMode)
std::vector<RifSummaryCaseFileInfo> RifSummaryCaseRestartSelector::getFilesToImportUsingPrefs(const QStringList& initialSummaryFiles)
{
std::vector<RifSummaryCaseFileInfo> filesToImport;
RicSummaryCaseRestartDialogResult lastResult;
for (const QString& initialFile : initialFiles)
{
QString file = RiaFilePathTools::toInternalSeparator(initialFile);
m_gridCaseFiles.clear();
if (summaryRestartMode == RiaPreferences::IMPORT)
for (const QString& summaryFile : initialSummaryFiles)
{
QString file = RiaFilePathTools::toInternalSeparator(summaryFile);
if (m_defaultRestartImportMode == RicSummaryCaseRestartDialog::IMPORT_ALL)
{
filesToImport.push_back(RifSummaryCaseFileInfo(file, true));
if (m_buildGridCaseFileList)
{
m_gridCaseFiles.push_back(RifEclipseSummaryTools::findGridCaseFileFromSummaryHeaderFile(file));
}
}
else if (summaryRestartMode == RiaPreferences::NOT_IMPORT)
else if (m_defaultRestartImportMode == RicSummaryCaseRestartDialog::NOT_IMPORT)
{
filesToImport.push_back(RifSummaryCaseFileInfo(file, false));
if (m_buildGridCaseFileList)
{
m_gridCaseFiles.push_back(RifEclipseSummaryTools::findGridCaseFileFromSummaryHeaderFile(file));
}
}
else if (summaryRestartMode == RiaPreferences::SEPARATE_CASES)
else if (m_defaultRestartImportMode == RicSummaryCaseRestartDialog::SEPARATE_CASES)
{
filesToImport.push_back(RifSummaryCaseFileInfo(file, false));
if (m_buildGridCaseFileList)
{
m_gridCaseFiles.push_back(RifEclipseSummaryTools::findGridCaseFileFromSummaryHeaderFile(file));
}
RifReaderEclipseSummary reader;
std::vector<RifRestartFileInfo> restartFileInfos = reader.getRestartFiles(file);
@ -157,9 +201,40 @@ std::vector<RifSummaryCaseFileInfo> RifSummaryCaseRestartSelector::getFilesToImp
if (!vectorContains(filesToImport, fi))
{
filesToImport.push_back(fi);
if (m_buildGridCaseFileList)
{
m_gridCaseFiles.push_back(RifEclipseSummaryTools::findGridCaseFileFromSummaryHeaderFile(fi.fileName));
}
}
}
}
}
return filesToImport;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QStringList RifSummaryCaseRestartSelector::getSummaryFilesFromGridFiles(const QStringList& gridFiles)
{
QStringList summaryFiles;
// Find summary header file names from eclipse case file names
for (const auto& gridFile : gridFiles)
{
if (!gridFile.isEmpty())
{
QString summaryHeaderFile;
bool formatted;
RifEclipseSummaryTools::findSummaryHeaderFile(gridFile, &summaryHeaderFile, &formatted);
if (!summaryHeaderFile.isEmpty())
{
summaryFiles.push_back(summaryHeaderFile);
}
}
}
return summaryFiles;
}

28
ApplicationCode/FileInterface/RifSummaryCaseRestartSelector.h
View File

@ -19,13 +19,15 @@
#pragma once
#include "RiaPreferences.h"
#include "RicSummaryCaseRestartDialog.h"
#include <QString>
#include <QStringList>
#include <string>
#include <vector>
#include <map>
class QStringList;
class RifSummaryCaseFileInfo;
@ -39,16 +41,28 @@ public:
RifSummaryCaseRestartSelector();
~RifSummaryCaseRestartSelector();
std::vector<RifSummaryCaseFileInfo> getFilesToImport(const QStringList& selectedFiles);
std::vector<RifSummaryCaseFileInfo> getFilesToImportFromSummaryFiles(const QStringList& initialSummaryFiles);
std::vector<RifSummaryCaseFileInfo> getFilesToImportFromGridFiles(const QStringList& initialGridFiles);
void showDialog(bool show) { m_showDialog = show; }
void buildGridCaseFileList(bool build) { m_buildGridCaseFileList = build; }
QStringList gridCaseFiles() const { return m_gridCaseFiles; }
static QStringList getSummaryFilesFromGridFiles(const QStringList& gridFiles);
private:
std::vector<RifSummaryCaseFileInfo> getFilesToImportByAskingUser(const QStringList& initialFiles,
bool enableApplyToAllField,
RiaPreferences::SummaryRestartFilesImportModeType defaultSummaryRestartMode);
std::vector<RifSummaryCaseFileInfo> getFilesToImportUsingPrefs(const QStringList& initialFiles,
RiaPreferences::SummaryRestartFilesImportModeType summaryRestartMode);
std::vector<RifSummaryCaseFileInfo> getFilesToImport(const QStringList& initialSummaryFiles);
std::vector<RifSummaryCaseFileInfo> getFilesToImportByAskingUser(const QStringList& initialSummaryFiles,
bool enableApplyToAllField);
std::vector<RifSummaryCaseFileInfo> getFilesToImportUsingPrefs(const QStringList& initialSummaryFiles);
bool m_showDialog;
RicSummaryCaseRestartDialog::ReadOptions m_defaultRestartImportMode;
bool m_importRestartGridCaseFiles;
bool m_buildGridCaseFileList;
QStringList m_gridCaseFiles;
};
//==================================================================================================

16
ApplicationCode/ProjectDataModel/RimProject.cpp
View File

@ -23,6 +23,7 @@
#include "RiaApplication.h"
#include "RiaProjectFileVersionTools.h"
#include "RiaVersionInfo.h"
#include "RiaFilePathTools.h"
#include "RigEclipseCaseData.h"
#include "RigGridBase.h"
@ -860,6 +861,21 @@ std::vector<RimEclipseCase*> RimProject::eclipseCases() const
return allCases;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseCase* RimProject::eclipseCaseFromGridFileName(const QString& gridFileName) const
{
for (RimEclipseCase* eclCase : eclipseCases())
{
if (RiaFilePathTools::toInternalSeparator(eclCase->gridFileName()) == RiaFilePathTools::toInternalSeparator(gridFileName))
{
return eclCase;
}
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/ProjectDataModel/RimProject.h
View File

@ -132,6 +132,8 @@ public:
RimDialogData* dialogData() const;
std::vector<RimEclipseCase*> eclipseCases() const;
RimEclipseCase* eclipseCaseFromGridFileName(const QString& gridFileName) const;
std::vector<QString> simulationWellNames() const;
RimWellPath* wellPathFromSimWellName(const QString& simWellName, int branchIndex = -1);

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

@ -113,7 +113,12 @@ void RimSummaryCaseMainCollection::createSummaryCasesFromRelevantEclipseResultCa
if (!isFound)
{
// Create new GridSummaryCase
createAndAddSummaryCasesFromEclipseResultCase(eclResCase);
QStringList summaryFileNames = RifSummaryCaseRestartSelector::getSummaryFilesFromGridFiles(QStringList({ eclResCase->gridFileName() }));
if (!summaryFileNames.isEmpty())
{
RifSummaryCaseFileInfo fileInfo(summaryFileNames.front(), false);
createAndAddSummaryCasesFromFileInfos({ fileInfo });
}
}
}
}
@ -291,78 +296,49 @@ void RimSummaryCaseMainCollection::loadAllSummaryCaseData()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimSummaryCase*> RimSummaryCaseMainCollection::createAndAddSummaryCasesFromEclipseResultCase(RimEclipseResultCase* eclResCase)
std::vector<RimSummaryCase*> RimSummaryCaseMainCollection::createAndAddSummaryCasesFromFileInfos(const std::vector<RifSummaryCaseFileInfo>& summaryHeaderFileInfos)
{
RimProject* project = RiaApplication::instance()->project();
std::vector<RimSummaryCase*> sumCases;
QString gridFileName = eclResCase->gridFileName();
QString summaryHeaderFile;
bool formatted;
RifEclipseSummaryTools::findSummaryHeaderFile(QDir::toNativeSeparators(gridFileName), &summaryHeaderFile, &formatted);
if(!summaryHeaderFile.isEmpty())
for (RifSummaryCaseFileInfo fileInfo : summaryHeaderFileInfos)
{
RifSummaryCaseRestartSelector fileSelector;
std::vector<RifSummaryCaseFileInfo> importFileInfos = fileSelector.getFilesToImport(QStringList({ summaryHeaderFile }));
RimEclipseCase* eclCase = nullptr;
QString gridCaseFile = RifEclipseSummaryTools::findGridCaseFileFromSummaryHeaderFile(fileInfo.fileName);
if (!gridCaseFile.isEmpty())
{
eclCase = project->eclipseCaseFromGridFileName(gridCaseFile);
}
if (!importFileInfos.empty())
if (eclCase)
{
RimGridSummaryCase* newSumCase = new RimGridSummaryCase();
this->m_cases.push_back(newSumCase);
newSumCase->setIncludeRestartFiles(importFileInfos.front().includeRestartFiles);
newSumCase->setAssociatedEclipseCase(eclResCase);
newSumCase->setIncludeRestartFiles(fileInfo.includeRestartFiles);
newSumCase->setAssociatedEclipseCase(eclCase);
newSumCase->createSummaryReaderInterface();
newSumCase->updateOptionSensitivity();
addCaseRealizationParametersIfFound(*newSumCase, importFileInfos.front().fileName);
addCaseRealizationParametersIfFound(*newSumCase, fileInfo.fileName);
sumCases.push_back(newSumCase);
}
else
{
RimFileSummaryCase* newSumCase = new RimFileSummaryCase();
this->m_cases.push_back(newSumCase);
newSumCase->setIncludeRestartFiles(fileInfo.includeRestartFiles);
newSumCase->setSummaryHeaderFileName(fileInfo.fileName);
newSumCase->createSummaryReaderInterface();
newSumCase->updateOptionSensitivity();
addCaseRealizationParametersIfFound(*newSumCase, fileInfo.fileName);
sumCases.push_back(newSumCase);
// Remove the processed element and add 'orphan' summary cases
importFileInfos.erase(importFileInfos.begin());
for (const RifSummaryCaseFileInfo& fileInfo : importFileInfos)
{
RimFileSummaryCase* newSumCase = new RimFileSummaryCase();
this->m_cases.push_back(newSumCase);
newSumCase->setIncludeRestartFiles(fileInfo.includeRestartFiles);
newSumCase->setSummaryHeaderFileName(fileInfo.fileName);
newSumCase->createSummaryReaderInterface();
newSumCase->updateOptionSensitivity();
addCaseRealizationParametersIfFound(*newSumCase, fileInfo.fileName);
sumCases.push_back(newSumCase);
}
}
}
return sumCases;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimSummaryCase*> RimSummaryCaseMainCollection::createAndAddSummaryCasesFromFiles(const QStringList& inputFileNames)
{
std::vector<RimSummaryCase*> sumCases;
RifSummaryCaseRestartSelector fileSelector;
std::vector<RifSummaryCaseFileInfo> importFileInfos = fileSelector.getFilesToImport(inputFileNames);
for (const RifSummaryCaseFileInfo& fileInfo : importFileInfos)
{
RimFileSummaryCase* newSumCase = new RimFileSummaryCase();
this->m_cases.push_back(newSumCase);
newSumCase->setIncludeRestartFiles(fileInfo.includeRestartFiles);
newSumCase->setSummaryHeaderFileName(fileInfo.fileName);
newSumCase->createSummaryReaderInterface();
newSumCase->updateOptionSensitivity();
addCaseRealizationParametersIfFound(*newSumCase, fileInfo.fileName);
sumCases.push_back(newSumCase);
}
return sumCases;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

8
ApplicationCode/ProjectDataModel/Summary/RimSummaryCaseMainCollection.h
View File

@ -25,6 +25,7 @@
class RimSummaryCase;
class RimEclipseResultCase;
class RimSummaryCaseCollection;
class RifSummaryCaseFileInfo;
//==================================================================================================
///
@ -44,12 +45,11 @@ public:
std::vector<RimSummaryCaseCollection*> summaryCaseCollections() const;
void createSummaryCasesFromRelevantEclipseResultCases();
std::vector<RimSummaryCase*> createAndAddSummaryCasesFromEclipseResultCase(RimEclipseResultCase* eclResCase);
std::vector<RimSummaryCase*> createAndAddSummaryCasesFromFiles(const QStringList& inputFileNames);
std::vector<RimSummaryCase*> createAndAddSummaryCasesFromFileInfos(const std::vector<RifSummaryCaseFileInfo>& summaryHeaderFileInfos);
RimSummaryCase* findSummaryCaseFromEclipseResultCase(RimEclipseResultCase* eclResCase) const;
RimSummaryCase* findSummaryCaseFromFileName(const QString& fileName) const;
void addCase(RimSummaryCase* summaryCase);
void removeCase(RimSummaryCase* summaryCase);