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

Import and plot of FMU RFT data works

Browse Source
This commit is contained in:
Gaute Lindkvist
2019-08-20 15:09:13 +02:00
parent f76c67dab3
commit 2c5ca4ce46
51 changed files with 862 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
ApplicationCode/Application/RiaApplication.cpp
View File

@@ -55,7 +55,7 @@
#include "RimGridCrossPlotCollection.h"
#include "RimIdenticalGridCaseGroup.h"
#include "RimMainPlotCollection.h"
#include "RimObservedData.h"
#include "RimObservedSummaryData.h"
#include "RimObservedDataCollection.h"
#include "RimOilField.h"
#include "RimPltPlotCollection.h"
@@ -485,9 +485,10 @@ bool RiaApplication::loadProject(const QString& projectFileName,
{
oilField->observedDataCollection = new RimObservedDataCollection();
}
for (RimObservedData* observedData : oilField->observedDataCollection()->allObservedData())
for (RimObservedSummaryData* observedData : oilField->observedDataCollection()->allObservedSummaryData())
{
observedData->createSummaryReaderInterface();
observedData->createRftReaderInterface();
observedData->updateMetaData();
}

2
ApplicationCode/Application/RiaGuiApplication.cpp
View File

@@ -59,7 +59,7 @@
#include "RimGridCrossPlotCollection.h"
#include "RimIdenticalGridCaseGroup.h"
#include "RimMainPlotCollection.h"
#include "RimObservedData.h"
#include "RimObservedSummaryData.h"
#include "RimObservedDataCollection.h"
#include "RimOilField.h"
#include "RimPltPlotCollection.h"

6
ApplicationCode/Commands/CMakeLists_files.cmake
View File

@@ -41,8 +41,9 @@ ${CMAKE_CURRENT_LIST_DIR}/RicImportGeoMechCaseTimeStepFilterFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicImportSummaryCaseFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicImportSummaryCasesFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicImportObservedDataFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicImportFmuObservedDataFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicImportObservedDataInMenuFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicImportObservedFmuDataFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicImportObservedFmuDataInMenuFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicImportGeneralDataFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicExportFeatureImpl.h
@@ -122,8 +123,9 @@ ${CMAKE_CURRENT_LIST_DIR}/RicImportGeoMechCaseTimeStepFilterFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicImportSummaryCaseFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicImportSummaryCasesFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicImportObservedDataFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicImportFmuObservedDataFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicImportObservedDataInMenuFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicImportObservedFmuDataFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicImportObservedFmuDataInMenuFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicImportGeneralDataFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicExportFeatureImpl.cpp

59
ApplicationCode/Commands/RicCloseObservedDataFeature.cpp
View File

@@ -21,11 +21,15 @@
#include "RiaApplication.h"
#include "RiaSummaryTools.h"
#include "RimObservedData.h"
#include "RimMainPlotCollection.h"
#include "RimObservedFmuRftData.h"
#include "RimObservedSummaryData.h"
#include "RimObservedDataCollection.h"
#include "RimProject.h"
#include "RimRftPlotCollection.h"
#include "RimSummaryPlot.h"
#include "RimSummaryPlotCollection.h"
#include "RimWellRftPlot.h"
#include "cafSelectionManager.h"
@@ -47,11 +51,11 @@ void RicCloseObservedDataFeature::setupActionLook(QAction* actionToSetup)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicCloseObservedDataFeature::deleteObservedData(const std::vector<RimObservedData*>& data)
void RicCloseObservedDataFeature::deleteObservedSummaryData(const std::vector<RimObservedSummaryData*>& data)
{
RimSummaryPlotCollection* summaryPlotColl = RiaSummaryTools::summaryPlotCollection();
for (RimObservedData* observedData : data)
for (RimObservedSummaryData* observedData : data)
{
for (RimSummaryPlot* summaryPlot : summaryPlotColl->summaryPlots)
{
@@ -62,7 +66,30 @@ void RicCloseObservedDataFeature::deleteObservedData(const std::vector<RimObserv
RimObservedDataCollection* observedDataCollection = nullptr;
observedData->firstAncestorOrThisOfTypeAsserted(observedDataCollection);
observedDataCollection->removeObservedData(observedData);
observedDataCollection->removeObservedSummaryData(observedData);
delete observedData;
observedDataCollection->updateConnectedEditors();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicCloseObservedDataFeature::deleteObservedRmuRftData(const std::vector<RimObservedFmuRftData*>& data)
{
RimProject* proj = RiaApplication::instance()->project();
RimRftPlotCollection* rftPlotColl = proj->mainPlotCollection()->rftPlotCollection();
for (RimObservedFmuRftData* observedData : data)
{
RimObservedDataCollection* observedDataCollection = nullptr;
observedData->firstAncestorOrThisOfTypeAsserted(observedDataCollection);
for (RimWellRftPlot* plot : rftPlotColl->rftPlots())
{
plot->deleteCurvesAssosicatedWithObservedData(observedData);
}
observedDataCollection->removeObservedFmuRftData(observedData);
delete observedData;
observedDataCollection->updateConnectedEditors();
}
@@ -73,14 +100,17 @@ void RicCloseObservedDataFeature::deleteObservedData(const std::vector<RimObserv
//--------------------------------------------------------------------------------------------------
bool RicCloseObservedDataFeature::isCommandEnabled()
{
std::vector<RimObservedData*> selection;
caf::SelectionManager::instance()->objectsByType(&selection);
std::vector<RimObservedSummaryData*> summarySelection;
caf::SelectionManager::instance()->objectsByType(&summarySelection);
if (selection.size() == 0)
std::vector<RimObservedFmuRftData*> fmuRftSelection;
caf::SelectionManager::instance()->objectsByType(&fmuRftSelection);
if (summarySelection.size() == 0 && fmuRftSelection.size() == 0)
{
return false;
}
for (RimObservedData* data : selection)
for (RimObservedSummaryData* data : summarySelection)
{
if (!data->isObservedData())
{
@@ -96,9 +126,14 @@ bool RicCloseObservedDataFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicCloseObservedDataFeature::onActionTriggered(bool isChecked)
{
std::vector<RimObservedData*> selection;
caf::SelectionManager::instance()->objectsByType(&selection);
CVF_ASSERT(selection.size() > 0);
std::vector<RimObservedSummaryData*> summarySelection;
caf::SelectionManager::instance()->objectsByType(&summarySelection);
std::vector<RimObservedFmuRftData*> fmuRftSelection;
caf::SelectionManager::instance()->objectsByType(&fmuRftSelection);
CVF_ASSERT(!(summarySelection.empty() && fmuRftSelection.empty()));
RicCloseObservedDataFeature::deleteObservedData(selection);
RicCloseObservedDataFeature::deleteObservedSummaryData(summarySelection);
RicCloseObservedDataFeature::deleteObservedRmuRftData(fmuRftSelection);
}

6
ApplicationCode/Commands/RicCloseObservedDataFeature.h
View File

@@ -22,7 +22,8 @@
#include <vector>
class RimObservedData;
class RimObservedFmuRftData;
class RimObservedSummaryData;
//==================================================================================================
///
@@ -31,7 +32,8 @@ class RicCloseObservedDataFeature : public caf::CmdFeature
{
CAF_CMD_HEADER_INIT;
public:
static void deleteObservedData(const std::vector<RimObservedData*>& data);
static void deleteObservedSummaryData(const std::vector<RimObservedSummaryData*>& data);
static void deleteObservedRmuRftData(const std::vector<RimObservedFmuRftData*>& data);
protected:
// Overrides

10
ApplicationCode/Commands/RicImportObservedDataFeature.cpp
View File

@@ -20,7 +20,7 @@
#include "RiaApplication.h"
#include "RimObservedData.h"
#include "RimObservedSummaryData.h"
#include "RimObservedDataCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
@@ -55,7 +55,7 @@ void RicImportObservedDataFeature::selectObservedDataFileInDialog()
RimObservedDataCollection* observedDataCollection = proj->activeOilField() ? proj->activeOilField()->observedDataCollection() : nullptr;
if (!observedDataCollection) return;
RimObservedData* observedData = nullptr;
RimObservedSummaryData* observedData = nullptr;
for (const QString& fileName : fileNames)
{
@@ -67,13 +67,13 @@ void RicImportObservedDataFeature::selectObservedDataFileInDialog()
if (fileName.endsWith(".rsm", Qt::CaseInsensitive))
{
observedData = observedDataCollection->createAndAddRsmObservedDataFromFile(fileName, &errorText);
observedData = observedDataCollection->createAndAddRsmObservedSummaryDataFromFile(fileName, &errorText);
retryImport = false;
}
else if (fileName.endsWith(".txt", Qt::CaseInsensitive) || fileName.endsWith(".csv", Qt::CaseInsensitive))
{
bool useSavedFieldValuesInDialog = retryImport;
observedData = observedDataCollection->createAndAddCvsObservedDataFromFile(fileName, useSavedFieldValuesInDialog, &errorText);
observedData = observedDataCollection->createAndAddCvsObservedSummaryDataFromFile(fileName, useSavedFieldValuesInDialog, &errorText);
retryImport = !errorText.isEmpty();
}
else
@@ -105,7 +105,7 @@ bool RicImportObservedDataFeature::isCommandEnabled()
std::vector<RimObservedDataCollection*> selectionObservedDataCollection;
caf::SelectionManager::instance()->objectsByType(&selectionObservedDataCollection);
std::vector<RimObservedData*> selectionObservedData;
std::vector<RimObservedSummaryData*> selectionObservedData;
caf::SelectionManager::instance()->objectsByType(&selectionObservedData);
return (selectionObservedDataCollection.size() > 0 || selectionObservedData.size() > 0);

46
ApplicationCode/Commands/RicImportFmuObservedDataFeature.cpp → ApplicationCode/Commands/RicImportObservedFmuDataFeature.cpp
View File

@@ -15,45 +15,68 @@
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RicImportFmuObservedDataFeature.h"
#include "RicImportObservedFmuDataFeature.h"
#include "RiaApplication.h"
#include "RifReaderFmuRft.h"
#include "RimObservedData.h"
#include "RimObservedFmuRftData.h"
#include "RimObservedSummaryData.h"
#include "RimObservedDataCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RiuPlotMainWindowTools.h"
#include "cafPdmObject.h"
#include "cafSelectionManager.h"
#include <QAction>
#include <QFileDialog>
#include <QMessageBox>
CAF_CMD_SOURCE_INIT(RicImportObservedFmuDataFeature, "RicImportObservedFmuDataFeature");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicImportFmuObservedDataFeature::selectObservedDataPathInDialog()
void RicImportObservedFmuDataFeature::selectObservedDataPathInDialog()
{
RiaApplication* app = RiaApplication::instance();
QString defaultDir = app->lastUsedDialogDirectory("SUMMARY_CASE_DIR");
QString directory = QFileDialog::getExistingDirectory(
nullptr, "Import Fmu Observed Data Recursively from Directory", defaultDir, QFileDialog::ShowDirsOnly);
nullptr, "Import Observed FMU Data Recursively from Directory", defaultDir, QFileDialog::ShowDirsOnly);
QStringList subDirsWithFmuData = RifReaderFmuRft::findSubDirectoriesWithFmuRftData(directory);
if (subDirsWithFmuData.empty()) return;
RimProject* proj = app->project();
RimObservedDataCollection* observedDataCollection =
proj->activeOilField() ? proj->activeOilField()->observedDataCollection() : nullptr;
if (!observedDataCollection) return;
const RimObservedFmuRftData* importedData = nullptr;
for (const QString& subDir : subDirsWithFmuData)
{
importedData = observedDataCollection->createAndAddFmuRftDataFromPath(subDir);
}
if (importedData != nullptr)
{
RiuPlotMainWindowTools::showPlotMainWindow();
RiuPlotMainWindowTools::selectAsCurrentItem(importedData);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicImportFmuObservedDataFeature::isCommandEnabled()
bool RicImportObservedFmuDataFeature::isCommandEnabled()
{
std::vector<RimObservedDataCollection*> selectionObservedDataCollection;
caf::SelectionManager::instance()->objectsByType(&selectionObservedDataCollection);
std::vector<RimObservedData*> selectionObservedData;
std::vector<RimObservedSummaryData*> selectionObservedData;
caf::SelectionManager::instance()->objectsByType(&selectionObservedData);
return (selectionObservedDataCollection.size() > 0 || selectionObservedData.size() > 0);
@@ -62,9 +85,16 @@ bool RicImportFmuObservedDataFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicImportFmuObservedDataFeature::onActionTriggered(bool isChecked) {}
void RicImportObservedFmuDataFeature::onActionTriggered(bool isChecked)
{
selectObservedDataPathInDialog();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicImportFmuObservedDataFeature::setupActionLook(QAction* actionToSetup) {}
void RicImportObservedFmuDataFeature::setupActionLook(QAction* actionToSetup)
{
actionToSetup->setIcon(QIcon(":/ObservedDataFile16x16.png"));
actionToSetup->setText("Import Observed FMU Data");
}

2
ApplicationCode/Commands/RicImportFmuObservedDataFeature.h → ApplicationCode/Commands/RicImportObservedFmuDataFeature.h
View File

@@ -26,7 +26,7 @@
//
//
//==================================================================================================
class RicImportFmuObservedDataFeature : public caf::CmdFeature
class RicImportObservedFmuDataFeature : public caf::CmdFeature
{
CAF_CMD_HEADER_INIT;

63
ApplicationCode/Commands/RicImportObservedFmuDataInMenuFeature.cpp Normal file
View File

@@ -0,0 +1,63 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2017 Statoil ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RicImportObservedFmuDataInMenuFeature.h"
#include "RiaApplication.h"
#include "RicImportObservedFmuDataFeature.h"
#include "RimObservedDataCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimSummaryObservedDataFile.h"
#include <QAction>
#include <QFileDialog>
CAF_CMD_SOURCE_INIT(RicImportObservedFmuDataInMenuFeature, "RicImportObservedFmuDataInMenuFeature");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicImportObservedFmuDataInMenuFeature::RicImportObservedFmuDataInMenuFeature() {}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicImportObservedFmuDataInMenuFeature::isCommandEnabled()
{
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicImportObservedFmuDataInMenuFeature::onActionTriggered(bool isChecked)
{
RicImportObservedFmuDataFeature::selectObservedDataPathInDialog();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicImportObservedFmuDataInMenuFeature::setupActionLook(QAction* actionToSetup)
{
actionToSetup->setIcon(QIcon(":/ObservedDataFile16x16.png"));
actionToSetup->setText("Import Observed FMU Data");
}

41
ApplicationCode/Commands/RicImportObservedFmuDataInMenuFeature.h Normal file
View File

@@ -0,0 +1,41 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2019- 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.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "cafCmdFeature.h"
#include "cafPdmField.h"
//==================================================================================================
//
//
//
//==================================================================================================
class RicImportObservedFmuDataInMenuFeature : public caf::CmdFeature
{
CAF_CMD_HEADER_INIT;
public:
RicImportObservedFmuDataInMenuFeature();
private:
bool isCommandEnabled() override;
void onActionTriggered(bool isChecked) override;
void setupActionLook(QAction* actionToSetup) override;
};

5
ApplicationCode/Commands/RicReloadSummaryCaseFeature.cpp
View File

@@ -23,7 +23,7 @@
#include "RiaSummaryTools.h"
#include "RimMainPlotCollection.h"
#include "RimObservedData.h"
#include "RimObservedSummaryData.h"
#include "RimObservedDataCollection.h"
#include "RimProject.h"
#include "RimSummaryCase.h"
@@ -60,6 +60,7 @@ void RicReloadSummaryCaseFeature::onActionTriggered(bool isChecked)
for (RimSummaryCase* summaryCase : caseSelection)
{
summaryCase->createSummaryReaderInterface();
summaryCase->createRftReaderInterface();
RiaLogging::info(QString("Reloaded data for %1").arg(summaryCase->summaryHeaderFilename()));
}
@@ -112,7 +113,7 @@ std::vector<RimSummaryCase*> RicReloadSummaryCaseFeature::selectedSummaryCases()
for (auto collection : collectionSelection)
{
std::vector<RimObservedData*> observedCases = collection->allObservedData();
std::vector<RimObservedSummaryData*> observedCases = collection->allObservedSummaryData();
caseSelection.insert(caseSelection.end(), observedCases.begin(), observedCases.end());
}
}

4
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryCurveCreator.cpp
View File

@@ -33,7 +33,7 @@
#include "RimEnsembleCurveSetCollection.h"
#include "RimEnsembleCurveSetColorManager.h"
#include "RimMainPlotCollection.h"
#include "RimObservedData.h"
#include "RimObservedSummaryData.h"
#include "RimObservedDataCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
@@ -873,7 +873,7 @@ void RicSummaryCurveCreator::updateCurveNames()
//--------------------------------------------------------------------------------------------------
bool RicSummaryCurveCreator::isObservedData(RimSummaryCase* sumCase) const
{
return dynamic_cast<RimObservedData*>(sumCase) != nullptr;
return dynamic_cast<RimObservedSummaryData*>(sumCase) != nullptr;
}
//--------------------------------------------------------------------------------------------------

52
ApplicationCode/FileInterface/RifDataSourceForRftPlt.cpp
View File

@@ -18,6 +18,7 @@
#include "RifDataSourceForRftPlt.h"
#include "RimEclipseCase.h"
#include "RimObservedFmuRftData.h"
#include "RimSummaryCase.h"
#include "RimSummaryCaseCollection.h"
#include "RimWellLogFile.h"
@@ -84,6 +85,17 @@ RifDataSourceForRftPlt::RifDataSourceForRftPlt(SourceType sourceType,
m_ensemble = ensemble;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifDataSourceForRftPlt::RifDataSourceForRftPlt(SourceType sourceType, RimObservedFmuRftData* observedFmuRftData)
{
CVF_ASSERT(sourceType == SourceType::OBSERVED_FMU_RFT);
m_sourceType = sourceType;
m_observedFmuRftData = observedFmuRftData;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -146,6 +158,14 @@ RimWellLogFile* RifDataSourceForRftPlt::wellLogFile() const
return m_wellLogFile;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimObservedFmuRftData* RifDataSourceForRftPlt::observedFmuRftData() const
{
return m_observedFmuRftData;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -163,6 +183,8 @@ QString RifDataSourceForRftPlt::sourceTypeUiText(SourceType sourceType)
return QString("Ensembles with RFT Data");
case SourceType::SUMMARY_RFT:
return QString("Summary case with RFT Data");
case SourceType::OBSERVED_FMU_RFT:
return QString("Observed FMU data");
}
return QString();
}
@@ -174,7 +196,7 @@ bool operator==(const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPl
{
return addr1.sourceType() == addr2.sourceType() && addr1.eclCase() == addr2.eclCase() &&
addr1.wellLogFile() == addr2.wellLogFile() && addr1.summaryCase() == addr2.summaryCase() &&
addr1.ensemble() == addr2.ensemble();
addr1.ensemble() == addr2.ensemble() && addr1.observedFmuRftData() == addr2.observedFmuRftData();
}
//--------------------------------------------------------------------------------------------------
@@ -216,10 +238,7 @@ bool operator<(const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPlt
{
return addr1.wellLogFile()->fileName() < addr2.wellLogFile()->fileName();
}
else
{
return addr1.wellLogFile() < addr2.wellLogFile();
}
return addr1.wellLogFile() < addr2.wellLogFile();
}
else if (addr1.m_sourceType == RifDataSourceForRftPlt::SUMMARY_RFT)
{
@@ -227,10 +246,7 @@ bool operator<(const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPlt
{
return addr1.summaryCase()->caseName() < addr2.summaryCase()->caseName();
}
else
{
return addr1.summaryCase() < addr2.summaryCase();
}
return addr1.summaryCase() < addr2.summaryCase();
}
else if (addr1.m_sourceType == RifDataSourceForRftPlt::ENSEMBLE_RFT)
{
@@ -238,21 +254,23 @@ bool operator<(const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPlt
{
return addr1.ensemble()->name() < addr2.ensemble()->name();
}
else
{
return addr1.ensemble() < addr2.ensemble();
}
return addr1.ensemble() < addr2.ensemble();
}
else if (addr1.m_sourceType == RifDataSourceForRftPlt::OBSERVED_FMU_RFT)
{
if (addr1.observedFmuRftData() && addr2.observedFmuRftData())
{
return addr1.observedFmuRftData()->name() < addr2.observedFmuRftData()->name();
}
return addr1.observedFmuRftData() < addr2.observedFmuRftData();
}
else
{
if (addr1.eclCase() && addr2.eclCase())
{
return addr1.eclCase()->caseId() < addr2.eclCase()->caseId();
}
else
{
return addr1.eclCase() < addr2.eclCase();
}
return addr1.eclCase() < addr2.eclCase();
}
}
#if 0

7
ApplicationCode/FileInterface/RifDataSourceForRftPlt.h
View File

@@ -35,6 +35,7 @@ class RimEclipseCase;
class RifReaderRftInterface;
class RimSummaryCase;
class RimSummaryCaseCollection;
class RimObservedFmuRftData;
//==================================================================================================
///
@@ -50,7 +51,8 @@ public:
RFT,
GRID,
ENSEMBLE_RFT,
SUMMARY_RFT
SUMMARY_RFT,
OBSERVED_FMU_RFT
};
RifDataSourceForRftPlt();
@@ -58,6 +60,7 @@ public:
RifDataSourceForRftPlt(SourceType sourceType, RimSummaryCaseCollection* ensemble);
RifDataSourceForRftPlt(SourceType sourceType, RimSummaryCase* summaryCase, RimSummaryCaseCollection* ensemble);
RifDataSourceForRftPlt(SourceType sourceType, RimWellLogFile* wellLogFile = nullptr);
RifDataSourceForRftPlt(SourceType sourceType, RimObservedFmuRftData* observedFmuRftData);
SourceType sourceType() const;
RimEclipseCase* eclCase() const;
@@ -65,6 +68,7 @@ public:
RimSummaryCaseCollection* ensemble() const;
RimSummaryCase* summaryCase() const;
RimWellLogFile* wellLogFile() const;
RimObservedFmuRftData* observedFmuRftData() const;
static QString sourceTypeUiText(SourceType sourceType);
@@ -77,6 +81,7 @@ private:
caf::PdmPointer<RimSummaryCase> m_summaryCase;
caf::PdmPointer<RimSummaryCaseCollection> m_ensemble;
caf::PdmPointer<RimWellLogFile> m_wellLogFile;
caf::PdmPointer<RimObservedFmuRftData> m_observedFmuRftData;
};
bool operator==(const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPlt& addr2);

3
ApplicationCode/FileInterface/RifEclipseRftAddress.cpp
View File

@@ -25,9 +25,6 @@ RifEclipseRftAddress::RifEclipseRftAddress(QString wellName, QDateTime timeStep,
: m_wellName(wellName)
, m_wellLogChannel(wellLogChannelName)
{
timeStep.setTimeSpec(Qt::TimeSpec::UTC);
m_timeStep.setTimeSpec(Qt::TimeSpec::UTC);
m_timeStep = timeStep;
}

36
ApplicationCode/FileInterface/RifReaderFmuRft.cpp
View File

@@ -227,6 +227,7 @@ void RifReaderFmuRft::load()
QDir dir(m_filePath);
WellObservationMap wellObservations = loadWellDates(dir, &errorMsg);
WellObservationMap validObservations;
if (wellObservations.empty())
{
if (errorMsg.isEmpty())
@@ -243,23 +244,22 @@ void RifReaderFmuRft::load()
WellObservationSet& wellObservationSet = it->second;
QString txtFile = QString("%1.txt").arg(wellName);
QString obsFile = QString("%1.obs").arg(wellName);
QFileInfo txtFileInfo(dir.absoluteFilePath(txtFile));
QFileInfo obsFileInfo(dir.absoluteFilePath(obsFile));
if (!readTxtFile(txtFile, &errorMsg, &wellObservationSet))
if (!readTxtFile(dir.absoluteFilePath(txtFile), &errorMsg, &wellObservationSet))
{
RiaLogging::error(errorMsg);
return;
RiaLogging::warning(errorMsg);
continue;
}
if (!readObsFile(obsFile, &errorMsg, &wellObservationSet))
if (!readObsFile(dir.absoluteFilePath(obsFile), &errorMsg, &wellObservationSet))
{
RiaLogging::error(errorMsg);
return;
RiaLogging::warning(errorMsg);
continue;
}
validObservations.insert(*it);
}
m_allWellObservations.swap(wellObservations);
m_allWellObservations.swap(validObservations);
}
//--------------------------------------------------------------------------------------------------
@@ -390,6 +390,7 @@ RifReaderFmuRft::WellObservationMap RifReaderFmuRft::loadWellDates(QDir& dir, QS
}
QDateTime dateTime(QDate(year, month, day));
dateTime.setTimeSpec(Qt::UTC);
WellObservationSet observationSet(dateTime, measurementIndex);
validObservations.insert(std::make_pair(wellName, observationSet));
}
@@ -416,8 +417,8 @@ bool RifReaderFmuRft::readTxtFile(const QString& fileName, QString* errorMsg, We
QTextStream stream(&file);
while (true)
{
QString line = stream.readLine();
if (line.isNull())
QString line = stream.readLine().trimmed();
if (line.isNull() || line.isEmpty())
{
break;
}
@@ -465,17 +466,16 @@ bool RifReaderFmuRft::readObsFile(const QString& fileName, QString* errorMsg, We
QTextStream stream(&file);
while (true)
{
if (lineNumber >= wellObservationSet->observations.size())
QString line = stream.readLine().trimmed();
if (line.isNull() || line.isEmpty())
{
break;
}
else if (lineNumber >= wellObservationSet->observations.size())
{
*errorMsg = QString("'%1' has more lines than corresponding txt file").arg(fileName);
return false;
}
QString line = stream.readLine();
if (line.isNull())
{
break;
}
else
{
QTextStream lineStream(&line);

4
ApplicationCode/ProjectDataModel/CMakeLists_files.cmake
View File

@@ -131,6 +131,8 @@ ${CMAKE_CURRENT_LIST_DIR}/RimRiuQwtPlotOwnerInterface.h
${CMAKE_CURRENT_LIST_DIR}/RimPlotAxisPropertiesInterface.h
${CMAKE_CURRENT_LIST_DIR}/RimPlotAxisProperties.h
${CMAKE_CURRENT_LIST_DIR}/RimPlotAxisAnnotation.h
${CMAKE_CURRENT_LIST_DIR}/RimObservedDataCollection.h
${CMAKE_CURRENT_LIST_DIR}/RimObservedFmuRftData.h
)
@@ -265,6 +267,8 @@ ${CMAKE_CURRENT_LIST_DIR}/RimReloadCaseTools.cpp
${CMAKE_CURRENT_LIST_DIR}/RimPlotAxisPropertiesInterface.cpp
${CMAKE_CURRENT_LIST_DIR}/RimPlotAxisProperties.cpp
${CMAKE_CURRENT_LIST_DIR}/RimPlotAxisAnnotation.cpp
${CMAKE_CURRENT_LIST_DIR}/RimObservedDataCollection.cpp
${CMAKE_CURRENT_LIST_DIR}/RimObservedFmuRftData.cpp
)
list(APPEND CODE_HEADER_FILES

82
ApplicationCode/ProjectDataModel/Flow/RimDataSourceForRftPlt.cpp
View File

@@ -1,23 +1,25 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2017 Statoil ASA
//
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RimDataSourceForRftPlt.h"
#include "RimEclipseCase.h"
#include "RimObservedFmuRftData.h"
#include "RimSummaryCaseCollection.h"
#include "RimWellLogFile.h"
#include "cafAppEnum.h"
@@ -27,25 +29,25 @@
namespace caf
{
template<>
void caf::AppEnum<RifDataSourceForRftPlt::SourceType>::setUp()
{
addItem(RifDataSourceForRftPlt::SourceType::RFT, "RFT", "RFT Cases");
addItem(RifDataSourceForRftPlt::SourceType::GRID, "GRID", "Grid Cases");
addItem(RifDataSourceForRftPlt::SourceType::OBSERVED, "OBSERVED", "Observed Data");
addItem(RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT, "ENSEMBLE", "Ensembles with RFT Data");
setDefault(RifDataSourceForRftPlt::SourceType::NONE);
}
template<>
void caf::AppEnum<RifDataSourceForRftPlt::SourceType>::setUp()
{
addItem(RifDataSourceForRftPlt::SourceType::RFT, "RFT", "RFT Cases");
addItem(RifDataSourceForRftPlt::SourceType::GRID, "GRID", "Grid Cases");
addItem(RifDataSourceForRftPlt::SourceType::OBSERVED, "OBSERVED", "Observed Data");
addItem(RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT, "ENSEMBLE", "Ensembles with RFT Data");
addItem(RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT, "OBSERVED_FMU", "Observed FMU Data");
setDefault(RifDataSourceForRftPlt::SourceType::NONE);
}
} // namespace caf
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
CAF_PDM_SOURCE_INIT(RimDataSourceForRftPlt, "RftAddress");
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
RimDataSourceForRftPlt::RimDataSourceForRftPlt()
{
@@ -53,7 +55,7 @@ RimDataSourceForRftPlt::RimDataSourceForRftPlt()
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
RimDataSourceForRftPlt::RimDataSourceForRftPlt(const RifDataSourceForRftPlt& addr)
{
@@ -62,42 +64,62 @@ RimDataSourceForRftPlt::RimDataSourceForRftPlt(const RifDataSourceForRftPlt& add
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
void RimDataSourceForRftPlt::setAddress(const RifDataSourceForRftPlt& address)
{
m_sourceType = address.sourceType();
m_eclCase = address.eclCase();
m_wellLogFile = address.wellLogFile();
m_sourceType = address.sourceType();
m_eclCase = address.eclCase();
m_wellLogFile = address.wellLogFile();
m_ensemble = address.ensemble();
m_observedFmuRftData = address.observedFmuRftData();
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
RifDataSourceForRftPlt RimDataSourceForRftPlt::address() const
{
return m_eclCase() != nullptr ?
RifDataSourceForRftPlt(m_sourceType(), m_eclCase()) :
RifDataSourceForRftPlt(m_sourceType(), m_wellLogFile());
if (m_eclCase())
{
return RifDataSourceForRftPlt(m_sourceType(), m_eclCase);
}
else if (m_wellLogFile())
{
return RifDataSourceForRftPlt(m_sourceType(), m_wellLogFile);
}
else if (m_ensemble())
{
return RifDataSourceForRftPlt(m_sourceType(), m_ensemble);
}
else if (m_observedFmuRftData())
{
return RifDataSourceForRftPlt(m_sourceType(), m_observedFmuRftData);
}
return RifDataSourceForRftPlt(RifDataSourceForRftPlt::NONE);
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
void RimDataSourceForRftPlt::InitPdmObject()
{
CAF_PDM_InitFieldNoDefault(&m_sourceType, "SourceType", "Source Type", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_eclCase, "EclipseCase", "Eclipse Case", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_wellLogFile, "WellLogFile", "Well Log File", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_ensemble, "Ensemble", "Ensemble", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_observedFmuRftData, "ObservedFmuRftData", "Observed FMU Data", "", "", "");
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
RimDataSourceForRftPlt& RimDataSourceForRftPlt::operator=(const RimDataSourceForRftPlt& other)
{
m_sourceType = other.m_sourceType();
m_eclCase = other.m_eclCase();
m_wellLogFile = other.m_wellLogFile();
m_sourceType = other.m_sourceType();
m_eclCase = other.m_eclCase();
m_wellLogFile = other.m_wellLogFile();
m_ensemble = other.m_ensemble();
m_observedFmuRftData = other.m_observedFmuRftData();
return *this;
}

10
ApplicationCode/ProjectDataModel/Flow/RimDataSourceForRftPlt.h
View File

@@ -34,6 +34,8 @@
#include <QDate>
#include <QMetaType>
class RimObservedFmuRftData;
class RimSummaryCaseCollection;
class RimWellLogFile;
class RimEclipseCase;
@@ -58,7 +60,9 @@ public:
private:
void InitPdmObject();
caf::PdmField<caf::AppEnum<RifDataSourceForRftPlt::SourceType> > m_sourceType;
caf::PdmPtrField<RimEclipseCase*> m_eclCase;
caf::PdmPtrField<RimWellLogFile*> m_wellLogFile;
caf::PdmField<caf::AppEnum<RifDataSourceForRftPlt::SourceType>> m_sourceType;
caf::PdmPtrField<RimEclipseCase*> m_eclCase;
caf::PdmPtrField<RimWellLogFile*> m_wellLogFile;
caf::PdmPtrField<RimSummaryCaseCollection*> m_ensemble;
caf::PdmPtrField<RimObservedFmuRftData*> m_observedFmuRftData;
};

79
ApplicationCode/ProjectDataModel/Flow/RimWellPlotTools.cpp
View File

@@ -30,6 +30,8 @@
#include "RimEclipseCase.h"
#include "RimEclipseResultCase.h"
#include "RimObservedDataCollection.h"
#include "RimObservedFmuRftData.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimSummaryCase.h"
@@ -450,6 +452,39 @@ std::vector<RimSummaryCaseCollection*> RimWellPlotTools::rftEnsembles()
return rftEnsembles;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimObservedFmuRftData*> RimWellPlotTools::observedFmuRftDataForWell(const QString& simWellName)
{
std::vector<RimObservedFmuRftData*> observedDataForWell;
std::vector<RimObservedFmuRftData*> allObservedData = observedFmuRftData();
for (RimObservedFmuRftData* observedData : allObservedData)
{
if (observedData->hasWell(simWellName))
{
observedDataForWell.push_back(observedData);
}
}
return observedDataForWell;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimObservedFmuRftData*> RimWellPlotTools::observedFmuRftData()
{
const RimProject* project = RiaApplication::instance()->project();
RimObservedDataCollection* observedDataCollection =
project->activeOilField() ? project->activeOilField()->observedDataCollection() : nullptr;
if (observedDataCollection)
{
return observedDataCollection->allObservedFmuRftData();
}
return {};
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -542,6 +577,7 @@ RiaRftPltCurveDefinition RimWellPlotTools::curveDefFromCurve(const RimWellLogCur
RimEclipseResultCase* rftCase = dynamic_cast<RimEclipseResultCase*>(rftCurve->eclipseResultCase());
RimSummaryCase* rftSummaryCase = rftCurve->summaryCase();
RimSummaryCaseCollection* rftEnsemble = rftCurve->ensemble();
RimObservedFmuRftData* rftFmuData = rftCurve->observedFmuRftData();
const RifEclipseRftAddress rftAddress = rftCurve->rftAddress();
const QString& wellName = rftAddress.wellName();
@@ -562,6 +598,11 @@ RiaRftPltCurveDefinition RimWellPlotTools::curveDefFromCurve(const RimWellLogCur
return RiaRftPltCurveDefinition(
RifDataSourceForRftPlt(RifDataSourceForRftPlt::ENSEMBLE_RFT, rftEnsemble), wellName, timeStep);
}
else if (rftFmuData != nullptr)
{
return RiaRftPltCurveDefinition(
RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED_FMU_RFT, rftFmuData), wellName, timeStep);
}
}
else if (gridCurve != nullptr)
{
@@ -687,6 +728,21 @@ std::set<RiaRftPltCurveDefinition>
}
}
}
else if (addr.sourceType() == RifDataSourceForRftPlt::OBSERVED_FMU_RFT)
{
RimObservedFmuRftData* observedFmuRftData = addr.observedFmuRftData();
if (observedFmuRftData && observedFmuRftData->rftReader())
{
std::set<QDateTime> timeSteps = observedFmuRftData->rftReader()->availableTimeSteps(simWellName);
for (const QDateTime& time : timeSteps)
{
if (selectedTimeStepSet.count(time))
{
curveDefs.insert(RiaRftPltCurveDefinition(addr, simWellName, time));
}
}
}
}
else if (addr.sourceType() == RifDataSourceForRftPlt::ENSEMBLE_RFT)
{
if (addr.ensemble())
@@ -889,6 +945,7 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
hasGridData = true;
break;
case RifDataSourceForRftPlt::OBSERVED:
case RifDataSourceForRftPlt::OBSERVED_FMU_RFT:
hasObservedData = true;
break;
case RifDataSourceForRftPlt::SUMMARY_RFT:
@@ -914,6 +971,15 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
{
observedTimeStepsWithSources[source.wellLogFile()->date()].insert(source);
}
else if (source.sourceType() == RifDataSourceForRftPlt::OBSERVED_FMU_RFT && source.observedFmuRftData())
{
std::set<QDateTime> rftFmuTimes =
source.observedFmuRftData()->rftReader()->availableTimeSteps(wellPathNameOrSimWellName);
for (const QDateTime& date : rftFmuTimes)
{
observedTimeStepsWithSources[date].insert(source);
}
}
}
}
@@ -996,10 +1062,10 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
{
timeBaseline = &rftTimeStepsWithSources;
}
else if (hasSummaryRftData)
{
else if (hasSummaryRftData)
{
timeBaseline = &summaryRftTimeStepsWithSources;
}
}
else if (hasEnsembleData)
{
timeBaseline = &ensembleTimeStepsWithSources;
@@ -1019,7 +1085,7 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
for (const auto& dateSourceSetPair : gridTimestepsWithSources)
gridTimeSteps.insert(dateSourceSetPair.first);
std::set<QDateTime> summaryRftTimeSteps;
std::set<QDateTime> summaryRftTimeSteps;
for (const auto& dateSourceSetPair : summaryRftTimeStepsWithSources)
summaryRftTimeSteps.insert(dateSourceSetPair.first);
@@ -1056,14 +1122,14 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
timestepsToShowWithSources[time].insert(sourceSet.begin(), sourceSet.end());
}
auto gridTimeSourceSetIt = gridTimestepsWithSources.find(time);
auto gridTimeSourceSetIt = gridTimestepsWithSources.find(time);
if (gridTimeSourceSetIt != gridTimestepsWithSources.end())
{
std::set<RifDataSourceForRftPlt>& sourceSet = gridTimeSourceSetIt->second;
timestepsToShowWithSources[time].insert(sourceSet.begin(), sourceSet.end());
}
auto summaryRftTimeSourceSetIt = summaryRftTimeStepsWithSources.find(time);
auto summaryRftTimeSourceSetIt = summaryRftTimeStepsWithSources.find(time);
if (summaryRftTimeSourceSetIt != summaryRftTimeStepsWithSources.end())
{
std::set<RifDataSourceForRftPlt>& sourceSet = summaryRftTimeSourceSetIt->second;
@@ -1123,6 +1189,7 @@ void RimWellPlotTools::calculateValueOptionsForTimeSteps(
switch (source.sourceType())
{
case RifDataSourceForRftPlt::OBSERVED:
case RifDataSourceForRftPlt::OBSERVED_FMU_RFT:
hasObs = true;
break;
case RifDataSourceForRftPlt::RFT:

3
ApplicationCode/ProjectDataModel/Flow/RimWellPlotTools.h
View File

@@ -33,6 +33,7 @@
class RimEclipseCase;
class RimEclipseResultCase;
class RimObservedFmuRftData;
class RimSummaryCaseCollection;
class RimWellLogCurve;
class RimWellLogFileChannel;
@@ -85,6 +86,8 @@ public:
static std::vector<RimEclipseResultCase*> rftCasesForWell(const QString& simWellName);
static std::vector<RimSummaryCaseCollection*> rftEnsemblesForWell(const QString& simWellName);
static std::vector<RimSummaryCaseCollection*> rftEnsembles();
static std::vector<RimObservedFmuRftData*> observedFmuRftDataForWell(const QString& simWellName);
static std::vector<RimObservedFmuRftData*> observedFmuRftData();
static QString simWellName(const QString& wellPathNameOrSimWellName);
static std::map<QDateTime, std::set<RifDataSourceForRftPlt>>

173
ApplicationCode/ProjectDataModel/Flow/RimWellRftPlot.cpp
View File

@@ -19,8 +19,8 @@
#include "RimWellRftPlot.h"
#include "RiaApplication.h"
#include "RiaColorTools.h"
#include "RiaColorTables.h"
#include "RiaColorTools.h"
#include "RiaDateStringParser.h"
#include "RiaSimWellBranchTools.h"
@@ -35,6 +35,7 @@
#include "RimEclipseCaseCollection.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseResultDefinition.h"
#include "RimObservedFmuRftData.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimSummaryCaseCollection.h"
@@ -144,32 +145,33 @@ void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
RiuQwtPlotCurve::LineStyleEnum currentLineStyle = RiuQwtPlotCurve::STYLE_SOLID;
cvf::Color3f currentColor;
if (newCurveDef.address().sourceType() == RifDataSourceForRftPlt::SUMMARY_RFT)
{
cvf::Color3f currentColor;
if (newCurveDef.address().sourceType() == RifDataSourceForRftPlt::SUMMARY_RFT)
{
RifDataSourceForRftPlt sourceAddress(RifDataSourceForRftPlt::ENSEMBLE_RFT, newCurveDef.address().ensemble());
currentColor = m_dataSourceColors[sourceAddress];
if (m_showStatisticsCurves)
{
cvf::Color3f backgroundColor =
RiaColorTools::fromQColorTo3f(m_wellLogPlot->trackByIndex(0)->viewer()->canvasBackground().color());
currentColor = RiaColorTools::blendCvfColors(backgroundColor, currentColor, 2, 1);
}
}
else
{
if (m_showStatisticsCurves)
{
cvf::Color3f backgroundColor =
RiaColorTools::fromQColorTo3f(m_wellLogPlot->trackByIndex(0)->viewer()->canvasBackground().color());
currentColor = RiaColorTools::blendCvfColors(backgroundColor, currentColor, 2, 1);
}
}
else
{
currentColor = m_dataSourceColors[newCurveDef.address()];
}
}
RiuQwtSymbol::PointSymbolEnum currentSymbol = RiuQwtSymbol::SYMBOL_NONE;
if (newCurveDef.address().sourceType() != RifDataSourceForRftPlt::ENSEMBLE_RFT)
{
if (newCurveDef.address().sourceType() != RifDataSourceForRftPlt::ENSEMBLE_RFT)
{
currentSymbol = m_timeStepSymbols[newCurveDef.timeStep()];
}
}
bool isObservedData = newCurveDef.address().sourceType() == RifDataSourceForRftPlt::OBSERVED ||
newCurveDef.address().sourceType() == RifDataSourceForRftPlt::OBSERVED_FMU_RFT;
// Observed data
currentLineStyle = newCurveDef.address().sourceType() == RifDataSourceForRftPlt::OBSERVED ? RiuQwtPlotCurve::STYLE_NONE
: RiuQwtPlotCurve::STYLE_SOLID;
currentLineStyle = isObservedData ? RiuQwtPlotCurve::STYLE_NONE : RiuQwtPlotCurve::STYLE_SOLID;
newCurve->setColor(currentColor);
newCurve->setSymbolEdgeColor(currentColor);
@@ -253,6 +255,11 @@ void RimWellRftPlot::applyInitialSelections()
}
}
for (RimObservedFmuRftData* const observedFmuRftData : RimWellPlotTools::observedFmuRftData())
{
sourcesToSelect.push_back(RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED_FMU_RFT, observedFmuRftData));
}
m_selectedSources = sourcesToSelect;
{
@@ -402,7 +409,7 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<RiaRftPltCurveDefinition>
// Delete curves
plotTrack->deleteAllCurves();
defineCurveColorsAndSymbols(allCurveDefs);
defineCurveColorsAndSymbols(allCurveDefs);
std::set<RimSummaryCaseCollection*> ensemblesWithSummaryCurves;
@@ -424,6 +431,18 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<RiaRftPltCurveDefinition>
applyCurveAppearance(curve);
}
else if (curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::OBSERVED_FMU_RFT)
{
auto curve = new RimWellLogRftCurve();
plotTrack->addCurve(curve);
auto observedFmuRftData = curveDefToAdd.address().observedFmuRftData();
curve->setObservedFmuRftData(observedFmuRftData);
RifEclipseRftAddress address(simWellName, curveDefToAdd.timeStep(), RifEclipseRftAddress::PRESSURE);
curve->setRftAddress(address);
curve->setZOrder(RiuQwtPlotCurve::Z_SINGLE_CURVE_OBSERVED);
applyCurveAppearance(curve);
}
else if (m_showEnsembleCurves && curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::SUMMARY_RFT)
{
auto curve = new RimWellLogRftCurve();
@@ -621,6 +640,26 @@ const char* RimWellRftPlot::plotNameFormatString()
return PLOT_NAME_QFORMAT_STRING;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellRftPlot::deleteCurvesAssosicatedWithObservedData(const RimObservedFmuRftData* observedFmuRftData)
{
for (auto track : m_wellLogPlot->tracks())
{
auto curves = track->curvesVector();
for (auto curve : curves)
{
RimWellLogRftCurve* rftCurve = dynamic_cast<RimWellLogRftCurve*>(curve);
if (rftCurve && rftCurve->observedFmuRftData() == observedFmuRftData)
{
track->takeOutCurve(rftCurve);
delete rftCurve;
}
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -692,6 +731,22 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions(const caf::P
item.setLevel(1);
options.push_back(item);
}
const std::vector<RimObservedFmuRftData*> observedFmuRftCases = RimWellPlotTools::observedFmuRftDataForWell(simWellName);
if (!observedFmuRftCases.empty())
{
options.push_back(caf::PdmOptionItemInfo::createHeader(
RifDataSourceForRftPlt::sourceTypeUiText(RifDataSourceForRftPlt::OBSERVED_FMU_RFT), true));
for (const auto& observedFmuRftCase : observedFmuRftCases)
{
auto addr = RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED_FMU_RFT, observedFmuRftCase);
auto item = caf::PdmOptionItemInfo(observedFmuRftCase->name(), QVariant::fromValue(addr));
item.setLevel(1);
options.push_back(item);
}
}
}
else if (fieldNeedingOptions == &m_selectedTimeSteps)
{
@@ -881,6 +936,19 @@ void RimWellRftPlot::calculateValueOptionsForWells(QList<caf::PdmOptionItemInfo>
}
}
// Observer FMU RFT wells
const std::vector<RimObservedFmuRftData*> allRftFmuData = RimWellPlotTools::observedFmuRftData();
if (!allRftFmuData.empty())
{
for (RimObservedFmuRftData* rftFmuData : allRftFmuData)
{
for (QString wellName : rftFmuData->wells())
{
wellNames.insert(std::make_pair(wellName, wellName));
}
}
}
for (const auto& wellName : wellNames)
{
options.push_back(caf::PdmOptionItemInfo(wellName.first, wellName.second));
@@ -1014,42 +1082,41 @@ void RimWellRftPlot::defineCurveColorsAndSymbols(const std::set<RiaRftPltCurveDe
{
m_dataSourceColors.clear();
m_timeStepSymbols.clear();
std::vector<cvf::Color3f> colorTable;
std::vector<cvf::Color3f> colorTable;
RiaColorTables::summaryCurveDefaultPaletteColors().color3fArray().toStdVector(&colorTable);
std::vector<RiuQwtSymbol::PointSymbolEnum> symbolTable = {RiuQwtSymbol::SYMBOL_ELLIPSE,
RiuQwtSymbol::SYMBOL_RECT,
RiuQwtSymbol::SYMBOL_DIAMOND,
RiuQwtSymbol::SYMBOL_CROSS,
RiuQwtSymbol::SYMBOL_XCROSS,
RiuQwtSymbol::SYMBOL_STAR1};
std::vector<RiuQwtSymbol::PointSymbolEnum> symbolTable = {RiuQwtSymbol::SYMBOL_ELLIPSE,
RiuQwtSymbol::SYMBOL_RECT,
RiuQwtSymbol::SYMBOL_DIAMOND,
RiuQwtSymbol::SYMBOL_CROSS,
RiuQwtSymbol::SYMBOL_XCROSS,
RiuQwtSymbol::SYMBOL_STAR1};
// Add new curves
for (const RiaRftPltCurveDefinition& curveDefToAdd : allCurveDefs)
{
auto colorTableIndex = m_dataSourceColors.size();
auto symbolTableIndex = m_timeStepSymbols.size();
// Add new curves
for (const RiaRftPltCurveDefinition& curveDefToAdd : allCurveDefs)
{
auto colorTableIndex = m_dataSourceColors.size();
auto symbolTableIndex = m_timeStepSymbols.size();
RifDataSourceForRftPlt address = curveDefToAdd.address();
if (address.sourceType() != RifDataSourceForRftPlt::SUMMARY_RFT)
{
if (!m_dataSourceColors.count(curveDefToAdd.address()))
{
colorTableIndex = colorTableIndex % colorTable.size();
m_dataSourceColors[curveDefToAdd.address()] = colorTable[colorTableIndex];
}
}
RifDataSourceForRftPlt address = curveDefToAdd.address();
if (address.sourceType() != RifDataSourceForRftPlt::ENSEMBLE_RFT)
{
if (!m_timeStepSymbols.count(curveDefToAdd.timeStep()))
{
symbolTableIndex = symbolTableIndex % symbolTable.size();
m_timeStepSymbols[curveDefToAdd.timeStep()] = symbolTable[symbolTableIndex];
}
}
if (address.sourceType() != RifDataSourceForRftPlt::SUMMARY_RFT)
{
if (!m_dataSourceColors.count(curveDefToAdd.address()))
{
colorTableIndex = colorTableIndex % colorTable.size();
m_dataSourceColors[curveDefToAdd.address()] = colorTable[colorTableIndex];
}
}
if (address.sourceType() != RifDataSourceForRftPlt::ENSEMBLE_RFT)
{
if (!m_timeStepSymbols.count(curveDefToAdd.timeStep()))
{
symbolTableIndex = symbolTableIndex % symbolTable.size();
m_timeStepSymbols[curveDefToAdd.timeStep()] = symbolTable[symbolTableIndex];
}
}
}
}

2
ApplicationCode/ProjectDataModel/Flow/RimWellRftPlot.h
View File

@@ -90,6 +90,8 @@ public:
static const char* plotNameFormatString();
void deleteCurvesAssosicatedWithObservedData(const RimObservedFmuRftData* observedFmuRftData);
protected:
// Overridden PDM methods
caf::PdmFieldHandle* userDescriptionField() override

5
ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp
View File

@@ -68,7 +68,7 @@
#include "RimIntersection.h"
#include "RimIntersectionBox.h"
#include "RimIntersectionCollection.h"
#include "RimObservedData.h"
#include "RimObservedSummaryData.h"
#include "RimPerforationCollection.h"
#include "RimPerforationInterval.h"
#include "RimPltPlotCollection.h"
@@ -644,7 +644,7 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
menuBuilder << "RicNewSummaryCrossPlotFeature";
menuBuilder.addSeparator();
if (!dynamic_cast<RimObservedData*>(uiItem))
if (!dynamic_cast<RimObservedSummaryData*>(uiItem))
{
menuBuilder << "RicShowSummaryCurveCalculatorFeature";
//menuBuilder << "RicNewSummaryPlotFeature";
@@ -835,6 +835,7 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
menuBuilder << "RicFlyToObjectFeature";
menuBuilder << "RicImportObservedDataFeature";
menuBuilder << "RicImportObservedFmuDataFeature";
menuBuilder << "RicReloadSummaryCaseFeature";
menuBuilder << "RicCreateSummaryCaseCollectionFeature";
menuBuilder << "Separator";

61
ApplicationCode/ProjectDataModel/Summary/RimObservedDataCollection.cpp → ApplicationCode/ProjectDataModel/RimObservedDataCollection.cpp
View File

@@ -26,7 +26,8 @@
#include "RifKeywordVectorParser.h"
#include "RimObservedData.h"
#include "RimObservedFmuRftData.h"
#include "RimObservedSummaryData.h"
#include "RimCsvUserData.h"
#include "RimObservedEclipseUserData.h"
#include "RimSummaryObservedDataFile.h"
@@ -51,8 +52,9 @@ RimObservedDataCollection::RimObservedDataCollection()
CAF_PDM_InitObject("Observed Data", ":/Folder.png", "", "");
CAF_PDM_InitFieldNoDefault(&m_observedDataArray, "ObservedDataArray", "", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_observedFmuRftArray, "ObservedFmuRftDataArray", "", "", "", "");
m_observedDataArray.uiCapability()->setUiHidden(true);
m_observedFmuRftArray.uiCapability()->setUiHidden(true);
}
//--------------------------------------------------------------------------------------------------
@@ -61,25 +63,43 @@ RimObservedDataCollection::RimObservedDataCollection()
RimObservedDataCollection::~RimObservedDataCollection()
{
m_observedDataArray.deleteAllChildObjects();
m_observedFmuRftArray.deleteAllChildObjects();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimObservedDataCollection::removeObservedData(RimObservedData* observedData)
void RimObservedDataCollection::removeObservedSummaryData(RimObservedSummaryData* observedData)
{
m_observedDataArray.removeChildObject(observedData);
caf::PdmUiObjectEditorHandle::updateUiAllObjectEditors();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimObservedDataCollection::removeObservedFmuRftData(RimObservedFmuRftData* observedFmuRftData)
{
m_observedFmuRftArray.removeChildObject(observedFmuRftData);
caf::PdmUiObjectEditorHandle::updateUiAllObjectEditors();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimObservedData*> RimObservedDataCollection::allObservedData()
std::vector<RimObservedSummaryData*> RimObservedDataCollection::allObservedSummaryData() const
{
return m_observedDataArray.childObjects();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimObservedFmuRftData*> RimObservedDataCollection::allObservedFmuRftData() const
{
return m_observedFmuRftArray.childObjects();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -100,7 +120,7 @@ bool RimObservedDataCollection::fileExists(const QString& fileName, QString* err
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void updateNewSummaryObjectCreated(caf::PdmObject* object)
void updateNewObservedDataCreated(caf::PdmObject* object)
{
RiuPlotMainWindowTools::showPlotMainWindow();
RiuPlotMainWindowTools::selectAsCurrentItem(object);
@@ -115,11 +135,11 @@ void updateNewSummaryObjectCreated(caf::PdmObject* object)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimObservedData* RimObservedDataCollection::createAndAddRsmObservedDataFromFile(const QString& fileName, QString* errorText /*= nullptr*/)
RimObservedSummaryData* RimObservedDataCollection::createAndAddRsmObservedSummaryDataFromFile(const QString& fileName, QString* errorText /*= nullptr*/)
{
if (!fileExists(fileName, errorText)) return nullptr;
RimObservedData* observedData = nullptr;
RimObservedSummaryData* observedData = nullptr;
RimObservedEclipseUserData* columnBasedUserData = new RimObservedEclipseUserData();
observedData = columnBasedUserData;
@@ -134,7 +154,7 @@ RimObservedData* RimObservedDataCollection::createAndAddRsmObservedDataFromFile(
errorText->append(observedData->errorMessagesFromReader());
}
updateNewSummaryObjectCreated(observedData);
updateNewObservedDataCreated(observedData);
this->updateConnectedEditors();
@@ -144,11 +164,11 @@ RimObservedData* RimObservedDataCollection::createAndAddRsmObservedDataFromFile(
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimObservedData* RimObservedDataCollection::createAndAddCvsObservedDataFromFile(const QString& fileName, bool useSavedFieldsValuesInDialog, QString* errorText /*= nullptr*/)
RimObservedSummaryData* RimObservedDataCollection::createAndAddCvsObservedSummaryDataFromFile(const QString& fileName, bool useSavedFieldsValuesInDialog, QString* errorText /*= nullptr*/)
{
if (!fileExists(fileName, errorText)) return nullptr;
RimObservedData* observedData = nullptr;
RimObservedSummaryData* observedData = nullptr;
RimCsvUserData* userData = new RimCsvUserData();
RicPasteAsciiDataToSummaryPlotFeatureUi* parseOptions = userData->parseOptions();
@@ -192,9 +212,28 @@ RimObservedData* RimObservedDataCollection::createAndAddCvsObservedDataFromFile(
return nullptr;
}
updateNewSummaryObjectCreated(observedData);
updateNewObservedDataCreated(observedData);
this->updateConnectedEditors();
return observedData;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimObservedFmuRftData* RimObservedDataCollection::createAndAddFmuRftDataFromPath(const QString& directoryPath)
{
QString name = QString("Imported FMU RFT Data %1").arg(m_observedFmuRftArray.size() + 1);
RimObservedFmuRftData* fmuRftData = new RimObservedFmuRftData;
fmuRftData->setDirectoryPath(directoryPath);
fmuRftData->createRftReaderInterface();
fmuRftData->setName(name);
m_observedFmuRftArray.push_back(fmuRftData);
updateNewObservedDataCreated(fmuRftData);
this->updateConnectedEditors();
return fmuRftData;
}

17
ApplicationCode/ProjectDataModel/Summary/RimObservedDataCollection.h → ApplicationCode/ProjectDataModel/RimObservedDataCollection.h
View File

@@ -21,7 +21,8 @@
#include "cafPdmObject.h"
#include "cafPdmChildArrayField.h"
class RimObservedData;
class RimObservedFmuRftData;
class RimObservedSummaryData;
class QFile;
//--------------------------------------------------------------------------------------------------
@@ -35,14 +36,18 @@ public:
RimObservedDataCollection();
~RimObservedDataCollection() override;
void removeObservedData(RimObservedData* observedData);
RimObservedData* createAndAddRsmObservedDataFromFile(const QString& fileName, QString* errorText = nullptr);
RimObservedData* createAndAddCvsObservedDataFromFile(const QString& fileName, bool useSavedFieldsValuesInDialog, QString* errorText = nullptr);
std::vector<RimObservedData*> allObservedData();
void removeObservedSummaryData(RimObservedSummaryData* observedSummaryData);
void removeObservedFmuRftData(RimObservedFmuRftData* observedFmuRftData);
RimObservedSummaryData* createAndAddRsmObservedSummaryDataFromFile(const QString& fileName, QString* errorText = nullptr);
RimObservedSummaryData* createAndAddCvsObservedSummaryDataFromFile(const QString& fileName, bool useSavedFieldsValuesInDialog, QString* errorText = nullptr);
RimObservedFmuRftData* createAndAddFmuRftDataFromPath(const QString& directoryPath);
std::vector<RimObservedSummaryData*> allObservedSummaryData() const;
std::vector<RimObservedFmuRftData*> allObservedFmuRftData() const;
private:
bool fileExists(const QString& fileName, QString* errorText = nullptr);
private:
caf::PdmChildArrayField<RimObservedData*> m_observedDataArray;
caf::PdmChildArrayField<RimObservedSummaryData*> m_observedDataArray;
caf::PdmChildArrayField<RimObservedFmuRftData*> m_observedFmuRftArray;
};

95
ApplicationCode/ProjectDataModel/RimObservedFmuRftData.cpp Normal file
View File

@@ -0,0 +1,95 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2019- 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 "RimObservedFmuRftData.h"
//==================================================================================================
//
//
//
//==================================================================================================
CAF_PDM_SOURCE_INIT(RimObservedFmuRftData, "ObservedFmuRftData");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimObservedFmuRftData::RimObservedFmuRftData()
{
CAF_PDM_InitObject("Observed FMU Data", ":/ObservedRFTDataFile16x16.png", "", "");
CAF_PDM_InitFieldNoDefault(&m_directoryPath, "Directory", "Directory", "", "", "");
m_directoryPath.uiCapability()->setUiReadOnly(true);
CAF_PDM_InitFieldNoDefault(&m_wells, "Wells", "Wells", "", "", "");
m_wells.xmlCapability()->disableIO();
m_wells.uiCapability()->setUiReadOnly(true);
m_wells.registerGetMethod(this, &RimObservedFmuRftData::wells);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimObservedFmuRftData::setDirectoryPath(const QString& path)
{
m_directoryPath = path;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimObservedFmuRftData::createRftReaderInterface()
{
m_fmuRftReader = new RifReaderFmuRft(m_directoryPath);
m_fmuRftReader->load();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifReaderRftInterface* RimObservedFmuRftData::rftReader()
{
if (m_fmuRftReader.isNull())
{
createRftReaderInterface();
}
return m_fmuRftReader.p();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimObservedFmuRftData::hasWell(const QString& simWellName) const
{
std::vector<QString> allWells = wells();
for (const QString& well : allWells)
{
if (well == simWellName)
{
return true;
}
}
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<QString> RimObservedFmuRftData::wells() const
{
std::set<QString> wellNames = const_cast<RifReaderFmuRft*>(m_fmuRftReader.p())->wellNames();
return std::vector<QString>(wellNames.begin(), wellNames.end());
}

48
ApplicationCode/ProjectDataModel/RimObservedFmuRftData.h Normal file
View File

@@ -0,0 +1,48 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2019- 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.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RimNamedObject.h"
#include "RifReaderFmuRft.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "cafPdmProxyValueField.h"
class RimObservedFmuRftData : public RimNamedObject
{
CAF_PDM_HEADER_INIT;
public:
RimObservedFmuRftData();
void setDirectoryPath(const QString& path);
void createRftReaderInterface();
RifReaderRftInterface* rftReader();
bool hasWell(const QString& simWellName) const;
std::vector<QString> wells() const;
private:
cvf::ref<RifReaderFmuRft> m_fmuRftReader;
caf::PdmField<QString> m_directoryPath;
caf::PdmProxyValueField<std::vector<QString>> m_wells;
};

4
ApplicationCode/ProjectDataModel/RimOilField.cpp
View File

@@ -27,7 +27,7 @@
#include "RimFractureTemplateCollection.h"
#include "RimValveTemplateCollection.h"
#include "RimGeoMechModels.h"
#include "RimObservedData.h"
#include "RimObservedSummaryData.h"
#include "RimObservedDataCollection.h"
#include "RimSummaryCase.h"
#include "RimSummaryCaseMainCollection.h"
@@ -121,7 +121,7 @@ QString RimOilField::uniqueShortNameForCase(RimSummaryCase* summaryCase)
std::set<QString> allAutoShortNames;
std::vector<RimSummaryCase*> allCases = summaryCaseMainCollection->allSummaryCases();
std::vector<RimObservedData*> observedDataCases = observedDataCollection->allObservedData();
std::vector<RimObservedSummaryData*> observedDataCases = observedDataCollection->allObservedSummaryData();
for (auto observedData : observedDataCases)
{

6
ApplicationCode/ProjectDataModel/RimProject.cpp
View File

@@ -54,7 +54,7 @@
#include "RimIdenticalGridCaseGroup.h"
#include "RimMainPlotCollection.h"
#include "RimMeasurement.h"
#include "RimObservedData.h"
#include "RimObservedSummaryData.h"
#include "RimObservedDataCollection.h"
#include "RimOilField.h"
#include "RimPltPlotCollection.h"
@@ -544,9 +544,9 @@ std::vector<RimSummaryCase*> RimProject::allSummaryCases() const
}
auto observedDataColl = oilField->observedDataCollection();
if (observedDataColl != nullptr && observedDataColl->allObservedData().size() > 0)
if (observedDataColl != nullptr && observedDataColl->allObservedSummaryData().size() > 0)
{
auto observedData = observedDataColl->allObservedData();
auto observedData = observedDataColl->allObservedSummaryData();
sumCases.insert(sumCases.end(), observedData.begin(), observedData.end());
}
}

2
ApplicationCode/ProjectDataModel/RimProject.h
View File

@@ -49,7 +49,7 @@ class RimIdenticalGridCaseGroup;
class RimMainPlotCollection;
class RimMeasurement;
class RimAdvancedSnapshotExportDefinition;
class RimObservedData;
class RimObservedSummaryData;
class RimOilField;
class RimScriptCollection;
class RimSummaryCase;

8
ApplicationCode/ProjectDataModel/RimWellLogPlot.cpp
View File

@@ -329,6 +329,14 @@ size_t RimWellLogPlot::firstVisibleTrackIndex() const
return std::numeric_limits<size_t>::max();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimWellLogTrack*> RimWellLogPlot::tracks() const
{
return m_tracks.childObjects();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/ProjectDataModel/RimWellLogPlot.h
View File

@@ -94,7 +94,7 @@ public:
size_t trackIndex(const RimWellLogTrack* track) const;
RimWellLogTrack* trackByIndex(size_t index);
size_t firstVisibleTrackIndex() const;
std::vector<RimWellLogTrack*> tracks() const;
void updateTracks(bool autoScaleXAxis = false);
void updateTrackNames();

46
ApplicationCode/ProjectDataModel/RimWellLogRftCurve.cpp
View File

@@ -35,6 +35,7 @@
#include "RimEclipseResultCase.h"
#include "RimMainPlotCollection.h"
#include "RimObservedFmuRftData.h"
#include "RimProject.h"
#include "RimSummaryCase.h"
#include "RimSummaryCaseCollection.h"
@@ -100,6 +101,9 @@ RimWellLogRftCurve::RimWellLogRftCurve()
CAF_PDM_InitFieldNoDefault(&m_ensemble, "CurveEnsemble", "Ensemble", "", "", "");
m_ensemble.uiCapability()->setUiTreeChildrenHidden(true);
CAF_PDM_InitFieldNoDefault(&m_observedFmuRftData, "ObservedFmuRftData", "Observed FMU RFT Data", "", "", "");
m_observedFmuRftData.uiCapability()->setUiTreeChildrenHidden(true);
CAF_PDM_InitFieldNoDefault(&m_timeStep, "TimeStep", "Time Step", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_wellName, "WellName", "Well Name", "", "", "");
@@ -186,6 +190,23 @@ RimSummaryCaseCollection* RimWellLogRftCurve::ensemble() const
return m_ensemble;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogRftCurve::setObservedFmuRftData(RimObservedFmuRftData* observedFmuRftData)
{
m_observedFmuRftData = observedFmuRftData;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimObservedFmuRftData* RimWellLogRftCurve::observedFmuRftData() const
{
return m_observedFmuRftData;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -316,6 +337,10 @@ QString RimWellLogRftCurve::createCurveAutoName()
{
name.push_back(m_summaryCase->caseName());
}
else if (m_observedFmuRftData)
{
name.push_back(m_observedFmuRftData->name());
}
if (wellLogChannelName() != caf::AppEnum<RifEclipseRftAddress::RftWellLogChannelType>::text(RifEclipseRftAddress::NONE))
{
RifEclipseRftAddress::RftWellLogChannelType channelNameEnum =
@@ -369,6 +394,11 @@ void RimWellLogRftCurve::onLoadDataAndUpdate(bool updateParentPlot)
else if (m_ensemble)
{
unitSystem = m_ensemble->unitSystem();
}
else if (m_observedFmuRftData)
{
// TODO: Read unit system somewhere for FMU RFT Data
unitSystem = RiaEclipseUnitTools::UNITS_METRIC;
}
else
{
@@ -600,6 +630,10 @@ RifReaderRftInterface* RimWellLogRftCurve::rftReader() const
{
return m_ensemble()->rftStatisticsReader();
}
else if (m_observedFmuRftData())
{
return m_observedFmuRftData()->rftReader();
}
return nullptr;
}
@@ -801,6 +835,18 @@ std::vector<double> RimWellLogRftCurve::tvDepthValues()
//--------------------------------------------------------------------------------------------------
std::vector<double> RimWellLogRftCurve::measuredDepthValues()
{
if (m_observedFmuRftData)
{
RifReaderRftInterface* reader = rftReader();
std::vector<double> values;
if (!reader) return values;
RifEclipseRftAddress depthAddress(m_wellName(), m_timeStep, RifEclipseRftAddress::MD);
reader->values(depthAddress, &values);
return values;
}
std::vector<double> measuredDepthForCells;
RigEclipseWellLogExtractor* eclExtractor = extractor();

8
ApplicationCode/ProjectDataModel/RimWellLogRftCurve.h
View File

@@ -34,6 +34,7 @@
class RifReaderRftInterface;
class RigEclipseWellLogExtractor;
class RimEclipseResultCase;
class RimObservedFmuRftData;
class RimSummaryCase;
class RimSummaryCaseCollection;
class RimWellPath;
@@ -59,8 +60,11 @@ public:
void setSummaryCase(RimSummaryCase* summaryCase);
RimSummaryCase* summaryCase() const;
void setEnsemble(RimSummaryCaseCollection* ensemble);
void setEnsemble(RimSummaryCaseCollection* ensemble);
RimSummaryCaseCollection* ensemble() const;
void setObservedFmuRftData(RimObservedFmuRftData* observedFmuRftData);
RimObservedFmuRftData* observedFmuRftData() const;
void setRftAddress(RifEclipseRftAddress address);
RifEclipseRftAddress rftAddress() const;
@@ -97,6 +101,7 @@ private:
caf::PdmPtrField<RimEclipseResultCase*> m_eclipseResultCase;
caf::PdmPtrField<RimSummaryCase*> m_summaryCase;
caf::PdmPtrField<RimSummaryCaseCollection*> m_ensemble;
caf::PdmPtrField<RimObservedFmuRftData*> m_observedFmuRftData;
caf::PdmField<QDateTime> m_timeStep;
caf::PdmField<QString> m_wellName;
caf::PdmField<int> m_branchIndex;
@@ -105,4 +110,5 @@ private:
std::map<size_t, size_t> m_idxInWellPathToIdxInRftFile;
bool m_isUsingPseudoLength;
caf::PdmField<caf::AppEnum<RifEclipseRftAddress::RftWellLogChannelType>> m_wellLogChannelName;
};

6
ApplicationCode/ProjectDataModel/Summary/CMakeLists_files.cmake
View File

@@ -17,8 +17,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimSummaryPlot.h
${CMAKE_CURRENT_LIST_DIR}/RimSummaryPlotCollection.h
${CMAKE_CURRENT_LIST_DIR}/RimSummaryCrossPlotCollection.h
${CMAKE_CURRENT_LIST_DIR}/RimSummaryTimeAxisProperties.h
${CMAKE_CURRENT_LIST_DIR}/RimObservedData.h
${CMAKE_CURRENT_LIST_DIR}/RimObservedDataCollection.h
${CMAKE_CURRENT_LIST_DIR}/RimObservedSummaryData.h
${CMAKE_CURRENT_LIST_DIR}/RimSummaryObservedDataFile.h
${CMAKE_CURRENT_LIST_DIR}/RimObservedEclipseUserData.h
${CMAKE_CURRENT_LIST_DIR}/RimCalculatedSummaryCase.h
@@ -57,8 +56,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimSummaryPlot.cpp
${CMAKE_CURRENT_LIST_DIR}/RimSummaryPlotCollection.cpp
${CMAKE_CURRENT_LIST_DIR}/RimSummaryCrossPlotCollection.cpp
${CMAKE_CURRENT_LIST_DIR}/RimSummaryTimeAxisProperties.cpp
${CMAKE_CURRENT_LIST_DIR}/RimObservedData.cpp
${CMAKE_CURRENT_LIST_DIR}/RimObservedDataCollection.cpp
${CMAKE_CURRENT_LIST_DIR}/RimObservedSummaryData.cpp
${CMAKE_CURRENT_LIST_DIR}/RimSummaryObservedDataFile.cpp
${CMAKE_CURRENT_LIST_DIR}/RimObservedEclipseUserData.cpp
${CMAKE_CURRENT_LIST_DIR}/RimCalculatedSummaryCase.cpp

4
ApplicationCode/ProjectDataModel/Summary/RimCsvUserData.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RimObservedData.h"
#include "RimObservedSummaryData.h"
#include "../../Commands/SummaryPlotCommands/RicPasteAsciiDataToSummaryPlotFeatureUi.h"
@@ -32,7 +32,7 @@ class RifSummaryReaderInterface;
//==================================================================================================
//
//==================================================================================================
class RimCsvUserData : public RimObservedData
class RimCsvUserData : public RimObservedSummaryData
{
CAF_PDM_HEADER_INIT;
public:

1
ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSet.cpp
View File

@@ -175,6 +175,7 @@ RimEnsembleCurveSet::RimEnsembleCurveSet()
m_ensembleStatCase.reset(new RimEnsembleStatisticsCase(this));
m_ensembleStatCase->createSummaryReaderInterface();
m_ensembleStatCase->createRftReaderInterface();
m_disableStatisticCurves = false;
m_isCurveSetFiltered = false;

7
ApplicationCode/ProjectDataModel/Summary/RimFileSummaryCase.cpp
View File

@@ -87,6 +87,13 @@ void RimFileSummaryCase::updateFilePathsFromProjectPath(const QString & newProje
void RimFileSummaryCase::createSummaryReaderInterface()
{
m_summaryFileReader = RimFileSummaryCase::findRelatedFilesAndCreateReader(this->summaryHeaderFilename(), m_includeRestartFiles);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFileSummaryCase::createRftReaderInterface()
{
m_summaryEclipseRftReader = RimFileSummaryCase::findRftDataAndCreateReader(this->summaryHeaderFilename());
if (m_summaryEclipseRftReader.notNull())
{

1
ApplicationCode/ProjectDataModel/Summary/RimFileSummaryCase.h
View File

@@ -43,6 +43,7 @@ public:
void updateFilePathsFromProjectPath(const QString& newProjectPath, const QString& oldProjectPath) override;
void createSummaryReaderInterface() override;
void createRftReaderInterface() override;
RifSummaryReaderInterface* summaryReader() override;
RifReaderRftInterface* rftReader() override;

4
ApplicationCode/ProjectDataModel/Summary/RimObservedEclipseUserData.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RimObservedData.h"
#include "RimObservedSummaryData.h"
#include "cafPdmObject.h"
#include "cafPdmField.h"
@@ -29,7 +29,7 @@ class RifSummaryReaderInterface;
//==================================================================================================
//
//==================================================================================================
class RimObservedEclipseUserData : public RimObservedData
class RimObservedEclipseUserData : public RimObservedSummaryData
{
CAF_PDM_HEADER_INIT;
public:

22
ApplicationCode/ProjectDataModel/Summary/RimObservedData.cpp → ApplicationCode/ProjectDataModel/Summary/RimObservedSummaryData.cpp
View File

@@ -16,7 +16,7 @@
//
/////////////////////////////////////////////////////////////////////////////////
#include "RimObservedData.h"
#include "RimObservedSummaryData.h"
#include "RifSummaryReaderInterface.h"
#include "RimTools.h"
@@ -25,12 +25,12 @@
#include <QFileInfo>
CAF_PDM_ABSTRACT_SOURCE_INIT(RimObservedData, "ObservedData");
CAF_PDM_ABSTRACT_SOURCE_INIT(RimObservedSummaryData, "ObservedData");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimObservedData::RimObservedData()
RimObservedSummaryData::RimObservedSummaryData()
{
m_isObservedData = true;
@@ -50,7 +50,7 @@ RimObservedData::RimObservedData()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimObservedData::caseName() const
QString RimObservedSummaryData::caseName() const
{
QFileInfo caseFileName(this->summaryHeaderFilename());
@@ -60,7 +60,7 @@ QString RimObservedData::caseName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimObservedData::updateFilePathsFromProjectPath(const QString & newProjectPath, const QString & oldProjectPath)
void RimObservedSummaryData::updateFilePathsFromProjectPath(const QString & newProjectPath, const QString & oldProjectPath)
{
m_summaryHeaderFilename = RimTools::relocateFile(m_summaryHeaderFilename(), newProjectPath, oldProjectPath, nullptr, nullptr);
}
@@ -68,7 +68,7 @@ void RimObservedData::updateFilePathsFromProjectPath(const QString & newProjectP
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimObservedData::identifierName() const
QString RimObservedSummaryData::identifierName() const
{
return m_identifierName();
}
@@ -76,7 +76,7 @@ QString RimObservedData::identifierName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress::SummaryVarCategory RimObservedData::summaryCategory() const
RifEclipseSummaryAddress::SummaryVarCategory RimObservedSummaryData::summaryCategory() const
{
return m_summaryCategory();
}
@@ -84,7 +84,7 @@ RifEclipseSummaryAddress::SummaryVarCategory RimObservedData::summaryCategory()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimObservedData::updateMetaData()
void RimObservedSummaryData::updateMetaData()
{
std::string metaDataString;
@@ -104,7 +104,7 @@ void RimObservedData::updateMetaData()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimObservedData::customWellName() const
QString RimObservedSummaryData::customWellName() const
{
if (m_useCustomIdentifier() && m_summaryCategory() == RifEclipseSummaryAddress::SUMMARY_WELL)
{
@@ -117,7 +117,7 @@ QString RimObservedData::customWellName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> RimObservedData::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly)
QList<caf::PdmOptionItemInfo> RimObservedSummaryData::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly)
{
if (fieldNeedingOptions == &m_summaryCategory)
{
@@ -136,7 +136,7 @@ QList<caf::PdmOptionItemInfo> RimObservedData::calculateValueOptions(const caf::
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimObservedData::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
void RimObservedSummaryData::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
if (changedField == &m_useCustomIdentifier ||
changedField == &m_summaryCategory ||

35
ApplicationCode/ProjectDataModel/Summary/RimObservedData.h → ApplicationCode/ProjectDataModel/Summary/RimObservedSummaryData.h
View File

@@ -1,17 +1,17 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2017- Statoil ASA
//
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
@@ -26,35 +26,36 @@
#include "cafPdmObject.h"
#include "cvfObject.h"
//==================================================================================================
//
//==================================================================================================
class RimObservedData : public RimSummaryCase
class RimObservedSummaryData : public RimSummaryCase
{
CAF_PDM_HEADER_INIT;
public:
RimObservedData();
QString caseName() const override;
void updateFilePathsFromProjectPath(const QString& newProjectPath, const QString& oldProjectPath) override;
public:
RimObservedSummaryData();
QString caseName() const override;
void updateFilePathsFromProjectPath(const QString& newProjectPath, const QString& oldProjectPath) override;
QString identifierName() const;
RifEclipseSummaryAddress::SummaryVarCategory summaryCategory() const;
void updateMetaData();
void updateMetaData();
protected:
QString customWellName() const;
QString customWellName() const;
private:
QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly) override;
QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions,
bool* useOptionsOnly) override;
void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
private:
caf::PdmField<caf::AppEnum<RifEclipseSummaryAddress::SummaryVarCategory> > m_summaryCategory;
caf::PdmField<QString> m_identifierName;
caf::PdmField<bool> m_useCustomIdentifier;
caf::PdmField<caf::AppEnum<RifEclipseSummaryAddress::SummaryVarCategory>> m_summaryCategory;
caf::PdmField<QString> m_identifierName;
caf::PdmField<bool> m_useCustomIdentifier;
caf::PdmField<QString> m_importedSummaryData;
caf::PdmField<QString> m_importedSummaryData;
};

1
ApplicationCode/ProjectDataModel/Summary/RimSummaryCase.h
View File

@@ -52,6 +52,7 @@ public:
void updateOptionSensitivity();
virtual void createSummaryReaderInterface() = 0;
virtual void createRftReaderInterface() {}
virtual RifSummaryReaderInterface* summaryReader() = 0;
virtual RifReaderRftInterface* rftReader();
virtual QString errorMessagesFromReader() { return QString(); }

1
ApplicationCode/ProjectDataModel/Summary/RimSummaryCaseMainCollection.cpp
View File

@@ -351,6 +351,7 @@ void RimSummaryCaseMainCollection::loadSummaryCaseData(std::vector<RimSummaryCas
if (sumCase)
{
sumCase->createSummaryReaderInterface();
sumCase->createRftReaderInterface();
addCaseRealizationParametersIfFound(*sumCase, sumCase->summaryHeaderFilename());
}

4
ApplicationCode/ProjectDataModel/Summary/RimSummaryObservedDataFile.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RimObservedData.h"
#include "RimObservedSummaryData.h"
#include "cafPdmObject.h"
#include "cafPdmField.h"
@@ -29,7 +29,7 @@ class RifReaderObservedData;
//==================================================================================================
//
//==================================================================================================
class RimSummaryObservedDataFile : public RimObservedData
class RimSummaryObservedDataFile : public RimObservedSummaryData
{
CAF_PDM_HEADER_INIT;
public:

BIN
ApplicationCode/Resources/ObservedRFTDataFile16x16.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.2 KiB

1
ApplicationCode/Resources/ResInsight.qrc
View File

@@ -80,6 +80,7 @@
<file>SummaryXPlotsLight16x16.png</file>
<file>ObservedDataFile16x16.png</file>
<file>ObservedRSMDataFile16x16.png</file>
<file>ObservedRFTDataFile16x16.png</file>
<file>ObservedCSVDataFile16x16.png</file>
<file>FormationCollection16x16.png</file>
<file>Formations16x16.png</file>

1
ApplicationCode/UserInterface/RiuMainWindow.cpp
View File

@@ -448,6 +448,7 @@ void RiuMainWindow::createMenus()
importMenu->addSeparator();
importMenu->addAction(cmdFeatureMgr->action("RicImportObservedDataInMenuFeature"));
importMenu->addAction(cmdFeatureMgr->action("RicImportObservedFmuDataInMenuFeature"));
importMenu->addAction(cmdFeatureMgr->action("RicImportFormationNamesFeature"));
QMenu* exportMenu = fileMenu->addMenu("&Export");

1
ApplicationCode/UserInterface/RiuPlotMainWindow.cpp
View File

@@ -250,6 +250,7 @@ void RiuPlotMainWindow::createMenus()
importMenu->addSeparator();
importMenu->addAction(cmdFeatureMgr->action("RicImportObservedDataInMenuFeature"));
importMenu->addAction(cmdFeatureMgr->action("RicImportObservedFmuDataInMenuFeature"));
importMenu->addAction(cmdFeatureMgr->action("RicImportFormationNamesFeature"));
QMenu* exportMenu = fileMenu->addMenu("&Export");

8
ApplicationCode/UserInterface/RiuSummaryCurveDefSelection.cpp
View File

@@ -27,7 +27,7 @@
#include "RifSummaryReaderInterface.h"
#include "RimCalculatedSummaryCase.h"
#include "RimObservedData.h"
#include "RimObservedSummaryData.h"
#include "RimObservedDataCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
@@ -634,11 +634,11 @@ QList<caf::PdmOptionItemInfo> RiuSummaryCurveDefSelection::calculateValueOptions
// Observed data
auto observedDataColl = oilField->observedDataCollection();
if (observedDataColl->allObservedData().size() > 0)
if (observedDataColl->allObservedSummaryData().size() > 0)
{
options.push_back(caf::PdmOptionItemInfo::createHeader("Observed Data", true));
for (const auto& obsData : observedDataColl->allObservedData())
for (const auto& obsData : observedDataColl->allObservedSummaryData())
{
auto optionItem = caf::PdmOptionItemInfo(obsData->caseName(), obsData);
optionItem.setLevel(1);
@@ -1234,7 +1234,7 @@ void RiuSummaryCurveDefSelection::resetAllFields()
//--------------------------------------------------------------------------------------------------
bool RiuSummaryCurveDefSelection::isObservedData(const RimSummaryCase *sumCase) const
{
return dynamic_cast<const RimObservedData*>(sumCase) != nullptr;
return dynamic_cast<const RimObservedSummaryData*>(sumCase) != nullptr;
}
//--------------------------------------------------------------------------------------------------