mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-20 11:48:35 -06:00
508 lines
18 KiB
C++
508 lines
18 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2016- 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 "RimSummaryCaseMainCollection.h"
|
|
|
|
#include "RifCaseRealizationParametersReader.h"
|
|
#include "RifEclipseSummaryTools.h"
|
|
#include "RifSummaryCaseRestartSelector.h"
|
|
|
|
#include "RimDerivedEnsembleCaseCollection.h"
|
|
#include "RimEclipseResultCase.h"
|
|
#include "RimFileSummaryCase.h"
|
|
#include "RimGridSummaryCase.h"
|
|
#include "RimOilField.h"
|
|
#include "RimProject.h"
|
|
#include "RimSummaryCase.h"
|
|
#include "RimSummaryCaseCollection.h"
|
|
|
|
#include "cafProgressInfo.h"
|
|
#include <QDir>
|
|
|
|
CAF_PDM_SOURCE_INIT( RimSummaryCaseMainCollection, "SummaryCaseCollection" );
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Internal function
|
|
//--------------------------------------------------------------------------------------------------
|
|
void addCaseRealizationParametersIfFound( RimSummaryCase& sumCase, const QString modelFolderOrFile )
|
|
{
|
|
QString parametersFile = RifCaseRealizationParametersFileLocator::locate( modelFolderOrFile );
|
|
if ( !parametersFile.isEmpty() )
|
|
{
|
|
auto reader = RifCaseRealizationReader::createReaderFromFileName( parametersFile );
|
|
if ( reader )
|
|
{
|
|
// Try parse case realization parameters
|
|
try
|
|
{
|
|
reader->parse();
|
|
sumCase.setCaseRealizationParameters( reader->parameters() );
|
|
}
|
|
catch ( ... )
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimSummaryCaseMainCollection::RimSummaryCaseMainCollection()
|
|
{
|
|
CAF_PDM_InitObject( "Summary Cases", ":/SummaryCases16x16.png", "", "" );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_cases, "SummaryCases", "", "", "", "" );
|
|
CAF_PDM_InitFieldNoDefault( &m_caseCollections, "SummaryCaseCollections", "", "", "", "" );
|
|
|
|
m_cases.uiCapability()->setUiHidden( true );
|
|
m_caseCollections.uiCapability()->setUiHidden( true );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimSummaryCaseMainCollection::~RimSummaryCaseMainCollection()
|
|
{
|
|
m_cases.deleteAllChildObjectsAsync();
|
|
m_caseCollections.deleteAllChildObjectsAsync();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimSummaryCase*
|
|
RimSummaryCaseMainCollection::findSummaryCaseFromEclipseResultCase( const RimEclipseResultCase* eclipseResultCase ) const
|
|
{
|
|
for ( RimSummaryCase* summaryCase : m_cases )
|
|
{
|
|
RimGridSummaryCase* gridSummaryCase = dynamic_cast<RimGridSummaryCase*>( summaryCase );
|
|
if ( gridSummaryCase && gridSummaryCase->associatedEclipseCase() )
|
|
{
|
|
if ( gridSummaryCase->associatedEclipseCase()->gridFileName() == eclipseResultCase->gridFileName() )
|
|
{
|
|
return gridSummaryCase;
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( auto collection : m_caseCollections )
|
|
{
|
|
for ( RimSummaryCase* sumCase : collection->allSummaryCases() )
|
|
{
|
|
RimGridSummaryCase* gridSummaryCase = dynamic_cast<RimGridSummaryCase*>( sumCase );
|
|
if ( gridSummaryCase &&
|
|
gridSummaryCase->associatedEclipseCase()->gridFileName() == eclipseResultCase->gridFileName() )
|
|
{
|
|
return gridSummaryCase;
|
|
}
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimSummaryCase* RimSummaryCaseMainCollection::findSummaryCaseFromFileName( const QString& fileName ) const
|
|
{
|
|
// Use QFileInfo object to compare two file names to avoid mix of / and \\
|
|
|
|
QFileInfo incomingFileInfo( fileName );
|
|
|
|
for ( RimSummaryCase* summaryCase : m_cases )
|
|
{
|
|
if ( summaryCase )
|
|
{
|
|
QFileInfo summaryFileInfo( summaryCase->summaryHeaderFilename() );
|
|
if ( incomingFileInfo == summaryFileInfo )
|
|
{
|
|
return summaryCase;
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( auto collection : m_caseCollections )
|
|
{
|
|
for ( RimSummaryCase* summaryCase : collection->allSummaryCases() )
|
|
{
|
|
if ( summaryCase )
|
|
{
|
|
QFileInfo summaryFileInfo( summaryCase->summaryHeaderFilename() );
|
|
if ( incomingFileInfo == summaryFileInfo )
|
|
{
|
|
return summaryCase;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryCaseMainCollection::convertGridSummaryCasesToFileSummaryCases( RimGridSummaryCase* gridSummaryCase )
|
|
{
|
|
RimFileSummaryCase* fileSummaryCase = gridSummaryCase->createFileSummaryCaseCopy();
|
|
addCaseRealizationParametersIfFound( *fileSummaryCase, fileSummaryCase->summaryHeaderFilename() );
|
|
|
|
RimSummaryCaseCollection* collection;
|
|
gridSummaryCase->firstAncestorOrThisOfType( collection );
|
|
|
|
removeCase( gridSummaryCase );
|
|
delete gridSummaryCase;
|
|
|
|
if ( collection )
|
|
{
|
|
collection->addCase( fileSummaryCase );
|
|
collection->updateConnectedEditors();
|
|
}
|
|
else
|
|
{
|
|
this->addCase( fileSummaryCase );
|
|
this->updateConnectedEditors();
|
|
}
|
|
loadSummaryCaseData( {fileSummaryCase} );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryCaseMainCollection::addCases( const std::vector<RimSummaryCase*> cases )
|
|
{
|
|
for ( RimSummaryCase* sumCase : cases )
|
|
{
|
|
addCase( sumCase );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryCaseMainCollection::addCase( RimSummaryCase* summaryCase )
|
|
{
|
|
m_cases.push_back( summaryCase );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryCaseMainCollection::removeCase( RimSummaryCase* summaryCase )
|
|
{
|
|
std::vector<RimDerivedEnsembleCaseCollection*> derivedEnsembles;
|
|
|
|
// Build a list of derived ensembles that must be updated after delete
|
|
for ( auto group : summaryCaseCollections() )
|
|
{
|
|
auto derEnsemble = dynamic_cast<RimDerivedEnsembleCaseCollection*>( group );
|
|
if ( derEnsemble )
|
|
{
|
|
if ( derEnsemble->hasCaseReference( summaryCase ) )
|
|
{
|
|
derivedEnsembles.push_back( derEnsemble );
|
|
}
|
|
}
|
|
}
|
|
|
|
m_cases.removeChildObject( summaryCase );
|
|
for ( RimSummaryCaseCollection* summaryCaseCollection : m_caseCollections )
|
|
{
|
|
summaryCaseCollection->removeCase( summaryCase );
|
|
}
|
|
|
|
// Update derived ensemble cases (if any)
|
|
for ( auto derEnsemble : derivedEnsembles )
|
|
{
|
|
derEnsemble->updateDerivedEnsembleCases();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimSummaryCaseCollection*
|
|
RimSummaryCaseMainCollection::addCaseCollection( std::vector<RimSummaryCase*> summaryCases,
|
|
const QString& collectionName,
|
|
bool isEnsemble,
|
|
std::function<RimSummaryCaseCollection*()> allocator )
|
|
{
|
|
RimSummaryCaseCollection* summaryCaseCollection = allocator();
|
|
if ( !collectionName.isEmpty() ) summaryCaseCollection->setName( collectionName );
|
|
|
|
for ( RimSummaryCase* summaryCase : summaryCases )
|
|
{
|
|
RimSummaryCaseCollection* currentSummaryCaseCollection = nullptr;
|
|
summaryCase->firstAncestorOrThisOfType( currentSummaryCaseCollection );
|
|
|
|
if ( currentSummaryCaseCollection )
|
|
{
|
|
currentSummaryCaseCollection->removeCase( summaryCase );
|
|
}
|
|
else
|
|
{
|
|
m_cases.removeChildObject( summaryCase );
|
|
}
|
|
|
|
summaryCaseCollection->addCase( summaryCase );
|
|
}
|
|
|
|
summaryCaseCollection->setAsEnsemble( isEnsemble );
|
|
|
|
m_caseCollections.push_back( summaryCaseCollection );
|
|
|
|
return summaryCaseCollection;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryCaseMainCollection::removeCaseCollection( RimSummaryCaseCollection* caseCollection )
|
|
{
|
|
m_caseCollections.removeChildObject( caseCollection );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimSummaryCase* RimSummaryCaseMainCollection::summaryCase( size_t idx )
|
|
{
|
|
return m_cases[idx];
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
size_t RimSummaryCaseMainCollection::summaryCaseCount() const
|
|
{
|
|
return m_cases.size();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimSummaryCase*> RimSummaryCaseMainCollection::allSummaryCases() const
|
|
{
|
|
std::vector<RimSummaryCase*> cases;
|
|
this->descendantsIncludingThisOfType( cases );
|
|
|
|
return cases;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimSummaryCase*> RimSummaryCaseMainCollection::topLevelSummaryCases() const
|
|
{
|
|
std::vector<RimSummaryCase*> cases;
|
|
for ( const auto& sumCase : m_cases )
|
|
{
|
|
cases.push_back( sumCase );
|
|
}
|
|
return cases;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimSummaryCaseCollection*> RimSummaryCaseMainCollection::summaryCaseCollections() const
|
|
{
|
|
std::vector<RimSummaryCaseCollection*> summaryCaseCollections;
|
|
for ( const auto& caseColl : m_caseCollections )
|
|
{
|
|
summaryCaseCollections.push_back( caseColl );
|
|
}
|
|
return summaryCaseCollections;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryCaseMainCollection::loadAllSummaryCaseData()
|
|
{
|
|
std::vector<RimSummaryCase*> sumCases = allSummaryCases();
|
|
|
|
RimSummaryCaseMainCollection::loadSummaryCaseData( sumCases );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryCaseMainCollection::loadSummaryCaseData( std::vector<RimSummaryCase*> summaryCases )
|
|
{
|
|
caf::ProgressInfo progInfo( summaryCases.size(), "Loading Summary Cases" );
|
|
|
|
for ( int cIdx = 0; cIdx < static_cast<int>( summaryCases.size() ); ++cIdx )
|
|
{
|
|
RimSummaryCase* sumCase = summaryCases[cIdx];
|
|
if ( sumCase )
|
|
{
|
|
sumCase->createSummaryReaderInterface();
|
|
sumCase->createRftReaderInterface();
|
|
addCaseRealizationParametersIfFound( *sumCase, sumCase->summaryHeaderFilename() );
|
|
}
|
|
|
|
{
|
|
progInfo.incrementProgress();
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimSummaryCaseCollection* RimSummaryCaseMainCollection::defaultAllocator()
|
|
{
|
|
return new RimSummaryCaseCollection();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimSummaryCase*> RimSummaryCaseMainCollection::createSummaryCasesFromFileInfos(
|
|
const std::vector<RifSummaryCaseFileResultInfo>& summaryHeaderFileInfos, bool showProgress )
|
|
{
|
|
RimProject* project = RiaApplication::instance()->project();
|
|
|
|
std::vector<RimSummaryCase*> sumCases;
|
|
|
|
// Split into two stages to be able to use multi threading
|
|
// First stage : Create summary case objects
|
|
// Second stage : Load data
|
|
{
|
|
std::unique_ptr<caf::ProgressInfo> progress;
|
|
|
|
if ( showProgress )
|
|
{
|
|
progress.reset( new caf::ProgressInfo( summaryHeaderFileInfos.size(), "Creating summary cases" ) );
|
|
}
|
|
|
|
for ( const RifSummaryCaseFileResultInfo& fileInfo : summaryHeaderFileInfos )
|
|
{
|
|
RimEclipseCase* eclCase = nullptr;
|
|
QString gridCaseFile = RifEclipseSummaryTools::findGridCaseFileFromSummaryHeaderFile(
|
|
fileInfo.summaryFileName() );
|
|
if ( !gridCaseFile.isEmpty() )
|
|
{
|
|
eclCase = project->eclipseCaseFromGridFileName( gridCaseFile );
|
|
}
|
|
|
|
RimGridSummaryCase* existingGridSummaryCase = dynamic_cast<RimGridSummaryCase*>(
|
|
findSummaryCaseFromFileName( fileInfo.summaryFileName() ) );
|
|
|
|
if ( eclCase && !existingGridSummaryCase )
|
|
{
|
|
RimGridSummaryCase* newSumCase = new RimGridSummaryCase();
|
|
|
|
newSumCase->setIncludeRestartFiles( fileInfo.includeRestartFiles() );
|
|
newSumCase->setAssociatedEclipseCase( eclCase );
|
|
newSumCase->updateOptionSensitivity();
|
|
sumCases.push_back( newSumCase );
|
|
}
|
|
else
|
|
{
|
|
RimFileSummaryCase* newSumCase = new RimFileSummaryCase();
|
|
|
|
newSumCase->setIncludeRestartFiles( fileInfo.includeRestartFiles() );
|
|
newSumCase->setSummaryHeaderFileName( fileInfo.summaryFileName() );
|
|
newSumCase->updateOptionSensitivity();
|
|
sumCases.push_back( newSumCase );
|
|
}
|
|
|
|
if ( progress != nullptr ) progress->incrementProgress();
|
|
}
|
|
}
|
|
|
|
RimSummaryCaseMainCollection::loadSummaryCaseData( sumCases );
|
|
|
|
return sumCases;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RimSummaryCaseMainCollection::uniqueShortNameForCase( RimSummaryCase* summaryCase )
|
|
{
|
|
std::set<QString> allAutoShortNames;
|
|
|
|
for ( RimSummaryCase* sumCase : m_cases )
|
|
{
|
|
if ( sumCase && sumCase != summaryCase )
|
|
{
|
|
allAutoShortNames.insert( sumCase->shortName() );
|
|
}
|
|
}
|
|
|
|
bool foundUnique = false;
|
|
|
|
QString caseName = summaryCase->caseName();
|
|
QString shortName;
|
|
|
|
if ( caseName.size() > 2 )
|
|
{
|
|
QString candidate;
|
|
candidate += caseName[0];
|
|
|
|
for ( int i = 1; i < caseName.size(); ++i )
|
|
{
|
|
if ( allAutoShortNames.count( candidate + caseName[i] ) == 0 )
|
|
{
|
|
shortName = candidate + caseName[i];
|
|
foundUnique = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
shortName = caseName.left( 2 );
|
|
if ( allAutoShortNames.count( shortName ) == 0 )
|
|
{
|
|
foundUnique = true;
|
|
}
|
|
}
|
|
|
|
QString candidate = shortName;
|
|
int autoNumber = 0;
|
|
|
|
while ( !foundUnique )
|
|
{
|
|
candidate = shortName + QString::number( autoNumber++ );
|
|
if ( allAutoShortNames.count( candidate ) == 0 )
|
|
{
|
|
shortName = candidate;
|
|
foundUnique = true;
|
|
}
|
|
}
|
|
|
|
return shortName;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryCaseMainCollection::updateFilePathsFromProjectPath( const QString& newProjectPath,
|
|
const QString& oldProjectPath )
|
|
{
|
|
for ( auto summaryCase : m_cases )
|
|
{
|
|
summaryCase->updateFilePathsFromProjectPath( newProjectPath, oldProjectPath );
|
|
}
|
|
}
|