mirror of
https://github.com/OPM/ResInsight.git
synced 2026-10-26 07:00:17 -05:00
Magne Sjaastad
6022980d54
Statistics cases were filtered out of the case lists used by the grid calculator, both in the variable table and in the Select Result dialog. Statistics cases belonging to a grid ensemble were also missing from RimProject::allGridCases(), as only the source cases of the ensemble were collected. Statistics cases in a grid case group were already included. A statistics case can be used as source only. A calculated result stored in a statistics case is interpreted as computed statistics, and would block recomputation of the statistics, so a statistics case is never assigned as destination case. A statistics case with no computed statistics is not necessarily opened. Make sure source cases are opened before grid dimensions are validated and before result data is read.
1529 lines
55 KiB
C++
1529 lines
55 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2011- Statoil ASA
|
|
// Copyright (C) 2013- Ceetron Solutions AS
|
|
// Copyright (C) 2011-2012 Ceetron AS
|
|
//
|
|
// 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 "RimProject.h"
|
|
|
|
#include "RiaCompletionTypeCalculationScheduler.h"
|
|
#include "RiaFieldHandleTools.h"
|
|
#include "RiaFilePathTools.h"
|
|
#include "RiaGuiApplication.h"
|
|
#include "RiaPreferences.h"
|
|
#include "RiaProjectBackupTools.h"
|
|
#include "RiaProjectFileTools.h"
|
|
#include "RiaVersionInfo.h"
|
|
|
|
#include "RigEclipseCaseData.h"
|
|
|
|
#include "Cloud/RimCloudDataSourceCollection.h"
|
|
#include "ContourMap/RimEclipseContourMapViewCollection.h"
|
|
#include "EnsembleFileSet/RimEnsembleFileSetCollection.h"
|
|
#include "Formations/RimFormationNamesCollection.h"
|
|
#include "Jobs/RimJobCollection.h"
|
|
#include "PlotTemplates/RimPlotTemplateFolderItem.h"
|
|
#include "Polygons/RimPolygonCollection.h"
|
|
#include "QuickAccess/RimQuickAccessCollection.h"
|
|
#include "RimAdvancedSnapshotExportDefinition.h"
|
|
#include "RimAnalysisPlotCollection.h"
|
|
#include "RimAnnotationCollection.h"
|
|
#include "RimAnnotationInViewCollection.h"
|
|
#include "RimCase.h"
|
|
#include "RimCaseCollection.h"
|
|
#include "RimColorLegendCollection.h"
|
|
#include "RimCompletionTemplateCollection.h"
|
|
#include "RimContextCommandBuilder.h"
|
|
#include "RimCorrelationPlotCollection.h"
|
|
#include "RimDialogData.h"
|
|
#include "RimEclipseCase.h"
|
|
#include "RimEclipseCaseCollection.h"
|
|
#include "RimEclipseCaseEnsemble.h"
|
|
#include "RimEclipseView.h"
|
|
#include "RimEclipseViewCollection.h"
|
|
#include "RimEnsembleWellLogsCollection.h"
|
|
#include "RimFlowPlotCollection.h"
|
|
#include "RimFractureTemplate.h"
|
|
#include "RimFractureTemplateCollection.h"
|
|
#include "RimGeoMechCase.h"
|
|
#include "RimGeoMechModels.h"
|
|
#include "RimGridCalculationCollection.h"
|
|
#include "RimGridCrossPlotCollection.h"
|
|
#include "RimGridView.h"
|
|
#include "RimIdenticalGridCaseGroup.h"
|
|
#include "RimMainPlotCollection.h"
|
|
#include "RimMeasurement.h"
|
|
#include "RimMultiPlotCollection.h"
|
|
#include "RimObservedDataCollection.h"
|
|
#include "RimObservedSummaryData.h"
|
|
#include "RimOilField.h"
|
|
#include "RimPlotWindow.h"
|
|
#include "RimPltPlotCollection.h"
|
|
#include "RimPolylinesFromFileAnnotation.h"
|
|
#include "RimReservoirGridEnsemble.h"
|
|
#include "RimRftPlotCollection.h"
|
|
#include "RimSaturationPressurePlotCollection.h"
|
|
#include "RimScriptCollection.h"
|
|
#include "RimSeismicDataCollection.h"
|
|
#include "RimSeismicView.h"
|
|
#include "RimSeismicViewCollection.h"
|
|
#include "RimStimPlanModelPlotCollection.h"
|
|
#include "RimSummaryCalculationCollection.h"
|
|
#include "RimSummaryCase.h"
|
|
#include "RimSummaryCaseMainCollection.h"
|
|
#include "RimSummaryEnsemble.h"
|
|
#include "RimSummaryMultiPlotCollection.h"
|
|
#include "RimSummaryTableCollection.h"
|
|
#include "RimSurfaceCollection.h"
|
|
#include "RimTools.h"
|
|
#include "RimValveTemplate.h"
|
|
#include "RimValveTemplateCollection.h"
|
|
#include "RimViewLinker.h"
|
|
#include "RimViewLinkerCollection.h"
|
|
#include "RimWellLogPlotCollection.h"
|
|
#include "RimWellPath.h"
|
|
#include "RimWellPathCollection.h"
|
|
#include "RimWellTargetMapping.h"
|
|
#include "Tools/RimAutomationSettings.h"
|
|
#include "VerticalFlowPerformance/RimVfpDataCollection.h"
|
|
#include "VerticalFlowPerformance/RimVfpPlotCollection.h"
|
|
|
|
#include "RiuPlotMainWindow.h"
|
|
|
|
#include "cafCmdFeatureMenuBuilder.h"
|
|
#include "cafPdmObjectScriptingCapability.h"
|
|
#include "cafPdmUiTreeOrdering.h"
|
|
|
|
#include <QDir>
|
|
#include <QFile>
|
|
|
|
#include <algorithm>
|
|
|
|
CAF_PDM_SOURCE_INIT( RimProject, "ResInsightProject" );
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimProject::RimProject()
|
|
{
|
|
CAF_PDM_InitScriptableObjectWithNameAndComment( "Project", "", "", "", "Project", "The ResInsight Project" );
|
|
|
|
CAF_PDM_InitField( &m_projectFileVersionString, "ProjectFileVersionString", QString( STRPRODUCTVER ), "" );
|
|
m_projectFileVersionString.uiCapability()->setUiHidden( true );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_globalPathList, "ReferencedExternalFiles", "" );
|
|
m_globalPathList.uiCapability()->setUiHidden( true );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &oilFields, "OilFields", "Oil Fields" );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &colorLegendCollection, "ColorLegendCollection", "Color Legend Collection" );
|
|
colorLegendCollection = new RimColorLegendCollection();
|
|
colorLegendCollection->createStandardColorLegends();
|
|
|
|
CAF_PDM_InitFieldNoDefault( &scriptCollection, "ScriptCollection", "Octave Scripts", ":/octave.png" );
|
|
scriptCollection.xmlCapability()->disableIO();
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_jobCollection, "JobCollection", "Jobs", ":/gear.png" );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_mainPlotCollection, "MainPlotCollection", "Plots" );
|
|
CAF_PDM_InitFieldNoDefault( &m_pinnedFieldCollection, "PinnedFieldCollection", "PinnedFieldCollection" );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &viewLinkerCollection, "LinkedViews", "Linked Views", ":/LinkView.svg" );
|
|
viewLinkerCollection = new RimViewLinkerCollection;
|
|
|
|
CAF_PDM_InitFieldNoDefault( &calculationCollection, "CalculationCollection", "Calculation Collection" );
|
|
calculationCollection = new RimSummaryCalculationCollection;
|
|
|
|
CAF_PDM_InitFieldNoDefault( &gridCalculationCollection, "GridCalculationCollection", "Grid Calculation Collection" );
|
|
gridCalculationCollection = new RimGridCalculationCollection;
|
|
|
|
CAF_PDM_InitFieldNoDefault( &multiSnapshotDefinitions, "MultiSnapshotDefinitions", "Multi Snapshot Definitions" );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &mainWindowTreeViewStates, "TreeViewStates", "" );
|
|
mainWindowTreeViewStates.uiCapability()->setUiHidden( true );
|
|
CAF_PDM_InitFieldNoDefault( &mainWindowCurrentModelIndexPaths, "TreeViewCurrentModelIndexPaths", "" );
|
|
mainWindowCurrentModelIndexPaths.uiCapability()->setUiHidden( true );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &plotWindowTreeViewStates, "PlotWindowTreeViewStates", "" );
|
|
plotWindowTreeViewStates.uiCapability()->setUiHidden( true );
|
|
CAF_PDM_InitFieldNoDefault( &plotWindowCurrentModelIndexPaths, "PlotWindowTreeViewCurrentModelIndexPaths", "" );
|
|
plotWindowCurrentModelIndexPaths.uiCapability()->setUiHidden( true );
|
|
|
|
CAF_PDM_InitField( &m_show3DWindow, "show3DWindow", true, "Show 3D Window" );
|
|
m_show3DWindow.uiCapability()->setUiHidden( true );
|
|
|
|
CAF_PDM_InitField( &m_showPlotWindow, "showPlotWindow", false, "Show Plot Window" );
|
|
m_showPlotWindow.uiCapability()->setUiHidden( true );
|
|
|
|
CAF_PDM_InitField( &m_showPlotWindowOnTopOf3DWindow, "showPlotWindowOnTopOf3DWindow", false, "Show Plot On Top" );
|
|
m_showPlotWindowOnTopOf3DWindow.uiCapability()->setUiHidden( true );
|
|
|
|
CAF_PDM_InitField( &mainWindowDockState, "MainWindowDockState", QString(), "Dock State 3D Window" );
|
|
mainWindowDockState.uiCapability()->setUiHidden( true );
|
|
|
|
CAF_PDM_InitField( &plotWindowDockState, "PlotWindowDockState", QString(), "Dock State Plot Window" );
|
|
plotWindowDockState.uiCapability()->setUiHidden( true );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_dialogData, "DialogData", "DialogData" );
|
|
m_dialogData = new RimDialogData();
|
|
m_dialogData.uiCapability()->setUiTreeChildrenHidden( true );
|
|
|
|
// Obsolete fields. The content is moved to OilFields and friends
|
|
CAF_PDM_InitFieldNoDefault( &casesObsolete, "Reservoirs", "" );
|
|
RiaFieldHandleTools::disableWriteAndSetFieldHidden( &casesObsolete );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &caseGroupsObsolete, "CaseGroups", "" );
|
|
RiaFieldHandleTools::disableWriteAndSetFieldHidden( &caseGroupsObsolete );
|
|
|
|
// Initialization
|
|
|
|
scriptCollection = new RimScriptCollection();
|
|
scriptCollection->directory.uiCapability()->setUiHidden( true );
|
|
scriptCollection->uiCapability()->setUiName( "Scripts" );
|
|
scriptCollection->uiCapability()->setUiIconFromResourceString( ":/octave.png" );
|
|
|
|
m_mainPlotCollection = new RimMainPlotCollection();
|
|
m_pinnedFieldCollection = new RimQuickAccessCollection();
|
|
m_jobCollection = new RimJobCollection();
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_plotTemplateTopFolder, "PlotTemplateCollection", "Plot Templates" );
|
|
m_plotTemplateTopFolder = new RimPlotTemplateFolderItem();
|
|
m_plotTemplateTopFolder.xmlCapability()->disableIO();
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_automationSettings, "AutomationSettings", "Automation Settings" );
|
|
m_automationSettings = new RimAutomationSettings();
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_ensembleFileSetCollection, "EnsembleFileSetCollection", "Ensemble File Sets" );
|
|
m_ensembleFileSetCollection = new RimEnsembleFileSetCollection();
|
|
|
|
// For now, create a default first oilfield that contains the rest of the project
|
|
oilFields.push_back( new RimOilField );
|
|
|
|
setUiHidden( true );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimProject::~RimProject()
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimProject* RimProject::current()
|
|
{
|
|
return RiaApplication::instance()->project();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::close()
|
|
{
|
|
if ( m_mainPlotCollection() )
|
|
{
|
|
m_mainPlotCollection()->deleteAllContainedObjects();
|
|
}
|
|
|
|
m_jobCollection->deleteAllJobs();
|
|
m_ensembleFileSetCollection()->deleteAllFileSets();
|
|
oilFields.deleteChildren();
|
|
oilFields.push_back( new RimOilField );
|
|
|
|
casesObsolete.deleteChildren();
|
|
caseGroupsObsolete.deleteChildren();
|
|
|
|
multiSnapshotDefinitions.deleteChildren();
|
|
|
|
m_dialogData->clearProjectSpecificData();
|
|
|
|
calculationCollection->deleteAllContainedObjects();
|
|
gridCalculationCollection->deleteAllContainedObjects();
|
|
colorLegendCollection->deleteCustomColorLegends();
|
|
|
|
delete viewLinkerCollection->viewLinker();
|
|
viewLinkerCollection->viewLinker = nullptr;
|
|
|
|
setFileName( "" );
|
|
|
|
m_globalPathList = "";
|
|
|
|
mainWindowCurrentModelIndexPaths = "";
|
|
mainWindowTreeViewStates = "";
|
|
plotWindowCurrentModelIndexPaths = "";
|
|
plotWindowTreeViewStates = "";
|
|
mainWindowDockState = "";
|
|
plotWindowDockState = "";
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::updatesAfterProjectFileIsRead()
|
|
{
|
|
RiaProjectFileTools::distributePathsFromGlobalPathList( this, m_globalPathList() );
|
|
|
|
// Create an empty oil field in case the project did not contain one
|
|
if ( oilFields.empty() )
|
|
{
|
|
oilFields.push_back( new RimOilField );
|
|
}
|
|
|
|
// Handle old project files with obsolete structure.
|
|
// Move caseGroupsObsolete and casesObsolete to oilFields()[idx]->analysisModels()
|
|
RimEclipseCaseCollection* analysisModels = activeOilField() ? activeOilField()->analysisModels() : nullptr;
|
|
bool movedOneRimIdenticalGridCaseGroup = false;
|
|
for ( size_t cgIdx = 0; cgIdx < caseGroupsObsolete.size(); ++cgIdx )
|
|
{
|
|
RimIdenticalGridCaseGroup* sourceCaseGroup = caseGroupsObsolete[cgIdx];
|
|
if ( analysisModels )
|
|
{
|
|
analysisModels->caseGroups.push_back( sourceCaseGroup );
|
|
movedOneRimIdenticalGridCaseGroup = true; // moved at least one so assume the others will be moved too...
|
|
}
|
|
}
|
|
|
|
if ( movedOneRimIdenticalGridCaseGroup )
|
|
{
|
|
caseGroupsObsolete.clearWithoutDelete();
|
|
}
|
|
|
|
bool movedOneRimCase = false;
|
|
for ( size_t cIdx = 0; cIdx < casesObsolete().size(); ++cIdx )
|
|
{
|
|
if ( analysisModels )
|
|
{
|
|
RimEclipseCase* sourceCase = casesObsolete[cIdx];
|
|
casesObsolete.set( cIdx, nullptr );
|
|
analysisModels->cases.push_back( sourceCase );
|
|
movedOneRimCase = true; // moved at least one so assume the others will be moved too...
|
|
}
|
|
}
|
|
|
|
if ( movedOneRimCase )
|
|
{
|
|
casesObsolete.clearWithoutDelete();
|
|
}
|
|
|
|
// Set project pointer to each well path
|
|
for ( size_t oilFieldIdx = 0; oilFieldIdx < oilFields().size(); oilFieldIdx++ )
|
|
{
|
|
RimOilField* oilField = oilFields[oilFieldIdx];
|
|
if ( oilField == nullptr || oilField->wellPathCollection == nullptr ) continue;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimQuickAccessCollection* RimProject::pinnedFieldCollection() const
|
|
{
|
|
return m_pinnedFieldCollection();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimJobCollection* RimProject::jobCollection() const
|
|
{
|
|
return m_jobCollection();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimAutomationSettings* RimProject::automationSettings() const
|
|
{
|
|
return m_automationSettings();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimEnsembleFileSetCollection* RimProject::ensembleFileSetCollection() const
|
|
{
|
|
return m_ensembleFileSetCollection();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::initAfterRead()
|
|
{
|
|
// Function moved to beforeInitAfterRead() to make sure that file path objects are replaced before other initAfterRead() is called
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::setupBeforeSave()
|
|
{
|
|
if ( RiaGuiApplication::isRunning() )
|
|
{
|
|
RiaGuiApplication* guiApp = RiaGuiApplication::instance();
|
|
|
|
if ( guiApp )
|
|
{
|
|
m_show3DWindow = guiApp->isMain3dWindowVisible();
|
|
m_showPlotWindow = guiApp->isMainPlotWindowVisible();
|
|
|
|
if ( m_showPlotWindow )
|
|
{
|
|
auto plotWindow = RiuPlotMainWindow::instance();
|
|
m_showPlotWindowOnTopOf3DWindow = plotWindow->isTopLevel();
|
|
}
|
|
}
|
|
}
|
|
|
|
m_projectFileVersionString = STRPRODUCTVER;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<caf::PdmFieldHandle*> RimProject::fieldsForExport() const
|
|
{
|
|
std::vector<QString> orderedKeywords;
|
|
|
|
orderedKeywords.push_back( fileNameHandle()->keyword() );
|
|
orderedKeywords.push_back( m_projectFileVersionString.keyword() );
|
|
orderedKeywords.push_back( m_globalPathList.keyword() );
|
|
orderedKeywords.push_back( m_ensembleFileSetCollection.keyword() );
|
|
|
|
std::vector<caf::PdmFieldHandle*> ordered;
|
|
|
|
auto fieldHandles = fields();
|
|
for ( const auto& kw : orderedKeywords )
|
|
{
|
|
auto it = std::find_if( fieldHandles.begin(),
|
|
fieldHandles.end(),
|
|
[&]( const caf::PdmFieldHandle* field ) { return field->keyword() == kw; } );
|
|
if ( it != fieldHandles.end() )
|
|
{
|
|
ordered.push_back( *it );
|
|
}
|
|
}
|
|
|
|
// Append the rest of the fields
|
|
for ( auto fieldHandle : fields() )
|
|
{
|
|
if ( std::find( ordered.begin(), ordered.end(), fieldHandle ) == ordered.end() )
|
|
{
|
|
ordered.push_back( fieldHandle );
|
|
}
|
|
}
|
|
|
|
return ordered;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimMainPlotCollection* RimProject::mainPlotCollection() const
|
|
{
|
|
return m_mainPlotCollection();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimProject::writeProjectFile()
|
|
{
|
|
m_globalPathList = RiaProjectFileTools::transferPathsToGlobalPathList( this );
|
|
|
|
QFile xmlFile( fileName() );
|
|
if ( !xmlFile.open( QIODevice::WriteOnly | QIODevice::Text ) ) return false;
|
|
|
|
QString content = documentAsString();
|
|
xmlFile.write( content.toUtf8() );
|
|
|
|
if ( RiaPreferences::current()->storeBackupOfProjectFiles() )
|
|
{
|
|
QString backupFilename = fileName() + "db";
|
|
const int maximumRecordCount = 50;
|
|
RiaProjectBackupTools::appendTextToDatabase( backupFilename, maximumRecordCount, content );
|
|
}
|
|
|
|
RiaProjectFileTools::distributePathsFromGlobalPathList( this, m_globalPathList() );
|
|
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Support list of multiple script paths divided by ';'
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::setScriptDirectories( const QString& scriptDirectories, int maxFolderDepth )
|
|
{
|
|
scriptCollection->calcScripts().deleteChildren();
|
|
scriptCollection->subDirectories().deleteChildren();
|
|
|
|
QStringList pathList = scriptDirectories.split( ';' );
|
|
for ( const QString& path : pathList )
|
|
{
|
|
QDir dir( path );
|
|
if ( !path.isEmpty() && dir.exists() && dir.isReadable() )
|
|
{
|
|
RimScriptCollection* sharedScriptLocation = new RimScriptCollection;
|
|
sharedScriptLocation->directory = path;
|
|
sharedScriptLocation->setUiName( dir.dirName() );
|
|
|
|
sharedScriptLocation->readContentFromDisc( maxFolderDepth );
|
|
|
|
scriptCollection->subDirectories.push_back( sharedScriptLocation );
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::setPlotTemplateFolders( const QStringList& plotTemplateFolders )
|
|
{
|
|
if ( !m_plotTemplateTopFolder() )
|
|
{
|
|
m_plotTemplateTopFolder = new RimPlotTemplateFolderItem();
|
|
}
|
|
|
|
m_plotTemplateTopFolder->createRootFolderItemsFromFolderPaths( plotTemplateFolders );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RimProject::projectFileVersionString() const
|
|
{
|
|
return m_projectFileVersionString;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimProject::isProjectFileVersionEqualOrOlderThan( const QString& otherProjectFileVersion ) const
|
|
{
|
|
QString candidateProjectFileVersion = projectFileVersionString();
|
|
|
|
return !RiaProjectFileTools::isCandidateVersionNewerThanOther( candidateProjectFileVersion, otherProjectFileVersion );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::setProjectFileNameAndUpdateDependencies( const QString& projectFileName )
|
|
{
|
|
// Extract the filename of the project file when it was saved
|
|
QString oldProjectFileName = fileName();
|
|
|
|
// Replace with the new actual filename
|
|
setFileName( projectFileName );
|
|
|
|
QFileInfo fileInfo( projectFileName );
|
|
QString newProjectPath = fileInfo.path();
|
|
|
|
QFileInfo fileInfoOld( oldProjectFileName );
|
|
QString oldProjectPath = fileInfoOld.path();
|
|
|
|
if ( newProjectPath == oldProjectPath ) return;
|
|
|
|
for ( caf::FilePath* filePath : allFilePaths() )
|
|
{
|
|
QString filePathCandidate = filePath->path();
|
|
|
|
QString newFilePath = RimTools::relocateFile( filePathCandidate, newProjectPath, oldProjectPath );
|
|
filePath->setPath( newFilePath );
|
|
}
|
|
|
|
if ( ensembleFileSetCollection() ) ensembleFileSetCollection()->updateFilePathsFromProjectPath( newProjectPath, oldProjectPath );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::assignCaseIdToSummaryCase( RimSummaryCase* summaryCase )
|
|
{
|
|
if ( summaryCase )
|
|
{
|
|
int nextValidId = 1;
|
|
for ( RimSummaryCase* s : allSummaryCases() )
|
|
{
|
|
nextValidId = std::max( nextValidId, s->caseId() + 1 );
|
|
}
|
|
|
|
summaryCase->setCaseId( nextValidId );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::assignIdToEnsemble( RimSummaryEnsemble* summaryCaseCollection )
|
|
{
|
|
if ( summaryCaseCollection )
|
|
{
|
|
int nextValidId = 1;
|
|
for ( RimSummaryEnsemble* ensemble : summaryEnsembles() )
|
|
{
|
|
nextValidId = std::max( nextValidId, ensemble->ensembleId() + 1 );
|
|
}
|
|
|
|
summaryCaseCollection->setEnsembleId( nextValidId );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimCase*> RimProject::allGridCases() const
|
|
{
|
|
std::vector<RimCase*> cases;
|
|
|
|
for ( RimOilField* oilField : oilFields() )
|
|
{
|
|
if ( !oilField ) continue;
|
|
|
|
RimEclipseCaseCollection* analysisModels = oilField->analysisModels();
|
|
if ( analysisModels )
|
|
{
|
|
for ( RimEclipseCase* eclipseCase : analysisModels->cases )
|
|
{
|
|
cases.push_back( eclipseCase );
|
|
}
|
|
|
|
for ( RimIdenticalGridCaseGroup* cg : analysisModels->caseGroups )
|
|
{
|
|
// Load the Main case of each IdenticalGridCaseGroup
|
|
if ( cg == nullptr ) continue;
|
|
|
|
if ( cg->statisticsCaseCollection() )
|
|
{
|
|
for ( RimEclipseCase* eclipseCase : cg->statisticsCaseCollection()->reservoirs )
|
|
{
|
|
cases.push_back( eclipseCase );
|
|
}
|
|
}
|
|
if ( cg->caseCollection() )
|
|
{
|
|
for ( RimEclipseCase* eclipseCase : cg->caseCollection()->reservoirs )
|
|
{
|
|
cases.push_back( eclipseCase );
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( RimEclipseCaseEnsemble* ensemble : analysisModels->caseEnsembles() )
|
|
{
|
|
// The ensemble can be null if this function is called while the ensembles are being deleted,
|
|
// as PdmPointer entries in the child array field are nulled one by one during deletion.
|
|
if ( ensemble == nullptr ) continue;
|
|
|
|
for ( RimEclipseCase* acase : ensemble->cases() )
|
|
{
|
|
cases.push_back( acase );
|
|
}
|
|
|
|
for ( RimWellTargetMapping* wellTargetMapping : ensemble->wellTargetMappings() )
|
|
{
|
|
if ( auto ensembleStatisticsCase = wellTargetMapping->ensembleStatisticsCase() )
|
|
cases.push_back( ensembleStatisticsCase );
|
|
}
|
|
}
|
|
|
|
for ( RimReservoirGridEnsemble* ensemble : analysisModels->reservoirGridEnsembles.childrenByType() )
|
|
{
|
|
if ( ensemble == nullptr ) continue;
|
|
|
|
for ( RimEclipseCase* acase : ensemble->cases() )
|
|
{
|
|
cases.push_back( acase );
|
|
}
|
|
|
|
if ( ensemble->statisticsCaseCollection() )
|
|
{
|
|
for ( RimEclipseCase* eclipseCase : ensemble->statisticsCaseCollection()->reservoirs )
|
|
{
|
|
cases.push_back( eclipseCase );
|
|
}
|
|
}
|
|
}
|
|
|
|
RimGeoMechModels* geomModels = oilField->geoMechModels();
|
|
if ( geomModels )
|
|
{
|
|
for ( auto acase : geomModels->cases() )
|
|
{
|
|
cases.push_back( acase );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return cases;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::assignCaseIdToCase( RimCase* reservoirCase )
|
|
{
|
|
if ( reservoirCase )
|
|
{
|
|
int nextValidId = 0;
|
|
for ( RimCase* rimCase : descendantsIncludingThisOfType<RimCase>() )
|
|
{
|
|
nextValidId = std::max( nextValidId, rimCase->caseId() + 1 );
|
|
}
|
|
|
|
reservoirCase->setCaseId( nextValidId );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::assignIdToCaseGroup( RimIdenticalGridCaseGroup* caseGroup )
|
|
{
|
|
if ( caseGroup )
|
|
{
|
|
int nextValidId = 0;
|
|
|
|
for ( RimIdenticalGridCaseGroup* existingCaseGroup : descendantsIncludingThisOfType<RimIdenticalGridCaseGroup>() )
|
|
{
|
|
nextValidId = std::max( nextValidId, existingCaseGroup->groupId() + 1 );
|
|
}
|
|
|
|
caseGroup->groupId = nextValidId;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::assignIdToCaseGroup( RimReservoirGridEnsemble* gridEnsemble )
|
|
{
|
|
if ( gridEnsemble )
|
|
{
|
|
int nextValidId = 0;
|
|
|
|
for ( RimIdenticalGridCaseGroup* existingCaseGroup : descendantsIncludingThisOfType<RimIdenticalGridCaseGroup>() )
|
|
{
|
|
nextValidId = std::max( nextValidId, existingCaseGroup->groupId() + 1 );
|
|
}
|
|
|
|
for ( RimReservoirGridEnsemble* existingEnsemble : descendantsIncludingThisOfType<RimReservoirGridEnsemble>() )
|
|
{
|
|
nextValidId = std::max( nextValidId, existingEnsemble->groupId() + 1 );
|
|
}
|
|
|
|
gridEnsemble->setGroupId( nextValidId );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::assignViewIdToView( Rim3dView* view )
|
|
{
|
|
if ( view )
|
|
{
|
|
int nextValidId = 0;
|
|
for ( Rim3dView* existingView : descendantsIncludingThisOfType<Rim3dView>() )
|
|
{
|
|
nextValidId = std::max( nextValidId, existingView->id() + 1 );
|
|
}
|
|
|
|
view->setId( nextValidId );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::assignPlotIdToPlotWindow( RimPlotWindow* plotWindow )
|
|
{
|
|
if ( plotWindow )
|
|
{
|
|
int nextValidId = 0;
|
|
for ( RimPlotWindow* existingPlotWindow : descendantsIncludingThisOfType<RimPlotWindow>() )
|
|
{
|
|
nextValidId = std::max( nextValidId, existingPlotWindow->id() + 1 );
|
|
}
|
|
|
|
plotWindow->setId( nextValidId );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimSummaryCase*> RimProject::allSummaryCases() const
|
|
{
|
|
std::vector<RimSummaryCase*> sumCases;
|
|
|
|
for ( RimOilField* oilField : oilFields )
|
|
{
|
|
if ( !oilField ) continue;
|
|
RimSummaryCaseMainCollection* sumCaseMainColl = oilField->summaryCaseMainCollection();
|
|
if ( sumCaseMainColl )
|
|
{
|
|
std::vector<RimSummaryCase*> allSummaryCases = sumCaseMainColl->allSummaryCases();
|
|
if ( !allSummaryCases.empty() )
|
|
{
|
|
sumCases.insert( sumCases.end(), allSummaryCases.begin(), allSummaryCases.end() );
|
|
}
|
|
}
|
|
|
|
auto& observedDataColl = oilField->observedDataCollection();
|
|
if ( observedDataColl != nullptr && !observedDataColl->allObservedSummaryData().empty() )
|
|
{
|
|
auto observedData = observedDataColl->allObservedSummaryData();
|
|
sumCases.insert( sumCases.end(), observedData.begin(), observedData.end() );
|
|
}
|
|
}
|
|
|
|
return sumCases;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimSummaryEnsemble*> RimProject::summaryEnsembles() const
|
|
{
|
|
std::vector<RimSummaryEnsemble*> ensembles;
|
|
|
|
for ( RimOilField* oilField : oilFields )
|
|
{
|
|
if ( !oilField ) continue;
|
|
RimSummaryCaseMainCollection* sumCaseMainColl = oilField->summaryCaseMainCollection();
|
|
if ( sumCaseMainColl )
|
|
{
|
|
std::vector<RimSummaryEnsemble*> ensemble = sumCaseMainColl->summaryEnsembles();
|
|
ensembles.insert( ensembles.end(), ensemble.begin(), ensemble.end() );
|
|
}
|
|
}
|
|
|
|
return ensembles;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<Rim3dView*> RimProject::allNotLinkedViews() const
|
|
{
|
|
std::vector<Rim3dView*> alreadyLinkedViews;
|
|
if ( viewLinkerCollection->viewLinker() )
|
|
{
|
|
alreadyLinkedViews = viewLinkerCollection->viewLinker()->allViews();
|
|
}
|
|
|
|
std::vector<Rim3dView*> views;
|
|
|
|
for ( RimCase* rimCase : allGridCases() )
|
|
{
|
|
if ( !rimCase ) continue;
|
|
|
|
for ( Rim3dView* caseView : rimCase->views() )
|
|
{
|
|
RimGridView* gridView = dynamic_cast<RimGridView*>( caseView );
|
|
|
|
if ( !gridView ) continue;
|
|
|
|
bool isLinked = false;
|
|
for ( size_t lnIdx = 0; lnIdx < alreadyLinkedViews.size(); lnIdx++ )
|
|
{
|
|
if ( gridView == alreadyLinkedViews[lnIdx] )
|
|
{
|
|
isLinked = true;
|
|
}
|
|
}
|
|
if ( !isLinked )
|
|
{
|
|
views.push_back( gridView );
|
|
}
|
|
}
|
|
}
|
|
|
|
return views;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<Rim3dView*> RimProject::allViews() const
|
|
{
|
|
std::vector<Rim3dView*> views;
|
|
|
|
for ( RimCase* rimCase : allGridCases() )
|
|
{
|
|
if ( !rimCase ) continue;
|
|
|
|
for ( Rim3dView* view : rimCase->views() )
|
|
{
|
|
if ( view )
|
|
{
|
|
views.push_back( view );
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( RimOilField* oilField : oilFields() )
|
|
{
|
|
if ( !oilField ) continue;
|
|
|
|
if ( oilField->seismicViewCollection() )
|
|
{
|
|
for ( auto seisview : oilField->seismicViewCollection()->views() )
|
|
{
|
|
views.push_back( seisview );
|
|
}
|
|
}
|
|
|
|
if ( oilField->analysisModels() )
|
|
{
|
|
for ( auto ensemble : oilField->analysisModels()->caseEnsembles.childrenByType() )
|
|
{
|
|
if ( !ensemble ) continue;
|
|
|
|
for ( auto view : ensemble->allViews() )
|
|
{
|
|
views.push_back( view );
|
|
}
|
|
}
|
|
|
|
for ( auto gridEnsemble : oilField->analysisModels()->reservoirGridEnsembles.childrenByType() )
|
|
{
|
|
if ( !gridEnsemble ) continue;
|
|
|
|
for ( auto view : gridEnsemble->allViews() )
|
|
{
|
|
views.push_back( view );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return views;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<Rim3dView*> RimProject::allVisibleViews() const
|
|
{
|
|
std::vector<Rim3dView*> views;
|
|
|
|
for ( auto view : allViews() )
|
|
{
|
|
if ( view && view->viewer() )
|
|
{
|
|
views.push_back( view );
|
|
}
|
|
}
|
|
|
|
return views;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimGridView*> RimProject::allVisibleGridViews() const
|
|
{
|
|
std::vector<RimGridView*> views;
|
|
for ( Rim3dView* view : allVisibleViews() )
|
|
{
|
|
RimGridView* gridView = dynamic_cast<RimGridView*>( view );
|
|
if ( gridView ) views.push_back( gridView );
|
|
}
|
|
|
|
return views;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::scheduleCreateDisplayModelAndRedrawAllViews()
|
|
{
|
|
for ( auto view : allViews() )
|
|
{
|
|
if ( view ) view->scheduleCreateDisplayModelAndRedraw();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimOilField*> RimProject::allOilFields() const
|
|
{
|
|
return oilFields.childrenByType();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Currently there will be only one oil field in Resinsight, so return hardcoded first oil field
|
|
/// from the RimOilField collection.
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimOilField* RimProject::activeOilField()
|
|
{
|
|
CAF_ASSERT( oilFields.size() == 1 );
|
|
|
|
return oilFields[0];
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Currently there will be only one oil field in Resinsight, so return hardcoded first oil field
|
|
/// from the RimOilField collection.
|
|
//--------------------------------------------------------------------------------------------------
|
|
const RimOilField* RimProject::activeOilField() const
|
|
{
|
|
CAF_ASSERT( oilFields.size() == 1 );
|
|
|
|
return oilFields[0];
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::actionsBasedOnSelection( QMenu& contextMenu )
|
|
{
|
|
caf::CmdFeatureMenuBuilder menuBuilder = RimContextCommandBuilder::commandsFromSelection();
|
|
|
|
menuBuilder.appendToMenu( &contextMenu );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimProject::show3DWindow() const
|
|
{
|
|
return m_show3DWindow;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimProject::showPlotWindow() const
|
|
{
|
|
return m_showPlotWindow;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimProject::showPlotWindowOnTop() const
|
|
{
|
|
return m_showPlotWindowOnTopOf3DWindow();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::reloadCompletionTypeResultsInAllViews()
|
|
{
|
|
RiaCompletionTypeCalculationScheduler::instance()->clearCompletionTypeResultsInAllCases();
|
|
scheduleCreateDisplayModelAndRedrawAllViews();
|
|
|
|
m_mainPlotCollection()->scheduleUpdatePlotsWithCompletions();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimDialogData* RimProject::dialogData() const
|
|
{
|
|
return m_dialogData;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimEclipseCase*> RimProject::eclipseCases() const
|
|
{
|
|
std::vector<RimEclipseCase*> allGridCases;
|
|
for ( const auto& oilField : oilFields )
|
|
{
|
|
const auto& cases = oilField->analysisModels->cases;
|
|
allGridCases.insert( allGridCases.end(), cases.begin(), cases.end() );
|
|
}
|
|
return allGridCases;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimEclipseCase* RimProject::eclipseCaseFromGridFileName( const QString& gridFileName ) const
|
|
{
|
|
for ( RimEclipseCase* eclCase : eclipseCases() )
|
|
{
|
|
if ( RiaFilePathTools::toInternalSeparator( eclCase->gridFileName() ) == RiaFilePathTools::toInternalSeparator( gridFileName ) )
|
|
{
|
|
return eclCase;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimEclipseCase* RimProject::eclipseCaseFromCaseId( const int caseId ) const
|
|
{
|
|
for ( RimEclipseCase* eclCase : eclipseCases() )
|
|
{
|
|
if ( eclCase->caseId() == caseId )
|
|
{
|
|
return eclCase;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<QString> RimProject::simulationWellNames() const
|
|
{
|
|
std::set<QString> wellNames;
|
|
|
|
for ( RimOilField* oilField : oilFields )
|
|
{
|
|
auto analysisCaseColl = oilField->analysisModels();
|
|
for ( RimEclipseCase* eclCase : analysisCaseColl->cases() )
|
|
{
|
|
const auto& eclData = eclCase->eclipseCaseData();
|
|
if ( eclData == nullptr ) continue;
|
|
|
|
const auto names = eclData->simulationWellNames();
|
|
wellNames.insert( names.begin(), names.end() );
|
|
}
|
|
}
|
|
return std::vector<QString>( wellNames.begin(), wellNames.end() );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimWellPath* RimProject::wellPathFromSimWellName( const QString& simWellName, int branchIndex )
|
|
{
|
|
for ( RimWellPath* const path : allWellPaths() )
|
|
{
|
|
if ( QString::compare( path->associatedSimulationWellName(), simWellName ) == 0 &&
|
|
( branchIndex < 0 || path->associatedSimulationWellBranch() == branchIndex ) )
|
|
{
|
|
return path;
|
|
}
|
|
}
|
|
|
|
for ( RimWellPath* const path : allWellPaths() )
|
|
{
|
|
if ( QString::compare( path->name(), simWellName ) == 0 )
|
|
{
|
|
return path;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimWellPath* RimProject::wellPathByName( const QString& wellPathName ) const
|
|
{
|
|
for ( RimWellPath* const path : allWellPaths() )
|
|
{
|
|
if ( path->name() == wellPathName ) return path;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimWellPath*> RimProject::allWellPaths() const
|
|
{
|
|
std::vector<RimWellPath*> wellPaths;
|
|
for ( const auto& oilField : oilFields() )
|
|
{
|
|
auto wellPathColl = oilField->wellPathCollection();
|
|
for ( auto wellPath : wellPathColl->allWellPaths() )
|
|
{
|
|
wellPaths.push_back( wellPath );
|
|
}
|
|
}
|
|
return wellPaths;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimTextAnnotation*> RimProject::textAnnotations() const
|
|
{
|
|
std::vector<RimTextAnnotation*> annotations;
|
|
|
|
// 'Global' text annotations
|
|
for ( const auto& oilField : oilFields() )
|
|
{
|
|
auto annotationColl = oilField->annotationCollection();
|
|
for ( const auto& annotation : annotationColl->textAnnotations() )
|
|
{
|
|
annotations.push_back( annotation );
|
|
}
|
|
}
|
|
|
|
// 'Local' text annotations
|
|
for ( const auto& view : allVisibleGridViews() )
|
|
{
|
|
std::vector<RimAnnotationInViewCollection*> annotationColls = view->descendantsIncludingThisOfType<RimAnnotationInViewCollection>();
|
|
|
|
if ( annotationColls.size() == 1 )
|
|
{
|
|
for ( const auto& annotation : annotationColls.front()->textAnnotations() )
|
|
{
|
|
annotations.push_back( annotation );
|
|
}
|
|
}
|
|
}
|
|
|
|
return annotations;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimReachCircleAnnotation*> RimProject::reachCircleAnnotations() const
|
|
{
|
|
std::vector<RimReachCircleAnnotation*> annotations;
|
|
for ( const auto& oilField : oilFields() )
|
|
{
|
|
auto annotationColl = oilField->annotationCollection();
|
|
for ( const auto& annotation : annotationColl->reachCircleAnnotations() )
|
|
{
|
|
annotations.push_back( annotation );
|
|
}
|
|
}
|
|
return annotations;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimGeoMechCase*> RimProject::geoMechCases() const
|
|
{
|
|
std::vector<RimGeoMechCase*> cases;
|
|
for ( RimOilField* oilField : oilFields() )
|
|
{
|
|
if ( !oilField ) continue;
|
|
|
|
RimGeoMechModels* geomModels = oilField->geoMechModels();
|
|
if ( geomModels )
|
|
{
|
|
for ( auto acase : geomModels->cases() )
|
|
{
|
|
cases.push_back( acase );
|
|
}
|
|
}
|
|
}
|
|
return cases;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimFractureTemplateCollection*> RimProject::allFractureTemplateCollections() const
|
|
{
|
|
std::vector<RimFractureTemplateCollection*> templColls;
|
|
for ( RimOilField* oilField : allOilFields() )
|
|
{
|
|
templColls.push_back( oilField->fractureDefinitionCollection() );
|
|
}
|
|
return templColls;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimFractureTemplate*> RimProject::allFractureTemplates() const
|
|
{
|
|
std::vector<RimFractureTemplate*> templates;
|
|
for ( RimFractureTemplateCollection* templColl : allFractureTemplateCollections() )
|
|
{
|
|
for ( RimFractureTemplate* templ : templColl->fractureTemplates() )
|
|
{
|
|
templates.push_back( templ );
|
|
}
|
|
}
|
|
return templates;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimValveTemplateCollection*> RimProject::allValveTemplateCollections() const
|
|
{
|
|
std::vector<RimValveTemplateCollection*> templColls;
|
|
for ( RimOilField* oilField : allOilFields() )
|
|
{
|
|
templColls.push_back( oilField->valveTemplateCollection() );
|
|
}
|
|
return templColls;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimValveTemplate*> RimProject::allValveTemplates() const
|
|
{
|
|
std::vector<RimValveTemplate*> templates;
|
|
for ( RimValveTemplateCollection* templColl : allValveTemplateCollections() )
|
|
{
|
|
for ( RimValveTemplate* templ : templColl->items() )
|
|
{
|
|
templates.push_back( templ );
|
|
}
|
|
}
|
|
return templates;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
caf::AppEnum<RiaDefines::EclipseUnitSystem> RimProject::commonUnitSystemForAllCases() const
|
|
{
|
|
RiaDefines::EclipseUnitSystem commonUnitSystem = RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN;
|
|
|
|
for ( const auto& c : allGridCases() )
|
|
{
|
|
auto eclipseCase = dynamic_cast<RimEclipseCase*>( c );
|
|
if ( eclipseCase && eclipseCase->eclipseCaseData() )
|
|
{
|
|
if ( commonUnitSystem == RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN )
|
|
{
|
|
commonUnitSystem = eclipseCase->eclipseCaseData()->unitsType();
|
|
}
|
|
else if ( commonUnitSystem != eclipseCase->eclipseCaseData()->unitsType() )
|
|
{
|
|
commonUnitSystem = RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return commonUnitSystem;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimMeasurement* RimProject::measurement() const
|
|
{
|
|
return activeOilField()->measurement;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimPlotTemplateFolderItem* RimProject::rootPlotTemplateItem() const
|
|
{
|
|
return m_plotTemplateTopFolder;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<caf::FilePath*> RimProject::allFilePaths() const
|
|
{
|
|
std::vector<caf::FilePath*> filePaths = RiaProjectFileTools::writableFieldContent<caf::FilePath>( this );
|
|
|
|
return filePaths;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::reloadCompletionTypeResultsForEclipseCase( RimEclipseCase* eclipseCase )
|
|
{
|
|
for ( Rim3dView* view : eclipseCase->views() )
|
|
{
|
|
view->scheduleCreateDisplayModelAndRedraw();
|
|
}
|
|
|
|
RiaCompletionTypeCalculationScheduler::instance()->scheduleRecalculateCompletionTypeAndRedrawAllViews( { eclipseCase } );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimProject::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/ )
|
|
{
|
|
if ( uiConfigName == "PlotWindow.Plots" )
|
|
{
|
|
if ( m_mainPlotCollection )
|
|
{
|
|
if ( m_mainPlotCollection->summaryMultiPlotCollection() )
|
|
{
|
|
uiTreeOrdering.add( m_mainPlotCollection->summaryMultiPlotCollection() );
|
|
}
|
|
|
|
if ( m_mainPlotCollection->analysisPlotCollection() )
|
|
{
|
|
uiTreeOrdering.add( m_mainPlotCollection->analysisPlotCollection() );
|
|
}
|
|
|
|
if ( m_mainPlotCollection->correlationPlotCollection() )
|
|
{
|
|
uiTreeOrdering.add( m_mainPlotCollection->correlationPlotCollection() );
|
|
}
|
|
|
|
if ( m_mainPlotCollection->summaryTableCollection() )
|
|
{
|
|
uiTreeOrdering.add( m_mainPlotCollection->summaryTableCollection() );
|
|
}
|
|
|
|
if ( m_mainPlotCollection->wellLogPlotCollection() )
|
|
{
|
|
uiTreeOrdering.add( m_mainPlotCollection->wellLogPlotCollection() );
|
|
}
|
|
|
|
if ( m_mainPlotCollection->rftPlotCollection() )
|
|
{
|
|
uiTreeOrdering.add( m_mainPlotCollection->rftPlotCollection() );
|
|
}
|
|
|
|
if ( m_mainPlotCollection->pltPlotCollection() )
|
|
{
|
|
uiTreeOrdering.add( m_mainPlotCollection->pltPlotCollection() );
|
|
}
|
|
|
|
if ( m_mainPlotCollection->flowPlotCollection() )
|
|
{
|
|
uiTreeOrdering.add( m_mainPlotCollection->flowPlotCollection() );
|
|
}
|
|
|
|
if ( m_mainPlotCollection->gridCrossPlotCollection() )
|
|
{
|
|
uiTreeOrdering.add( m_mainPlotCollection->gridCrossPlotCollection() );
|
|
}
|
|
|
|
if ( m_mainPlotCollection->saturationPressurePlotCollection() )
|
|
{
|
|
uiTreeOrdering.add( m_mainPlotCollection->saturationPressurePlotCollection() );
|
|
}
|
|
|
|
if ( m_mainPlotCollection->multiPlotCollection() )
|
|
{
|
|
uiTreeOrdering.add( m_mainPlotCollection->multiPlotCollection() );
|
|
}
|
|
|
|
if ( m_mainPlotCollection->stimPlanModelPlotCollection() )
|
|
{
|
|
uiTreeOrdering.add( m_mainPlotCollection->stimPlanModelPlotCollection() );
|
|
}
|
|
|
|
if ( m_mainPlotCollection->vfpPlotCollection() )
|
|
{
|
|
uiTreeOrdering.add( m_mainPlotCollection->vfpPlotCollection() );
|
|
}
|
|
|
|
if ( m_mainPlotCollection->histogramMultiPlotCollection() )
|
|
{
|
|
uiTreeOrdering.add( m_mainPlotCollection->histogramMultiPlotCollection() );
|
|
}
|
|
|
|
uiTreeOrdering.add( automationSettings() );
|
|
}
|
|
}
|
|
else if ( uiConfigName == "PlotWindow.DataSources" )
|
|
{
|
|
RimOilField* oilField = activeOilField();
|
|
if ( oilField )
|
|
{
|
|
if ( oilField->summaryCaseMainCollection() )
|
|
{
|
|
uiTreeOrdering.add( oilField->summaryCaseMainCollection() );
|
|
}
|
|
if ( oilField->observedDataCollection() )
|
|
{
|
|
uiTreeOrdering.add( oilField->observedDataCollection() );
|
|
}
|
|
if ( oilField->ensembleWellLogsCollection() )
|
|
{
|
|
uiTreeOrdering.add( oilField->ensembleWellLogsCollection() );
|
|
}
|
|
if ( oilField->vfpDataCollection() )
|
|
{
|
|
uiTreeOrdering.add( oilField->vfpDataCollection() );
|
|
}
|
|
}
|
|
}
|
|
else if ( uiConfigName == "PlotWindow.Scripts" || uiConfigName == "MainWindow.Scripts" )
|
|
{
|
|
uiTreeOrdering.add( scriptCollection() );
|
|
uiTreeOrdering.add( jobCollection() );
|
|
}
|
|
else if ( uiConfigName == "PlotWindow.Templates" )
|
|
{
|
|
uiTreeOrdering.add( m_plotTemplateTopFolder );
|
|
}
|
|
else if ( uiConfigName == "PlotWindow.Cloud" )
|
|
{
|
|
uiTreeOrdering.add( &m_ensembleFileSetCollection );
|
|
if ( m_mainPlotCollection )
|
|
{
|
|
if ( activeOilField()->cloudDataCollection() )
|
|
{
|
|
uiTreeOrdering.add( activeOilField()->cloudDataCollection() );
|
|
}
|
|
}
|
|
}
|
|
else if ( uiConfigName == "MainWindow.DataSources" )
|
|
{
|
|
RimOilField* oilField = activeOilField();
|
|
if ( oilField )
|
|
{
|
|
if ( oilField->analysisModels() ) uiTreeOrdering.add( oilField->analysisModels() );
|
|
}
|
|
uiTreeOrdering.add( &m_ensembleFileSetCollection );
|
|
}
|
|
else
|
|
{
|
|
// Use object instead of field to avoid duplicate entries in the tree view
|
|
uiTreeOrdering.add( viewLinkerCollection() );
|
|
|
|
RimOilField* oilField = activeOilField();
|
|
if ( oilField )
|
|
{
|
|
if ( oilField->analysisModels() ) uiTreeOrdering.add( oilField->analysisModels() );
|
|
if ( oilField->eclipseViewCollection() ) uiTreeOrdering.add( oilField->eclipseViewCollection() );
|
|
if ( oilField->geoMechModels() ) uiTreeOrdering.add( oilField->geoMechModels() );
|
|
if ( oilField->wellPathCollection() ) uiTreeOrdering.add( oilField->wellPathCollection() );
|
|
if ( oilField->polygonCollection() ) uiTreeOrdering.add( oilField->polygonCollection() );
|
|
if ( oilField->surfaceCollection() ) uiTreeOrdering.add( oilField->surfaceCollection() );
|
|
if ( oilField->seismicDataCollection() )
|
|
{
|
|
auto child = uiTreeOrdering.add( "Seismic", ":/Seismic16x16.png" );
|
|
child->add( oilField->seismicDataCollection() );
|
|
child->add( oilField->seismicViewCollection() );
|
|
}
|
|
if ( oilField->formationNamesCollection() ) uiTreeOrdering.add( oilField->formationNamesCollection() );
|
|
if ( oilField->completionTemplateCollection() ) uiTreeOrdering.add( oilField->completionTemplateCollection() );
|
|
if ( oilField->annotationCollection() ) uiTreeOrdering.add( oilField->annotationCollection() );
|
|
if ( oilField->eclipseContourMapCollection() ) uiTreeOrdering.add( oilField->eclipseContourMapCollection() );
|
|
}
|
|
|
|
uiTreeOrdering.add( colorLegendCollection() );
|
|
}
|
|
|
|
uiTreeOrdering.skipRemainingChildren( true );
|
|
}
|