mirror of
https://github.com/OPM/ResInsight.git
synced 2026-07-31 16:58:18 -05:00
Kristian BendiksenandMagne Sjaastad
ff209ad7c2
* #9773 Refactor ensemble import dialog. * #9773 Add support for ensemble import of StimPlan/Reveal summary data. * #9773 Add method for finding min and max time steps. * #9773 Add option for resampling to hour intervals. * #9773 Add option for resampling to minute intervals. * #9773 Ensemble statistics: determine sub-sampling period dynamically. * Use RiaWeightedMeanCalculator for curve resampling. * Add HOUR and MINUTE to date time app enum. * #9773 Generate better ensembles for StimPlan summaries. * #9773 Fix parameters.txt lookup for StimPlan summaries * Refactor: Improve interface of RicImportSummaryCasesFreature::createSummaryCasesFromFiles Co-authored-by: Magne Sjaastad <magne.sjaastad@ceetronsolutions.com>
435 lines
16 KiB
C++
435 lines
16 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2021 Equinor 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 "RiaEnsembleNameTools.h"
|
|
|
|
#include "RiaFilePathTools.h"
|
|
#include "RiaTextStringTools.h"
|
|
|
|
#include "RimCaseDisplayNameTools.h"
|
|
#include "RimProject.h"
|
|
#include "RimSummaryCase.h"
|
|
#include "RimSummaryCaseCollection.h"
|
|
|
|
#include "cafAppEnum.h"
|
|
|
|
#include <QFileInfo>
|
|
#include <QRegularExpression>
|
|
|
|
template <>
|
|
void caf::AppEnum<RiaEnsembleNameTools::EnsembleGroupingMode>::setUp()
|
|
{
|
|
addItem( RiaEnsembleNameTools::EnsembleGroupingMode::FMU_FOLDER_STRUCTURE, "FMU_FOLDER_MODE", "Sub Folder" );
|
|
addItem( RiaEnsembleNameTools::EnsembleGroupingMode::EVEREST_FOLDER_STRUCTURE, "EVEREST_FOLDER_MODE", "Main Folder" );
|
|
addItem( RiaEnsembleNameTools::EnsembleGroupingMode::NONE, "None", "None" );
|
|
setDefault( RiaEnsembleNameTools::EnsembleGroupingMode::FMU_FOLDER_STRUCTURE );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiaEnsembleNameTools::findSuitableEnsembleName( const QStringList& fileNames, EnsembleGroupingMode folderLevel )
|
|
{
|
|
if ( folderLevel == EnsembleGroupingMode::EVEREST_FOLDER_STRUCTURE )
|
|
{
|
|
QString commonRoot = RiaTextStringTools::commonRoot( fileNames );
|
|
commonRoot = commonRoot.left( commonRoot.lastIndexOf( '/' ) );
|
|
QStringList rootComponents = RiaFilePathTools::splitPathIntoComponents( commonRoot );
|
|
|
|
if ( !rootComponents.empty() )
|
|
{
|
|
return rootComponents.back();
|
|
}
|
|
}
|
|
|
|
std::vector<QStringList> componentsForAllFilePaths;
|
|
|
|
for ( const auto& filePath : fileNames )
|
|
{
|
|
QStringList components = RiaFilePathTools::splitPathIntoComponents( filePath );
|
|
componentsForAllFilePaths.push_back( components );
|
|
}
|
|
|
|
QStringList iterations = findUniqueEnsembleNames( fileNames, componentsForAllFilePaths, folderLevel );
|
|
if ( iterations.size() == 1u )
|
|
{
|
|
return iterations.front();
|
|
}
|
|
|
|
if ( !iterations.empty() )
|
|
{
|
|
return QString( "Multiple iterations: %1" ).arg( iterations.join( ", " ) );
|
|
}
|
|
|
|
QString root = RiaFilePathTools::commonRootOfFileNames( fileNames );
|
|
|
|
QRegularExpression trimRe( "[^a-zA-Z0-9]+$" );
|
|
QString trimmedRoot = root.replace( trimRe, "" );
|
|
if ( trimmedRoot.length() >= 4 )
|
|
{
|
|
return trimmedRoot;
|
|
}
|
|
|
|
return "Ensemble";
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<QStringList> RiaEnsembleNameTools::groupFilesByEnsemble( const QStringList& fileNames, EnsembleGroupingMode groupingMode )
|
|
{
|
|
std::vector<QStringList> componentsForAllFilePaths;
|
|
|
|
for ( const auto& filePath : fileNames )
|
|
{
|
|
QStringList components = RiaFilePathTools::splitPathIntoComponents( filePath );
|
|
componentsForAllFilePaths.push_back( components );
|
|
}
|
|
|
|
QStringList iterations = findUniqueEnsembleNames( fileNames, componentsForAllFilePaths, groupingMode );
|
|
if ( iterations.size() <= 1 )
|
|
{
|
|
// All the files are in the same ensemble
|
|
return { fileNames };
|
|
}
|
|
|
|
std::vector<QStringList> groupedByIteration;
|
|
for ( const auto& iteration : iterations )
|
|
{
|
|
QStringList fileNamesFromIteration;
|
|
|
|
for ( int i = 0; i < fileNames.size(); i++ )
|
|
{
|
|
auto components = componentsForAllFilePaths[i];
|
|
bool foundMatch = false;
|
|
for ( const auto& component : components )
|
|
{
|
|
if ( component == iteration ) foundMatch = true;
|
|
}
|
|
|
|
if ( foundMatch )
|
|
{
|
|
fileNamesFromIteration << fileNames[i];
|
|
}
|
|
}
|
|
groupedByIteration.push_back( fileNamesFromIteration );
|
|
}
|
|
|
|
return groupedByIteration;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::map<QString, QStringList> RiaEnsembleNameTools::groupFilesByStimPlanEnsemble( const QStringList& fileNames )
|
|
{
|
|
std::vector<QStringList> componentsForAllFilePaths;
|
|
for ( const auto& filePath : fileNames )
|
|
{
|
|
QStringList components = RiaFilePathTools::splitPathIntoComponents( filePath );
|
|
componentsForAllFilePaths.push_back( components );
|
|
}
|
|
|
|
auto mapping = findUniqueStimPlanEnsembleNames( fileNames, componentsForAllFilePaths );
|
|
|
|
std::set<QString> iterations;
|
|
for ( const auto& [name, iterFileNamePair] : mapping )
|
|
{
|
|
iterations.insert( iterFileNamePair.first );
|
|
}
|
|
|
|
std::map<QString, QStringList> groupedByIteration;
|
|
|
|
for ( const QString& groupIteration : iterations )
|
|
{
|
|
QStringList fileNamesFromIteration;
|
|
|
|
for ( const auto& [name, iterFileNamePair] : mapping )
|
|
{
|
|
QString iteration = iterFileNamePair.first;
|
|
QString fileName = iterFileNamePair.second;
|
|
|
|
if ( groupIteration == iteration )
|
|
{
|
|
fileNamesFromIteration << fileName;
|
|
}
|
|
}
|
|
groupedByIteration[groupIteration] = fileNamesFromIteration;
|
|
}
|
|
|
|
return groupedByIteration;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::map<QString, std::pair<QString, QString>>
|
|
RiaEnsembleNameTools::findUniqueStimPlanEnsembleNames( const QStringList& fileNames, const std::vector<QStringList>& fileNameComponents )
|
|
{
|
|
CAF_ASSERT( fileNames.size() == static_cast<int>( fileNameComponents.size() ) );
|
|
|
|
struct StimPlanComponents
|
|
{
|
|
QString realization;
|
|
QString iteration;
|
|
QString well;
|
|
QString fracture;
|
|
QString job;
|
|
QString fileName;
|
|
};
|
|
|
|
std::vector<StimPlanComponents> comps;
|
|
|
|
int i = 0;
|
|
for ( const auto& fileComponents : fileNameComponents )
|
|
{
|
|
int numComponents = fileComponents.size();
|
|
|
|
if ( numComponents >= 7 )
|
|
{
|
|
StimPlanComponents c;
|
|
c.fileName = fileNames[i];
|
|
c.fracture = fileComponents[numComponents - 2];
|
|
c.iteration = fileComponents[numComponents - 6];
|
|
c.realization = fileComponents[numComponents - 7];
|
|
|
|
QString wellJobComponent = fileComponents[numComponents - 3];
|
|
QStringList parts = wellJobComponent.split( "_" );
|
|
|
|
if ( parts.size() == 4 )
|
|
{
|
|
c.well = parts[0];
|
|
c.job = parts[3];
|
|
}
|
|
|
|
comps.push_back( c );
|
|
}
|
|
i++;
|
|
}
|
|
|
|
std::map<QString, std::pair<QString, QString>> mapping;
|
|
for ( const StimPlanComponents& c : comps )
|
|
{
|
|
QString key = QString( "%1, %2, %3, %4, %5" ).arg( c.iteration, c.realization, c.well, c.fracture, c.job );
|
|
QString iteration = QString( "%1, %2, %3, %4" ).arg( c.iteration, c.well, c.fracture, c.job );
|
|
mapping[key] = std::make_pair( iteration, c.fileName );
|
|
}
|
|
|
|
return mapping;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiaEnsembleNameTools::uniqueShortNameForEnsembleCase( RimSummaryCase* summaryCase )
|
|
{
|
|
CAF_ASSERT( summaryCase && summaryCase->ensemble() );
|
|
|
|
auto ensembleCaseName = summaryCase->nativeCaseName();
|
|
auto ensemble = summaryCase->ensemble();
|
|
auto summaryCases = ensemble->allSummaryCases();
|
|
|
|
QStringList summaryFilePaths;
|
|
summaryFilePaths.push_back( summaryCase->summaryHeaderFilename() );
|
|
|
|
for ( auto otherSummaryCase : summaryCases )
|
|
{
|
|
if ( otherSummaryCase != summaryCase )
|
|
{
|
|
summaryFilePaths.push_back( otherSummaryCase->summaryHeaderFilename() );
|
|
}
|
|
}
|
|
|
|
return RiaEnsembleNameTools::uniqueShortName( summaryCase->summaryHeaderFilename(), summaryFilePaths, ensembleCaseName );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiaEnsembleNameTools::uniqueShortNameForSummaryCase( RimSummaryCase* summaryCase )
|
|
{
|
|
std::set<QString> allAutoShortNames;
|
|
|
|
std::vector<RimSummaryCase*> allCases;
|
|
RimProject::current()->descendantsOfType( allCases );
|
|
|
|
for ( auto sumCase : allCases )
|
|
{
|
|
if ( sumCase && sumCase != summaryCase )
|
|
{
|
|
allAutoShortNames.insert( sumCase->displayCaseName() );
|
|
}
|
|
}
|
|
|
|
return RimCaseDisplayNameTools::uniqueShortName( summaryCase->nativeCaseName(),
|
|
allAutoShortNames,
|
|
RimCaseDisplayNameTools::CASE_SHORT_NAME_LENGTH );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QStringList RiaEnsembleNameTools::findUniqueEnsembleNames( const QStringList& fileNames,
|
|
const std::vector<QStringList>& fileNameComponents,
|
|
EnsembleGroupingMode groupingMode )
|
|
{
|
|
QStringList iterations;
|
|
if ( groupingMode == EnsembleGroupingMode::EVEREST_FOLDER_STRUCTURE )
|
|
{
|
|
QString commonRoot = RiaTextStringTools::commonRoot( fileNames );
|
|
QStringList rootComponents = RiaFilePathTools::splitPathIntoComponents( commonRoot );
|
|
auto commonComponentCount = rootComponents.size();
|
|
|
|
// Example:
|
|
// /myPath/batch_01/realization-1/....
|
|
// /myPath/batch_01/realization-2/....
|
|
// /myPath/batch_01/realization-N/....
|
|
// /myPath/batch_02/realization-1/....
|
|
// /myPath/batch_02/realization-2/....
|
|
// /myPath/batch_02/realization-N/....
|
|
|
|
// commonRoot will return /myPath/batch_
|
|
// ensembleNameSet will contain [batch_01, batch_02]
|
|
|
|
std::set<QString> ensembleNameSet;
|
|
for ( const auto& componentsForFile : fileNameComponents )
|
|
{
|
|
if ( commonComponentCount - 1 < componentsForFile.size() )
|
|
{
|
|
ensembleNameSet.insert( componentsForFile[commonComponentCount - 1] );
|
|
}
|
|
}
|
|
|
|
for ( const auto& ensembleName : ensembleNameSet )
|
|
{
|
|
iterations.push_back( ensembleName );
|
|
}
|
|
}
|
|
else if ( groupingMode == EnsembleGroupingMode::FMU_FOLDER_STRUCTURE )
|
|
{
|
|
// Find list of all folders inside a folder matching realization-*
|
|
QRegularExpression realizationRe( "realization\\-\\d+" );
|
|
|
|
for ( const auto& fileComponents : fileNameComponents )
|
|
{
|
|
QString lastComponent = "";
|
|
for ( auto it = fileComponents.rbegin(); it != fileComponents.rend(); ++it )
|
|
{
|
|
if ( realizationRe.match( *it ).hasMatch() )
|
|
{
|
|
iterations.push_back( lastComponent );
|
|
}
|
|
lastComponent = *it;
|
|
}
|
|
}
|
|
}
|
|
|
|
iterations.removeDuplicates();
|
|
return iterations;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiaEnsembleNameTools::findCommonBaseName( const QStringList& fileNames )
|
|
{
|
|
QStringList baseNames;
|
|
for ( const auto& f : fileNames )
|
|
{
|
|
QFileInfo fi( f );
|
|
baseNames.push_back( fi.baseName() );
|
|
}
|
|
|
|
if ( baseNames.isEmpty() ) return "Empty";
|
|
|
|
auto firstName = baseNames.front();
|
|
for ( int i = 0; i < firstName.size(); i++ )
|
|
{
|
|
auto candidate = firstName.left( firstName.size() - i );
|
|
bool identicalNames = true;
|
|
|
|
for ( const auto& baseName : baseNames )
|
|
{
|
|
auto str = baseName.left( firstName.size() - i );
|
|
if ( candidate != str ) identicalNames = false;
|
|
}
|
|
|
|
if ( identicalNames )
|
|
{
|
|
return candidate;
|
|
}
|
|
}
|
|
|
|
return "Mixed Items";
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiaEnsembleNameTools::uniqueShortName( const QString& sourceFileName, const QStringList& allFileNames, const QString& ensembleCaseName )
|
|
{
|
|
std::map<QString, QStringList> keyFileComponentsForAllFiles = RiaFilePathTools::keyPathComponentsForEachFilePath( allFileNames );
|
|
|
|
return uniqueShortNameFromComponents( sourceFileName, keyFileComponentsForAllFiles, ensembleCaseName );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiaEnsembleNameTools::uniqueShortNameFromComponents( const QString& sourceFileName,
|
|
const std::map<QString, QStringList>& keyFileComponentsForAllFiles,
|
|
const QString& ensembleCaseName )
|
|
{
|
|
QRegularExpression trimRe( "^[^a-zA-Z0-9]+" );
|
|
|
|
auto modifyableMap( keyFileComponentsForAllFiles );
|
|
QStringList keyFileComponents = modifyableMap[sourceFileName];
|
|
if ( keyFileComponents.empty() ) return "Unnamed";
|
|
|
|
if ( !ensembleCaseName.isEmpty() )
|
|
{
|
|
for ( auto& component : keyFileComponents )
|
|
{
|
|
component = component.replace( ensembleCaseName, "" );
|
|
component = component.replace( trimRe, "" );
|
|
}
|
|
}
|
|
|
|
QStringList shortNameComponents;
|
|
QRegularExpression numberRe( "[0-9]+" );
|
|
for ( auto keyComponent : keyFileComponents )
|
|
{
|
|
QStringList subComponents;
|
|
QString numberGroup = numberRe.match( keyComponent ).captured();
|
|
if ( !numberGroup.isEmpty() )
|
|
{
|
|
keyComponent = keyComponent.replace( numberGroup, "" );
|
|
QString stem = keyComponent.left( RimCaseDisplayNameTools::CASE_SHORT_NAME_LENGTH );
|
|
if ( !stem.isEmpty() ) subComponents.push_back( stem );
|
|
subComponents.push_back( numberGroup );
|
|
}
|
|
else
|
|
{
|
|
subComponents.push_back( keyComponent.left( RimCaseDisplayNameTools::CASE_SHORT_NAME_LENGTH ) );
|
|
}
|
|
|
|
shortNameComponents.push_back( subComponents.join( "-" ) );
|
|
}
|
|
return shortNameComponents.join( "," );
|
|
}
|