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

#1948 PLT plot. Prepare for saving PLT plot editor selections to project file

Browse Source
This commit is contained in:
Bjørn Erik Jensen 2017-10-26 10:35:23 +02:00
parent fcefa1e55b
commit cb78ad8c31
11 changed files with 453 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ApplicationCode/FileInterface/CMakeLists_files.cmake
View File

@ -34,6 +34,8 @@ ${CEE_CURRENT_LIST_DIR}RifWellPathImporter.h
${CEE_CURRENT_LIST_DIR}RifHdf5ReaderInterface.h ${CEE_CURRENT_LIST_DIR}RifHdf5ReaderInterface.h
${CEE_CURRENT_LIST_DIR}RifColumnBasedUserData.h ${CEE_CURRENT_LIST_DIR}RifColumnBasedUserData.h
${CEE_CURRENT_LIST_DIR}RifKeywordVectorUserData.h ${CEE_CURRENT_LIST_DIR}RifKeywordVectorUserData.h
${CEE_CURRENT_LIST_DIR}RifWellRftAddress.h
${CEE_CURRENT_LIST_DIR}RifWellRftAddressQMetaType.h
# HDF5 file reader is directly included in ResInsight main CmakeList.txt # HDF5 file reader is directly included in ResInsight main CmakeList.txt
#${CEE_CURRENT_LIST_DIR}RifHdf5Reader.h #${CEE_CURRENT_LIST_DIR}RifHdf5Reader.h
@ -74,6 +76,7 @@ ${CEE_CURRENT_LIST_DIR}RifWellPathImporter.cpp
${CEE_CURRENT_LIST_DIR}RifHdf5ReaderInterface.cpp ${CEE_CURRENT_LIST_DIR}RifHdf5ReaderInterface.cpp
${CEE_CURRENT_LIST_DIR}RifColumnBasedUserData.cpp ${CEE_CURRENT_LIST_DIR}RifColumnBasedUserData.cpp
${CEE_CURRENT_LIST_DIR}RifKeywordVectorUserData.cpp ${CEE_CURRENT_LIST_DIR}RifKeywordVectorUserData.cpp
${CEE_CURRENT_LIST_DIR}RifWellRftAddress.cpp
# HDF5 file reader is directly included in ResInsight main CmakeList.txt # HDF5 file reader is directly included in ResInsight main CmakeList.txt

46
ApplicationCode/ProjectDataModel/Flow/RimWellRftAddress.cpp → ApplicationCode/FileInterface/RifWellRftAddress.cpp
View File

