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}RifColumnBasedUserData.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
#${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}RifColumnBasedUserData.cpp
${CEE_CURRENT_LIST_DIR}RifKeywordVectorUserData.cpp
${CEE_CURRENT_LIST_DIR}RifWellRftAddress.cpp
# 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 "RimWellLogFile.h"
@ -25,32 +25,20 @@
#include <QString>
#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);
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_wellLogFile = wellLogFile;
@ -71,7 +59,7 @@ RimWellRftAddress::RimWellRftAddress(RftSourceType sourceType, RimWellLogFile* w
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RftSourceType RimWellRftAddress::sourceType() const
RifWellRftAddress::SourceType RifWellRftAddress::sourceType() const
{
return m_sourceType;
}
@ -79,7 +67,7 @@ RftSourceType RimWellRftAddress::sourceType() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseCase* RimWellRftAddress::eclCase() const
RimEclipseCase* RifWellRftAddress::eclCase() const
{
return m_eclCase;
}
@ -87,7 +75,7 @@ RimEclipseCase* RimWellRftAddress::eclCase() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellLogFile* RimWellRftAddress::wellLogFile() const
RimWellLogFile* RifWellRftAddress::wellLogFile() const
{
return m_wellLogFile;
}
@ -95,13 +83,13 @@ RimWellLogFile* RimWellRftAddress::wellLogFile() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimWellRftAddress::sourceTypeUiText(RftSourceType sourceType)
QString RifWellRftAddress::sourceTypeUiText(SourceType sourceType)
{
switch (sourceType)
{
case RftSourceType::RFT: return QString("RFT Cases");
case RftSourceType::GRID: return QString("Grid Cases");
case RftSourceType::OBSERVED: return QString("Observed Data");
case SourceType::RFT: return QString("RFT Cases");
case SourceType::GRID: return QString("Grid Cases");
case SourceType::OBSERVED: return QString("Observed Data");
}
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()
&& 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
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
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) ||
(addr1.m_sourceType == addr2.m_sourceType &&

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

@ -38,40 +38,39 @@ class RimEclipseCase;
///
///
//==================================================================================================
enum class RftSourceType
class RifWellRftAddress
{
public:
enum SourceType
{
NONE,
RFT,
GRID,
OBSERVED
};
};
class RimWellRftAddress
{
RifWellRftAddress();
RifWellRftAddress(SourceType sourceType, RimEclipseCase* eclCase);
RifWellRftAddress(SourceType sourceType, RimWellLogFile* wellLogFile = nullptr);
public:
RimWellRftAddress();
RimWellRftAddress(RftSourceType sourceType, RimEclipseCase* eclCase);
RimWellRftAddress(RftSourceType sourceType, RimWellLogFile* wellLogFile = nullptr);
RftSourceType sourceType() const;
SourceType sourceType() const;
RimEclipseCase* eclCase() const;
RimWellLogFile* wellLogFile() const;
static QString sourceTypeUiText(RftSourceType sourceType);
static QString sourceTypeUiText(SourceType sourceType);
friend QTextStream& operator >> (QTextStream& str, RimWellRftAddress& addr);
friend bool operator<(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2);
friend QTextStream& operator >> (QTextStream& str, RifWellRftAddress& addr);
friend bool operator<(const RifWellRftAddress& addr1, const RifWellRftAddress& addr2);
private:
RftSourceType m_sourceType;
SourceType m_sourceType;
caf::PdmPointer<RimEclipseCase> m_eclCase;
caf::PdmPointer<RimWellLogFile> m_wellLogFile;
};
Q_DECLARE_METATYPE(RimWellRftAddress);
//Q_DECLARE_METATYPE(RifWellRftAddress);
bool operator==(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2);
QTextStream& operator <<(QTextStream& str, const RimWellRftAddress& addr);
QTextStream& operator >> (QTextStream& str, RimWellRftAddress& addr);
bool operator<(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2);
bool operator==(const RifWellRftAddress& addr1, const RifWellRftAddress& addr2);
QTextStream& operator <<(QTextStream& str, const RifWellRftAddress& addr);
QTextStream& operator >> (QTextStream& str, RifWellRftAddress& addr);
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}RimWellRftPlot.h
${CEE_CURRENT_LIST_DIR}RimWellPltPlot.h
${CEE_CURRENT_LIST_DIR}RimWellRftAddress.h
${CEE_CURRENT_LIST_DIR}RimRftAddress.h
)
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}RimWellRftPlot.cpp
${CEE_CURRENT_LIST_DIR}RimWellPltPlot.cpp
${CEE_CURRENT_LIST_DIR}RimWellRftAddress.cpp
${CEE_CURRENT_LIST_DIR}RimRftAddress.cpp
)
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)
//{
// const std::pair<RimWellRftAddress, QDateTime>& newCurveDef = curveDefFromCurve(newCurve);
// const std::pair<RifWellRftAddress, QDateTime>& newCurveDef = curveDefFromCurve(newCurve);
//
// std::vector<cvf::Color3f> colorTable;
// RiaColorTables::summaryCurveDefaultPaletteColors().color3fArray().toStdVector(&colorTable);
@ -182,7 +182,7 @@ void RimWellPltPlot::deleteViewWidget()
// {
// if (curve == newCurve) continue;
//
// std::pair<RimWellRftAddress, QDateTime> cDef = curveDefFromCurve(curve);
// std::pair<RifWellRftAddress, QDateTime> cDef = curveDefFromCurve(curve);
// if (cDef.first == newCurveDef.first)
// {
// currentColor = curve->color();
@ -253,15 +253,15 @@ void RimWellPltPlot::deleteViewWidget()
void RimWellPltPlot::updateSelectedTimeStepsFromSelectedSources()
{
std::vector<QDateTime> newTimeStepsSelections;
std::vector<RimWellRftAddress> selectedSourcesVector = selectedSources();
auto selectedSources = std::set<RimWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RifWellRftAddress> selectedSourcesVector = selectedSources();
auto selectedSources = std::set<RifWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
for (const QDateTime& timeStep : m_selectedTimeSteps())
{
if(m_timeStepsToAddresses.count(timeStep) > 0)
{
std::vector<RimWellRftAddress> intersectVector;
const std::set<RimWellRftAddress>& addresses = m_timeStepsToAddresses[timeStep];
std::vector<RifWellRftAddress> intersectVector;
const std::set<RifWellRftAddress>& addresses = m_timeStepsToAddresses[timeStep];
std::set_intersection(selectedSources.begin(), selectedSources.end(),
addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end()));
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<RimWellRftAddress> sourcesToSelect;
// std::map<QDateTime, std::set<RimWellRftAddress>> rftTimeStepsMap;
// std::map<QDateTime, std::set<RimWellRftAddress>> observedTimeStepsMap;
// std::map<QDateTime, std::set<RimWellRftAddress>> gridTimeStepsMap;
// std::vector<RifWellRftAddress> sourcesToSelect;
// std::map<QDateTime, std::set<RifWellRftAddress>> rftTimeStepsMap;
// std::map<QDateTime, std::set<RifWellRftAddress>> observedTimeStepsMap;
// std::map<QDateTime, std::set<RifWellRftAddress>> gridTimeStepsMap;
//
// for(RimEclipseResultCase* const rftCase : rftCasesFromEclipseCases(eclCaseTuples))
// {
// sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::RFT, rftCase));
// sourcesToSelect.push_back(RifWellRftAddress(RftSourceType::RFT, rftCase));
// addTimeStepsToMap(rftTimeStepsMap, timeStepsFromRftCase(rftCase));
// }
//
// for (RimEclipseResultCase* const gridCase : gridCasesFromEclipseCases(eclCaseTuples))
// {
// sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::GRID, gridCase));
// sourcesToSelect.push_back(RifWellRftAddress(RftSourceType::GRID, gridCase));
// addTimeStepsToMap(gridTimeStepsMap, timeStepsFromGridCase(gridCase));
// }
//
// std::vector<RimWellLogFile*> wellLogFiles = wellLogFilesContainingFlow(m_wellName);
// if(wellLogFiles.size() > 0)
// {
// sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::OBSERVED));
// sourcesToSelect.push_back(RifWellRftAddress(RftSourceType::OBSERVED));
// for (RimWellLogFile* const wellLogFile : wellLogFiles)
// {
// addTimeStepsToMap(observedTimeStepsMap, timeStepsFromWellLogFile(wellLogFile));
@ -370,11 +370,11 @@ std::vector<RimEclipseCase*> RimWellPltPlot::eclipseCases() const
// m_selectedSources = sourcesToSelect;
//
// 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);
// }
// for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& dateTimePair : observedTimeStepsMap)
// for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& dateTimePair : observedTimeStepsMap)
// {
// timeStepsToSelect.insert(dateTimePair.first);
// }
@ -391,26 +391,26 @@ std::vector<RimEclipseCase*> RimWellPltPlot::eclipseCases() const
//--------------------------------------------------------------------------------------------------
void RimWellPltPlot::updateEditorsFromCurves()
{
// std::set<RimWellRftAddress> selectedSources;
// std::set<RifWellRftAddress> selectedSources;
// 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)
// selectedSources.insert(RimWellRftAddress(RftSourceType::OBSERVED));
// selectedSources.insert(RifWellRftAddress(RftSourceType::OBSERVED));
// else
// 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);
// 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());
// addTimeStepsToMap(m_timeStepsToAddresses, selectedTimeStepsMap);
}
@ -441,7 +441,7 @@ void RimWellPltPlot::updateWidgetTitleWindowTitle()
void RimWellPltPlot::syncCurvesFromUiSelection()
{
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);
}
@ -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();
// if (reader != nullptr)
// {
@ -608,9 +608,9 @@ RimWellPath* RimWellPltPlot::wellPathFromWellLogFile(const RimWellLogFile* wellL
// {
// 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;
@ -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();
// size_t resultIndex = eclipseCaseData != nullptr ?
// eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, PRESSURE_DATA_NAME) :
// cvf::UNDEFINED_SIZE_T;
//
// std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsMap;
// std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
// if (resultIndex != cvf::UNDEFINED_SIZE_T)
// {
// for (const QDateTime& timeStep : eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->timeStepDates(resultIndex))
// {
// 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;
@ -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());
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;
}
@ -662,16 +662,16 @@ std::map<QDateTime, std::set<RimWellRftAddress> > RimWellPltPlot::timeStepsFromW
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RimWellRftAddress>>
RimWellPltPlot::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>& allTimeSteps,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& searchTimeStepPair)
std::map<QDateTime, std::set<RifWellRftAddress>>
RimWellPltPlot::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>& allTimeSteps,
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)
{
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;
});
@ -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;
}) != 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<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
//const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
for (const QDateTime& timeStep : m_selectedTimeSteps())
{
for (const RimWellRftAddress& addr : selectedSources())
for (const RifWellRftAddress& addr : selectedSources())
{
//if (addr.sourceType() == RftSourceType::RFT)
//{
// 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))
// {
// curveDefs.insert(std::make_pair(addr, timeStep));
@ -730,7 +730,7 @@ std::set < std::pair<RimWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurv
//{
// 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))
// {
// curveDefs.insert(std::make_pair(addr, timeStep));
@ -738,14 +738,14 @@ std::set < std::pair<RimWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurv
// }
//}
//else
if (addr.sourceType() == RftSourceType::OBSERVED)
if (addr.sourceType() == RifWellRftAddress::OBSERVED)
{
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))
{
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);
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 RimWellLogExtractionCurve* gridCurve = dynamic_cast<const RimWellLogExtractionCurve*>(curve);
@ -785,7 +785,7 @@ std::pair<RimWellRftAddress, QDateTime> RimWellPltPlot::curveDefFromCurve(const
// {
// const RifEclipseRftAddress rftAddress = rftCurve->rftAddress();
// 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)
@ -794,12 +794,12 @@ std::pair<RimWellRftAddress, QDateTime> RimWellPltPlot::curveDefFromCurve(const
// if (gridCase != nullptr)
// {
// size_t timeStepIndex = gridCurve->currentTimeStep();
// const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
// auto timeStepsVector = std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>(
// const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
// auto timeStepsVector = std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>(
// timeStepsMap.begin(), timeStepsMap.end());
// if (timeStepIndex < timeStepsMap.size())
// {
// return std::make_pair(RimWellRftAddress(RftSourceType::GRID, gridCase),
// return std::make_pair(RifWellRftAddress(RftSourceType::GRID, gridCase),
// timeStepsVector[timeStepIndex].first);
// }
// }
@ -816,17 +816,17 @@ std::pair<RimWellRftAddress, QDateTime> RimWellPltPlot::curveDefFromCurve(const
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);
@ -840,7 +840,7 @@ void RimWellPltPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
}
// Add curves
for (const std::pair<RimWellRftAddress, QDateTime>& curveDefToAdd : curveDefs)
for (const std::pair<RifWellRftAddress, QDateTime>& curveDefToAdd : curveDefs)
{
//if (curveDefToAdd.first.sourceType() == RftSourceType::RFT)
//{
@ -879,9 +879,9 @@ void RimWellPltPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
// curve->setEclipseResultDefinition(resultDef);
// // 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(),
// [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);
// curve->setCurrentTimeStep(currentTimeStepIndex);
// curve->setZOrder(0);
@ -891,7 +891,7 @@ void RimWellPltPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
// }
//}
//else
if (curveDefToAdd.first.sourceType() == RftSourceType::OBSERVED)
if (curveDefToAdd.first.sourceType() == RifWellRftAddress::OBSERVED)
{
RimWellLogFile* const wellLogFile = curveDefToAdd.first.wellLogFile();
RimWellPath* const wellPath = wellPathFromWellLogFile(wellLogFile);
@ -947,21 +947,21 @@ void RimWellPltPlot::addStackedCurve(const QString& channelName,
//--------------------------------------------------------------------------------------------------
bool RimWellPltPlot::isOnlyGridSourcesSelected() const
{
const std::vector<RimWellRftAddress>& selSources = m_selectedSources();
return std::find_if(selSources.begin(), selSources.end(), [](const RimWellRftAddress& addr)
const std::vector<RifWellRftAddress>& selSources = m_selectedSources();
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();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
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 auto selectedSources = std::set<RimWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RimWellRftAddress> intersectVector;
const std::vector<RifWellRftAddress>& selectedSourcesVector = m_selectedSources();
const auto selectedSources = std::set<RifWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RifWellRftAddress> intersectVector;
std::set_intersection(selectedSources.begin(), selectedSources.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;
for (const RimWellRftAddress& addr : m_selectedSources())
std::vector<RifWellRftAddress> sources;
for (const RifWellRftAddress& addr : m_selectedSources())
{
if (addr.sourceType() == RftSourceType::OBSERVED)
if (addr.sourceType() == RifWellRftAddress::OBSERVED)
{
for (RimWellLogFile* const wellLogFile : wellLogFilesContainingFlow(m_wellName))
{
sources.push_back(RimWellRftAddress(RftSourceType::OBSERVED, wellLogFile));
sources.push_back(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile));
}
}
else
@ -1107,11 +1107,11 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions(const caf::P
//const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
//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)
//{
// auto addr = RimWellRftAddress(RftSourceType::RFT, rftCase);
// auto addr = RifWellRftAddress(RftSourceType::RFT, rftCase);
// auto item = caf::PdmOptionItemInfo(rftCase->caseUserDescription(), QVariant::fromValue(addr));
// item.setLevel(1);
// options.push_back(item);
@ -1120,11 +1120,11 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions(const caf::P
//const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
//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)
//{
// auto addr = RimWellRftAddress(RftSourceType::GRID, gridCase);
// auto addr = RifWellRftAddress(RftSourceType::GRID, gridCase);
// auto item = caf::PdmOptionItemInfo(gridCase->caseUserDescription(), QVariant::fromValue(addr));
// item.setLevel(1);
// options.push_back(item);
@ -1132,9 +1132,9 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions(const caf::P
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));
item.setLevel(1);
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,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepToAdd)
void RimWellPltPlot::addTimeStepToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
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);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPltPlot::addTimeStepsToMap(std::map<QDateTime, std::set<RimWellRftAddress>>& destMap,
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsToAdd)
void RimWellPltPlot::addTimeStepsToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::map<QDateTime, std::set<RifWellRftAddress>>& 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)
{
destMap.insert(std::make_pair(timeStepPair.first, std::set<RimWellRftAddress>()));
destMap.insert(std::make_pair(timeStepPair.first, std::set<RifWellRftAddress>()));
}
auto addresses = timeStepPair.second;
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)
{
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<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
//const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
for (const RimWellRftAddress& selection : selectedSources())
for (const RifWellRftAddress& selection : selectedSources())
{
//if (selection.sourceType() == RftSourceType::RFT)
//{
@ -1374,7 +1374,7 @@ void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
// }
//}
//else
if (selection.sourceType() == RftSourceType::OBSERVED)
if (selection.sourceType() == RifWellRftAddress::OBSERVED)
{
if (selection.wellLogFile() != nullptr)
{
@ -1389,11 +1389,11 @@ void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
}
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);
}
@ -1408,7 +1408,7 @@ void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
{
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))
{
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
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);
}
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));
}

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

@ -26,8 +26,11 @@
#include "cafPdmObject.h"
#include "cafPdmPtrField.h"
#include "cvfCollection.h"
#include "RimWellRftAddress.h"
#include "RimPlotCurve.h"
#include "RifWellRftAddress.h"
#include "RifWellRftAddressQMetaType.h"
#include <QPointer>
#include <QDate>
#include <QMetaType>
@ -112,10 +115,10 @@ protected:
virtual void defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute);
private:
void addTimeStepToMap(std::map<QDateTime, std::set<RimWellRftAddress>>& destMap,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepToAdd);
void addTimeStepsToMap(std::map<QDateTime, std::set<RimWellRftAddress>>& destMap,
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsToAdd);
void addTimeStepToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepToAdd);
void addTimeStepsToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsToAdd);
void calculateValueOptionsForWells(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<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::map<QDateTime, std::set<RimWellRftAddress>> timeStepsFromRftCase(RimEclipseResultCase* gridCase) const;
//std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsFromGridCase(RimEclipseCase* gridCase) const;
std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsFromWellLogFile(RimWellLogFile* wellLogFile) const;
std::map<QDateTime, std::set<RimWellRftAddress>> adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>& allTimeSteps,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& searchTimeStepPair);
static bool mapContainsTimeStep(const std::map<QDateTime, std::set<RimWellRftAddress>>& map, const QDateTime& timeStep);
//std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsFromRftCase(RimEclipseResultCase* gridCase) const;
//std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsFromGridCase(RimEclipseCase* gridCase) const;
std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsFromWellLogFile(RimWellLogFile* wellLogFile) const;
std::map<QDateTime, std::set<RifWellRftAddress>> adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>& allTimeSteps,
const std::pair<QDateTime, std::set<RifWellRftAddress>>& searchTimeStepPair);
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<RimWellRftAddress, QDateTime>> curveDefsFromCurves() const;
std::pair<RimWellRftAddress, QDateTime> curveDefFromCurve(const RimWellLogCurve* curve) const;
void updateCurvesInPlot(const std::set<std::pair<RimWellRftAddress, QDateTime>>& curveDefs);
std::set<std::pair<RifWellRftAddress, QDateTime>> selectedCurveDefs() const;
std::set<std::pair<RifWellRftAddress, QDateTime>> curveDefsFromCurves() const;
std::pair<RifWellRftAddress, QDateTime> curveDefFromCurve(const RimWellLogCurve* curve) const;
void updateCurvesInPlot(const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefs);
void addStackedCurve(const QString& tracerName,
const std::vector<double>& depthValues,
const std::vector<double>& accFlow,
RimWellLogTrack* plotTrack);
bool isOnlyGridSourcesSelected() const;
bool isAnySourceAddressSelected(const std::set<RimWellRftAddress>& addresses) const;
std::vector<RimWellRftAddress> selectedSources() const;
bool isAnySourceAddressSelected(const std::set<RifWellRftAddress>& addresses) const;
std::vector<RifWellRftAddress> selectedSources() const;
// RimViewWindow overrides
@ -169,7 +172,7 @@ private:
caf::PdmField<QString> m_wellName;
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;
@ -177,7 +180,7 @@ private:
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<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)
{
const std::pair<RimWellRftAddress, QDateTime>& newCurveDef = curveDefFromCurve(newCurve);
const std::pair<RifWellRftAddress, QDateTime>& newCurveDef = curveDefFromCurve(newCurve);
std::vector<cvf::Color3f> colorTable;
RiaColorTables::summaryCurveDefaultPaletteColors().color3fArray().toStdVector(&colorTable);
@ -152,7 +152,7 @@ void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
{
if (curve == newCurve) continue;
std::pair<RimWellRftAddress, QDateTime> cDef = curveDefFromCurve(curve);
std::pair<RifWellRftAddress, QDateTime> cDef = curveDefFromCurve(curve);
if (cDef.first == newCurveDef.first)
{
currentColor = curve->color();
@ -209,7 +209,7 @@ void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
}
// Observed data
currentLineStyle = newCurveDef.first.sourceType() == RftSourceType::OBSERVED
currentLineStyle = newCurveDef.first.sourceType() == RifWellRftAddress::OBSERVED
? RimPlotCurve::STYLE_NONE : RimPlotCurve::STYLE_SOLID;
newCurve->setColor(currentColor);
@ -223,15 +223,15 @@ void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
void RimWellRftPlot::updateSelectedTimeStepsFromSelectedSources()
{
std::vector<QDateTime> newTimeStepsSelections;
std::vector<RimWellRftAddress> selectedSourcesVector = selectedSources();
auto selectedSources = std::set<RimWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RifWellRftAddress> selectedSourcesVector = selectedSources();
auto selectedSources = std::set<RifWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
for (const QDateTime& timeStep : m_selectedTimeSteps())
{
if(m_timeStepsToAddresses.count(timeStep) > 0)
{
std::vector<RimWellRftAddress> intersectVector;
const std::set<RimWellRftAddress>& addresses = m_timeStepsToAddresses[timeStep];
std::vector<RifWellRftAddress> intersectVector;
const std::set<RifWellRftAddress>& addresses = m_timeStepsToAddresses[timeStep];
std::set_intersection(selectedSources.begin(), selectedSources.end(),
addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end()));
if(intersectVector.size() > 0)
@ -250,27 +250,27 @@ void RimWellRftPlot::applyInitialSelections()
{
std::vector<std::tuple<RimEclipseResultCase*, bool, bool>> eclCaseTuples = eclipseCasesForWell(m_wellName);
std::vector<RimWellRftAddress> sourcesToSelect;
std::map<QDateTime, std::set<RimWellRftAddress>> rftTimeStepsMap;
std::map<QDateTime, std::set<RimWellRftAddress>> observedTimeStepsMap;
std::map<QDateTime, std::set<RimWellRftAddress>> gridTimeStepsMap;
std::vector<RifWellRftAddress> sourcesToSelect;
std::map<QDateTime, std::set<RifWellRftAddress>> rftTimeStepsMap;
std::map<QDateTime, std::set<RifWellRftAddress>> observedTimeStepsMap;
std::map<QDateTime, std::set<RifWellRftAddress>> gridTimeStepsMap;
for(RimEclipseResultCase* const rftCase : rftCasesFromEclipseCases(eclCaseTuples))
{
sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::RFT, rftCase));
sourcesToSelect.push_back(RifWellRftAddress(RifWellRftAddress::RFT, rftCase));
addTimeStepsToMap(rftTimeStepsMap, timeStepsFromRftCase(rftCase));
}
for (RimEclipseResultCase* const gridCase : gridCasesFromEclipseCases(eclCaseTuples))
{
sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::GRID, gridCase));
sourcesToSelect.push_back(RifWellRftAddress(RifWellRftAddress::GRID, gridCase));
addTimeStepsToMap(gridTimeStepsMap, timeStepsFromGridCase(gridCase));
}
std::vector<RimWellLogFile*> wellLogFiles = wellLogFilesContainingPressure(m_wellName);
if(wellLogFiles.size() > 0)
{
sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::OBSERVED));
sourcesToSelect.push_back(RifWellRftAddress(RifWellRftAddress::OBSERVED));
for (RimWellLogFile* const wellLogFile : wellLogFiles)
{
addTimeStepsToMap(observedTimeStepsMap, timeStepsFromWellLogFile(wellLogFile));
@ -280,11 +280,11 @@ void RimWellRftPlot::applyInitialSelections()
m_selectedSources = sourcesToSelect;
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);
}
for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& dateTimePair : observedTimeStepsMap)
for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& dateTimePair : observedTimeStepsMap)
{
timeStepsToSelect.insert(dateTimePair.first);
}
@ -301,26 +301,26 @@ void RimWellRftPlot::applyInitialSelections()
//--------------------------------------------------------------------------------------------------
void RimWellRftPlot::updateEditorsFromCurves()
{
std::set<RimWellRftAddress> selectedSources;
std::set<RifWellRftAddress> selectedSources;
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)
selectedSources.insert(RimWellRftAddress(RftSourceType::OBSERVED));
if (curveDef.first.sourceType() == RifWellRftAddress::OBSERVED)
selectedSources.insert(RifWellRftAddress(RifWellRftAddress::OBSERVED));
else
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);
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());
addTimeStepsToMap(m_timeStepsToAddresses, selectedTimeStepsMap);
}
@ -351,22 +351,22 @@ void RimWellRftPlot::updateWidgetTitleWindowTitle()
void RimWellRftPlot::syncCurvesFromUiSelection()
{
RimWellLogTrack* plotTrack = m_wellLogPlot->trackByIndex(0);
const std::set<std::pair<RimWellRftAddress, QDateTime>>& allCurveDefs = selectedCurveDefs();
const std::set<std::pair<RimWellRftAddress, QDateTime>>& curveDefsInPlot = curveDefsFromCurves();
const std::set<std::pair<RifWellRftAddress, QDateTime>>& allCurveDefs = selectedCurveDefs();
const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefsInPlot = curveDefsFromCurves();
std::set<RimWellLogCurve*> curvesToDelete;
std::set<std::pair<RimWellRftAddress, QDateTime>> newCurveDefs;
std::set<std::pair<RifWellRftAddress, QDateTime>> newCurveDefs;
if (allCurveDefs.size() < curveDefsInPlot.size())
{
// 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(),
allCurveDefs.begin(), allCurveDefs.end(),
std::inserter(deleteCurveDefs, deleteCurveDefs.end()));
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)
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();
if (reader != nullptr)
{
@ -543,9 +543,9 @@ std::map<QDateTime, std::set<RimWellRftAddress>> RimWellRftPlot::timeStepsFromRf
{
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;
@ -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();
size_t resultIndex = eclipseCaseData != nullptr ?
eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, PRESSURE_DATA_NAME) :
cvf::UNDEFINED_SIZE_T;
std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsMap;
std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
if (resultIndex != cvf::UNDEFINED_SIZE_T)
{
for (const QDateTime& timeStep : eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->timeStepDates(resultIndex))
{
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;
@ -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());
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;
}
@ -597,16 +597,16 @@ std::map<QDateTime, std::set<RimWellRftAddress> > RimWellRftPlot::timeStepsFromW
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RimWellRftAddress>>
RimWellRftPlot::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>& allTimeSteps,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& searchTimeStepPair)
std::map<QDateTime, std::set<RifWellRftAddress>>
RimWellRftPlot::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>& allTimeSteps,
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)
{
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;
});
@ -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;
}) != 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<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
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)
{
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromRftCase(rftCase);
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromRftCase(rftCase);
if (mapContainsTimeStep(timeStepsMap , 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)
{
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
if (mapContainsTimeStep(timeStepsMap, timeStep))
{
curveDefs.insert(std::make_pair(addr, timeStep));
}
}
}
else if (addr.sourceType() == RftSourceType::OBSERVED)
else if (addr.sourceType() == RifWellRftAddress::OBSERVED)
{
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))
{
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);
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 RimWellLogExtractionCurve* gridCurve = dynamic_cast<const RimWellLogExtractionCurve*>(curve);
@ -719,7 +719,7 @@ std::pair<RimWellRftAddress, QDateTime> RimWellRftPlot::curveDefFromCurve(const
{
const RifEclipseRftAddress rftAddress = rftCurve->rftAddress();
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)
@ -728,12 +728,12 @@ std::pair<RimWellRftAddress, QDateTime> RimWellRftPlot::curveDefFromCurve(const
if (gridCase != nullptr)
{
size_t timeStepIndex = gridCurve->currentTimeStep();
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
auto timeStepsVector = std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>(
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
auto timeStepsVector = std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>(
timeStepsMap.begin(), timeStepsMap.end());
if (timeStepIndex < timeStepsMap.size())
{
return std::make_pair(RimWellRftAddress(RftSourceType::GRID, gridCase),
return std::make_pair(RifWellRftAddress(RifWellRftAddress::GRID, gridCase),
timeStepsVector[timeStepIndex].first);
}
}
@ -749,18 +749,18 @@ std::pair<RimWellRftAddress, QDateTime> RimWellRftPlot::curveDefFromCurve(const
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,
const std::set<std::pair<RimWellRftAddress, QDateTime>>& curveDefsToAdd,
void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RifWellRftAddress, QDateTime>>& allCurveDefs,
const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefsToAdd,
const std::set<RimWellLogCurve*>& curvesToDelete)
{
RimWellLogTrack* const plotTrack = m_wellLogPlot->trackByIndex(0);
@ -772,9 +772,9 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
}
// 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();
plotTrack->addCurve(curve);
@ -789,7 +789,7 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
applyCurveAppearance(curve);
curve->loadDataAndUpdate(true);
}
else if (curveDefToAdd.first.sourceType() == RftSourceType::GRID)
else if (curveDefToAdd.first.sourceType() == RifWellRftAddress::GRID)
{
auto curve = new RimWellLogExtractionCurve();
plotTrack->addCurve(curve);
@ -811,9 +811,9 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
curve->setEclipseResultDefinition(resultDef);
// 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(),
[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);
curve->setCurrentTimeStep(currentTimeStepIndex);
curve->setZOrder(0);
@ -822,7 +822,7 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
curve->loadDataAndUpdate(false);
}
}
else if (curveDefToAdd.first.sourceType() == RftSourceType::OBSERVED)
else if (curveDefToAdd.first.sourceType() == RifWellRftAddress::OBSERVED)
{
RimWellLogFile* const wellLogFile = curveDefToAdd.first.wellLogFile();
RimWellPath* const wellPath = wellPathFromWellLogFile(wellLogFile);
@ -848,21 +848,21 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
//--------------------------------------------------------------------------------------------------
bool RimWellRftPlot::isOnlyGridSourcesSelected() const
{
const std::vector<RimWellRftAddress>& selSources = m_selectedSources();
return std::find_if(selSources.begin(), selSources.end(), [](const RimWellRftAddress& addr)
const std::vector<RifWellRftAddress>& selSources = m_selectedSources();
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();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
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 auto selectedSources = std::set<RimWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RimWellRftAddress> intersectVector;
const std::vector<RifWellRftAddress>& selectedSourcesVector = m_selectedSources();
const auto selectedSources = std::set<RifWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RifWellRftAddress> intersectVector;
std::set_intersection(selectedSources.begin(), selectedSources.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;
for (const RimWellRftAddress& addr : m_selectedSources())
std::vector<RifWellRftAddress> sources;
for (const RifWellRftAddress& addr : m_selectedSources())
{
if (addr.sourceType() == RftSourceType::OBSERVED)
if (addr.sourceType() == RifWellRftAddress::OBSERVED)
{
for (RimWellLogFile* const wellLogFile : wellLogFilesContainingPressure(m_wellName))
{
sources.push_back(RimWellRftAddress(RftSourceType::OBSERVED, wellLogFile));
sources.push_back(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile));
}
}
else
@ -1003,11 +1003,11 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions(const caf::P
const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
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)
{
auto addr = RimWellRftAddress(RftSourceType::RFT, rftCase);
auto addr = RifWellRftAddress(RifWellRftAddress::RFT, rftCase);
auto item = caf::PdmOptionItemInfo(rftCase->caseUserDescription(), QVariant::fromValue(addr));
item.setLevel(1);
options.push_back(item);
@ -1016,11 +1016,11 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions(const caf::P
const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
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)
{
auto addr = RimWellRftAddress(RftSourceType::GRID, gridCase);
auto addr = RifWellRftAddress(RifWellRftAddress::GRID, gridCase);
auto item = caf::PdmOptionItemInfo(gridCase->caseUserDescription(), QVariant::fromValue(addr));
item.setLevel(1);
options.push_back(item);
@ -1028,9 +1028,9 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions(const caf::P
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));
item.setLevel(1);
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,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepToAdd)
void RimWellRftPlot::addTimeStepToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
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);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellRftPlot::addTimeStepsToMap(std::map<QDateTime, std::set<RimWellRftAddress>>& destMap,
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsToAdd)
void RimWellRftPlot::addTimeStepsToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::map<QDateTime, std::set<RifWellRftAddress>>& 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)
{
destMap.insert(std::make_pair(timeStepPair.first, std::set<RimWellRftAddress>()));
destMap.insert(std::make_pair(timeStepPair.first, std::set<RifWellRftAddress>()));
}
auto addresses = timeStepPair.second;
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)
{
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<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(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)
{
addTimeStepsToMap(obsAndRftTimeStepsMap, timeStepsFromRftCase(rftCase));
}
}
else if (selection.sourceType() == RftSourceType::GRID)
else if (selection.sourceType() == RifWellRftAddress::GRID)
{
for (RimEclipseResultCase* const gridCase : gridCases)
{
addTimeStepsToMap(gridTimeStepsMap, timeStepsFromGridCase(gridCase));
}
}
else if (selection.sourceType() == RftSourceType::OBSERVED)
else if (selection.sourceType() == RifWellRftAddress::OBSERVED)
{
if (selection.wellLogFile() != nullptr)
{
@ -1248,11 +1248,11 @@ void RimWellRftPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
}
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);
}
@ -1267,7 +1267,7 @@ void RimWellRftPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
{
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))
{
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
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);
}
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));
}

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

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