mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-25 18:55:39 -06:00
591 lines
23 KiB
C++
591 lines
23 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2017 Statoil ASA
|
|
//
|
|
// ResInsight is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
// FITNESS FOR A PARTICULAR PURPOSE.
|
|
//
|
|
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
|
|
// for more details.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "RiaImportEclipseCaseTools.h"
|
|
|
|
#include "ApplicationCommands/RicShowMainWindowFeature.h"
|
|
|
|
#include "PlotBuilderCommands/RicSummaryPlotBuilder.h"
|
|
#include "SummaryPlotCommands/RicNewSummaryCurveFeature.h"
|
|
#include "SummaryPlotCommands/RicSummaryPlotFeatureImpl.h"
|
|
|
|
#include "RiaGuiApplication.h"
|
|
#include "RiaLogging.h"
|
|
|
|
#include "RifEclipseSummaryTools.h"
|
|
#include "RifReaderSettings.h"
|
|
#include "RifSummaryCaseRestartSelector.h"
|
|
|
|
#include "RigGridManager.h"
|
|
|
|
#include "RimCaseCollection.h"
|
|
#include "RimCompletionTemplateCollection.h"
|
|
#include "RimEclipseCaseCollection.h"
|
|
#include "RimEclipseCellColors.h"
|
|
#include "RimEclipseInputCase.h"
|
|
#include "RimEclipseResultCase.h"
|
|
#include "RimEclipseView.h"
|
|
#include "RimFileSummaryCase.h"
|
|
#include "RimIdenticalGridCaseGroup.h"
|
|
#include "RimMainPlotCollection.h"
|
|
#include "RimOilField.h"
|
|
#include "RimProject.h"
|
|
#include "RimRoffCase.h"
|
|
#include "RimSummaryCase.h"
|
|
#include "RimSummaryCaseCollection.h"
|
|
#include "RimSummaryCaseMainCollection.h"
|
|
#include "RimSummaryCurve.h"
|
|
#include "RimSummaryCurveCollection.h"
|
|
#include "RimSummaryPlot.h"
|
|
#include "RimWellLogRftCurve.h"
|
|
|
|
#include "Riu3DMainWindowTools.h"
|
|
#include "RiuMainWindow.h"
|
|
#include "RiuPlotMainWindow.h"
|
|
#include "RiuPlotMainWindowTools.h"
|
|
|
|
#include "cafProgressInfo.h"
|
|
#include "cafUtils.h"
|
|
|
|
#include <QFileInfo>
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RiaImportEclipseCaseTools::openEclipseCasesFromFile( const QStringList& fileNames,
|
|
bool createView,
|
|
FileCaseIdMap* openedFilesOut,
|
|
bool noDialog,
|
|
std::shared_ptr<RifReaderSettings> readerSettings )
|
|
{
|
|
RimProject* project = RimProject::current();
|
|
if ( !project ) return false;
|
|
|
|
// Get list of files to import
|
|
RifSummaryCaseRestartSelector selector;
|
|
if ( noDialog || !RiaGuiApplication::isRunning() ) selector.showDialog( false );
|
|
selector.determineFilesToImportFromGridFiles( fileNames );
|
|
std::vector<RifSummaryCaseFileResultInfo> summaryFileInfos = selector.summaryFileInfos();
|
|
|
|
FileCaseIdMap openedFiles;
|
|
|
|
// Import eclipse case files
|
|
for ( const QString& gridCaseFile : selector.gridCaseFiles() )
|
|
{
|
|
int caseId = RiaImportEclipseCaseTools::openEclipseCaseFromFile( gridCaseFile, createView, readerSettings );
|
|
if ( caseId >= 0 )
|
|
{
|
|
openedFiles.insert( std::make_pair( gridCaseFile, caseId ) );
|
|
}
|
|
}
|
|
|
|
if ( !openedFiles.empty() )
|
|
{
|
|
RimMainPlotCollection::current()->ensureDefaultFlowPlotsAreCreated();
|
|
}
|
|
|
|
// The default value for summary case import is true, but we use the state from RifReaderSettings if defined
|
|
//
|
|
// TODO:
|
|
// Refactor RifReaderSettings, separate the data structure sent to reader from the data structure in
|
|
// preferences. See RifReaderSettings::createGridOnlyReaderSettings() for the only use of importSummaryData flag
|
|
//
|
|
bool importSummaryCases = true;
|
|
if ( readerSettings ) importSummaryCases = readerSettings->importSummaryData;
|
|
|
|
if ( importSummaryCases && !summaryFileInfos.empty() )
|
|
{
|
|
RimSummaryCaseMainCollection* sumCaseColl = project->activeOilField() ? project->activeOilField()->summaryCaseMainCollection()
|
|
: nullptr;
|
|
if ( sumCaseColl )
|
|
{
|
|
std::vector<RimSummaryCase*> candidateCases = sumCaseColl->createSummaryCasesFromFileInfos( summaryFileInfos );
|
|
std::vector<RimSummaryCase*> duplicatedCases;
|
|
|
|
for ( RimSummaryCase* newSumCase : candidateCases )
|
|
{
|
|
RimSummaryCaseCollection* existingCollection = nullptr;
|
|
auto existingSummaryCase = sumCaseColl->findTopLevelSummaryCaseFromFileName( newSumCase->summaryHeaderFilename() );
|
|
if ( existingSummaryCase )
|
|
{
|
|
existingCollection = existingSummaryCase->firstAncestorOrThisOfType<RimSummaryCaseCollection>();
|
|
|
|
// Replace file summary case pointers in Rft Curves
|
|
auto rftCurves = existingSummaryCase->objectsWithReferringPtrFieldsOfType<RimWellLogRftCurve>();
|
|
for ( RimWellLogRftCurve* curve : rftCurves )
|
|
{
|
|
if ( curve->summaryCase() == existingSummaryCase )
|
|
{
|
|
curve->setSummaryCase( newSumCase );
|
|
}
|
|
}
|
|
|
|
// Replace all occurrences of file sum with ecl sum
|
|
|
|
auto objects = existingSummaryCase->objectsWithReferringPtrFieldsOfType<RimSummaryCurve>();
|
|
|
|
// 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 ( RimSummaryCurve* summaryCurve : objects )
|
|
{
|
|
if ( summaryCurve )
|
|
{
|
|
if ( summaryCurve->summaryCaseX() == existingSummaryCase )
|
|
{
|
|
summaryCurve->setSummaryCaseX( newSumCase );
|
|
}
|
|
if ( summaryCurve->summaryCaseY() == existingSummaryCase )
|
|
{
|
|
summaryCurve->setSummaryCaseY( newSumCase );
|
|
}
|
|
|
|
auto parentCollection = summaryCurve->firstAncestorOrThisOfType<RimSummaryCurveCollection>();
|
|
if ( parentCollection )
|
|
{
|
|
parentCollection->loadDataAndUpdate( true );
|
|
parentCollection->updateConnectedEditors();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove existing case
|
|
sumCaseColl->removeCase( existingSummaryCase );
|
|
|
|
duplicatedCases.push_back( existingSummaryCase );
|
|
}
|
|
|
|
if ( existingCollection )
|
|
{
|
|
existingCollection->addCase( newSumCase );
|
|
}
|
|
else
|
|
{
|
|
sumCaseColl->addCase( newSumCase );
|
|
}
|
|
sumCaseColl->updateAllRequiredEditors();
|
|
}
|
|
|
|
// Delete cases that already was present
|
|
for ( auto duplicateCase : duplicatedCases )
|
|
{
|
|
candidateCases.erase( std::remove( candidateCases.begin(), candidateCases.end(), duplicateCase ), candidateCases.end() );
|
|
delete duplicateCase;
|
|
}
|
|
|
|
if ( !candidateCases.empty() && RiaGuiApplication::isRunning() && RiuPlotMainWindow::instance()->isVisible() )
|
|
{
|
|
RicSummaryPlotBuilder::createAndAppendDefaultSummaryMultiPlot( { candidateCases.front() }, {} );
|
|
RiuPlotMainWindowTools::setExpanded( candidateCases.front() );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( selector.foundErrors() )
|
|
{
|
|
QString errorMessage = selector.createCombinedErrorMessage();
|
|
RiaLogging::error( errorMessage );
|
|
}
|
|
|
|
project->activeOilField()->completionTemplateCollection()->setDefaultUnitSystemBasedOnLoadedCases();
|
|
|
|
if ( RiaGuiApplication::isRunning() )
|
|
{
|
|
if ( RiuPlotMainWindow::instance()->isVisible() ) RiuPlotMainWindowTools::refreshToolbars();
|
|
|
|
// Call process events to clear the queue. This make sure that we are able raise the 3D window on top of the
|
|
// plot window. Otherwise the event processing ends up with the plot window on top.
|
|
QApplication::processEvents();
|
|
RiuMainWindow::instance()->activateWindow();
|
|
}
|
|
|
|
if ( openedFilesOut )
|
|
{
|
|
*openedFilesOut = openedFiles;
|
|
}
|
|
|
|
return !openedFiles.empty();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
int RiaImportEclipseCaseTools::openEclipseCaseFromFile( const QString& fileName, bool createView, std::shared_ptr<RifReaderSettings> readerSettings )
|
|
{
|
|
if ( !caf::Utils::fileExists( fileName ) ) return -1;
|
|
|
|
bool showTimeStepFilter = false;
|
|
return RiaImportEclipseCaseTools::openEclipseCaseShowTimeStepFilterImpl( fileName, showTimeStepFilter, createView, readerSettings );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RiaImportEclipseCaseTools::openEclipseCaseShowTimeStepFilter( const QString& fileName )
|
|
{
|
|
if ( !caf::Utils::fileExists( fileName ) ) return false;
|
|
|
|
bool showTimeStepFilter = true;
|
|
bool createView = true;
|
|
return RiaImportEclipseCaseTools::openEclipseCaseShowTimeStepFilterImpl( fileName, showTimeStepFilter, createView, nullptr ) >= 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RiaImportEclipseCaseTools::CaseFileNameAndId
|
|
RiaImportEclipseCaseTools::openEclipseInputCaseAndPropertiesFromFileNames( const QStringList& fileNames, bool createDefaultView )
|
|
{
|
|
RimProject* project = RimProject::current();
|
|
if ( !project ) return { QString(), -1 };
|
|
|
|
auto* rimInputReservoir = new RimEclipseInputCase();
|
|
project->assignCaseIdToCase( rimInputReservoir );
|
|
|
|
bool gridImportSuccess = rimInputReservoir->openDataFileSet( fileNames );
|
|
if ( !gridImportSuccess )
|
|
{
|
|
RiaLogging::error( "Failed to import grid" );
|
|
delete rimInputReservoir;
|
|
return { QString(), -1 };
|
|
}
|
|
|
|
RimEclipseCaseCollection* analysisModels = project->activeOilField() ? project->activeOilField()->analysisModels() : nullptr;
|
|
if ( analysisModels == nullptr ) return { QString(), -1 };
|
|
|
|
analysisModels->cases.push_back( rimInputReservoir );
|
|
|
|
RimEclipseView* eclipseView = nullptr;
|
|
if ( createDefaultView )
|
|
{
|
|
eclipseView = rimInputReservoir->createAndAddReservoirView();
|
|
|
|
eclipseView->cellResult()->setResultType( RiaDefines::ResultCatType::INPUT_PROPERTY );
|
|
|
|
eclipseView->loadDataAndUpdate();
|
|
|
|
if ( !eclipseView->cellResult()->hasResult() )
|
|
{
|
|
eclipseView->cellResult()->setResultVariable( RiaResultNames::undefinedResultName() );
|
|
}
|
|
}
|
|
|
|
analysisModels->updateConnectedEditors();
|
|
|
|
if ( eclipseView )
|
|
{
|
|
Riu3DMainWindowTools::selectAsCurrentItem( eclipseView->cellResult() );
|
|
}
|
|
|
|
return { rimInputReservoir->gridFileName(), rimInputReservoir->caseId() };
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<int> RiaImportEclipseCaseTools::openEclipseInputCasesFromFileNames( const QStringList& fileNames, bool createDefaultView )
|
|
{
|
|
std::vector<int> eclipseCaseIds;
|
|
for ( const auto& fileName : fileNames )
|
|
{
|
|
// Open with single file
|
|
auto [caseFileName, caseId] = openEclipseInputCaseAndPropertiesFromFileNames( { fileName }, createDefaultView );
|
|
eclipseCaseIds.push_back( caseId );
|
|
}
|
|
return eclipseCaseIds;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RiaImportEclipseCaseTools::openMockModel( const QString& name )
|
|
{
|
|
bool showTimeStepFilter = false;
|
|
bool createView = true;
|
|
return RiaImportEclipseCaseTools::openEclipseCaseShowTimeStepFilterImpl( name, showTimeStepFilter, createView, nullptr );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
int RiaImportEclipseCaseTools::openEclipseCaseShowTimeStepFilterImpl( const QString& fileName,
|
|
bool showTimeStepFilter,
|
|
bool createView,
|
|
std::shared_ptr<RifReaderSettings> readerSettings )
|
|
{
|
|
RimProject* project = RimProject::current();
|
|
if ( !project ) return -1;
|
|
|
|
RimEclipseCaseCollection* analysisModels = project->activeOilField() ? project->activeOilField()->analysisModels() : nullptr;
|
|
if ( analysisModels == nullptr ) return -1;
|
|
|
|
QFileInfo gridFileName( fileName );
|
|
QString caseName = gridFileName.completeBaseName();
|
|
|
|
auto* rimResultReservoir = new RimEclipseResultCase();
|
|
rimResultReservoir->setCaseInfo( caseName, fileName );
|
|
rimResultReservoir->setReaderSettings( readerSettings );
|
|
|
|
if ( RiaGuiApplication::isRunning() )
|
|
{
|
|
RicShowMainWindowFeature::showMainWindow();
|
|
}
|
|
|
|
analysisModels->cases.push_back( rimResultReservoir );
|
|
|
|
if ( !rimResultReservoir->importGridAndResultMetaData( showTimeStepFilter ) )
|
|
{
|
|
analysisModels->removeCaseFromAllGroups( rimResultReservoir );
|
|
delete rimResultReservoir;
|
|
return -1;
|
|
}
|
|
|
|
if ( createView )
|
|
{
|
|
RimEclipseView* riv = rimResultReservoir->createAndAddReservoirView();
|
|
|
|
riv->loadDataAndUpdate();
|
|
|
|
if ( !riv->cellResult()->hasResult() )
|
|
{
|
|
riv->cellResult()->setResultVariable( RiaResultNames::undefinedResultName() );
|
|
}
|
|
|
|
analysisModels->updateConnectedEditors();
|
|
|
|
if ( RiaGuiApplication::isRunning() )
|
|
{
|
|
if ( RiuMainWindow::instance() ) RiuMainWindow::instance()->selectAsCurrentItem( riv->cellResult() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Make sure the placeholder result entries are created, as this functionality is triggered when creating a
|
|
// view. See RimEclipseView::onLoadDataAndUpdate() and the call to openReserviorCase()
|
|
rimResultReservoir->openReserviorCase();
|
|
|
|
analysisModels->updateConnectedEditors();
|
|
}
|
|
|
|
return rimResultReservoir->caseId();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RiaImportEclipseCaseTools::addEclipseCases( const QStringList& fileNames, RimIdenticalGridCaseGroup** resultingCaseGroup /*=nullptr*/ )
|
|
{
|
|
if ( fileNames.empty() ) return true;
|
|
|
|
// First file is read completely including grid.
|
|
// The main grid from the first case is reused directly in for the other cases.
|
|
// When reading active cell info, only the total cell count is tested for consistency
|
|
RimEclipseResultCase* mainResultCase = nullptr;
|
|
std::vector<std::vector<int>> mainCaseGridDimensions;
|
|
RimIdenticalGridCaseGroup* gridCaseGroup = nullptr;
|
|
|
|
RimProject* project = RimProject::current();
|
|
if ( !project ) return false;
|
|
|
|
{
|
|
QString firstFileName = fileNames[0];
|
|
QFileInfo gridFileName( firstFileName );
|
|
|
|
QString caseName = gridFileName.completeBaseName();
|
|
|
|
auto* rimResultReservoir = new RimEclipseResultCase();
|
|
rimResultReservoir->setCaseInfo( caseName, firstFileName );
|
|
if ( !rimResultReservoir->openEclipseGridFile() )
|
|
{
|
|
delete rimResultReservoir;
|
|
return false;
|
|
}
|
|
|
|
rimResultReservoir->readGridDimensions( mainCaseGridDimensions );
|
|
|
|
mainResultCase = rimResultReservoir;
|
|
RimOilField* oilField = project->activeOilField();
|
|
if ( oilField && oilField->analysisModels() )
|
|
{
|
|
gridCaseGroup = oilField->analysisModels->createIdenticalCaseGroupFromMainCase( mainResultCase );
|
|
}
|
|
}
|
|
|
|
caf::ProgressInfo info( fileNames.size(), "Reading Active Cell data" );
|
|
|
|
for ( int i = 1; i < fileNames.size(); i++ )
|
|
{
|
|
QString caseFileName = fileNames[i];
|
|
QFileInfo gridFileName( caseFileName );
|
|
|
|
QString caseName = gridFileName.completeBaseName();
|
|
|
|
auto* rimResultReservoir = new RimEclipseResultCase();
|
|
rimResultReservoir->setCaseInfo( caseName, caseFileName );
|
|
|
|
std::vector<std::vector<int>> caseGridDimensions;
|
|
rimResultReservoir->readGridDimensions( caseGridDimensions );
|
|
|
|
bool identicalGrid = RigGridManager::isGridDimensionsEqual( mainCaseGridDimensions, caseGridDimensions );
|
|
if ( identicalGrid )
|
|
{
|
|
if ( rimResultReservoir->openAndReadActiveCellData( mainResultCase->eclipseCaseData() ) )
|
|
{
|
|
RimOilField* oilField = project->activeOilField();
|
|
if ( oilField && oilField->analysisModels() )
|
|
{
|
|
oilField->analysisModels()->insertCaseInCaseGroup( gridCaseGroup, rimResultReservoir );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
delete rimResultReservoir;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
delete rimResultReservoir;
|
|
}
|
|
|
|
info.setProgress( i );
|
|
}
|
|
|
|
if ( gridCaseGroup )
|
|
{
|
|
// Create placeholder results and propagate results info from main case to all other cases
|
|
gridCaseGroup->loadMainCaseAndActiveCellInfo();
|
|
|
|
if ( resultingCaseGroup )
|
|
{
|
|
*resultingCaseGroup = gridCaseGroup;
|
|
}
|
|
}
|
|
|
|
project->activeOilField()->analysisModels()->updateConnectedEditors();
|
|
|
|
if ( RiaGuiApplication::isRunning() && gridCaseGroup && !gridCaseGroup->statisticsCaseCollection()->reservoirs.empty() )
|
|
{
|
|
if ( RiuMainWindow::instance() )
|
|
RiuMainWindow::instance()->selectAsCurrentItem( gridCaseGroup->statisticsCaseCollection()->reservoirs[0] );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<int> RiaImportEclipseCaseTools::openRoffCasesFromFileNames( const QStringList& fileNames, bool createDefaultView )
|
|
{
|
|
CAF_ASSERT( !fileNames.empty() );
|
|
|
|
RimProject* project = RimProject::current();
|
|
if ( !project ) return {};
|
|
|
|
RimEclipseCaseCollection* analysisModels = project->activeOilField() ? project->activeOilField()->analysisModels() : nullptr;
|
|
if ( !analysisModels ) return {};
|
|
|
|
std::vector<int> roffCaseIds;
|
|
for ( const auto& fileName : fileNames )
|
|
{
|
|
auto* roffCase = new RimRoffCase();
|
|
project->assignCaseIdToCase( roffCase );
|
|
roffCase->setGridFileName( fileName );
|
|
|
|
bool gridImportSuccess = roffCase->openEclipseGridFile();
|
|
if ( !gridImportSuccess )
|
|
{
|
|
const auto errMsg = "Failed to import grid from file: " + fileName.toStdString();
|
|
RiaLogging::error( errMsg.c_str() );
|
|
delete roffCase;
|
|
continue;
|
|
}
|
|
|
|
analysisModels->cases.push_back( roffCase );
|
|
|
|
RimEclipseView* eclipseView = nullptr;
|
|
if ( createDefaultView )
|
|
{
|
|
eclipseView = roffCase->createAndAddReservoirView();
|
|
|
|
eclipseView->cellResult()->setResultType( RiaDefines::ResultCatType::INPUT_PROPERTY );
|
|
|
|
if ( RiaGuiApplication::isRunning() )
|
|
{
|
|
if ( RiuMainWindow::instance() ) RiuMainWindow::instance()->selectAsCurrentItem( eclipseView->cellResult() );
|
|
}
|
|
|
|
eclipseView->loadDataAndUpdate();
|
|
}
|
|
|
|
analysisModels->updateConnectedEditors();
|
|
roffCaseIds.push_back( roffCase->caseId() );
|
|
}
|
|
return roffCaseIds;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimRoffCase* RiaImportEclipseCaseTools::openRoffCaseFromFileName( const QString& fileName, bool createDefaultView )
|
|
{
|
|
RimProject* project = RimProject::current();
|
|
if ( !project ) return nullptr;
|
|
|
|
RimEclipseCaseCollection* analysisModels = project->activeOilField() ? project->activeOilField()->analysisModels() : nullptr;
|
|
if ( !analysisModels ) return nullptr;
|
|
|
|
auto* roffCase = new RimRoffCase();
|
|
project->assignCaseIdToCase( roffCase );
|
|
roffCase->setGridFileName( fileName );
|
|
|
|
bool gridImportSuccess = roffCase->openEclipseGridFile();
|
|
if ( !gridImportSuccess )
|
|
{
|
|
const auto errMsg = "Failed to import grid from file: " + fileName.toStdString();
|
|
RiaLogging::error( errMsg.c_str() );
|
|
delete roffCase;
|
|
return nullptr;
|
|
}
|
|
|
|
analysisModels->cases.push_back( roffCase );
|
|
analysisModels->updateConnectedEditors();
|
|
|
|
RimEclipseView* eclipseView = nullptr;
|
|
if ( createDefaultView )
|
|
{
|
|
eclipseView = roffCase->createAndAddReservoirView();
|
|
|
|
eclipseView->cellResult()->setResultType( RiaDefines::ResultCatType::INPUT_PROPERTY );
|
|
eclipseView->loadDataAndUpdate();
|
|
|
|
roffCase->updateAllRequiredEditors();
|
|
if ( RiaGuiApplication::isRunning() )
|
|
{
|
|
if ( RiuMainWindow::instance() ) RiuMainWindow::instance()->selectAsCurrentItem( eclipseView->cellResult() );
|
|
|
|
// Make sure the call to setExpanded is done after the call to selectAsCurrentItem
|
|
Riu3DMainWindowTools::setExpanded( eclipseView );
|
|
}
|
|
}
|
|
|
|
return roffCase;
|
|
}
|