@ -16,7 +16,7 @@
// //
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
#include "RimWellRftAddress.h" #include "RifWellRftAddress.h"
#include "RimEclipseCase.h" #include "RimEclipseCase.h"
#include "RimWellLogFile.h" #include "RimWellLogFile.h"
@ -25,32 +25,20 @@
#include <QString> #include <QString>
#include <QTextStream> #include <QTextStream>
namespace caf
{
template<>
void caf::AppEnum<RftSourceType>::setUp()
{
addItem(RftSourceType::RFT, "RFT", "RFT Cases");
addItem(RftSourceType::GRID, "GRID", "Grid Cases");
addItem(RftSourceType::OBSERVED, "OBSERVED", "Observed Data");
setDefault(RftSourceType::NONE);
}
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimWellRftAddress::RimWellRftAddress() : m_sourceType(RftSourceType::NONE) RifWellRftAddress::RifWellRftAddress() : m_sourceType(SourceType::NONE)
{ {
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimWellRftAddress::RimWellRftAddress(RftSourceType sourceType, RimEclipseCase* eclCase) RifWellRftAddress::RifWellRftAddress(SourceType sourceType, RimEclipseCase* eclCase)
{ {
CVF_ASSERT(sourceType == RftSourceType::RFT || sourceType == RftSourceType::GRID); CVF_ASSERT(sourceType == SourceType::RFT || sourceType == SourceType::GRID);
CVF_ASSERT(eclCase != nullptr); CVF_ASSERT(eclCase != nullptr);
m_sourceType = sourceType; m_sourceType = sourceType;
@ -60,9 +48,9 @@ RimWellRftAddress::RimWellRftAddress(RftSourceType sourceType, RimEclipseCase* e
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimWellRftAddress::RimWellRftAddress(RftSourceType sourceType, RimWellLogFile* wellLogFile) RifWellRftAddress::RifWellRftAddress(SourceType sourceType, RimWellLogFile* wellLogFile)
{ {
CVF_ASSERT(sourceType == RftSourceType::OBSERVED); CVF_ASSERT(sourceType == SourceType::OBSERVED);
m_sourceType = sourceType; m_sourceType = sourceType;
m_wellLogFile = wellLogFile; m_wellLogFile = wellLogFile;
@ -71,7 +59,7 @@ RimWellRftAddress::RimWellRftAddress(RftSourceType sourceType, RimWellLogFile* w
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RftSourceType RimWellRftAddress::sourceType() const RifWellRftAddress::SourceType RifWellRftAddress::sourceType() const
{ {
return m_sourceType; return m_sourceType;
} }
@ -79,7 +67,7 @@ RftSourceType RimWellRftAddress::sourceType() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimEclipseCase* RimWellRftAddress::eclCase() const RimEclipseCase* RifWellRftAddress::eclCase() const
{ {
return m_eclCase; return m_eclCase;
} }
@ -87,7 +75,7 @@ RimEclipseCase* RimWellRftAddress::eclCase() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimWellLogFile* RimWellRftAddress::wellLogFile() const RimWellLogFile* RifWellRftAddress::wellLogFile() const
{ {
return m_wellLogFile; return m_wellLogFile;
} }
@ -95,13 +83,13 @@ RimWellLogFile* RimWellRftAddress::wellLogFile() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QString RimWellRftAddress::sourceTypeUiText(RftSourceType sourceType) QString RifWellRftAddress::sourceTypeUiText(SourceType sourceType)
{ {
switch (sourceType) switch (sourceType)
{ {
case RftSourceType::RFT: return QString("RFT Cases"); case SourceType::RFT: return QString("RFT Cases");
case RftSourceType::GRID: return QString("Grid Cases"); case SourceType::GRID: return QString("Grid Cases");
case RftSourceType::OBSERVED: return QString("Observed Data"); case SourceType::OBSERVED: return QString("Observed Data");
} }
return QString(); return QString();
} }
@ -109,7 +97,7 @@ QString RimWellRftAddress::sourceTypeUiText(RftSourceType sourceType)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool operator==(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2) bool operator==(const RifWellRftAddress& addr1, const RifWellRftAddress& addr2)
{ {
return addr1.sourceType() == addr2.sourceType() return addr1.sourceType() == addr2.sourceType()
&& addr1.eclCase() == addr2.eclCase() && addr1.eclCase() == addr2.eclCase()
@ -119,7 +107,7 @@ bool operator==(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QTextStream& operator << (QTextStream& str, const RimWellRftAddress& addr) QTextStream& operator << (QTextStream& str, const RifWellRftAddress& addr)
{ {
// Not implemented // Not implemented
CVF_ASSERT(false); CVF_ASSERT(false);
@ -129,7 +117,7 @@ QTextStream& operator << (QTextStream& str, const RimWellRftAddress& addr)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QTextStream& operator >> (QTextStream& str, RimWellRftAddress& source) QTextStream& operator >> (QTextStream& str, RifWellRftAddress& source)
{ {
// Not implemented // Not implemented
CVF_ASSERT(false); CVF_ASSERT(false);
@ -139,7 +127,7 @@ QTextStream& operator >> (QTextStream& str, RimWellRftAddress& source)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool operator<(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2) bool operator<(const RifWellRftAddress& addr1, const RifWellRftAddress& addr2)
{ {
return (addr1.m_sourceType < addr2.m_sourceType) || return (addr1.m_sourceType < addr2.m_sourceType) ||
(addr1.m_sourceType == addr2.m_sourceType && (addr1.m_sourceType == addr2.m_sourceType &&

45
ApplicationCode/ProjectDataModel/Flow/RimWellRftAddress.h → ApplicationCode/FileInterface/RifWellRftAddress.h
View File

@ -38,40 +38,39 @@ class RimEclipseCase;
/// ///
/// ///
//================================================================================================== //==================================================================================================
enum class RftSourceType class RifWellRftAddress
{ {
NONE,
RFT,
GRID,
OBSERVED
};
class RimWellRftAddress
{
public: public:
RimWellRftAddress(); enum SourceType
RimWellRftAddress(RftSourceType sourceType, RimEclipseCase* eclCase); {
RimWellRftAddress(RftSourceType sourceType, RimWellLogFile* wellLogFile = nullptr); NONE,
RFT,
GRID,
OBSERVED
};
RftSourceType sourceType() const; RifWellRftAddress();
RifWellRftAddress(SourceType sourceType, RimEclipseCase* eclCase);
RifWellRftAddress(SourceType sourceType, RimWellLogFile* wellLogFile = nullptr);
SourceType sourceType() const;
RimEclipseCase* eclCase() const; RimEclipseCase* eclCase() const;
RimWellLogFile* wellLogFile() const; RimWellLogFile* wellLogFile() const;
static QString sourceTypeUiText(RftSourceType sourceType); static QString sourceTypeUiText(SourceType sourceType);
friend QTextStream& operator >> (QTextStream& str, RimWellRftAddress& addr); friend QTextStream& operator >> (QTextStream& str, RifWellRftAddress& addr);
friend bool operator<(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2); friend bool operator<(const RifWellRftAddress& addr1, const RifWellRftAddress& addr2);
private: private:
RftSourceType m_sourceType; SourceType m_sourceType;
caf::PdmPointer<RimEclipseCase> m_eclCase; caf::PdmPointer<RimEclipseCase> m_eclCase;
caf::PdmPointer<RimWellLogFile> m_wellLogFile; caf::PdmPointer<RimWellLogFile> m_wellLogFile;
}; };
Q_DECLARE_METATYPE(RimWellRftAddress); //Q_DECLARE_METATYPE(RifWellRftAddress);
bool operator==(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2); bool operator==(const RifWellRftAddress& addr1, const RifWellRftAddress& addr2);
QTextStream& operator <<(QTextStream& str, const RimWellRftAddress& addr); QTextStream& operator <<(QTextStream& str, const RifWellRftAddress& addr);
QTextStream& operator >> (QTextStream& str, RimWellRftAddress& addr); QTextStream& operator >> (QTextStream& str, RifWellRftAddress& addr);
bool operator<(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2); bool operator<(const RifWellRftAddress& addr1, const RifWellRftAddress& addr2);

24
ApplicationCode/FileInterface/RifWellRftAddressQMetaType.h Normal file
View File

@ -0,0 +1,24 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 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.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include <QMetaType>
#include "RifWellRftAddress.h"
Q_DECLARE_METATYPE(RifWellRftAddress);

4
ApplicationCode/ProjectDataModel/Flow/CMakeLists_files.cmake
View File

@ -15,7 +15,7 @@ ${CEE_CURRENT_LIST_DIR}RimWellAllocationPlotLegend.h
${CEE_CURRENT_LIST_DIR}RimFlowCharacteristicsPlot.h ${CEE_CURRENT_LIST_DIR}RimFlowCharacteristicsPlot.h
${CEE_CURRENT_LIST_DIR}RimWellRftPlot.h ${CEE_CURRENT_LIST_DIR}RimWellRftPlot.h
${CEE_CURRENT_LIST_DIR}RimWellPltPlot.h ${CEE_CURRENT_LIST_DIR}RimWellPltPlot.h
${CEE_CURRENT_LIST_DIR}RimWellRftAddress.h ${CEE_CURRENT_LIST_DIR}RimRftAddress.h
) )
set (SOURCE_GROUP_SOURCE_FILES set (SOURCE_GROUP_SOURCE_FILES
@ -29,7 +29,7 @@ ${CEE_CURRENT_LIST_DIR}RimWellAllocationPlotLegend.cpp
${CEE_CURRENT_LIST_DIR}RimFlowCharacteristicsPlot.cpp ${CEE_CURRENT_LIST_DIR}RimFlowCharacteristicsPlot.cpp
${CEE_CURRENT_LIST_DIR}RimWellRftPlot.cpp ${CEE_CURRENT_LIST_DIR}RimWellRftPlot.cpp
${CEE_CURRENT_LIST_DIR}RimWellPltPlot.cpp ${CEE_CURRENT_LIST_DIR}RimWellPltPlot.cpp
${CEE_CURRENT_LIST_DIR}RimWellRftAddress.cpp ${CEE_CURRENT_LIST_DIR}RimRftAddress.cpp
) )
list(APPEND CODE_HEADER_FILES list(APPEND CODE_HEADER_FILES

74
ApplicationCode/ProjectDataModel/Flow/RimRftAddress.cpp Normal file
View File

@ -0,0 +1,74 @@
/////////////////////////////////////////////////////////////////////////////////
//
// 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 "RimRftAddress.h"
#include "RimEclipseCase.h"
#include "RimWellLogFile.h"
#include "cafAppEnum.h"
#include "cvfAssert.h"
#include <QString>
#include <QTextStream>
namespace caf
{
template<>
void caf::AppEnum<RifWellRftAddress::SourceType>::setUp()
{
addItem(RifWellRftAddress::SourceType::RFT, "RFT", "RFT Cases");
addItem(RifWellRftAddress::SourceType::GRID, "GRID", "Grid Cases");
addItem(RifWellRftAddress::SourceType::OBSERVED, "OBSERVED", "Observed Data");
setDefault(RifWellRftAddress::SourceType::NONE);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
CAF_PDM_SOURCE_INIT(RimRftAddress, "RftAddress");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimRftAddress::RimRftAddress()
{
CAF_PDM_InitFieldNoDefault(&m_sourceType, "SourceType", "SourceType", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_eclCase, "EclipseCase", "EclipseCase", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_wellLogFile, "WellLogFile", "WellLogFile", "", "", "");
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimRftAddress::setAddress(const RifWellRftAddress& address)
{
m_sourceType = address.sourceType();
m_eclCase = address.eclCase();
m_wellLogFile = address.wellLogFile();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifWellRftAddress RimRftAddress::address() const
{
return m_eclCase() != nullptr ?
RifWellRftAddress(m_sourceType(), m_eclCase()) :
RifWellRftAddress(m_sourceType(), m_wellLogFile());
}

60
ApplicationCode/ProjectDataModel/Flow/RimRftAddress.h Normal file
View File

@ -0,0 +1,60 @@
/////////////////////////////////////////////////////////////////////////////////
//
// 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.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RimViewWindow.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "cafPdmPtrField.h"
#include "cafPdmPointer.h"
#include "RifWellRftAddressQMetaType.h"
#include "cafAppEnum.h"
#include <QPointer>
#include <QDate>
#include <QMetaType>
class RimWellLogFile;
class RimEclipseCase;
//==================================================================================================
///
///
//==================================================================================================
class RimRftAddress : public caf::PdmObject
{
CAF_PDM_HEADER_INIT;
public:
RimRftAddress();
void setAddress(const RifWellRftAddress& address);
RifWellRftAddress address() const;
private:
caf::PdmField<caf::AppEnum<RifWellRftAddress::SourceType> > m_sourceType;
caf::PdmPtrField<RimEclipseCase*> m_eclCase;
caf::PdmPtrField<RimWellLogFile*> m_wellLogFile;
};

194
ApplicationCode/ProjectDataModel/Flow/RimWellPltPlot.cpp
View File

@ -149,7 +149,7 @@ void RimWellPltPlot::deleteViewWidget()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
//void RimWellPltPlot::applyCurveAppearance(RimWellLogCurve* newCurve) //void RimWellPltPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
//{ //{
// const std::pair<RimWellRftAddress, QDateTime>& newCurveDef = curveDefFromCurve(newCurve); // const std::pair<RifWellRftAddress, QDateTime>& newCurveDef = curveDefFromCurve(newCurve);
// //
// std::vector<cvf::Color3f> colorTable; // std::vector<cvf::Color3f> colorTable;
// RiaColorTables::summaryCurveDefaultPaletteColors().color3fArray().toStdVector(&colorTable); // RiaColorTables::summaryCurveDefaultPaletteColors().color3fArray().toStdVector(&colorTable);
@ -182,7 +182,7 @@ void RimWellPltPlot::deleteViewWidget()
// { // {
// if (curve == newCurve) continue; // if (curve == newCurve) continue;
// //
// std::pair<RimWellRftAddress, QDateTime> cDef = curveDefFromCurve(curve); // std::pair<RifWellRftAddress, QDateTime> cDef = curveDefFromCurve(curve);
// if (cDef.first == newCurveDef.first) // if (cDef.first == newCurveDef.first)
// { // {
// currentColor = curve->color(); // currentColor = curve->color();
@ -253,15 +253,15 @@ void RimWellPltPlot::deleteViewWidget()
void RimWellPltPlot::updateSelectedTimeStepsFromSelectedSources() void RimWellPltPlot::updateSelectedTimeStepsFromSelectedSources()
{ {
std::vector<QDateTime> newTimeStepsSelections; std::vector<QDateTime> newTimeStepsSelections;
std::vector<RimWellRftAddress> selectedSourcesVector = selectedSources(); std::vector<RifWellRftAddress> selectedSourcesVector = selectedSources();
auto selectedSources = std::set<RimWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end()); auto selectedSources = std::set<RifWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
for (const QDateTime& timeStep : m_selectedTimeSteps()) for (const QDateTime& timeStep : m_selectedTimeSteps())
{ {
if(m_timeStepsToAddresses.count(timeStep) > 0) if(m_timeStepsToAddresses.count(timeStep) > 0)
{ {
std::vector<RimWellRftAddress> intersectVector; std::vector<RifWellRftAddress> intersectVector;
const std::set<RimWellRftAddress>& addresses = m_timeStepsToAddresses[timeStep]; const std::set<RifWellRftAddress>& addresses = m_timeStepsToAddresses[timeStep];
std::set_intersection(selectedSources.begin(), selectedSources.end(), std::set_intersection(selectedSources.begin(), selectedSources.end(),
addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end())); addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end()));
if(intersectVector.size() > 0) if(intersectVector.size() > 0)
@ -340,27 +340,27 @@ std::vector<RimEclipseCase*> RimWellPltPlot::eclipseCases() const
//{ //{
// std::vector<std::tuple<RimEclipseResultCase*, bool, bool>> eclCaseTuples = eclipseCasesForWell(m_wellName); // std::vector<std::tuple<RimEclipseResultCase*, bool, bool>> eclCaseTuples = eclipseCasesForWell(m_wellName);
// //
// std::vector<RimWellRftAddress> sourcesToSelect; // std::vector<RifWellRftAddress> sourcesToSelect;
// std::map<QDateTime, std::set<RimWellRftAddress>> rftTimeStepsMap; // std::map<QDateTime, std::set<RifWellRftAddress>> rftTimeStepsMap;
// std::map<QDateTime, std::set<RimWellRftAddress>> observedTimeStepsMap; // std::map<QDateTime, std::set<RifWellRftAddress>> observedTimeStepsMap;
// std::map<QDateTime, std::set<RimWellRftAddress>> gridTimeStepsMap; // std::map<QDateTime, std::set<RifWellRftAddress>> gridTimeStepsMap;
// //
// for(RimEclipseResultCase* const rftCase : rftCasesFromEclipseCases(eclCaseTuples)) // for(RimEclipseResultCase* const rftCase : rftCasesFromEclipseCases(eclCaseTuples))
// { // {
// sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::RFT, rftCase)); // sourcesToSelect.push_back(RifWellRftAddress(RftSourceType::RFT, rftCase));
// addTimeStepsToMap(rftTimeStepsMap, timeStepsFromRftCase(rftCase)); // addTimeStepsToMap(rftTimeStepsMap, timeStepsFromRftCase(rftCase));
// } // }
// //
// for (RimEclipseResultCase* const gridCase : gridCasesFromEclipseCases(eclCaseTuples)) // for (RimEclipseResultCase* const gridCase : gridCasesFromEclipseCases(eclCaseTuples))
// { // {
// sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::GRID, gridCase)); // sourcesToSelect.push_back(RifWellRftAddress(RftSourceType::GRID, gridCase));
// addTimeStepsToMap(gridTimeStepsMap, timeStepsFromGridCase(gridCase)); // addTimeStepsToMap(gridTimeStepsMap, timeStepsFromGridCase(gridCase));
// } // }
// //
// std::vector<RimWellLogFile*> wellLogFiles = wellLogFilesContainingFlow(m_wellName); // std::vector<RimWellLogFile*> wellLogFiles = wellLogFilesContainingFlow(m_wellName);
// if(wellLogFiles.size() > 0) // if(wellLogFiles.size() > 0)
// { // {
// sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::OBSERVED)); // sourcesToSelect.push_back(RifWellRftAddress(RftSourceType::OBSERVED));
// for (RimWellLogFile* const wellLogFile : wellLogFiles) // for (RimWellLogFile* const wellLogFile : wellLogFiles)
// { // {
// addTimeStepsToMap(observedTimeStepsMap, timeStepsFromWellLogFile(wellLogFile)); // addTimeStepsToMap(observedTimeStepsMap, timeStepsFromWellLogFile(wellLogFile));
@ -370,11 +370,11 @@ std::vector<RimEclipseCase*> RimWellPltPlot::eclipseCases() const
// m_selectedSources = sourcesToSelect; // m_selectedSources = sourcesToSelect;
// //
// std::set<QDateTime> timeStepsToSelect; // std::set<QDateTime> timeStepsToSelect;
// for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& dateTimePair : rftTimeStepsMap) // for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& dateTimePair : rftTimeStepsMap)
// { // {
// timeStepsToSelect.insert(dateTimePair.first); // timeStepsToSelect.insert(dateTimePair.first);
// } // }
// for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& dateTimePair : observedTimeStepsMap) // for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& dateTimePair : observedTimeStepsMap)
// { // {
// timeStepsToSelect.insert(dateTimePair.first); // timeStepsToSelect.insert(dateTimePair.first);
// } // }
@ -391,26 +391,26 @@ std::vector<RimEclipseCase*> RimWellPltPlot::eclipseCases() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPltPlot::updateEditorsFromCurves() void RimWellPltPlot::updateEditorsFromCurves()
{ {
// std::set<RimWellRftAddress> selectedSources; // std::set<RifWellRftAddress> selectedSources;
// std::set<QDateTime> selectedTimeSteps; // std::set<QDateTime> selectedTimeSteps;
// std::map<QDateTime, std::set<RimWellRftAddress>> selectedTimeStepsMap; // std::map<QDateTime, std::set<RifWellRftAddress>> selectedTimeStepsMap;
// //
// for (const std::pair<RimWellRftAddress, QDateTime>& curveDef : curveDefsFromCurves()) // for (const std::pair<RifWellRftAddress, QDateTime>& curveDef : curveDefsFromCurves())
// { // {
// if (curveDef.first.sourceType() == RftSourceType::OBSERVED) // if (curveDef.first.sourceType() == RftSourceType::OBSERVED)
// selectedSources.insert(RimWellRftAddress(RftSourceType::OBSERVED)); // selectedSources.insert(RifWellRftAddress(RftSourceType::OBSERVED));
// else // else
// selectedSources.insert(curveDef.first); // selectedSources.insert(curveDef.first);
// //
// auto newTimeStepMap = std::map<QDateTime, std::set<RimWellRftAddress>> // auto newTimeStepMap = std::map<QDateTime, std::set<RifWellRftAddress>>
// { // {
// { curveDef.second, std::set<RimWellRftAddress> { curveDef.first} } // { curveDef.second, std::set<RifWellRftAddress> { curveDef.first} }
// }; // };
// addTimeStepsToMap(selectedTimeStepsMap, newTimeStepMap); // addTimeStepsToMap(selectedTimeStepsMap, newTimeStepMap);
// selectedTimeSteps.insert(curveDef.second); // selectedTimeSteps.insert(curveDef.second);
// } // }
// //
// m_selectedSources = std::vector<RimWellRftAddress>(selectedSources.begin(), selectedSources.end()); // m_selectedSources = std::vector<RifWellRftAddress>(selectedSources.begin(), selectedSources.end());
// m_selectedTimeSteps = std::vector<QDateTime>(selectedTimeSteps.begin(), selectedTimeSteps.end()); // m_selectedTimeSteps = std::vector<QDateTime>(selectedTimeSteps.begin(), selectedTimeSteps.end());
// addTimeStepsToMap(m_timeStepsToAddresses, selectedTimeStepsMap); // addTimeStepsToMap(m_timeStepsToAddresses, selectedTimeStepsMap);
} }
@ -441,7 +441,7 @@ void RimWellPltPlot::updateWidgetTitleWindowTitle()
void RimWellPltPlot::syncCurvesFromUiSelection() void RimWellPltPlot::syncCurvesFromUiSelection()
{ {
RimWellLogTrack* plotTrack = m_wellLogPlot->trackByIndex(0); RimWellLogTrack* plotTrack = m_wellLogPlot->trackByIndex(0);
const std::set<std::pair<RimWellRftAddress, QDateTime>>& curveDefs = selectedCurveDefs(); const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefs = selectedCurveDefs();
updateCurvesInPlot(curveDefs); updateCurvesInPlot(curveDefs);
} }
@ -598,9 +598,9 @@ RimWellPath* RimWellPltPlot::wellPathFromWellLogFile(const RimWellLogFile* wellL
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
//std::map<QDateTime, std::set<RimWellRftAddress>> RimWellPltPlot::timeStepsFromRftCase(RimEclipseResultCase* rftCase) const //std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPltPlot::timeStepsFromRftCase(RimEclipseResultCase* rftCase) const
//{ //{
// std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsMap; // std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
// RifReaderEclipseRft* const reader = rftCase->rftReader(); // RifReaderEclipseRft* const reader = rftCase->rftReader();
// if (reader != nullptr) // if (reader != nullptr)
// { // {
@ -608,9 +608,9 @@ RimWellPath* RimWellPltPlot::wellPathFromWellLogFile(const RimWellLogFile* wellL
// { // {
// if (timeStepsMap.count(timeStep) == 0) // if (timeStepsMap.count(timeStep) == 0)
// { // {
// timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>())); // timeStepsMap.insert(std::make_pair(timeStep, std::set<RifWellRftAddress>()));
// } // }
// timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::RFT, rftCase)); // timeStepsMap[timeStep].insert(RifWellRftAddress(RftSourceType::RFT, rftCase));
// } // }
// } // }
// return timeStepsMap; // return timeStepsMap;
@ -619,23 +619,23 @@ RimWellPath* RimWellPltPlot::wellPathFromWellLogFile(const RimWellLogFile* wellL
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
//std::map<QDateTime, std::set<RimWellRftAddress>> RimWellPltPlot::timeStepsFromGridCase(RimEclipseCase* gridCase) const //std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPltPlot::timeStepsFromGridCase(RimEclipseCase* gridCase) const
//{ //{
// const RigEclipseCaseData* const eclipseCaseData = gridCase->eclipseCaseData(); // const RigEclipseCaseData* const eclipseCaseData = gridCase->eclipseCaseData();
// size_t resultIndex = eclipseCaseData != nullptr ? // size_t resultIndex = eclipseCaseData != nullptr ?
// eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, PRESSURE_DATA_NAME) : // eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, PRESSURE_DATA_NAME) :
// cvf::UNDEFINED_SIZE_T; // cvf::UNDEFINED_SIZE_T;
// //
// std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsMap; // std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
// if (resultIndex != cvf::UNDEFINED_SIZE_T) // if (resultIndex != cvf::UNDEFINED_SIZE_T)
// { // {
// for (const QDateTime& timeStep : eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->timeStepDates(resultIndex)) // for (const QDateTime& timeStep : eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->timeStepDates(resultIndex))
// { // {
// if (timeStepsMap.count(timeStep) == 0) // if (timeStepsMap.count(timeStep) == 0)
// { // {
// timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>())); // timeStepsMap.insert(std::make_pair(timeStep, std::set<RifWellRftAddress>()));
// } // }
// timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::GRID, gridCase)); // timeStepsMap[timeStep].insert(RifWellRftAddress(RftSourceType::GRID, gridCase));
// } // }
// } // }
// return timeStepsMap; // return timeStepsMap;
@ -644,17 +644,17 @@ RimWellPath* RimWellPltPlot::wellPathFromWellLogFile(const RimWellLogFile* wellL
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RimWellRftAddress> > RimWellPltPlot::timeStepsFromWellLogFile(RimWellLogFile* wellLogFile) const std::map<QDateTime, std::set<RifWellRftAddress> > RimWellPltPlot::timeStepsFromWellLogFile(RimWellLogFile* wellLogFile) const
{ {
std::map<QDateTime, std::set<RimWellRftAddress> > timeStepsMap; std::map<QDateTime, std::set<RifWellRftAddress> > timeStepsMap;
QDateTime timeStep = RiaDateStringParser::parseDateString(wellLogFile->date()); QDateTime timeStep = RiaDateStringParser::parseDateString(wellLogFile->date());
if (timeStepsMap.count(timeStep) == 0) if (timeStepsMap.count(timeStep) == 0)
{ {
timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>())); timeStepsMap.insert(std::make_pair(timeStep, std::set<RifWellRftAddress>()));
} }
timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::OBSERVED, wellLogFile)); timeStepsMap[timeStep].insert(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile));
return timeStepsMap; return timeStepsMap;
} }
@ -662,16 +662,16 @@ std::map<QDateTime, std::set<RimWellRftAddress> > RimWellPltPlot::timeStepsFromW
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RimWellRftAddress>> std::map<QDateTime, std::set<RifWellRftAddress>>
RimWellPltPlot::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>& allTimeSteps, RimWellPltPlot::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>& allTimeSteps,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& searchTimeStepPair) const std::pair<QDateTime, std::set<RifWellRftAddress>>& searchTimeStepPair)
{ {
std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsMap; std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
if (allTimeSteps.size() > 0) if (allTimeSteps.size() > 0)
{ {
auto itr = std::find_if(allTimeSteps.begin(), allTimeSteps.end(), auto itr = std::find_if(allTimeSteps.begin(), allTimeSteps.end(),
[searchTimeStepPair](const std::pair<QDateTime, std::set<RimWellRftAddress>>& dt) [searchTimeStepPair](const std::pair<QDateTime, std::set<RifWellRftAddress>>& dt)
{ {
return dt.first > searchTimeStepPair.first; return dt.first > searchTimeStepPair.first;
}); });
@ -693,9 +693,9 @@ RimWellPltPlot::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::se
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimWellPltPlot::mapContainsTimeStep(const std::map<QDateTime, std::set<RimWellRftAddress>>& map, const QDateTime& timeStep) bool RimWellPltPlot::mapContainsTimeStep(const std::map<QDateTime, std::set<RifWellRftAddress>>& map, const QDateTime& timeStep)
{ {
return std::find_if(map.begin(), map.end(), [timeStep](const std::pair<QDateTime, std::set<RimWellRftAddress>>& pair) return std::find_if(map.begin(), map.end(), [timeStep](const std::pair<QDateTime, std::set<RifWellRftAddress>>& pair)
{ {
return pair.first == timeStep; return pair.first == timeStep;
}) != map.end(); }) != map.end();
@ -704,22 +704,22 @@ bool RimWellPltPlot::mapContainsTimeStep(const std::map<QDateTime, std::set<RimW
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::set < std::pair<RimWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurveDefs() const std::set < std::pair<RifWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurveDefs() const
{ {
std::set<std::pair<RimWellRftAddress, QDateTime>> curveDefs; std::set<std::pair<RifWellRftAddress, QDateTime>> curveDefs;
//const std::vector<std::tuple<RimEclipseResultCase*,bool,bool>>& eclipseCases = eclipseCasesForWell(m_wellName); //const std::vector<std::tuple<RimEclipseResultCase*,bool,bool>>& eclipseCases = eclipseCasesForWell(m_wellName);
//const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases); //const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
//const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases); //const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
for (const QDateTime& timeStep : m_selectedTimeSteps()) for (const QDateTime& timeStep : m_selectedTimeSteps())
{ {
for (const RimWellRftAddress& addr : selectedSources()) for (const RifWellRftAddress& addr : selectedSources())
{ {
//if (addr.sourceType() == RftSourceType::RFT) //if (addr.sourceType() == RftSourceType::RFT)
//{ //{
// for (RimEclipseResultCase* const rftCase : rftCases) // for (RimEclipseResultCase* const rftCase : rftCases)
// { // {
// const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromRftCase(rftCase); // const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromRftCase(rftCase);
// if (mapContainsTimeStep(timeStepsMap , timeStep)) // if (mapContainsTimeStep(timeStepsMap , timeStep))
// { // {
// curveDefs.insert(std::make_pair(addr, timeStep)); // curveDefs.insert(std::make_pair(addr, timeStep));
@ -730,7 +730,7 @@ std::set < std::pair<RimWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurv
//{ //{
// for (RimEclipseResultCase* const gridCase : gridCases) // for (RimEclipseResultCase* const gridCase : gridCases)
// { // {
// const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase); // const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
// if (mapContainsTimeStep(timeStepsMap, timeStep)) // if (mapContainsTimeStep(timeStepsMap, timeStep))
// { // {
// curveDefs.insert(std::make_pair(addr, timeStep)); // curveDefs.insert(std::make_pair(addr, timeStep));
@ -738,14 +738,14 @@ std::set < std::pair<RimWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurv
// } // }
//} //}
//else //else
if (addr.sourceType() == RftSourceType::OBSERVED) if (addr.sourceType() == RifWellRftAddress::OBSERVED)
{ {
if (addr.wellLogFile() != nullptr) if (addr.wellLogFile() != nullptr)
{ {
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromWellLogFile(addr.wellLogFile()); const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromWellLogFile(addr.wellLogFile());
if (mapContainsTimeStep(timeStepsMap, timeStep)) if (mapContainsTimeStep(timeStepsMap, timeStep))
{ {
curveDefs.insert(std::make_pair(RimWellRftAddress(RftSourceType::OBSERVED, addr.wellLogFile()), timeStep)); curveDefs.insert(std::make_pair(RifWellRftAddress(RifWellRftAddress::OBSERVED, addr.wellLogFile()), timeStep));
} }
} }
} }
@ -757,9 +757,9 @@ std::set < std::pair<RimWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurv
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::set<std::pair<RimWellRftAddress, QDateTime>> RimWellPltPlot::curveDefsFromCurves() const std::set<std::pair<RifWellRftAddress, QDateTime>> RimWellPltPlot::curveDefsFromCurves() const
{ {
std::set<std::pair<RimWellRftAddress, QDateTime>> curveDefs; std::set<std::pair<RifWellRftAddress, QDateTime>> curveDefs;
RimWellLogTrack* const plotTrack = m_wellLogPlot->trackByIndex(0); RimWellLogTrack* const plotTrack = m_wellLogPlot->trackByIndex(0);
for (RimWellLogCurve* const curve : plotTrack->curvesVector()) for (RimWellLogCurve* const curve : plotTrack->curvesVector())
@ -772,7 +772,7 @@ std::set<std::pair<RimWellRftAddress, QDateTime>> RimWellPltPlot::curveDefsFromC
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::pair<RimWellRftAddress, QDateTime> RimWellPltPlot::curveDefFromCurve(const RimWellLogCurve* curve) const std::pair<RifWellRftAddress, QDateTime> RimWellPltPlot::curveDefFromCurve(const RimWellLogCurve* curve) const
{ {
const RimWellLogRftCurve* rftCurve = dynamic_cast<const RimWellLogRftCurve*>(curve); const RimWellLogRftCurve* rftCurve = dynamic_cast<const RimWellLogRftCurve*>(curve);
const RimWellLogExtractionCurve* gridCurve = dynamic_cast<const RimWellLogExtractionCurve*>(curve); const RimWellLogExtractionCurve* gridCurve = dynamic_cast<const RimWellLogExtractionCurve*>(curve);
@ -785,7 +785,7 @@ std::pair<RimWellRftAddress, QDateTime> RimWellPltPlot::curveDefFromCurve(const
// { // {
// const RifEclipseRftAddress rftAddress = rftCurve->rftAddress(); // const RifEclipseRftAddress rftAddress = rftCurve->rftAddress();
// const QDateTime timeStep = rftAddress.timeStep(); // const QDateTime timeStep = rftAddress.timeStep();
// return std::make_pair(RimWellRftAddress(RftSourceType::RFT, rftCase), timeStep); // return std::make_pair(RifWellRftAddress(RftSourceType::RFT, rftCase), timeStep);
// } // }
//} //}
//else if (gridCurve != nullptr) //else if (gridCurve != nullptr)
@ -794,12 +794,12 @@ std::pair<RimWellRftAddress, QDateTime> RimWellPltPlot::curveDefFromCurve(const
// if (gridCase != nullptr) // if (gridCase != nullptr)
// { // {
// size_t timeStepIndex = gridCurve->currentTimeStep(); // size_t timeStepIndex = gridCurve->currentTimeStep();
// const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase); // const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
// auto timeStepsVector = std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>( // auto timeStepsVector = std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>(
// timeStepsMap.begin(), timeStepsMap.end()); // timeStepsMap.begin(), timeStepsMap.end());
// if (timeStepIndex < timeStepsMap.size()) // if (timeStepIndex < timeStepsMap.size())
// { // {
// return std::make_pair(RimWellRftAddress(RftSourceType::GRID, gridCase), // return std::make_pair(RifWellRftAddress(RftSourceType::GRID, gridCase),
// timeStepsVector[timeStepIndex].first); // timeStepsVector[timeStepIndex].first);
// } // }
// } // }
@ -816,17 +816,17 @@ std::pair<RimWellRftAddress, QDateTime> RimWellPltPlot::curveDefFromCurve(const
if (date.isValid()) if (date.isValid())
{ {
return std::make_pair(RimWellRftAddress(RftSourceType::OBSERVED, wellLogFile), date); return std::make_pair(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile), date);
} }
} }
} }
return std::make_pair(RimWellRftAddress(), QDateTime()); return std::make_pair(RifWellRftAddress(), QDateTime());
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPltPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddress, QDateTime>>& curveDefs) void RimWellPltPlot::updateCurvesInPlot(const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefs)
{ {
RimWellLogTrack* const plotTrack = m_wellLogPlot->trackByIndex(0); RimWellLogTrack* const plotTrack = m_wellLogPlot->trackByIndex(0);
@ -840,7 +840,7 @@ void RimWellPltPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
} }
// Add curves // Add curves
for (const std::pair<RimWellRftAddress, QDateTime>& curveDefToAdd : curveDefs) for (const std::pair<RifWellRftAddress, QDateTime>& curveDefToAdd : curveDefs)
{ {
//if (curveDefToAdd.first.sourceType() == RftSourceType::RFT) //if (curveDefToAdd.first.sourceType() == RftSourceType::RFT)
//{ //{
@ -879,9 +879,9 @@ void RimWellPltPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
// curve->setEclipseResultDefinition(resultDef); // curve->setEclipseResultDefinition(resultDef);
// // Time step // // Time step
// const std::map<QDateTime, std::set<RimWellRftAddress>>& timeSteps = timeStepsFromGridCase(gridCase); // const std::map<QDateTime, std::set<RifWellRftAddress>>& timeSteps = timeStepsFromGridCase(gridCase);
// auto currentTimeStepItr = std::find_if(timeSteps.begin(), timeSteps.end(), // auto currentTimeStepItr = std::find_if(timeSteps.begin(), timeSteps.end(),
// [curveDefToAdd](std::pair<QDateTime, std::set<RimWellRftAddress>> pair) {return pair.first == curveDefToAdd.second; }); // [curveDefToAdd](std::pair<QDateTime, std::set<RifWellRftAddress>> pair) {return pair.first == curveDefToAdd.second; });
// auto currentTimeStepIndex = std::distance(timeSteps.begin(), currentTimeStepItr); // auto currentTimeStepIndex = std::distance(timeSteps.begin(), currentTimeStepItr);
// curve->setCurrentTimeStep(currentTimeStepIndex); // curve->setCurrentTimeStep(currentTimeStepIndex);
// curve->setZOrder(0); // curve->setZOrder(0);
@ -891,7 +891,7 @@ void RimWellPltPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
// } // }
//} //}
//else //else
if (curveDefToAdd.first.sourceType() == RftSourceType::OBSERVED) if (curveDefToAdd.first.sourceType() == RifWellRftAddress::OBSERVED)
{ {
RimWellLogFile* const wellLogFile = curveDefToAdd.first.wellLogFile(); RimWellLogFile* const wellLogFile = curveDefToAdd.first.wellLogFile();
RimWellPath* const wellPath = wellPathFromWellLogFile(wellLogFile); RimWellPath* const wellPath = wellPathFromWellLogFile(wellLogFile);
@ -947,21 +947,21 @@ void RimWellPltPlot::addStackedCurve(const QString& channelName,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimWellPltPlot::isOnlyGridSourcesSelected() const bool RimWellPltPlot::isOnlyGridSourcesSelected() const
{ {
const std::vector<RimWellRftAddress>& selSources = m_selectedSources(); const std::vector<RifWellRftAddress>& selSources = m_selectedSources();
return std::find_if(selSources.begin(), selSources.end(), [](const RimWellRftAddress& addr) return std::find_if(selSources.begin(), selSources.end(), [](const RifWellRftAddress& addr)
{ {
return addr.sourceType() == RftSourceType::RFT || addr.sourceType() == RftSourceType::OBSERVED; return addr.sourceType() == RifWellRftAddress::RFT || addr.sourceType() == RifWellRftAddress::OBSERVED;
}) == selSources.end(); }) == selSources.end();
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimWellPltPlot::isAnySourceAddressSelected(const std::set<RimWellRftAddress>& addresses) const bool RimWellPltPlot::isAnySourceAddressSelected(const std::set<RifWellRftAddress>& addresses) const
{ {
const std::vector<RimWellRftAddress>& selectedSourcesVector = m_selectedSources(); const std::vector<RifWellRftAddress>& selectedSourcesVector = m_selectedSources();
const auto selectedSources = std::set<RimWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end()); const auto selectedSources = std::set<RifWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RimWellRftAddress> intersectVector; std::vector<RifWellRftAddress> intersectVector;
std::set_intersection(selectedSources.begin(), selectedSources.end(), std::set_intersection(selectedSources.begin(), selectedSources.end(),
addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end())); addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end()));
@ -971,16 +971,16 @@ bool RimWellPltPlot::isAnySourceAddressSelected(const std::set<RimWellRftAddress
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<RimWellRftAddress> RimWellPltPlot::selectedSources() const std::vector<RifWellRftAddress> RimWellPltPlot::selectedSources() const
{ {
std::vector<RimWellRftAddress> sources; std::vector<RifWellRftAddress> sources;
for (const RimWellRftAddress& addr : m_selectedSources()) for (const RifWellRftAddress& addr : m_selectedSources())
{ {
if (addr.sourceType() == RftSourceType::OBSERVED) if (addr.sourceType() == RifWellRftAddress::OBSERVED)
{ {
for (RimWellLogFile* const wellLogFile : wellLogFilesContainingFlow(m_wellName)) for (RimWellLogFile* const wellLogFile : wellLogFilesContainingFlow(m_wellName))
{ {
sources.push_back(RimWellRftAddress(RftSourceType::OBSERVED, wellLogFile)); sources.push_back(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile));
} }
} }
else else
@ -1107,11 +1107,11 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions(const caf::P
//const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases); //const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
//if (rftCases.size() > 0) //if (rftCases.size() > 0)
//{ //{
// options.push_back(caf::PdmOptionItemInfo::createHeader(RimWellRftAddress::sourceTypeUiText(RftSourceType::RFT), true)); // options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RftSourceType::RFT), true));
//} //}
//for (const auto& rftCase : rftCases) //for (const auto& rftCase : rftCases)
//{ //{
// auto addr = RimWellRftAddress(RftSourceType::RFT, rftCase); // auto addr = RifWellRftAddress(RftSourceType::RFT, rftCase);
// auto item = caf::PdmOptionItemInfo(rftCase->caseUserDescription(), QVariant::fromValue(addr)); // auto item = caf::PdmOptionItemInfo(rftCase->caseUserDescription(), QVariant::fromValue(addr));
// item.setLevel(1); // item.setLevel(1);
// options.push_back(item); // options.push_back(item);
@ -1120,11 +1120,11 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions(const caf::P
//const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases); //const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
//if (gridCases.size() > 0) //if (gridCases.size() > 0)
//{ //{
// options.push_back(caf::PdmOptionItemInfo::createHeader(RimWellRftAddress::sourceTypeUiText(RftSourceType::GRID), true)); // options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RftSourceType::GRID), true));
//} //}
//for (const auto& gridCase : gridCases) //for (const auto& gridCase : gridCases)
//{ //{
// auto addr = RimWellRftAddress(RftSourceType::GRID, gridCase); // auto addr = RifWellRftAddress(RftSourceType::GRID, gridCase);
// auto item = caf::PdmOptionItemInfo(gridCase->caseUserDescription(), QVariant::fromValue(addr)); // auto item = caf::PdmOptionItemInfo(gridCase->caseUserDescription(), QVariant::fromValue(addr));
// item.setLevel(1); // item.setLevel(1);
// options.push_back(item); // options.push_back(item);
@ -1132,9 +1132,9 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions(const caf::P
if (wellLogFilesContainingFlow(m_wellName).size() > 0) if (wellLogFilesContainingFlow(m_wellName).size() > 0)
{ {
options.push_back(caf::PdmOptionItemInfo::createHeader(RimWellRftAddress::sourceTypeUiText(RftSourceType::OBSERVED), true)); options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RifWellRftAddress::OBSERVED), true));
auto addr = RimWellRftAddress(RftSourceType::OBSERVED); auto addr = RifWellRftAddress(RifWellRftAddress::OBSERVED);
auto item = caf::PdmOptionItemInfo("Observed Data", QVariant::fromValue(addr)); auto item = caf::PdmOptionItemInfo("Observed Data", QVariant::fromValue(addr));
item.setLevel(1); item.setLevel(1);
options.push_back(item); options.push_back(item);
@ -1290,18 +1290,18 @@ void RimWellPltPlot::defineEditorAttribute(const caf::PdmFieldHandle* field, QSt
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPltPlot::addTimeStepToMap(std::map<QDateTime, std::set<RimWellRftAddress>>& destMap, void RimWellPltPlot::addTimeStepToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepToAdd) const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepToAdd)
{ {
auto timeStepMapToAdd = std::map<QDateTime, std::set<RimWellRftAddress>> { timeStepToAdd }; auto timeStepMapToAdd = std::map<QDateTime, std::set<RifWellRftAddress>> { timeStepToAdd };
addTimeStepsToMap(destMap, timeStepMapToAdd); addTimeStepsToMap(destMap, timeStepMapToAdd);
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPltPlot::addTimeStepsToMap(std::map<QDateTime, std::set<RimWellRftAddress>>& destMap, void RimWellPltPlot::addTimeStepsToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsToAdd) const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsToAdd)
{ {
for (const auto& timeStepPair : timeStepsToAdd) for (const auto& timeStepPair : timeStepsToAdd)
{ {
@ -1309,7 +1309,7 @@ void RimWellPltPlot::addTimeStepsToMap(std::map<QDateTime, std::set<RimWellRftAd
{ {
if (destMap.count(timeStepPair.first) == 0) if (destMap.count(timeStepPair.first) == 0)
{ {
destMap.insert(std::make_pair(timeStepPair.first, std::set<RimWellRftAddress>())); destMap.insert(std::make_pair(timeStepPair.first, std::set<RifWellRftAddress>()));
} }
auto addresses = timeStepPair.second; auto addresses = timeStepPair.second;
destMap[timeStepPair.first].insert(addresses.begin(), addresses.end()); destMap[timeStepPair.first].insert(addresses.begin(), addresses.end());
@ -1352,12 +1352,12 @@ void RimWellPltPlot::calculateValueOptionsForWells(QList<caf::PdmOptionItemInfo>
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellName, QList<caf::PdmOptionItemInfo>& options) void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellName, QList<caf::PdmOptionItemInfo>& options)
{ {
std::map<QDateTime, std::set<RimWellRftAddress>> displayTimeStepsMap, obsAndRftTimeStepsMap, gridTimeStepsMap; std::map<QDateTime, std::set<RifWellRftAddress>> displayTimeStepsMap, obsAndRftTimeStepsMap, gridTimeStepsMap;
//const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCases = eclipseCasesForWell(wellName); //const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCases = eclipseCasesForWell(wellName);
//const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases); //const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
//const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases); //const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
for (const RimWellRftAddress& selection : selectedSources()) for (const RifWellRftAddress& selection : selectedSources())
{ {
//if (selection.sourceType() == RftSourceType::RFT) //if (selection.sourceType() == RftSourceType::RFT)
//{ //{
@ -1374,7 +1374,7 @@ void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
// } // }
//} //}
//else //else
if (selection.sourceType() == RftSourceType::OBSERVED) if (selection.sourceType() == RifWellRftAddress::OBSERVED)
{ {
if (selection.wellLogFile() != nullptr) if (selection.wellLogFile() != nullptr)
{ {
@ -1389,11 +1389,11 @@ void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
} }
else else
{ {
const auto gridTimeStepsVector = std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>(gridTimeStepsMap.begin(), gridTimeStepsMap.end()); const auto gridTimeStepsVector = std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>(gridTimeStepsMap.begin(), gridTimeStepsMap.end());
for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepPair : obsAndRftTimeStepsMap) for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : obsAndRftTimeStepsMap)
{ {
const std::map<QDateTime, std::set<RimWellRftAddress>>& adjTimeSteps = adjacentTimeSteps(gridTimeStepsVector, timeStepPair); const std::map<QDateTime, std::set<RifWellRftAddress>>& adjTimeSteps = adjacentTimeSteps(gridTimeStepsVector, timeStepPair);
addTimeStepsToMap(displayTimeStepsMap, adjTimeSteps); addTimeStepsToMap(displayTimeStepsMap, adjTimeSteps);
} }
@ -1408,7 +1408,7 @@ void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
{ {
if (m_timeStepsToAddresses.count(timeStep) > 0) if (m_timeStepsToAddresses.count(timeStep) > 0)
{ {
const std::set<RimWellRftAddress> sourceAddresses = m_timeStepsToAddresses[timeStep]; const std::set<RifWellRftAddress> sourceAddresses = m_timeStepsToAddresses[timeStep];
if (isAnySourceAddressSelected(sourceAddresses)) if (isAnySourceAddressSelected(sourceAddresses))
{ {
addTimeStepToMap(displayTimeStepsMap, std::make_pair(timeStep, m_timeStepsToAddresses[timeStep])); addTimeStepToMap(displayTimeStepsMap, std::make_pair(timeStep, m_timeStepsToAddresses[timeStep]));
@ -1421,13 +1421,13 @@ void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
// Create vector of all time steps // Create vector of all time steps
std::vector<QDateTime> allTimeSteps; std::vector<QDateTime> allTimeSteps;
for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepPair : m_timeStepsToAddresses) for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : m_timeStepsToAddresses)
{ {
allTimeSteps.push_back(timeStepPair.first); allTimeSteps.push_back(timeStepPair.first);
} }
const QString dateFormatString = RimTools::createTimeFormatStringFromDates(allTimeSteps); const QString dateFormatString = RimTools::createTimeFormatStringFromDates(allTimeSteps);
for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepPair : displayTimeStepsMap) for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : displayTimeStepsMap)
{ {
options.push_back(caf::PdmOptionItemInfo(timeStepPair.first.toString(dateFormatString), timeStepPair.first)); options.push_back(caf::PdmOptionItemInfo(timeStepPair.first.toString(dateFormatString), timeStepPair.first));
} }

41
ApplicationCode/ProjectDataModel/Flow/RimWellPltPlot.h
View File

@ -26,8 +26,11 @@
#include "cafPdmObject.h" #include "cafPdmObject.h"
#include "cafPdmPtrField.h" #include "cafPdmPtrField.h"
#include "cvfCollection.h" #include "cvfCollection.h"
#include "RimWellRftAddress.h"
#include "RimPlotCurve.h" #include "RimPlotCurve.h"
#include "RifWellRftAddress.h"
#include "RifWellRftAddressQMetaType.h"
#include <QPointer> #include <QPointer>
#include <QDate> #include <QDate>
#include <QMetaType> #include <QMetaType>
@ -112,10 +115,10 @@ protected:
virtual void defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute); virtual void defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute);
private: private:
void addTimeStepToMap(std::map<QDateTime, std::set<RimWellRftAddress>>& destMap, void addTimeStepToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepToAdd); const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepToAdd);
void addTimeStepsToMap(std::map<QDateTime, std::set<RimWellRftAddress>>& destMap, void addTimeStepsToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsToAdd); const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsToAdd);
void calculateValueOptionsForWells(QList<caf::PdmOptionItemInfo>& options); void calculateValueOptionsForWells(QList<caf::PdmOptionItemInfo>& options);
void calculateValueOptionsForTimeSteps(const QString& wellName, QList<caf::PdmOptionItemInfo>& options); void calculateValueOptionsForTimeSteps(const QString& wellName, QList<caf::PdmOptionItemInfo>& options);
@ -132,25 +135,25 @@ private:
//std::vector<std::tuple<RimEclipseResultCase*, bool, bool>> eclipseCasesForWell(const QString& wellName) const; //std::vector<std::tuple<RimEclipseResultCase*, bool, bool>> eclipseCasesForWell(const QString& wellName) const;
//std::vector<RimEclipseResultCase*> gridCasesFromEclipseCases(const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCasesTuple) const; //std::vector<RimEclipseResultCase*> gridCasesFromEclipseCases(const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCasesTuple) const;
//std::vector<RimEclipseResultCase*> rftCasesFromEclipseCases(const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCasesTuple) const; //std::vector<RimEclipseResultCase*> rftCasesFromEclipseCases(const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCasesTuple) const;
//std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsFromRftCase(RimEclipseResultCase* gridCase) const; //std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsFromRftCase(RimEclipseResultCase* gridCase) const;
//std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsFromGridCase(RimEclipseCase* gridCase) const; //std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsFromGridCase(RimEclipseCase* gridCase) const;
std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsFromWellLogFile(RimWellLogFile* wellLogFile) const; std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsFromWellLogFile(RimWellLogFile* wellLogFile) const;
std::map<QDateTime, std::set<RimWellRftAddress>> adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>& allTimeSteps, std::map<QDateTime, std::set<RifWellRftAddress>> adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>& allTimeSteps,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& searchTimeStepPair); const std::pair<QDateTime, std::set<RifWellRftAddress>>& searchTimeStepPair);
static bool mapContainsTimeStep(const std::map<QDateTime, std::set<RimWellRftAddress>>& map, const QDateTime& timeStep); static bool mapContainsTimeStep(const std::map<QDateTime, std::set<RifWellRftAddress>>& map, const QDateTime& timeStep);
std::set<std::pair<RimWellRftAddress, QDateTime>> selectedCurveDefs() const; std::set<std::pair<RifWellRftAddress, QDateTime>> selectedCurveDefs() const;
std::set<std::pair<RimWellRftAddress, QDateTime>> curveDefsFromCurves() const; std::set<std::pair<RifWellRftAddress, QDateTime>> curveDefsFromCurves() const;
std::pair<RimWellRftAddress, QDateTime> curveDefFromCurve(const RimWellLogCurve* curve) const; std::pair<RifWellRftAddress, QDateTime> curveDefFromCurve(const RimWellLogCurve* curve) const;
void updateCurvesInPlot(const std::set<std::pair<RimWellRftAddress, QDateTime>>& curveDefs); void updateCurvesInPlot(const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefs);
void addStackedCurve(const QString& tracerName, void addStackedCurve(const QString& tracerName,
const std::vector<double>& depthValues, const std::vector<double>& depthValues,
const std::vector<double>& accFlow, const std::vector<double>& accFlow,
RimWellLogTrack* plotTrack); RimWellLogTrack* plotTrack);
bool isOnlyGridSourcesSelected() const; bool isOnlyGridSourcesSelected() const;
bool isAnySourceAddressSelected(const std::set<RimWellRftAddress>& addresses) const; bool isAnySourceAddressSelected(const std::set<RifWellRftAddress>& addresses) const;
std::vector<RimWellRftAddress> selectedSources() const; std::vector<RifWellRftAddress> selectedSources() const;
// RimViewWindow overrides // RimViewWindow overrides
@ -169,7 +172,7 @@ private:
caf::PdmField<QString> m_wellName; caf::PdmField<QString> m_wellName;
caf::PdmField<int> m_branchIndex; caf::PdmField<int> m_branchIndex;
caf::PdmField<std::vector<RimWellRftAddress>> m_selectedSources; caf::PdmField<std::vector<RifWellRftAddress>> m_selectedSources;
caf::PdmField<std::vector<QDateTime>> m_selectedTimeSteps; caf::PdmField<std::vector<QDateTime>> m_selectedTimeSteps;
@ -177,7 +180,7 @@ private:
caf::PdmChildField<RimWellLogPlot*> m_wellLogPlot; caf::PdmChildField<RimWellLogPlot*> m_wellLogPlot;
std::map<QDateTime, std::set<RimWellRftAddress>> m_timeStepsToAddresses; std::map<QDateTime, std::set<RifWellRftAddress>> m_timeStepsToAddresses;
caf::PdmField<caf::AppEnum<FlowType>> m_phaseSelectionMode; caf::PdmField<caf::AppEnum<FlowType>> m_phaseSelectionMode;
caf::PdmField<std::vector<caf::AppEnum<FlowPhase>>> m_phases; caf::PdmField<std::vector<caf::AppEnum<FlowPhase>>> m_phases;

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

@ -119,7 +119,7 @@ void RimWellRftPlot::deleteViewWidget()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve) void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
{ {
const std::pair<RimWellRftAddress, QDateTime>& newCurveDef = curveDefFromCurve(newCurve); const std::pair<RifWellRftAddress, QDateTime>& newCurveDef = curveDefFromCurve(newCurve);
std::vector<cvf::Color3f> colorTable; std::vector<cvf::Color3f> colorTable;
RiaColorTables::summaryCurveDefaultPaletteColors().color3fArray().toStdVector(&colorTable); RiaColorTables::summaryCurveDefaultPaletteColors().color3fArray().toStdVector(&colorTable);
@ -152,7 +152,7 @@ void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
{ {
if (curve == newCurve) continue; if (curve == newCurve) continue;
std::pair<RimWellRftAddress, QDateTime> cDef = curveDefFromCurve(curve); std::pair<RifWellRftAddress, QDateTime> cDef = curveDefFromCurve(curve);
if (cDef.first == newCurveDef.first) if (cDef.first == newCurveDef.first)
{ {
currentColor = curve->color(); currentColor = curve->color();
@ -209,7 +209,7 @@ void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
} }
// Observed data // Observed data
currentLineStyle = newCurveDef.first.sourceType() == RftSourceType::OBSERVED currentLineStyle = newCurveDef.first.sourceType() == RifWellRftAddress::OBSERVED
? RimPlotCurve::STYLE_NONE : RimPlotCurve::STYLE_SOLID; ? RimPlotCurve::STYLE_NONE : RimPlotCurve::STYLE_SOLID;
newCurve->setColor(currentColor); newCurve->setColor(currentColor);
@ -223,15 +223,15 @@ void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
void RimWellRftPlot::updateSelectedTimeStepsFromSelectedSources() void RimWellRftPlot::updateSelectedTimeStepsFromSelectedSources()
{ {
std::vector<QDateTime> newTimeStepsSelections; std::vector<QDateTime> newTimeStepsSelections;
std::vector<RimWellRftAddress> selectedSourcesVector = selectedSources(); std::vector<RifWellRftAddress> selectedSourcesVector = selectedSources();
auto selectedSources = std::set<RimWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end()); auto selectedSources = std::set<RifWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
for (const QDateTime& timeStep : m_selectedTimeSteps()) for (const QDateTime& timeStep : m_selectedTimeSteps())
{ {
if(m_timeStepsToAddresses.count(timeStep) > 0) if(m_timeStepsToAddresses.count(timeStep) > 0)
{ {
std::vector<RimWellRftAddress> intersectVector; std::vector<RifWellRftAddress> intersectVector;
const std::set<RimWellRftAddress>& addresses = m_timeStepsToAddresses[timeStep]; const std::set<RifWellRftAddress>& addresses = m_timeStepsToAddresses[timeStep];
std::set_intersection(selectedSources.begin(), selectedSources.end(), std::set_intersection(selectedSources.begin(), selectedSources.end(),
addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end())); addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end()));
if(intersectVector.size() > 0) if(intersectVector.size() > 0)
@ -250,27 +250,27 @@ void RimWellRftPlot::applyInitialSelections()
{ {
std::vector<std::tuple<RimEclipseResultCase*, bool, bool>> eclCaseTuples = eclipseCasesForWell(m_wellName); std::vector<std::tuple<RimEclipseResultCase*, bool, bool>> eclCaseTuples = eclipseCasesForWell(m_wellName);
std::vector<RimWellRftAddress> sourcesToSelect; std::vector<RifWellRftAddress> sourcesToSelect;
std::map<QDateTime, std::set<RimWellRftAddress>> rftTimeStepsMap; std::map<QDateTime, std::set<RifWellRftAddress>> rftTimeStepsMap;
std::map<QDateTime, std::set<RimWellRftAddress>> observedTimeStepsMap; std::map<QDateTime, std::set<RifWellRftAddress>> observedTimeStepsMap;
std::map<QDateTime, std::set<RimWellRftAddress>> gridTimeStepsMap; std::map<QDateTime, std::set<RifWellRftAddress>> gridTimeStepsMap;
for(RimEclipseResultCase* const rftCase : rftCasesFromEclipseCases(eclCaseTuples)) for(RimEclipseResultCase* const rftCase : rftCasesFromEclipseCases(eclCaseTuples))
{ {
sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::RFT, rftCase)); sourcesToSelect.push_back(RifWellRftAddress(RifWellRftAddress::RFT, rftCase));
addTimeStepsToMap(rftTimeStepsMap, timeStepsFromRftCase(rftCase)); addTimeStepsToMap(rftTimeStepsMap, timeStepsFromRftCase(rftCase));
} }
for (RimEclipseResultCase* const gridCase : gridCasesFromEclipseCases(eclCaseTuples)) for (RimEclipseResultCase* const gridCase : gridCasesFromEclipseCases(eclCaseTuples))
{ {
sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::GRID, gridCase)); sourcesToSelect.push_back(RifWellRftAddress(RifWellRftAddress::GRID, gridCase));
addTimeStepsToMap(gridTimeStepsMap, timeStepsFromGridCase(gridCase)); addTimeStepsToMap(gridTimeStepsMap, timeStepsFromGridCase(gridCase));
} }
std::vector<RimWellLogFile*> wellLogFiles = wellLogFilesContainingPressure(m_wellName); std::vector<RimWellLogFile*> wellLogFiles = wellLogFilesContainingPressure(m_wellName);
if(wellLogFiles.size() > 0) if(wellLogFiles.size() > 0)
{ {
sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::OBSERVED)); sourcesToSelect.push_back(RifWellRftAddress(RifWellRftAddress::OBSERVED));
for (RimWellLogFile* const wellLogFile : wellLogFiles) for (RimWellLogFile* const wellLogFile : wellLogFiles)
{ {
addTimeStepsToMap(observedTimeStepsMap, timeStepsFromWellLogFile(wellLogFile)); addTimeStepsToMap(observedTimeStepsMap, timeStepsFromWellLogFile(wellLogFile));
@ -280,11 +280,11 @@ void RimWellRftPlot::applyInitialSelections()
m_selectedSources = sourcesToSelect; m_selectedSources = sourcesToSelect;
std::set<QDateTime> timeStepsToSelect; std::set<QDateTime> timeStepsToSelect;
for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& dateTimePair : rftTimeStepsMap) for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& dateTimePair : rftTimeStepsMap)
{ {
timeStepsToSelect.insert(dateTimePair.first); timeStepsToSelect.insert(dateTimePair.first);
} }
for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& dateTimePair : observedTimeStepsMap) for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& dateTimePair : observedTimeStepsMap)
{ {
timeStepsToSelect.insert(dateTimePair.first); timeStepsToSelect.insert(dateTimePair.first);
} }
@ -301,26 +301,26 @@ void RimWellRftPlot::applyInitialSelections()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellRftPlot::updateEditorsFromCurves() void RimWellRftPlot::updateEditorsFromCurves()
{ {
std::set<RimWellRftAddress> selectedSources; std::set<RifWellRftAddress> selectedSources;
std::set<QDateTime> selectedTimeSteps; std::set<QDateTime> selectedTimeSteps;
std::map<QDateTime, std::set<RimWellRftAddress>> selectedTimeStepsMap; std::map<QDateTime, std::set<RifWellRftAddress>> selectedTimeStepsMap;
for (const std::pair<RimWellRftAddress, QDateTime>& curveDef : curveDefsFromCurves()) for (const std::pair<RifWellRftAddress, QDateTime>& curveDef : curveDefsFromCurves())
{ {
if (curveDef.first.sourceType() == RftSourceType::OBSERVED) if (curveDef.first.sourceType() == RifWellRftAddress::OBSERVED)
selectedSources.insert(RimWellRftAddress(RftSourceType::OBSERVED)); selectedSources.insert(RifWellRftAddress(RifWellRftAddress::OBSERVED));
else else
selectedSources.insert(curveDef.first); selectedSources.insert(curveDef.first);
auto newTimeStepMap = std::map<QDateTime, std::set<RimWellRftAddress>> auto newTimeStepMap = std::map<QDateTime, std::set<RifWellRftAddress>>
{ {
{ curveDef.second, std::set<RimWellRftAddress> { curveDef.first} } { curveDef.second, std::set<RifWellRftAddress> { curveDef.first} }
}; };
addTimeStepsToMap(selectedTimeStepsMap, newTimeStepMap); addTimeStepsToMap(selectedTimeStepsMap, newTimeStepMap);
selectedTimeSteps.insert(curveDef.second); selectedTimeSteps.insert(curveDef.second);
} }
m_selectedSources = std::vector<RimWellRftAddress>(selectedSources.begin(), selectedSources.end()); m_selectedSources = std::vector<RifWellRftAddress>(selectedSources.begin(), selectedSources.end());
m_selectedTimeSteps = std::vector<QDateTime>(selectedTimeSteps.begin(), selectedTimeSteps.end()); m_selectedTimeSteps = std::vector<QDateTime>(selectedTimeSteps.begin(), selectedTimeSteps.end());
addTimeStepsToMap(m_timeStepsToAddresses, selectedTimeStepsMap); addTimeStepsToMap(m_timeStepsToAddresses, selectedTimeStepsMap);
} }
@ -351,22 +351,22 @@ void RimWellRftPlot::updateWidgetTitleWindowTitle()
void RimWellRftPlot::syncCurvesFromUiSelection() void RimWellRftPlot::syncCurvesFromUiSelection()
{ {
RimWellLogTrack* plotTrack = m_wellLogPlot->trackByIndex(0); RimWellLogTrack* plotTrack = m_wellLogPlot->trackByIndex(0);
const std::set<std::pair<RimWellRftAddress, QDateTime>>& allCurveDefs = selectedCurveDefs(); const std::set<std::pair<RifWellRftAddress, QDateTime>>& allCurveDefs = selectedCurveDefs();
const std::set<std::pair<RimWellRftAddress, QDateTime>>& curveDefsInPlot = curveDefsFromCurves(); const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefsInPlot = curveDefsFromCurves();
std::set<RimWellLogCurve*> curvesToDelete; std::set<RimWellLogCurve*> curvesToDelete;
std::set<std::pair<RimWellRftAddress, QDateTime>> newCurveDefs; std::set<std::pair<RifWellRftAddress, QDateTime>> newCurveDefs;
if (allCurveDefs.size() < curveDefsInPlot.size()) if (allCurveDefs.size() < curveDefsInPlot.size())
{ {
// Determine which curves to delete from plot // Determine which curves to delete from plot
std::set<std::pair<RimWellRftAddress, QDateTime>> deleteCurveDefs; std::set<std::pair<RifWellRftAddress, QDateTime>> deleteCurveDefs;
std::set_difference(curveDefsInPlot.begin(), curveDefsInPlot.end(), std::set_difference(curveDefsInPlot.begin(), curveDefsInPlot.end(),
allCurveDefs.begin(), allCurveDefs.end(), allCurveDefs.begin(), allCurveDefs.end(),
std::inserter(deleteCurveDefs, deleteCurveDefs.end())); std::inserter(deleteCurveDefs, deleteCurveDefs.end()));
for (RimWellLogCurve* const curve : plotTrack->curvesVector()) for (RimWellLogCurve* const curve : plotTrack->curvesVector())
{ {
std::pair<RimWellRftAddress, QDateTime> curveDef = curveDefFromCurve(curve); std::pair<RifWellRftAddress, QDateTime> curveDef = curveDefFromCurve(curve);
if (deleteCurveDefs.count(curveDef) > 0) if (deleteCurveDefs.count(curveDef) > 0)
curvesToDelete.insert(curve); curvesToDelete.insert(curve);
} }
@ -533,9 +533,9 @@ RimWellRftPlot::rftCasesFromEclipseCases(const std::vector<std::tuple<RimEclipse
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RimWellRftAddress>> RimWellRftPlot::timeStepsFromRftCase(RimEclipseResultCase* rftCase) const std::map<QDateTime, std::set<RifWellRftAddress>> RimWellRftPlot::timeStepsFromRftCase(RimEclipseResultCase* rftCase) const
{ {
std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsMap; std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
RifReaderEclipseRft* const reader = rftCase->rftReader(); RifReaderEclipseRft* const reader = rftCase->rftReader();
if (reader != nullptr) if (reader != nullptr)
{ {
@ -543,9 +543,9 @@ std::map<QDateTime, std::set<RimWellRftAddress>> RimWellRftPlot::timeStepsFromRf
{ {
if (timeStepsMap.count(timeStep) == 0) if (timeStepsMap.count(timeStep) == 0)
{ {
timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>())); timeStepsMap.insert(std::make_pair(timeStep, std::set<RifWellRftAddress>()));
} }
timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::RFT, rftCase)); timeStepsMap[timeStep].insert(RifWellRftAddress(RifWellRftAddress::RFT, rftCase));
} }
} }
return timeStepsMap; return timeStepsMap;
@ -554,23 +554,23 @@ std::map<QDateTime, std::set<RimWellRftAddress>> RimWellRftPlot::timeStepsFromRf
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RimWellRftAddress>> RimWellRftPlot::timeStepsFromGridCase(RimEclipseCase* gridCase) const std::map<QDateTime, std::set<RifWellRftAddress>> RimWellRftPlot::timeStepsFromGridCase(RimEclipseCase* gridCase) const
{ {
const RigEclipseCaseData* const eclipseCaseData = gridCase->eclipseCaseData(); const RigEclipseCaseData* const eclipseCaseData = gridCase->eclipseCaseData();
size_t resultIndex = eclipseCaseData != nullptr ? size_t resultIndex = eclipseCaseData != nullptr ?
eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, PRESSURE_DATA_NAME) : eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, PRESSURE_DATA_NAME) :
cvf::UNDEFINED_SIZE_T; cvf::UNDEFINED_SIZE_T;
std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsMap; std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
if (resultIndex != cvf::UNDEFINED_SIZE_T) if (resultIndex != cvf::UNDEFINED_SIZE_T)
{ {
for (const QDateTime& timeStep : eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->timeStepDates(resultIndex)) for (const QDateTime& timeStep : eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->timeStepDates(resultIndex))
{ {
if (timeStepsMap.count(timeStep) == 0) if (timeStepsMap.count(timeStep) == 0)
{ {
timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>())); timeStepsMap.insert(std::make_pair(timeStep, std::set<RifWellRftAddress>()));
} }
timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::GRID, gridCase)); timeStepsMap[timeStep].insert(RifWellRftAddress(RifWellRftAddress::GRID, gridCase));
} }
} }
return timeStepsMap; return timeStepsMap;
@ -579,17 +579,17 @@ std::map<QDateTime, std::set<RimWellRftAddress>> RimWellRftPlot::timeStepsFromGr
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RimWellRftAddress> > RimWellRftPlot::timeStepsFromWellLogFile(RimWellLogFile* wellLogFile) const std::map<QDateTime, std::set<RifWellRftAddress> > RimWellRftPlot::timeStepsFromWellLogFile(RimWellLogFile* wellLogFile) const
{ {
std::map<QDateTime, std::set<RimWellRftAddress> > timeStepsMap; std::map<QDateTime, std::set<RifWellRftAddress> > timeStepsMap;
QDateTime timeStep = RiaDateStringParser::parseDateString(wellLogFile->date()); QDateTime timeStep = RiaDateStringParser::parseDateString(wellLogFile->date());
if (timeStepsMap.count(timeStep) == 0) if (timeStepsMap.count(timeStep) == 0)
{ {
timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>())); timeStepsMap.insert(std::make_pair(timeStep, std::set<RifWellRftAddress>()));
} }
timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::OBSERVED, wellLogFile)); timeStepsMap[timeStep].insert(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile));
return timeStepsMap; return timeStepsMap;
} }
@ -597,16 +597,16 @@ std::map<QDateTime, std::set<RimWellRftAddress> > RimWellRftPlot::timeStepsFromW
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RimWellRftAddress>> std::map<QDateTime, std::set<RifWellRftAddress>>
RimWellRftPlot::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>& allTimeSteps, RimWellRftPlot::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>& allTimeSteps,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& searchTimeStepPair) const std::pair<QDateTime, std::set<RifWellRftAddress>>& searchTimeStepPair)
{ {
std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsMap; std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
if (allTimeSteps.size() > 0) if (allTimeSteps.size() > 0)
{ {
auto itr = std::find_if(allTimeSteps.begin(), allTimeSteps.end(), auto itr = std::find_if(allTimeSteps.begin(), allTimeSteps.end(),
[searchTimeStepPair](const std::pair<QDateTime, std::set<RimWellRftAddress>>& dt) [searchTimeStepPair](const std::pair<QDateTime, std::set<RifWellRftAddress>>& dt)
{ {
return dt.first > searchTimeStepPair.first; return dt.first > searchTimeStepPair.first;
}); });
@ -628,9 +628,9 @@ RimWellRftPlot::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::se
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimWellRftPlot::mapContainsTimeStep(const std::map<QDateTime, std::set<RimWellRftAddress>>& map, const QDateTime& timeStep) bool RimWellRftPlot::mapContainsTimeStep(const std::map<QDateTime, std::set<RifWellRftAddress>>& map, const QDateTime& timeStep)
{ {
return std::find_if(map.begin(), map.end(), [timeStep](const std::pair<QDateTime, std::set<RimWellRftAddress>>& pair) return std::find_if(map.begin(), map.end(), [timeStep](const std::pair<QDateTime, std::set<RifWellRftAddress>>& pair)
{ {
return pair.first == timeStep; return pair.first == timeStep;
}) != map.end(); }) != map.end();
@ -639,47 +639,47 @@ bool RimWellRftPlot::mapContainsTimeStep(const std::map<QDateTime, std::set<RimW
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::set < std::pair<RimWellRftAddress, QDateTime>> RimWellRftPlot::selectedCurveDefs() const std::set < std::pair<RifWellRftAddress, QDateTime>> RimWellRftPlot::selectedCurveDefs() const
{ {
std::set<std::pair<RimWellRftAddress, QDateTime>> curveDefs; std::set<std::pair<RifWellRftAddress, QDateTime>> curveDefs;
const std::vector<std::tuple<RimEclipseResultCase*,bool,bool>>& eclipseCases = eclipseCasesForWell(m_wellName); const std::vector<std::tuple<RimEclipseResultCase*,bool,bool>>& eclipseCases = eclipseCasesForWell(m_wellName);
const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases); const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases); const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
for (const QDateTime& timeStep : m_selectedTimeSteps()) for (const QDateTime& timeStep : m_selectedTimeSteps())
{ {
for (const RimWellRftAddress& addr : selectedSources()) for (const RifWellRftAddress& addr : selectedSources())
{ {
if (addr.sourceType() == RftSourceType::RFT) if (addr.sourceType() == RifWellRftAddress::RFT)
{ {
for (RimEclipseResultCase* const rftCase : rftCases) for (RimEclipseResultCase* const rftCase : rftCases)
{ {
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromRftCase(rftCase); const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromRftCase(rftCase);
if (mapContainsTimeStep(timeStepsMap , timeStep)) if (mapContainsTimeStep(timeStepsMap , timeStep))
{ {
curveDefs.insert(std::make_pair(addr, timeStep)); curveDefs.insert(std::make_pair(addr, timeStep));
} }
} }
} }
else if (addr.sourceType() == RftSourceType::GRID) else if (addr.sourceType() == RifWellRftAddress::GRID)
{ {
for (RimEclipseResultCase* const gridCase : gridCases) for (RimEclipseResultCase* const gridCase : gridCases)
{ {
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase); const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
if (mapContainsTimeStep(timeStepsMap, timeStep)) if (mapContainsTimeStep(timeStepsMap, timeStep))
{ {
curveDefs.insert(std::make_pair(addr, timeStep)); curveDefs.insert(std::make_pair(addr, timeStep));
} }
} }
} }
else if (addr.sourceType() == RftSourceType::OBSERVED) else if (addr.sourceType() == RifWellRftAddress::OBSERVED)
{ {
if (addr.wellLogFile() != nullptr) if (addr.wellLogFile() != nullptr)
{ {
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromWellLogFile(addr.wellLogFile()); const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromWellLogFile(addr.wellLogFile());
if (mapContainsTimeStep(timeStepsMap, timeStep)) if (mapContainsTimeStep(timeStepsMap, timeStep))
{ {
curveDefs.insert(std::make_pair(RimWellRftAddress(RftSourceType::OBSERVED, addr.wellLogFile()), timeStep)); curveDefs.insert(std::make_pair(RifWellRftAddress(RifWellRftAddress::OBSERVED, addr.wellLogFile()), timeStep));
} }
} }
} }
@ -691,9 +691,9 @@ std::set < std::pair<RimWellRftAddress, QDateTime>> RimWellRftPlot::selectedCurv
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::set<std::pair<RimWellRftAddress, QDateTime>> RimWellRftPlot::curveDefsFromCurves() const std::set<std::pair<RifWellRftAddress, QDateTime>> RimWellRftPlot::curveDefsFromCurves() const
{ {
std::set<std::pair<RimWellRftAddress, QDateTime>> curveDefs; std::set<std::pair<RifWellRftAddress, QDateTime>> curveDefs;
RimWellLogTrack* const plotTrack = m_wellLogPlot->trackByIndex(0); RimWellLogTrack* const plotTrack = m_wellLogPlot->trackByIndex(0);
for (RimWellLogCurve* const curve : plotTrack->curvesVector()) for (RimWellLogCurve* const curve : plotTrack->curvesVector())
@ -706,7 +706,7 @@ std::set<std::pair<RimWellRftAddress, QDateTime>> RimWellRftPlot::curveDefsFromC
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::pair<RimWellRftAddress, QDateTime> RimWellRftPlot::curveDefFromCurve(const RimWellLogCurve* curve) const std::pair<RifWellRftAddress, QDateTime> RimWellRftPlot::curveDefFromCurve(const RimWellLogCurve* curve) const
{ {
const RimWellLogRftCurve* rftCurve = dynamic_cast<const RimWellLogRftCurve*>(curve); const RimWellLogRftCurve* rftCurve = dynamic_cast<const RimWellLogRftCurve*>(curve);
const RimWellLogExtractionCurve* gridCurve = dynamic_cast<const RimWellLogExtractionCurve*>(curve); const RimWellLogExtractionCurve* gridCurve = dynamic_cast<const RimWellLogExtractionCurve*>(curve);
@ -719,7 +719,7 @@ std::pair<RimWellRftAddress, QDateTime> RimWellRftPlot::curveDefFromCurve(const
{ {
const RifEclipseRftAddress rftAddress = rftCurve->rftAddress(); const RifEclipseRftAddress rftAddress = rftCurve->rftAddress();
const QDateTime timeStep = rftAddress.timeStep(); const QDateTime timeStep = rftAddress.timeStep();
return std::make_pair(RimWellRftAddress(RftSourceType::RFT, rftCase), timeStep); return std::make_pair(RifWellRftAddress(RifWellRftAddress::RFT, rftCase), timeStep);
} }
} }
else if (gridCurve != nullptr) else if (gridCurve != nullptr)
@ -728,12 +728,12 @@ std::pair<RimWellRftAddress, QDateTime> RimWellRftPlot::curveDefFromCurve(const
if (gridCase != nullptr) if (gridCase != nullptr)
{ {
size_t timeStepIndex = gridCurve->currentTimeStep(); size_t timeStepIndex = gridCurve->currentTimeStep();
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase); const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
auto timeStepsVector = std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>( auto timeStepsVector = std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>(
timeStepsMap.begin(), timeStepsMap.end()); timeStepsMap.begin(), timeStepsMap.end());
if (timeStepIndex < timeStepsMap.size()) if (timeStepIndex < timeStepsMap.size())
{ {
return std::make_pair(RimWellRftAddress(RftSourceType::GRID, gridCase), return std::make_pair(RifWellRftAddress(RifWellRftAddress::GRID, gridCase),
timeStepsVector[timeStepIndex].first); timeStepsVector[timeStepIndex].first);
} }
} }
@ -749,18 +749,18 @@ std::pair<RimWellRftAddress, QDateTime> RimWellRftPlot::curveDefFromCurve(const
if (date.isValid()) if (date.isValid())
{ {
return std::make_pair(RimWellRftAddress(RftSourceType::OBSERVED, wellLogFile), date); return std::make_pair(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile), date);
} }
} }
} }
return std::make_pair(RimWellRftAddress(), QDateTime()); return std::make_pair(RifWellRftAddress(), QDateTime());
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddress, QDateTime>>& allCurveDefs, void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RifWellRftAddress, QDateTime>>& allCurveDefs,
const std::set<std::pair<RimWellRftAddress, QDateTime>>& curveDefsToAdd, const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefsToAdd,
const std::set<RimWellLogCurve*>& curvesToDelete) const std::set<RimWellLogCurve*>& curvesToDelete)
{ {
RimWellLogTrack* const plotTrack = m_wellLogPlot->trackByIndex(0); RimWellLogTrack* const plotTrack = m_wellLogPlot->trackByIndex(0);
@ -772,9 +772,9 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
} }
// Add new curves // Add new curves
for (const std::pair<RimWellRftAddress, QDateTime>& curveDefToAdd : curveDefsToAdd) for (const std::pair<RifWellRftAddress, QDateTime>& curveDefToAdd : curveDefsToAdd)
{ {
if (curveDefToAdd.first.sourceType() == RftSourceType::RFT) if (curveDefToAdd.first.sourceType() == RifWellRftAddress::RFT)
{ {
auto curve = new RimWellLogRftCurve(); auto curve = new RimWellLogRftCurve();
plotTrack->addCurve(curve); plotTrack->addCurve(curve);
@ -789,7 +789,7 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
applyCurveAppearance(curve); applyCurveAppearance(curve);
curve->loadDataAndUpdate(true); curve->loadDataAndUpdate(true);
} }
else if (curveDefToAdd.first.sourceType() == RftSourceType::GRID) else if (curveDefToAdd.first.sourceType() == RifWellRftAddress::GRID)
{ {
auto curve = new RimWellLogExtractionCurve(); auto curve = new RimWellLogExtractionCurve();
plotTrack->addCurve(curve); plotTrack->addCurve(curve);
@ -811,9 +811,9 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
curve->setEclipseResultDefinition(resultDef); curve->setEclipseResultDefinition(resultDef);
// Time step // Time step
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeSteps = timeStepsFromGridCase(gridCase); const std::map<QDateTime, std::set<RifWellRftAddress>>& timeSteps = timeStepsFromGridCase(gridCase);
auto currentTimeStepItr = std::find_if(timeSteps.begin(), timeSteps.end(), auto currentTimeStepItr = std::find_if(timeSteps.begin(), timeSteps.end(),
[curveDefToAdd](std::pair<QDateTime, std::set<RimWellRftAddress>> pair) {return pair.first == curveDefToAdd.second; }); [curveDefToAdd](std::pair<QDateTime, std::set<RifWellRftAddress>> pair) {return pair.first == curveDefToAdd.second; });
auto currentTimeStepIndex = std::distance(timeSteps.begin(), currentTimeStepItr); auto currentTimeStepIndex = std::distance(timeSteps.begin(), currentTimeStepItr);
curve->setCurrentTimeStep(currentTimeStepIndex); curve->setCurrentTimeStep(currentTimeStepIndex);
curve->setZOrder(0); curve->setZOrder(0);
@ -822,7 +822,7 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
curve->loadDataAndUpdate(false); curve->loadDataAndUpdate(false);
} }
} }
else if (curveDefToAdd.first.sourceType() == RftSourceType::OBSERVED) else if (curveDefToAdd.first.sourceType() == RifWellRftAddress::OBSERVED)
{ {
RimWellLogFile* const wellLogFile = curveDefToAdd.first.wellLogFile(); RimWellLogFile* const wellLogFile = curveDefToAdd.first.wellLogFile();
RimWellPath* const wellPath = wellPathFromWellLogFile(wellLogFile); RimWellPath* const wellPath = wellPathFromWellLogFile(wellLogFile);
@ -848,21 +848,21 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimWellRftPlot::isOnlyGridSourcesSelected() const bool RimWellRftPlot::isOnlyGridSourcesSelected() const
{ {
const std::vector<RimWellRftAddress>& selSources = m_selectedSources(); const std::vector<RifWellRftAddress>& selSources = m_selectedSources();
return std::find_if(selSources.begin(), selSources.end(), [](const RimWellRftAddress& addr) return std::find_if(selSources.begin(), selSources.end(), [](const RifWellRftAddress& addr)
{ {
return addr.sourceType() == RftSourceType::RFT || addr.sourceType() == RftSourceType::OBSERVED; return addr.sourceType() == RifWellRftAddress::RFT || addr.sourceType() == RifWellRftAddress::OBSERVED;
}) == selSources.end(); }) == selSources.end();
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimWellRftPlot::isAnySourceAddressSelected(const std::set<RimWellRftAddress>& addresses) const bool RimWellRftPlot::isAnySourceAddressSelected(const std::set<RifWellRftAddress>& addresses) const
{ {
const std::vector<RimWellRftAddress>& selectedSourcesVector = m_selectedSources(); const std::vector<RifWellRftAddress>& selectedSourcesVector = m_selectedSources();
const auto selectedSources = std::set<RimWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end()); const auto selectedSources = std::set<RifWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RimWellRftAddress> intersectVector; std::vector<RifWellRftAddress> intersectVector;
std::set_intersection(selectedSources.begin(), selectedSources.end(), std::set_intersection(selectedSources.begin(), selectedSources.end(),
addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end())); addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end()));
@ -872,16 +872,16 @@ bool RimWellRftPlot::isAnySourceAddressSelected(const std::set<RimWellRftAddress
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<RimWellRftAddress> RimWellRftPlot::selectedSources() const std::vector<RifWellRftAddress> RimWellRftPlot::selectedSources() const
{ {
std::vector<RimWellRftAddress> sources; std::vector<RifWellRftAddress> sources;
for (const RimWellRftAddress& addr : m_selectedSources()) for (const RifWellRftAddress& addr : m_selectedSources())
{ {
if (addr.sourceType() == RftSourceType::OBSERVED) if (addr.sourceType() == RifWellRftAddress::OBSERVED)
{ {
for (RimWellLogFile* const wellLogFile : wellLogFilesContainingPressure(m_wellName)) for (RimWellLogFile* const wellLogFile : wellLogFilesContainingPressure(m_wellName))
{ {
sources.push_back(RimWellRftAddress(RftSourceType::OBSERVED, wellLogFile)); sources.push_back(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile));
} }
} }
else else
@ -1003,11 +1003,11 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions(const caf::P
const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases); const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
if (rftCases.size() > 0) if (rftCases.size() > 0)
{ {
options.push_back(caf::PdmOptionItemInfo::createHeader(RimWellRftAddress::sourceTypeUiText(RftSourceType::RFT), true)); options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RifWellRftAddress::RFT), true));
} }
for (const auto& rftCase : rftCases) for (const auto& rftCase : rftCases)
{ {
auto addr = RimWellRftAddress(RftSourceType::RFT, rftCase); auto addr = RifWellRftAddress(RifWellRftAddress::RFT, rftCase);
auto item = caf::PdmOptionItemInfo(rftCase->caseUserDescription(), QVariant::fromValue(addr)); auto item = caf::PdmOptionItemInfo(rftCase->caseUserDescription(), QVariant::fromValue(addr));
item.setLevel(1); item.setLevel(1);
options.push_back(item); options.push_back(item);
@ -1016,11 +1016,11 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions(const caf::P
const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases); const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
if (gridCases.size() > 0) if (gridCases.size() > 0)
{ {
options.push_back(caf::PdmOptionItemInfo::createHeader(RimWellRftAddress::sourceTypeUiText(RftSourceType::GRID), true)); options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RifWellRftAddress::GRID), true));
} }
for (const auto& gridCase : gridCases) for (const auto& gridCase : gridCases)
{ {
auto addr = RimWellRftAddress(RftSourceType::GRID, gridCase); auto addr = RifWellRftAddress(RifWellRftAddress::GRID, gridCase);
auto item = caf::PdmOptionItemInfo(gridCase->caseUserDescription(), QVariant::fromValue(addr)); auto item = caf::PdmOptionItemInfo(gridCase->caseUserDescription(), QVariant::fromValue(addr));
item.setLevel(1); item.setLevel(1);
options.push_back(item); options.push_back(item);
@ -1028,9 +1028,9 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions(const caf::P
if (wellLogFilesContainingPressure(m_wellName).size() > 0) if (wellLogFilesContainingPressure(m_wellName).size() > 0)
{ {
options.push_back(caf::PdmOptionItemInfo::createHeader(RimWellRftAddress::sourceTypeUiText(RftSourceType::OBSERVED), true)); options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RifWellRftAddress::OBSERVED), true));
auto addr = RimWellRftAddress(RftSourceType::OBSERVED); auto addr = RifWellRftAddress(RifWellRftAddress::OBSERVED);
auto item = caf::PdmOptionItemInfo("Observed Data", QVariant::fromValue(addr)); auto item = caf::PdmOptionItemInfo("Observed Data", QVariant::fromValue(addr));
item.setLevel(1); item.setLevel(1);
options.push_back(item); options.push_back(item);
@ -1150,18 +1150,18 @@ void RimWellRftPlot::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering&
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellRftPlot::addTimeStepToMap(std::map<QDateTime, std::set<RimWellRftAddress>>& destMap, void RimWellRftPlot::addTimeStepToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepToAdd) const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepToAdd)
{ {
auto timeStepMapToAdd = std::map<QDateTime, std::set<RimWellRftAddress>> { timeStepToAdd }; auto timeStepMapToAdd = std::map<QDateTime, std::set<RifWellRftAddress>> { timeStepToAdd };
addTimeStepsToMap(destMap, timeStepMapToAdd); addTimeStepsToMap(destMap, timeStepMapToAdd);
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellRftPlot::addTimeStepsToMap(std::map<QDateTime, std::set<RimWellRftAddress>>& destMap, void RimWellRftPlot::addTimeStepsToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsToAdd) const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsToAdd)
{ {
for (const auto& timeStepPair : timeStepsToAdd) for (const auto& timeStepPair : timeStepsToAdd)
{ {
@ -1169,7 +1169,7 @@ void RimWellRftPlot::addTimeStepsToMap(std::map<QDateTime, std::set<RimWellRftAd
{ {
if (destMap.count(timeStepPair.first) == 0) if (destMap.count(timeStepPair.first) == 0)
{ {
destMap.insert(std::make_pair(timeStepPair.first, std::set<RimWellRftAddress>())); destMap.insert(std::make_pair(timeStepPair.first, std::set<RifWellRftAddress>()));
} }
auto addresses = timeStepPair.second; auto addresses = timeStepPair.second;
destMap[timeStepPair.first].insert(addresses.begin(), addresses.end()); destMap[timeStepPair.first].insert(addresses.begin(), addresses.end());
@ -1212,28 +1212,28 @@ void RimWellRftPlot::calculateValueOptionsForWells(QList<caf::PdmOptionItemInfo>
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellRftPlot::calculateValueOptionsForTimeSteps(const QString& wellName, QList<caf::PdmOptionItemInfo>& options) void RimWellRftPlot::calculateValueOptionsForTimeSteps(const QString& wellName, QList<caf::PdmOptionItemInfo>& options)
{ {
std::map<QDateTime, std::set<RimWellRftAddress>> displayTimeStepsMap, obsAndRftTimeStepsMap, gridTimeStepsMap; std::map<QDateTime, std::set<RifWellRftAddress>> displayTimeStepsMap, obsAndRftTimeStepsMap, gridTimeStepsMap;
const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCases = eclipseCasesForWell(wellName); const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCases = eclipseCasesForWell(wellName);
const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases); const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases); const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
for (const RimWellRftAddress& selection : selectedSources()) for (const RifWellRftAddress& selection : selectedSources())
{ {
if (selection.sourceType() == RftSourceType::RFT) if (selection.sourceType() == RifWellRftAddress::RFT)
{ {
for (RimEclipseResultCase* const rftCase : rftCases) for (RimEclipseResultCase* const rftCase : rftCases)
{ {
addTimeStepsToMap(obsAndRftTimeStepsMap, timeStepsFromRftCase(rftCase)); addTimeStepsToMap(obsAndRftTimeStepsMap, timeStepsFromRftCase(rftCase));
} }
} }
else if (selection.sourceType() == RftSourceType::GRID) else if (selection.sourceType() == RifWellRftAddress::GRID)
{ {
for (RimEclipseResultCase* const gridCase : gridCases) for (RimEclipseResultCase* const gridCase : gridCases)
{ {
addTimeStepsToMap(gridTimeStepsMap, timeStepsFromGridCase(gridCase)); addTimeStepsToMap(gridTimeStepsMap, timeStepsFromGridCase(gridCase));
} }
} }
else if (selection.sourceType() == RftSourceType::OBSERVED) else if (selection.sourceType() == RifWellRftAddress::OBSERVED)
{ {
if (selection.wellLogFile() != nullptr) if (selection.wellLogFile() != nullptr)
{ {
@ -1248,11 +1248,11 @@ void RimWellRftPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
} }
else else
{ {
const auto gridTimeStepsVector = std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>(gridTimeStepsMap.begin(), gridTimeStepsMap.end()); const auto gridTimeStepsVector = std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>(gridTimeStepsMap.begin(), gridTimeStepsMap.end());
for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepPair : obsAndRftTimeStepsMap) for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : obsAndRftTimeStepsMap)
{ {
const std::map<QDateTime, std::set<RimWellRftAddress>>& adjTimeSteps = adjacentTimeSteps(gridTimeStepsVector, timeStepPair); const std::map<QDateTime, std::set<RifWellRftAddress>>& adjTimeSteps = adjacentTimeSteps(gridTimeStepsVector, timeStepPair);
addTimeStepsToMap(displayTimeStepsMap, adjTimeSteps); addTimeStepsToMap(displayTimeStepsMap, adjTimeSteps);
} }
@ -1267,7 +1267,7 @@ void RimWellRftPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
{ {
if (m_timeStepsToAddresses.count(timeStep) > 0) if (m_timeStepsToAddresses.count(timeStep) > 0)
{ {
const std::set<RimWellRftAddress> sourceAddresses = m_timeStepsToAddresses[timeStep]; const std::set<RifWellRftAddress> sourceAddresses = m_timeStepsToAddresses[timeStep];
if (isAnySourceAddressSelected(sourceAddresses)) if (isAnySourceAddressSelected(sourceAddresses))
{ {
addTimeStepToMap(displayTimeStepsMap, std::make_pair(timeStep, m_timeStepsToAddresses[timeStep])); addTimeStepToMap(displayTimeStepsMap, std::make_pair(timeStep, m_timeStepsToAddresses[timeStep]));
@ -1280,13 +1280,13 @@ void RimWellRftPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
// Create vector of all time steps // Create vector of all time steps
std::vector<QDateTime> allTimeSteps; std::vector<QDateTime> allTimeSteps;
for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepPair : m_timeStepsToAddresses) for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : m_timeStepsToAddresses)
{ {
allTimeSteps.push_back(timeStepPair.first); allTimeSteps.push_back(timeStepPair.first);
} }
const QString dateFormatString = RimTools::createTimeFormatStringFromDates(allTimeSteps); const QString dateFormatString = RimTools::createTimeFormatStringFromDates(allTimeSteps);
for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepPair : displayTimeStepsMap) for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : displayTimeStepsMap)
{ {
options.push_back(caf::PdmOptionItemInfo(timeStepPair.first.toString(dateFormatString), timeStepPair.first)); options.push_back(caf::PdmOptionItemInfo(timeStepPair.first.toString(dateFormatString), timeStepPair.first));
} }

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

@ -25,8 +25,10 @@
#include "cafPdmObject.h" #include "cafPdmObject.h"
#include "cafPdmPtrField.h" #include "cafPdmPtrField.h"
#include "cvfCollection.h" #include "cvfCollection.h"
#include "RimWellRftAddress.h"
#include "RimPlotCurve.h" #include "RimPlotCurve.h"
#include "RifWellRftAddressQMetaType.h"
#include <QPointer> #include <QPointer>
#include <QDate> #include <QDate>
#include <QMetaType> #include <QMetaType>
@ -100,10 +102,10 @@ protected:
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override; virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
private: private:
void addTimeStepToMap(std::map<QDateTime, std::set<RimWellRftAddress>>& destMap, void addTimeStepToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepToAdd); const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepToAdd);
void addTimeStepsToMap(std::map<QDateTime, std::set<RimWellRftAddress>>& destMap, void addTimeStepsToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsToAdd); const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsToAdd);
void calculateValueOptionsForWells(QList<caf::PdmOptionItemInfo>& options); void calculateValueOptionsForWells(QList<caf::PdmOptionItemInfo>& options);
void calculateValueOptionsForTimeSteps(const QString& wellName, QList<caf::PdmOptionItemInfo>& options); void calculateValueOptionsForTimeSteps(const QString& wellName, QList<caf::PdmOptionItemInfo>& options);
@ -120,22 +122,22 @@ private:
std::vector<std::tuple<RimEclipseResultCase*, bool, bool>> eclipseCasesForWell(const QString& wellName) const; std::vector<std::tuple<RimEclipseResultCase*, bool, bool>> eclipseCasesForWell(const QString& wellName) const;
std::vector<RimEclipseResultCase*> gridCasesFromEclipseCases(const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCasesTuple) const; std::vector<RimEclipseResultCase*> gridCasesFromEclipseCases(const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCasesTuple) const;
std::vector<RimEclipseResultCase*> rftCasesFromEclipseCases(const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCasesTuple) const; std::vector<RimEclipseResultCase*> rftCasesFromEclipseCases(const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCasesTuple) const;
std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsFromRftCase(RimEclipseResultCase* gridCase) const; std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsFromRftCase(RimEclipseResultCase* gridCase) const;
std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsFromGridCase(RimEclipseCase* gridCase) const; std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsFromGridCase(RimEclipseCase* gridCase) const;
std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsFromWellLogFile(RimWellLogFile* wellLogFile) const; std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsFromWellLogFile(RimWellLogFile* wellLogFile) const;
std::map<QDateTime, std::set<RimWellRftAddress>> adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>& allTimeSteps, std::map<QDateTime, std::set<RifWellRftAddress>> adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>& allTimeSteps,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& searchTimeStepPair); const std::pair<QDateTime, std::set<RifWellRftAddress>>& searchTimeStepPair);
static bool mapContainsTimeStep(const std::map<QDateTime, std::set<RimWellRftAddress>>& map, const QDateTime& timeStep); static bool mapContainsTimeStep(const std::map<QDateTime, std::set<RifWellRftAddress>>& map, const QDateTime& timeStep);
std::set<std::pair<RimWellRftAddress, QDateTime>> selectedCurveDefs() const; std::set<std::pair<RifWellRftAddress, QDateTime>> selectedCurveDefs() const;
std::set<std::pair<RimWellRftAddress, QDateTime>> curveDefsFromCurves() const; std::set<std::pair<RifWellRftAddress, QDateTime>> curveDefsFromCurves() const;
std::pair<RimWellRftAddress, QDateTime> curveDefFromCurve(const RimWellLogCurve* curve) const; std::pair<RifWellRftAddress, QDateTime> curveDefFromCurve(const RimWellLogCurve* curve) const;
void updateCurvesInPlot(const std::set<std::pair<RimWellRftAddress, QDateTime>>& allCurveDefs, void updateCurvesInPlot(const std::set<std::pair<RifWellRftAddress, QDateTime>>& allCurveDefs,
const std::set<std::pair<RimWellRftAddress, QDateTime>>& curveDefsToAdd, const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefsToAdd,
const std::set<RimWellLogCurve*>& curvesToDelete); const std::set<RimWellLogCurve*>& curvesToDelete);
bool isOnlyGridSourcesSelected() const; bool isOnlyGridSourcesSelected() const;
bool isAnySourceAddressSelected(const std::set<RimWellRftAddress>& addresses) const; bool isAnySourceAddressSelected(const std::set<RifWellRftAddress>& addresses) const;
std::vector<RimWellRftAddress> selectedSources() const; std::vector<RifWellRftAddress> selectedSources() const;
// RimViewWindow overrides // RimViewWindow overrides
@ -151,7 +153,7 @@ private:
caf::PdmField<QString> m_wellName; caf::PdmField<QString> m_wellName;
caf::PdmField<int> m_branchIndex; caf::PdmField<int> m_branchIndex;
caf::PdmField<std::vector<RimWellRftAddress>> m_selectedSources; caf::PdmField<std::vector<RifWellRftAddress>> m_selectedSources;
caf::PdmField<std::vector<QDateTime>> m_selectedTimeSteps; caf::PdmField<std::vector<QDateTime>> m_selectedTimeSteps;
@ -159,7 +161,7 @@ private:
caf::PdmChildField<RimWellLogPlot*> m_wellLogPlot; caf::PdmChildField<RimWellLogPlot*> m_wellLogPlot;
std::map<QDateTime, std::set<RimWellRftAddress>> m_timeStepsToAddresses; std::map<QDateTime, std::set<RifWellRftAddress>> m_timeStepsToAddresses;
bool m_selectedSourcesOrTimeStepsFieldsChanged; bool m_selectedSourcesOrTimeStepsFieldsChanged;
}; };