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

#8048 Everest Import: Group into separate ensembles

Browse Source
This commit is contained in:
Magne Sjaastad 2021-09-30 09:08:09 +02:00 committed by GitHub
parent c88424dbcf
commit 0d4ab8b594
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 254 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
ApplicationLibCode/Application/Tools/RiaEnsembleNameTools.cpp
View File

@ -19,17 +19,52 @@
#include "RiaEnsembleNameTools.h"
#include "RiaFilePathTools.h"
#include "RiaTextStringTools.h"
#include "RimCaseDisplayNameTools.h"
#include "cafAppEnum.h"
#include <QFileInfo>
#include <QRegularExpression>
template <>
void caf::AppEnum<RiaEnsembleNameTools::EnsembleGroupingMode>::setUp()
{
addItem( RiaEnsembleNameTools::EnsembleGroupingMode::FMU_FOLDER_STRUCTURE, "FMU_FOLDER_MODE", "FMU Folder Structure" );
addItem( RiaEnsembleNameTools::EnsembleGroupingMode::EVEREST_FOLDER_STRUCTURE,
"EVEREST_FOLDER_MODE",
"Everest Folder Structure" );
addItem( RiaEnsembleNameTools::EnsembleGroupingMode::NONE, "None", "None" );
setDefault( RiaEnsembleNameTools::EnsembleGroupingMode::FMU_FOLDER_STRUCTURE );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaEnsembleNameTools::findSuitableEnsembleName( const QStringList& fileNames )
QString RiaEnsembleNameTools::findSuitableEnsembleName( const QStringList& fileNames, EnsembleGroupingMode folderLevel )
{
QStringList iterations = findUniqueIterations( fileNames );
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();
@ -55,9 +90,18 @@ QString RiaEnsembleNameTools::findSuitableEnsembleName( const QStringList& fileN
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<QStringList> RiaEnsembleNameTools::groupFilesByEnsemble( const QStringList& fileNames )
std::vector<QStringList> RiaEnsembleNameTools::groupFilesByEnsemble( const QStringList& fileNames,
EnsembleGroupingMode groupingMode )
{
QStringList iterations = findUniqueIterations( fileNames );
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
@ -65,14 +109,22 @@ std::vector<QStringList> RiaEnsembleNameTools::groupFilesByEnsemble( const QStri
}
std::vector<QStringList> groupedByIteration;
for ( auto iteration : iterations )
for ( const auto& iteration : iterations )
{
QStringList fileNamesFromIteration;
for ( auto filePath : fileNames )
for ( int i = 0; i < fileNames.size(); i++ )
{
if ( filePath.contains( iteration ) )
auto components = componentsForAllFilePaths[i];
bool foundMatch = false;
for ( const auto& component : components )
{
fileNamesFromIteration << filePath;
if ( component == iteration ) foundMatch = true;
}
if ( foundMatch )
{
fileNamesFromIteration << fileNames[i];
}
}
groupedByIteration.push_back( fileNamesFromIteration );
@ -84,30 +136,58 @@ std::vector<QStringList> RiaEnsembleNameTools::groupFilesByEnsemble( const QStri
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QStringList RiaEnsembleNameTools::findUniqueIterations( const QStringList& fileNames )
QStringList RiaEnsembleNameTools::findUniqueEnsembleNames( const QStringList& fileNames,
const std::vector<QStringList>& fileNameComponents,
EnsembleGroupingMode groupingMode )
{
std::vector<QStringList> componentsForAllFilePaths;
for ( const auto& filePath : fileNames )
{
QStringList components = RiaFilePathTools::splitPathIntoComponents( filePath );
componentsForAllFilePaths.push_back( components );
}
// Find list of all folders inside a folder matching realization-*
QRegularExpression realizationRe( "realization\\-\\d+" );
QStringList iterations;
for ( const auto& fileComponents : componentsForAllFilePaths )
if ( groupingMode == EnsembleGroupingMode::EVEREST_FOLDER_STRUCTURE )
{
QString lastComponent = "";
for ( auto it = fileComponents.rbegin(); it != fileComponents.rend(); ++it )
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 ( realizationRe.match( *it ).hasMatch() )
if ( commonComponentCount - 1 < componentsForFile.size() )
{
iterations.push_back( lastComponent );
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;
}
lastComponent = *it;
}
}

18
ApplicationLibCode/Application/Tools/RiaEnsembleNameTools.h
View File

@ -28,7 +28,15 @@
class RiaEnsembleNameTools
{
public:
static QString findSuitableEnsembleName( const QStringList& fileNames );
enum class EnsembleGroupingMode
{
FMU_FOLDER_STRUCTURE,
EVEREST_FOLDER_STRUCTURE,
NONE
};
public:
static QString findSuitableEnsembleName( const QStringList& fileNames, EnsembleGroupingMode groupingMode );
static QString findCommonBaseName( const QStringList& fileNames );
static QString uniqueShortName( const QString& sourceFileName,
@ -39,6 +47,10 @@ public:
const std::map<QString, QStringList>& keyFileComponentsForAllFiles,
const QString& ensembleCaseName );
static QStringList findUniqueIterations( const QStringList& fileNames );
static std::vector<QStringList> groupFilesByEnsemble( const QStringList& fileNames );
static std::vector<QStringList> groupFilesByEnsemble( const QStringList& fileNames, EnsembleGroupingMode groupingMode );
private:
static QStringList findUniqueEnsembleNames( const QStringList& fileNames,
const std::vector<QStringList>& fileNameComponents,
EnsembleGroupingMode groupingMode );
};

23
ApplicationLibCode/Commands/CompletionCommands/RicImportEnsembleFractureStatisticsFeature.cpp
View File

@ -59,18 +59,19 @@ void RicImportEnsembleFractureStatisticsFeature::onActionTriggered( bool isCheck
QString pathCacheName = "INPUT_FILES";
auto [fileNames, groupByEnsemble] = runRecursiveFileSearchDialog( "Import StimPlan Fractures", pathCacheName );
if ( groupByEnsemble )
if ( groupByEnsemble == RiaEnsembleNameTools::EnsembleGroupingMode::NONE )
{
std::vector<QStringList> groupedByEnsemble = RiaEnsembleNameTools::groupFilesByEnsemble( fileNames );
importSingleEnsembleFractureStatistics( fileNames );
}
else
{
std::vector<QStringList> groupedByEnsemble =
RiaEnsembleNameTools::groupFilesByEnsemble( fileNames, groupByEnsemble );
for ( const QStringList& groupedFileNames : groupedByEnsemble )
{
importSingleEnsembleFractureStatistics( groupedFileNames );
}
}
else
{
importSingleEnsembleFractureStatistics( fileNames );
}
}
//--------------------------------------------------------------------------------------------------
@ -79,7 +80,9 @@ void RicImportEnsembleFractureStatisticsFeature::onActionTriggered( bool isCheck
void RicImportEnsembleFractureStatisticsFeature::importSingleEnsembleFractureStatistics( const QStringList& fileNames )
{
auto fractureGroupStatistics = new RimEnsembleFractureStatistics;
QString ensembleNameSuggestion = RiaEnsembleNameTools::findSuitableEnsembleName( fileNames );
QString ensembleNameSuggestion =
RiaEnsembleNameTools::findSuitableEnsembleName( fileNames,
RiaEnsembleNameTools::EnsembleGroupingMode::FMU_FOLDER_STRUCTURE );
fractureGroupStatistics->setName( ensembleNameSuggestion );
caf::ProgressInfo progInfo( fileNames.size() + 1, "Creating Ensemble Fracture Statistics" );
@ -124,7 +127,7 @@ void RicImportEnsembleFractureStatisticsFeature::setupActionLook( QAction* actio
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<QStringList, bool>
std::pair<QStringList, RiaEnsembleNameTools::EnsembleGroupingMode>
RicImportEnsembleFractureStatisticsFeature::runRecursiveFileSearchDialog( const QString& dialogTitle,
const QString& pathCacheName )
{
@ -143,10 +146,10 @@ std::pair<QStringList, bool>
m_pathFilter = result.pathFilter;
m_fileNameFilter = result.fileNameFilter;
if ( !result.ok ) return std::make_pair( QStringList(), false );
if ( !result.ok ) return std::make_pair( QStringList(), RiaEnsembleNameTools::EnsembleGroupingMode::NONE );
// Remember the path to next time
app->setLastUsedDialogDirectory( pathCacheName, QFileInfo( result.rootDir ).absoluteFilePath() );
return std::make_pair( result.files, result.groupByEnsemble );
return std::make_pair( result.files, result.groupingMode );
}

6
ApplicationLibCode/Commands/CompletionCommands/RicImportEnsembleFractureStatisticsFeature.h
View File

@ -20,6 +20,8 @@
#include "cafCmdFeature.h"
#include "RiaEnsembleNameTools.h"
#include <QString>
//==================================================================================================
@ -32,8 +34,8 @@ class RicImportEnsembleFractureStatisticsFeature : public caf::CmdFeature
public:
RicImportEnsembleFractureStatisticsFeature() {}
static std::pair<QStringList, bool> runRecursiveFileSearchDialog( const QString& dialogTitle,
const QString& pathCacheName );
static std::pair<QStringList, RiaEnsembleNameTools::EnsembleGroupingMode>
runRecursiveFileSearchDialog( const QString& dialogTitle, const QString& pathCacheName );
protected:
static void importSingleEnsembleFractureStatistics( const QStringList& fileNames );

3
ApplicationLibCode/Commands/RicCreateEnsembleSurfaceFeature.cpp
View File

@ -120,7 +120,8 @@ void RicCreateEnsembleSurfaceFeature::executeCommand( const RicCreateEnsembleSur
progress.setProgress( fileNames.size() );
if ( ui.autoCreateEnsembleSurfaces() )
RicImportEnsembleSurfaceFeature::importEnsembleSurfaceFromFiles( allSurfaceFileNames );
RicImportEnsembleSurfaceFeature::importEnsembleSurfaceFromFiles( allSurfaceFileNames,
RiaEnsembleNameTools::EnsembleGroupingMode::FMU_FOLDER_STRUCTURE );
}
//--------------------------------------------------------------------------------------------------

3
ApplicationLibCode/Commands/RicCreateEnsembleWellLogFeature.cpp
View File

@ -237,7 +237,8 @@ void RicCreateEnsembleWellLogFeature::executeCommand( const RicCreateEnsembleWel
if ( ui.autoCreateEnsembleWellLogs() )
{
std::vector<RimEnsembleWellLogs*> ensembleWellLogs =
RicImportEnsembleWellLogsFeature::createEnsembleWellLogsFromFiles( allLasFileNames );
RicImportEnsembleWellLogsFeature::createEnsembleWellLogsFromFiles( allLasFileNames,
RiaEnsembleNameTools::EnsembleGroupingMode::FMU_FOLDER_STRUCTURE );
for ( auto ensembleWellLog : ensembleWellLogs )
{

27
ApplicationLibCode/Commands/RicImportEnsembleFeature.cpp
View File

@ -72,34 +72,37 @@ bool RicImportEnsembleFeature::isCommandEnabled()
void RicImportEnsembleFeature::onActionTriggered( bool isChecked )
{
QString pathCacheName = "ENSEMBLE_FILES";
auto [fileNames, groupByEnsemble] =
auto [fileNames, ensembleGroupingMode] =
RicImportSummaryCasesFeature::runRecursiveSummaryCaseFileSearchDialogWithGrouping( "Import Ensemble",
pathCacheName );
if ( fileNames.isEmpty() ) return;
if ( groupByEnsemble )
if ( ensembleGroupingMode == RiaEnsembleNameTools::EnsembleGroupingMode::NONE )
{
std::vector<QStringList> groupedByEnsemble = RiaEnsembleNameTools::groupFilesByEnsemble( fileNames );
for ( const QStringList& groupedFileNames : groupedByEnsemble )
{
bool useEnsembleNameDialog = false;
importSingleEnsemble( groupedFileNames, useEnsembleNameDialog );
}
bool useEnsembleNameDialog = true;
importSingleEnsemble( fileNames, useEnsembleNameDialog, ensembleGroupingMode );
}
else
{
bool useEnsembleNameDialog = true;
importSingleEnsemble( fileNames, useEnsembleNameDialog );
std::vector<QStringList> groupedByEnsemble =
RiaEnsembleNameTools::groupFilesByEnsemble( fileNames, ensembleGroupingMode );
for ( const QStringList& groupedFileNames : groupedByEnsemble )
{
bool useEnsembleNameDialog = false;
importSingleEnsemble( groupedFileNames, useEnsembleNameDialog, ensembleGroupingMode );
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicImportEnsembleFeature::importSingleEnsemble( const QStringList& fileNames, bool useEnsembleNameDialog )
void RicImportEnsembleFeature::importSingleEnsemble( const QStringList& fileNames,
bool useEnsembleNameDialog,
RiaEnsembleNameTools::EnsembleGroupingMode groupingMode )
{
QString ensembleName = RiaEnsembleNameTools::findSuitableEnsembleName( fileNames );
QString ensembleName = RiaEnsembleNameTools::findSuitableEnsembleName( fileNames, groupingMode );
if ( useEnsembleNameDialog ) ensembleName = askForEnsembleName( ensembleName );

6
ApplicationLibCode/Commands/RicImportEnsembleFeature.h
View File

@ -18,6 +18,8 @@
#pragma once
#include "RiaEnsembleNameTools.h"
#include "cafCmdFeature.h"
#include <QString>
@ -38,5 +40,7 @@ protected:
void setupActionLook( QAction* actionToSetup ) override;
static QString askForEnsembleName( const QString& suggestion );
static void importSingleEnsemble( const QStringList& fileNames, bool useEnsembleNameDialog );
static void importSingleEnsemble( const QStringList& fileNames,
bool useEnsembleNameDialog,
RiaEnsembleNameTools::EnsembleGroupingMode groupingMode );
};

25
ApplicationLibCode/Commands/RicImportEnsembleSurfaceFeature.cpp
View File

@ -66,30 +66,29 @@ void RicImportEnsembleSurfaceFeature::onActionTriggered( bool isChecked )
QString pathCacheName = "ENSEMBLE_SURFACE_FILES";
auto [fileNames, groupByEnsemble] = runRecursiveFileSearchDialog( "Import Ensemble Surface", pathCacheName );
if ( groupByEnsemble )
importEnsembleSurfaceFromFiles( fileNames );
else
importSingleEnsembleSurfaceFromFiles( fileNames );
importEnsembleSurfaceFromFiles( fileNames, groupByEnsemble );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicImportEnsembleSurfaceFeature::importEnsembleSurfaceFromFiles( const QStringList& fileNames )
void RicImportEnsembleSurfaceFeature::importEnsembleSurfaceFromFiles( const QStringList& fileNames,
RiaEnsembleNameTools::EnsembleGroupingMode groupingMode )
{
if ( fileNames.isEmpty() ) return;
std::vector<QStringList> groupedByEnsemble = RiaEnsembleNameTools::groupFilesByEnsemble( fileNames );
std::vector<QStringList> groupedByEnsemble = RiaEnsembleNameTools::groupFilesByEnsemble( fileNames, groupingMode );
for ( const QStringList& groupedFileNames : groupedByEnsemble )
{
importSingleEnsembleSurfaceFromFiles( groupedFileNames );
importSingleEnsembleSurfaceFromFiles( groupedFileNames, groupingMode );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicImportEnsembleSurfaceFeature::importSingleEnsembleSurfaceFromFiles( const QStringList& fileNames )
void RicImportEnsembleSurfaceFeature::importSingleEnsembleSurfaceFromFiles( const QStringList& fileNames,
RiaEnsembleNameTools::EnsembleGroupingMode groupingMode )
{
// Create a list of file names for each layer
std::map<QString, QStringList> fileNamesForEachLayer;
@ -107,7 +106,7 @@ void RicImportEnsembleSurfaceFeature::importSingleEnsembleSurfaceFromFiles( cons
// NB! This must be a const reference to avoid threading issues
const QStringList& layerFileNames = fileNamesForLayer.second;
QString ensembleName = RiaEnsembleNameTools::findSuitableEnsembleName( layerFileNames );
QString ensembleName = RiaEnsembleNameTools::findSuitableEnsembleName( layerFileNames, groupingMode );
QString layerName = fileNamesForLayer.first;
if ( !layerName.isEmpty() )
{
@ -186,8 +185,8 @@ void RicImportEnsembleSurfaceFeature::setupActionLook( QAction* actionToSetup )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<QStringList, bool> RicImportEnsembleSurfaceFeature::runRecursiveFileSearchDialog( const QString& dialogTitle,
const QString& pathCacheName )
std::pair<QStringList, RiaEnsembleNameTools::EnsembleGroupingMode>
RicImportEnsembleSurfaceFeature::runRecursiveFileSearchDialog( const QString& dialogTitle, const QString& pathCacheName )
{
RiaApplication* app = RiaApplication::instance();
QString defaultDir = app->lastUsedDialogDirectory( pathCacheName );
@ -205,10 +204,10 @@ std::pair<QStringList, bool> RicImportEnsembleSurfaceFeature::runRecursiveFileSe
m_pathFilter = result.pathFilter;
m_fileNameFilter = result.fileNameFilter;
if ( !result.ok ) return std::pair( QStringList(), false );
if ( !result.ok ) return std::pair( QStringList(), RiaEnsembleNameTools::EnsembleGroupingMode::NONE );
// Remember the path to next time
app->setLastUsedDialogDirectory( pathCacheName, QFileInfo( result.rootDir ).absoluteFilePath() );
return std::pair( result.files, result.groupByEnsemble );
return std::pair( result.files, result.groupingMode );
}

11
ApplicationLibCode/Commands/RicImportEnsembleSurfaceFeature.h
View File

@ -20,6 +20,8 @@
#include "cafCmdFeature.h"
#include "RiaEnsembleNameTools.h"
#include <QString>
//==================================================================================================
@ -32,7 +34,8 @@ public:
RicImportEnsembleSurfaceFeature();
static void importEnsembleSurfaceFromFiles( const QStringList& fileNames );
static void importEnsembleSurfaceFromFiles( const QStringList& fileNames,
RiaEnsembleNameTools::EnsembleGroupingMode groupingMode );
protected:
// Overrides
@ -40,9 +43,11 @@ protected:
void onActionTriggered( bool isChecked ) override;
void setupActionLook( QAction* actionToSetup ) override;
std::pair<QStringList, bool> runRecursiveFileSearchDialog( const QString& dialogTitle, const QString& pathCacheName );
std::pair<QStringList, RiaEnsembleNameTools::EnsembleGroupingMode>
runRecursiveFileSearchDialog( const QString& dialogTitle, const QString& pathCacheName );
static void importSingleEnsembleSurfaceFromFiles( const QStringList& fileNames );
static void importSingleEnsembleSurfaceFromFiles( const QStringList& fileNames,
RiaEnsembleNameTools::EnsembleGroupingMode groupingMode );
private:
QString m_pathFilter;

26
ApplicationLibCode/Commands/RicImportEnsembleWellLogsFeature.cpp
View File

@ -63,24 +63,22 @@ void RicImportEnsembleWellLogsFeature::onActionTriggered( bool isChecked )
auto [fileNames, groupByEnsemble] = runRecursiveFileSearchDialog( "Import Ensemble Well Logs", pathCacheName );
if ( fileNames.isEmpty() ) return;
if ( groupByEnsemble )
createEnsembleWellLogsFromFiles( fileNames );
else
createSingleEnsembleWellLogsFromFiles( fileNames );
createEnsembleWellLogsFromFiles( fileNames, groupByEnsemble );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimEnsembleWellLogs*>
RicImportEnsembleWellLogsFeature::createEnsembleWellLogsFromFiles( const QStringList& fileNames )
RicImportEnsembleWellLogsFeature::createEnsembleWellLogsFromFiles( const QStringList& fileNames,
RiaEnsembleNameTools::EnsembleGroupingMode groupingMode )
{
std::vector<RimEnsembleWellLogs*> ensembleWellLogs;
std::vector<QStringList> groupedByEnsemble = RiaEnsembleNameTools::groupFilesByEnsemble( fileNames );
std::vector<QStringList> groupedByEnsemble = RiaEnsembleNameTools::groupFilesByEnsemble( fileNames, groupingMode );
for ( const QStringList& groupedFileNames : groupedByEnsemble )
{
auto ensembleWellLog = createSingleEnsembleWellLogsFromFiles( groupedFileNames );
auto ensembleWellLog = createSingleEnsembleWellLogsFromFiles( groupedFileNames, groupingMode );
ensembleWellLogs.push_back( ensembleWellLog );
}
@ -90,7 +88,9 @@ std::vector<RimEnsembleWellLogs*>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEnsembleWellLogs* RicImportEnsembleWellLogsFeature::createSingleEnsembleWellLogsFromFiles( const QStringList& fileNames )
RimEnsembleWellLogs* RicImportEnsembleWellLogsFeature::createSingleEnsembleWellLogsFromFiles(
const QStringList& fileNames,
RiaEnsembleNameTools::EnsembleGroupingMode groupingMode )
{
if ( fileNames.isEmpty() ) return nullptr;
@ -110,7 +110,7 @@ RimEnsembleWellLogs* RicImportEnsembleWellLogsFeature::createSingleEnsembleWellL
RimEnsembleWellLogs* ensemble = new RimEnsembleWellLogs;
QString ensembleName = RiaEnsembleNameTools::findSuitableEnsembleName( fileNames );
QString ensembleName = RiaEnsembleNameTools::findSuitableEnsembleName( fileNames, groupingMode );
ensemble->setName( ensembleName );
for ( auto wellLogFile : cases )
ensemble->addWellLogFile( wellLogFile );
@ -133,8 +133,8 @@ void RicImportEnsembleWellLogsFeature::setupActionLook( QAction* actionToSetup )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<QStringList, bool> RicImportEnsembleWellLogsFeature::runRecursiveFileSearchDialog( const QString& dialogTitle,
const QString& pathCacheName )
std::pair<QStringList, RiaEnsembleNameTools::EnsembleGroupingMode>
RicImportEnsembleWellLogsFeature::runRecursiveFileSearchDialog( const QString& dialogTitle, const QString& pathCacheName )
{
RiaApplication* app = RiaApplication::instance();
QString defaultDir = app->lastUsedDialogDirectory( pathCacheName );
@ -152,10 +152,10 @@ std::pair<QStringList, bool> RicImportEnsembleWellLogsFeature::runRecursiveFileS
m_pathFilter = result.pathFilter;
m_fileNameFilter = result.fileNameFilter;
if ( !result.ok ) return std::make_pair( QStringList(), false );
if ( !result.ok ) return std::make_pair( QStringList(), RiaEnsembleNameTools::EnsembleGroupingMode::NONE );
// Remember the path to next time
app->setLastUsedDialogDirectory( pathCacheName, QFileInfo( result.rootDir ).absoluteFilePath() );
return std::make_pair( result.files, result.groupByEnsemble );
return std::make_pair( result.files, result.groupingMode );
}

18
ApplicationLibCode/Commands/RicImportEnsembleWellLogsFeature.h
View File

@ -20,6 +20,8 @@
#include "cafCmdFeature.h"
#include "RiaEnsembleNameTools.h"
#include <QString>
class RimEnsembleWellLogs;
@ -33,17 +35,21 @@ class RicImportEnsembleWellLogsFeature : public caf::CmdFeature
RicImportEnsembleWellLogsFeature();
static RimEnsembleWellLogs* createSingleEnsembleWellLogsFromFiles( const QStringList& fileNames );
static std::vector<RimEnsembleWellLogs*>
createEnsembleWellLogsFromFiles( const QStringList& fileNames,
RiaEnsembleNameTools::EnsembleGroupingMode groupingMode );
static std::vector<RimEnsembleWellLogs*> createEnsembleWellLogsFromFiles( const QStringList& fileNames );
protected:
// Overrides
private:
bool isCommandEnabled() override;
void onActionTriggered( bool isChecked ) override;
void setupActionLook( QAction* actionToSetup ) override;
std::pair<QStringList, bool> runRecursiveFileSearchDialog( const QString& dialogTitle, const QString& pathCacheName );
std::pair<QStringList, RiaEnsembleNameTools::EnsembleGroupingMode>
runRecursiveFileSearchDialog( const QString& dialogTitle, const QString& pathCacheName );
static RimEnsembleWellLogs*
createSingleEnsembleWellLogsFromFiles( const QStringList& fileNames,
RiaEnsembleNameTools::EnsembleGroupingMode groupingMode );
private:
QString m_pathFilter;

8
ApplicationLibCode/Commands/RicImportSummaryCasesFeature.cpp
View File

@ -251,7 +251,7 @@ void RicImportSummaryCasesFeature::addCasesToGroupIfRelevant( const std::vector<
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<QStringList, bool>
std::pair<QStringList, RiaEnsembleNameTools::EnsembleGroupingMode>
RicImportSummaryCasesFeature::runRecursiveSummaryCaseFileSearchDialogWithGrouping( const QString& dialogTitle,
const QString& pathCacheName )
{
@ -270,12 +270,12 @@ std::pair<QStringList, bool>
m_pathFilter = result.pathFilter;
m_fileNameFilter = result.fileNameFilter;
if ( !result.ok ) return std::make_pair( QStringList(), false );
if ( !result.ok ) return std::make_pair( QStringList(), RiaEnsembleNameTools::EnsembleGroupingMode::NONE );
// Remember the path to next time
app->setLastUsedDialogDirectory( pathCacheName, QFileInfo( result.rootDir ).absoluteFilePath() );
return std::make_pair( result.files, result.groupByEnsemble );
return std::make_pair( result.files, result.groupingMode );
}
//--------------------------------------------------------------------------------------------------
@ -284,6 +284,6 @@ std::pair<QStringList, bool>
QStringList RicImportSummaryCasesFeature::runRecursiveSummaryCaseFileSearchDialog( const QString& dialogTitle,
const QString& pathCacheName )
{
std::pair<QStringList, bool> result = runRecursiveSummaryCaseFileSearchDialogWithGrouping( dialogTitle, pathCacheName );
auto result = runRecursiveSummaryCaseFileSearchDialogWithGrouping( dialogTitle, pathCacheName );
return result.first;
}

4
ApplicationLibCode/Commands/RicImportSummaryCasesFeature.h
View File

@ -18,6 +18,8 @@
#pragma once
#include "RiaEnsembleNameTools.h"
#include "cafCmdFeature.h"
#include <QString>
@ -48,7 +50,7 @@ public:
static QStringList runRecursiveSummaryCaseFileSearchDialog( const QString& dialogTitle, const QString& pathCacheName );
static std::pair<QStringList, bool>
static std::pair<QStringList, RiaEnsembleNameTools::EnsembleGroupingMode>
runRecursiveSummaryCaseFileSearchDialogWithGrouping( const QString& dialogTitle, const QString& pathCacheName );
protected:

36
ApplicationLibCode/Commands/RicRecursiveFileSearchDialog.cpp
View File

@ -112,6 +112,11 @@ RicRecursiveFileSearchDialogResult RicRecursiveFileSearchDialog::runRecursiveSea
dialog.m_fileExtensions = trimLeftStrings( fileExtensions, "." );
for ( const auto& s : caf::AppEnum<RiaEnsembleNameTools::EnsembleGroupingMode>::uiTexts() )
{
dialog.m_ensembleGroupingMode->addItem( s );
}
dialog.updateEffectiveFilter();
dialog.clearFileList();
dialog.setOkButtonEnabled( false );
@ -142,7 +147,7 @@ RicRecursiveFileSearchDialogResult RicRecursiveFileSearchDialog::runRecursiveSea
dialog.rootDirWithEndSeparator(),
dialog.pathFilterWithoutStartSeparator(),
dialog.fileNameFilter(),
dialog.groupByEnsemble() );
dialog.ensembleGroupingMode() );
}
//--------------------------------------------------------------------------------------------------
@ -158,9 +163,6 @@ RicRecursiveFileSearchDialog::RicRecursiveFileSearchDialog( QWidget* parent, con
m_useRealizationStarCheckBox = new QCheckBox( "Use 'realization-*' in filter" );
connect( m_useRealizationStarCheckBox, SIGNAL( clicked() ), this, SLOT( slotUseRealizationStarClicked() ) );
m_groupByEnsembleCheckBox = new QCheckBox( "Group by ensemble" );
m_groupByEnsembleCheckBox->setChecked( true );
m_pathFilterLabel = new QLabel();
m_pathFilterField = new QComboBox();
m_fileFilterLabel = new QLabel();
@ -169,6 +171,7 @@ RicRecursiveFileSearchDialog::RicRecursiveFileSearchDialog( QWidget* parent, con
m_fileExtensionsField = new QLineEdit();
m_effectiveFilterLabel = new QLabel();
m_effectiveFilterContentLabel = new QLabel();
m_ensembleGroupingMode = new QComboBox();
m_searchRootLabel = new QLabel();
m_searchRootContentLabel = new QLabel();
m_findOrCancelButton = new QPushButton();
@ -204,6 +207,8 @@ RicRecursiveFileSearchDialog::RicRecursiveFileSearchDialog( QWidget* parent, con
connect( m_browseButton, SIGNAL( clicked() ), this, SLOT( slotBrowseButtonClicked() ) );
connect( m_ensembleGroupingMode, SIGNAL( currentIndexChanged() ), this, SLOT( slotFindOrCancelButtonClicked() ) );
connect( m_findOrCancelButton, SIGNAL( clicked() ), this, SLOT( slotFindOrCancelButtonClicked() ) );
connect( m_buttons, SIGNAL( accepted() ), this, SLOT( slotDialogOkClicked() ) );
@ -255,7 +260,10 @@ RicRecursiveFileSearchDialog::RicRecursiveFileSearchDialog( QWidget* parent, con
{
QHBoxLayout* horizontalLayout = new QHBoxLayout;
horizontalLayout->addWidget( m_useRealizationStarCheckBox );
horizontalLayout->addWidget( m_groupByEnsembleCheckBox );
QLabel* ensembleGroupingLabel = new QLabel( "Ensemble Grouping" );
horizontalLayout->addWidget( ensembleGroupingLabel );
horizontalLayout->addWidget( m_ensembleGroupingMode );
horizontalLayout->addStretch( 1 );
inputGridLayout->addLayout( horizontalLayout, row, 1 );
}
@ -415,12 +423,14 @@ void RicRecursiveFileSearchDialog::updateFileListWidget()
{
m_fileListWidget->clear();
if ( m_groupByEnsembleCheckBox->isChecked() )
if ( ensembleGroupingMode() != RiaEnsembleNameTools::EnsembleGroupingMode::NONE )
{
std::vector<QStringList> groupedByEnsemble = RiaEnsembleNameTools::groupFilesByEnsemble( m_foundFiles );
std::vector<QStringList> groupedByEnsemble =
RiaEnsembleNameTools::groupFilesByEnsemble( m_foundFiles, ensembleGroupingMode() );
for ( const QStringList& groupedFileNames : groupedByEnsemble )
{
QString ensembleName = RiaEnsembleNameTools::findSuitableEnsembleName( groupedFileNames );
QString ensembleName =
RiaEnsembleNameTools::findSuitableEnsembleName( groupedFileNames, ensembleGroupingMode() );
QListWidgetItem* item = new QListWidgetItem( QDir::toNativeSeparators( ensembleName ), m_fileListWidget );
addToFileListWidget( groupedFileNames );
}
@ -937,9 +947,15 @@ void RicRecursiveFileSearchDialog::slotUseRealizationStarClicked()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicRecursiveFileSearchDialog::groupByEnsemble() const
RiaEnsembleNameTools::EnsembleGroupingMode RicRecursiveFileSearchDialog::ensembleGroupingMode() const
{
return m_groupByEnsembleCheckBox->isChecked();
if ( m_ensembleGroupingMode->currentIndex() == 0 )
return RiaEnsembleNameTools::EnsembleGroupingMode::FMU_FOLDER_STRUCTURE;
if ( m_ensembleGroupingMode->currentIndex() == 1 )
return RiaEnsembleNameTools::EnsembleGroupingMode::EVEREST_FOLDER_STRUCTURE;
if ( m_ensembleGroupingMode->currentIndex() == 2 ) return RiaEnsembleNameTools::EnsembleGroupingMode::NONE;
return RiaEnsembleNameTools::EnsembleGroupingMode::FMU_FOLDER_STRUCTURE;
}
//--------------------------------------------------------------------------------------------------

24
ApplicationLibCode/Commands/RicRecursiveFileSearchDialog.h
View File

@ -22,6 +22,7 @@
#include "cafPdmPointer.h"
#include "RiaEnsembleNameTools.h"
#include <QDialog>
class QLabel;
@ -70,7 +71,8 @@ private:
QStringList fileExtensions() const;
QString extensionFromFileNameFilter() const;
bool groupByEnsemble() const;
RiaEnsembleNameTools::EnsembleGroupingMode ensembleGroupingMode() const;
void setOkButtonEnabled( bool enabled );
void warningIfInvalidCharacters();
@ -115,7 +117,6 @@ private:
QComboBox* m_pathFilterField;
QPushButton* m_browseButton;
QCheckBox* m_useRealizationStarCheckBox;
QCheckBox* m_groupByEnsembleCheckBox;
QLabel* m_fileFilterLabel;
QComboBox* m_fileFilterField;
@ -127,6 +128,8 @@ private:
QLabel* m_effectiveFilterContentLabel;
QPushButton* m_findOrCancelButton;
QComboBox* m_ensembleGroupingMode;
QGroupBox* m_outputGroup;
QLabel* m_searchRootLabel;
QLabel* m_searchRootContentLabel;
@ -151,18 +154,18 @@ private:
class RicRecursiveFileSearchDialogResult
{
public:
RicRecursiveFileSearchDialogResult( bool ok,
const QStringList& files,
const QString& rootDir,
const QString& pathFilter,
const QString& fileNameFilter,
bool groupByEnsemble )
RicRecursiveFileSearchDialogResult( bool ok,
const QStringList& files,
const QString& rootDir,
const QString& pathFilter,
const QString& fileNameFilter,
RiaEnsembleNameTools::EnsembleGroupingMode groupingMode )
: ok( ok )
, files( files )
, rootDir( rootDir )
, pathFilter( pathFilter )
, fileNameFilter( fileNameFilter )
, groupByEnsemble( groupByEnsemble )
, groupingMode( groupingMode )
{
}
@ -171,5 +174,6 @@ public:
QString rootDir;
QString pathFilter;
QString fileNameFilter;
bool groupByEnsemble;
RiaEnsembleNameTools::EnsembleGroupingMode groupingMode;
};