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

Rename of RifWellRftAddress to RifDataSourceForRftPlt

Browse Source
This commit is contained in:
Jacob Støren
2017-11-13 11:10:27 +01:00
parent 9853c15ec6
commit c02538b8bd
14 changed files with 219 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
ApplicationCode/Application/RiaRftPltCurveDefinition.cpp
View File

@@ -22,7 +22,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaRftPltCurveDefinition::RiaRftPltCurveDefinition(RifWellRftAddress address, const QDateTime timeStep)
RiaRftPltCurveDefinition::RiaRftPltCurveDefinition(RifDataSourceForRftPlt address, const QDateTime timeStep)
{
m_curveDefinition = std::make_pair(address, timeStep);
}
@@ -30,7 +30,7 @@ RiaRftPltCurveDefinition::RiaRftPltCurveDefinition(RifWellRftAddress address, co
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifWellRftAddress RiaRftPltCurveDefinition::address() const
RifDataSourceForRftPlt RiaRftPltCurveDefinition::address() const
{
return m_curveDefinition.first;
}

8
ApplicationCode/Application/RiaRftPltCurveDefinition.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RifWellRftAddress.h"
#include "RifDataSourceForRftPlt.h"
#include <QString>
@@ -33,13 +33,13 @@ class RimSummaryCase;
class RiaRftPltCurveDefinition
{
public:
explicit RiaRftPltCurveDefinition(RifWellRftAddress address, const QDateTime timeStep);
explicit RiaRftPltCurveDefinition(RifDataSourceForRftPlt address, const QDateTime timeStep);
RifWellRftAddress address() const;
RifDataSourceForRftPlt address() const;
QDateTime timeStep() const;
bool operator < (const RiaRftPltCurveDefinition& other) const;
private:
std::pair<RifWellRftAddress, QDateTime> m_curveDefinition;
std::pair<RifDataSourceForRftPlt, QDateTime> m_curveDefinition;
};

6
ApplicationCode/FileInterface/CMakeLists_files.cmake
View File

@@ -34,8 +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
${CEE_CURRENT_LIST_DIR}RifDataSourceForRftPlt.h
${CEE_CURRENT_LIST_DIR}RifDataSourceForRftPltQMetaType.h
${CEE_CURRENT_LIST_DIR}RifEclipseUserDataKeywordTools.h
# HDF5 file reader is directly included in ResInsight main CmakeList.txt
@@ -77,7 +77,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
${CEE_CURRENT_LIST_DIR}RifDataSourceForRftPlt.cpp
${CEE_CURRENT_LIST_DIR}RifEclipseUserDataKeywordTools.cpp

28
ApplicationCode/FileInterface/RifWellRftAddress.cpp → ApplicationCode/FileInterface/RifDataSourceForRftPlt.cpp
View File

@@ -16,7 +16,7 @@
//
/////////////////////////////////////////////////////////////////////////////////
#include "RifWellRftAddress.h"
#include "RifDataSourceForRftPlt.h"
#include "RimEclipseCase.h"
#include "RimWellLogFile.h"
@@ -29,14 +29,14 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifWellRftAddress::RifWellRftAddress() : m_sourceType(SourceType::NONE)
RifDataSourceForRftPlt::RifDataSourceForRftPlt() : m_sourceType(SourceType::NONE)
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifWellRftAddress::RifWellRftAddress(SourceType sourceType, RimEclipseCase* eclCase)
RifDataSourceForRftPlt::RifDataSourceForRftPlt(SourceType sourceType, RimEclipseCase* eclCase)
{
CVF_ASSERT(sourceType == SourceType::RFT || sourceType == SourceType::GRID);
CVF_ASSERT(eclCase != nullptr);
@@ -48,7 +48,7 @@ RifWellRftAddress::RifWellRftAddress(SourceType sourceType, RimEclipseCase* eclC
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifWellRftAddress::RifWellRftAddress(SourceType sourceType, RimWellLogFile* wellLogFile)
RifDataSourceForRftPlt::RifDataSourceForRftPlt(SourceType sourceType, RimWellLogFile* wellLogFile)
{
CVF_ASSERT(sourceType == SourceType::OBSERVED);
@@ -59,7 +59,7 @@ RifWellRftAddress::RifWellRftAddress(SourceType sourceType, RimWellLogFile* well
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifWellRftAddress::SourceType RifWellRftAddress::sourceType() const
RifDataSourceForRftPlt::SourceType RifDataSourceForRftPlt::sourceType() const
{
return m_sourceType;
}
@@ -67,7 +67,7 @@ RifWellRftAddress::SourceType RifWellRftAddress::sourceType() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseCase* RifWellRftAddress::eclCase() const
RimEclipseCase* RifDataSourceForRftPlt::eclCase() const
{
return m_eclCase;
}
@@ -75,7 +75,7 @@ RimEclipseCase* RifWellRftAddress::eclCase() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellLogFile* RifWellRftAddress::wellLogFile() const
RimWellLogFile* RifDataSourceForRftPlt::wellLogFile() const
{
return m_wellLogFile;
}
@@ -83,7 +83,7 @@ RimWellLogFile* RifWellRftAddress::wellLogFile() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RifWellRftAddress::sourceTypeUiText(SourceType sourceType)
QString RifDataSourceForRftPlt::sourceTypeUiText(SourceType sourceType)
{
switch (sourceType)
{
@@ -97,7 +97,7 @@ QString RifWellRftAddress::sourceTypeUiText(SourceType sourceType)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool operator==(const RifWellRftAddress& addr1, const RifWellRftAddress& addr2)
bool operator==(const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPlt& addr2)
{
return addr1.sourceType() == addr2.sourceType()
&& addr1.eclCase() == addr2.eclCase()
@@ -107,7 +107,7 @@ bool operator==(const RifWellRftAddress& addr1, const RifWellRftAddress& addr2)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QTextStream& operator << (QTextStream& str, const RifWellRftAddress& addr)
QTextStream& operator << (QTextStream& str, const RifDataSourceForRftPlt& addr)
{
// Not implemented
CVF_ASSERT(false);
@@ -117,7 +117,7 @@ QTextStream& operator << (QTextStream& str, const RifWellRftAddress& addr)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QTextStream& operator >> (QTextStream& str, RifWellRftAddress& source)
QTextStream& operator >> (QTextStream& str, RifDataSourceForRftPlt& source)
{
// Not implemented
CVF_ASSERT(false);
@@ -128,16 +128,16 @@ QTextStream& operator >> (QTextStream& str, RifWellRftAddress& source)
/// This sort order controls the plot order in PLT plot. (Layer-wise)
/// Observed data is supposed to be the bottom layers (first)
//--------------------------------------------------------------------------------------------------
bool operator<(const RifWellRftAddress& addr1, const RifWellRftAddress& addr2)
bool operator<(const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPlt& addr2)
{
if ( addr1.m_sourceType != addr2.m_sourceType )
{
return addr1.m_sourceType < addr2.m_sourceType;
}
if ( addr1.m_sourceType == RifWellRftAddress::NONE ) return false; //
if ( addr1.m_sourceType == RifDataSourceForRftPlt::NONE ) return false; //
if (addr1.m_sourceType == RifWellRftAddress::OBSERVED)
if (addr1.m_sourceType == RifDataSourceForRftPlt::OBSERVED)
{
if(addr1.wellLogFile() && addr2.wellLogFile())
{

20
ApplicationCode/FileInterface/RifWellRftAddress.h → ApplicationCode/FileInterface/RifDataSourceForRftPlt.h
View File

@@ -38,7 +38,7 @@ class RimEclipseCase;
///
///
//==================================================================================================
class RifWellRftAddress
class RifDataSourceForRftPlt
{
public:
enum SourceType
@@ -49,9 +49,9 @@ public:
GRID
};
RifWellRftAddress();
RifWellRftAddress(SourceType sourceType, RimEclipseCase* eclCase);
RifWellRftAddress(SourceType sourceType, RimWellLogFile* wellLogFile = nullptr);
RifDataSourceForRftPlt();
RifDataSourceForRftPlt(SourceType sourceType, RimEclipseCase* eclCase);
RifDataSourceForRftPlt(SourceType sourceType, RimWellLogFile* wellLogFile = nullptr);
SourceType sourceType() const;
RimEclipseCase* eclCase() const;
@@ -59,8 +59,8 @@ public:
static QString sourceTypeUiText(SourceType sourceType);
friend QTextStream& operator >> (QTextStream& str, RifWellRftAddress& addr);
friend bool operator<(const RifWellRftAddress& addr1, const RifWellRftAddress& addr2);
friend QTextStream& operator >> (QTextStream& str, RifDataSourceForRftPlt& addr);
friend bool operator<(const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPlt& addr2);
private:
SourceType m_sourceType;
@@ -68,7 +68,7 @@ private:
caf::PdmPointer<RimWellLogFile> m_wellLogFile;
};
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);
bool operator==(const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPlt& addr2);
QTextStream& operator <<(QTextStream& str, const RifDataSourceForRftPlt& addr);
QTextStream& operator >> (QTextStream& str, RifDataSourceForRftPlt& addr);
bool operator<(const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPlt& addr2);

4
ApplicationCode/FileInterface/RifWellRftAddressQMetaType.h → ApplicationCode/FileInterface/RifDataSourceForRftPltQMetaType.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include <QMetaType>
#include "RifWellRftAddress.h"
#include "RifDataSourceForRftPlt.h"
Q_DECLARE_METATYPE(RifWellRftAddress);
Q_DECLARE_METATYPE(RifDataSourceForRftPlt);

20
ApplicationCode/ProjectDataModel/Flow/RimRftAddress.cpp
View File

@@ -29,12 +29,12 @@ namespace caf
{
template<>
void caf::AppEnum<RifWellRftAddress::SourceType>::setUp()
void caf::AppEnum<RifDataSourceForRftPlt::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);
addItem(RifDataSourceForRftPlt::SourceType::RFT, "RFT", "RFT Cases");
addItem(RifDataSourceForRftPlt::SourceType::GRID, "GRID", "Grid Cases");
addItem(RifDataSourceForRftPlt::SourceType::OBSERVED, "OBSERVED", "Observed Data");
setDefault(RifDataSourceForRftPlt::SourceType::NONE);
}
}
@@ -54,7 +54,7 @@ RimRftAddress::RimRftAddress()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimRftAddress::RimRftAddress(const RifWellRftAddress& addr)
RimRftAddress::RimRftAddress(const RifDataSourceForRftPlt& addr)
{
InitPdmObject();
setAddress(addr);
@@ -63,7 +63,7 @@ RimRftAddress::RimRftAddress(const RifWellRftAddress& addr)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimRftAddress::setAddress(const RifWellRftAddress& address)
void RimRftAddress::setAddress(const RifDataSourceForRftPlt& address)
{
m_sourceType = address.sourceType();
m_eclCase = address.eclCase();
@@ -73,11 +73,11 @@ void RimRftAddress::setAddress(const RifWellRftAddress& address)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifWellRftAddress RimRftAddress::address() const
RifDataSourceForRftPlt RimRftAddress::address() const
{
return m_eclCase() != nullptr ?
RifWellRftAddress(m_sourceType(), m_eclCase()) :
RifWellRftAddress(m_sourceType(), m_wellLogFile());
RifDataSourceForRftPlt(m_sourceType(), m_eclCase()) :
RifDataSourceForRftPlt(m_sourceType(), m_wellLogFile());
}
//--------------------------------------------------------------------------------------------------

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

@@ -26,7 +26,7 @@
#include "cafPdmPtrField.h"
#include "cafPdmPointer.h"
#include "RifWellRftAddressQMetaType.h"
#include "RifDataSourceForRftPltQMetaType.h"
#include "cafAppEnum.h"
@@ -48,17 +48,17 @@ class RimRftAddress : public caf::PdmObject
public:
RimRftAddress();
RimRftAddress(const RifWellRftAddress& addr);
RimRftAddress(const RifDataSourceForRftPlt& addr);
void setAddress(const RifWellRftAddress& address);
RifWellRftAddress address() const;
void setAddress(const RifDataSourceForRftPlt& address);
RifDataSourceForRftPlt address() const;
RimRftAddress& operator=(const RimRftAddress& other);
private:
void InitPdmObject();
caf::PdmField<caf::AppEnum<RifWellRftAddress::SourceType> > m_sourceType;
caf::PdmField<caf::AppEnum<RifDataSourceForRftPlt::SourceType> > m_sourceType;
caf::PdmPtrField<RimEclipseCase*> m_eclCase;
caf::PdmPtrField<RimWellLogFile*> m_wellLogFile;
};

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

@@ -227,18 +227,18 @@ FlowPhase RimWellPlotTools::flowPhaseFromChannelName(const QString& channelName)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPlotTools::addTimeStepToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepToAdd)
void RimWellPlotTools::addTimeStepToMap(std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& destMap,
const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepToAdd)
{
auto timeStepMapToAdd = std::map<QDateTime, std::set<RifWellRftAddress>>{ timeStepToAdd };
auto timeStepMapToAdd = std::map<QDateTime, std::set<RifDataSourceForRftPlt>>{ timeStepToAdd };
addTimeStepsToMap(destMap, timeStepMapToAdd);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPlotTools::addTimeStepsToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsToAdd)
void RimWellPlotTools::addTimeStepsToMap(std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& destMap,
const std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepsToAdd)
{
for (const auto& timeStepPair : timeStepsToAdd)
{
@@ -246,7 +246,7 @@ void RimWellPlotTools::addTimeStepsToMap(std::map<QDateTime, std::set<RifWellRft
{
if (destMap.count(timeStepPair.first) == 0)
{
destMap.insert(std::make_pair(timeStepPair.first, std::set<RifWellRftAddress>()));
destMap.insert(std::make_pair(timeStepPair.first, std::set<RifDataSourceForRftPlt>()));
}
auto addresses = timeStepPair.second;
destMap[timeStepPair.first].insert(addresses.begin(), addresses.end());
@@ -539,9 +539,9 @@ QDateTime RimWellPlotTools::timeStepFromWellLogFile(RimWellLogFile* wellLogFile)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPlotTools::timeStepsMapFromRftCase(RimEclipseResultCase* rftCase, const QString& simWellName)
std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::timeStepsMapFromRftCase(RimEclipseResultCase* rftCase, const QString& simWellName)
{
std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
std::map<QDateTime, std::set<RifDataSourceForRftPlt>> timeStepsMap;
RifReaderEclipseRft* const reader = rftCase->rftReader();
if (reader != nullptr)
{
@@ -549,9 +549,9 @@ std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPlotTools::timeStepsMapF
{
if (timeStepsMap.count(timeStep) == 0)
{
timeStepsMap.insert(std::make_pair(timeStep, std::set<RifWellRftAddress>()));
timeStepsMap.insert(std::make_pair(timeStep, std::set<RifDataSourceForRftPlt>()));
}
timeStepsMap[timeStep].insert(RifWellRftAddress(RifWellRftAddress::RFT, rftCase));
timeStepsMap[timeStep].insert(RifDataSourceForRftPlt(RifDataSourceForRftPlt::RFT, rftCase));
}
}
return timeStepsMap;
@@ -560,21 +560,21 @@ std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPlotTools::timeStepsMapF
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPlotTools::timeStepsMapFromGridCase(RimEclipseCase* gridCase)
std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::timeStepsMapFromGridCase(RimEclipseCase* gridCase)
{
const RigEclipseCaseData* const eclipseCaseData = gridCase->eclipseCaseData();
std::pair<size_t, QString> resultDataInfo = pressureResultDataInfo(eclipseCaseData);
std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
std::map<QDateTime, std::set<RifDataSourceForRftPlt>> timeStepsMap;
if (resultDataInfo.first != cvf::UNDEFINED_SIZE_T)
{
for (const QDateTime& timeStep : eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->timeStepDates(resultDataInfo.first))
{
if (timeStepsMap.count(timeStep) == 0)
{
timeStepsMap.insert(std::make_pair(timeStep, std::set<RifWellRftAddress>()));
timeStepsMap.insert(std::make_pair(timeStep, std::set<RifDataSourceForRftPlt>()));
}
timeStepsMap[timeStep].insert(RifWellRftAddress(RifWellRftAddress::GRID, gridCase));
timeStepsMap[timeStep].insert(RifDataSourceForRftPlt(RifDataSourceForRftPlt::GRID, gridCase));
}
}
return timeStepsMap;
@@ -583,17 +583,17 @@ std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPlotTools::timeStepsMapF
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RifWellRftAddress> > RimWellPlotTools::timeStepsMapFromWellLogFile(RimWellLogFile* wellLogFile)
std::map<QDateTime, std::set<RifDataSourceForRftPlt> > RimWellPlotTools::timeStepsMapFromWellLogFile(RimWellLogFile* wellLogFile)
{
std::map<QDateTime, std::set<RifWellRftAddress> > timeStepsMap;
std::map<QDateTime, std::set<RifDataSourceForRftPlt> > timeStepsMap;
QDateTime timeStep = wellLogFile->date();
if (timeStepsMap.count(timeStep) == 0)
{
timeStepsMap.insert(std::make_pair(timeStep, std::set<RifWellRftAddress>()));
timeStepsMap.insert(std::make_pair(timeStep, std::set<RifDataSourceForRftPlt>()));
}
timeStepsMap[timeStep].insert(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile));
timeStepsMap[timeStep].insert(RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED, wellLogFile));
return timeStepsMap;
}
@@ -601,16 +601,16 @@ std::map<QDateTime, std::set<RifWellRftAddress> > RimWellPlotTools::timeStepsMap
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RifWellRftAddress>>
RimWellPlotTools::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>& allTimeSteps,
const std::pair<QDateTime, std::set<RifWellRftAddress>>& searchTimeStepPair)
std::map<QDateTime, std::set<RifDataSourceForRftPlt>>
RimWellPlotTools::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>>& allTimeSteps,
const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& searchTimeStepPair)
{
std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
std::map<QDateTime, std::set<RifDataSourceForRftPlt>> timeStepsMap;
if (allTimeSteps.size() > 0)
{
auto itr = std::find_if(allTimeSteps.begin(), allTimeSteps.end(),
[searchTimeStepPair](const std::pair<QDateTime, std::set<RifWellRftAddress>>& dt)
[searchTimeStepPair](const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& dt)
{
return dt.first > searchTimeStepPair.first;
});
@@ -632,9 +632,9 @@ RimWellPlotTools::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimWellPlotTools::mapContainsTimeStep(const std::map<QDateTime, std::set<RifWellRftAddress>>& map, const QDateTime& timeStep)
bool RimWellPlotTools::mapContainsTimeStep(const std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& map, const QDateTime& timeStep)
{
return std::find_if(map.begin(), map.end(), [timeStep](const std::pair<QDateTime, std::set<RifWellRftAddress>>& pair)
return std::find_if(map.begin(), map.end(), [timeStep](const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& pair)
{
return pair.first == timeStep;
}) != map.end();
@@ -656,7 +656,7 @@ RiaRftPltCurveDefinition RimWellPlotTools::curveDefFromCurve(const RimWellLogCur
{
const RifEclipseRftAddress rftAddress = rftCurve->rftAddress();
const QDateTime timeStep = rftAddress.timeStep();
return RiaRftPltCurveDefinition(RifWellRftAddress(RifWellRftAddress::RFT, rftCase), timeStep);
return RiaRftPltCurveDefinition(RifDataSourceForRftPlt(RifDataSourceForRftPlt::RFT, rftCase), timeStep);
}
}
else if (gridCurve != nullptr)
@@ -665,12 +665,12 @@ RiaRftPltCurveDefinition RimWellPlotTools::curveDefFromCurve(const RimWellLogCur
if (gridCase != nullptr)
{
size_t timeStepIndex = gridCurve->currentTimeStep();
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsMapFromGridCase(gridCase);
auto timeStepsVector = std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>(
const std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepsMap = timeStepsMapFromGridCase(gridCase);
auto timeStepsVector = std::vector<std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>>(
timeStepsMap.begin(), timeStepsMap.end());
if (timeStepIndex < timeStepsMap.size())
{
return RiaRftPltCurveDefinition(RifWellRftAddress(RifWellRftAddress::GRID, gridCase),
return RiaRftPltCurveDefinition(RifDataSourceForRftPlt(RifDataSourceForRftPlt::GRID, gridCase),
timeStepsVector[timeStepIndex].first);
}
}
@@ -686,11 +686,11 @@ RiaRftPltCurveDefinition RimWellPlotTools::curveDefFromCurve(const RimWellLogCur
if (date.isValid())
{
return RiaRftPltCurveDefinition(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile), date);
return RiaRftPltCurveDefinition(RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED, wellLogFile), date);
}
}
}
return RiaRftPltCurveDefinition(RifWellRftAddress(), QDateTime());
return RiaRftPltCurveDefinition(RifDataSourceForRftPlt(), QDateTime());
}
//--------------------------------------------------------------------------------------------------

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

@@ -19,7 +19,7 @@
#pragma once
#include "RifWellRftAddressQMetaType.h"
#include "RifDataSourceForRftPltQMetaType.h"
#include "RiaRftPltCurveDefinition.h"
#include <QMetaType>
@@ -72,10 +72,10 @@ public:
static bool hasFlowData(RimWellPath* wellPath);
static FlowPhase flowPhaseFromChannelName(const QString& channelName);
static void addTimeStepToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepToAdd);
static void addTimeStepsToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsToAdd);
static void addTimeStepToMap(std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& destMap,
const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepToAdd);
static void addTimeStepsToMap(std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& destMap,
const std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepsToAdd);
static std::vector<RimWellLogFile*> wellLogFilesContainingPressure(const QString& simWellName);
static RimWellLogFileChannel* getPressureChannelFromWellFile(const RimWellLogFile* wellLogFile);
@@ -92,12 +92,12 @@ public:
static std::set<QDateTime> timeStepsFromGridCase(RimEclipseCase* gridCase);
static QDateTime timeStepFromWellLogFile(RimWellLogFile* wellLogFile);
static std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMapFromRftCase(RimEclipseResultCase* rftCase, const QString& simWellName);
static std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMapFromGridCase(RimEclipseCase* gridCase);
static std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMapFromWellLogFile(RimWellLogFile* wellLogFile);
static 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);
static std::map<QDateTime, std::set<RifDataSourceForRftPlt>> timeStepsMapFromRftCase(RimEclipseResultCase* rftCase, const QString& simWellName);
static std::map<QDateTime, std::set<RifDataSourceForRftPlt>> timeStepsMapFromGridCase(RimEclipseCase* gridCase);
static std::map<QDateTime, std::set<RifDataSourceForRftPlt>> timeStepsMapFromWellLogFile(RimWellLogFile* wellLogFile);
static std::map<QDateTime, std::set<RifDataSourceForRftPlt>> adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>>& allTimeSteps,
const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& searchTimeStepPair);
static bool mapContainsTimeStep(const std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& map, const QDateTime& timeStep);
static RiaRftPltCurveDefinition curveDefFromCurve(const RimWellLogCurve* curve);

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

@@ -441,18 +441,18 @@ void RimWellPltPlot::updateWidgetTitleWindowTitle()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set < std::pair<RifWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurveDefs() const
std::set < std::pair<RifDataSourceForRftPlt, QDateTime>> RimWellPltPlot::selectedCurveDefs() const
{
std::set<std::pair<RifWellRftAddress, QDateTime>> curveDefs;
std::set<std::pair<RifDataSourceForRftPlt, QDateTime>> curveDefs;
const std::vector<RimEclipseResultCase*> rftCases = RimWellPlotTools::rftCasesForWell(RimWellPlotTools::simWellName(m_wellPathName));
const std::vector<RimEclipseResultCase*> gridCases = RimWellPlotTools::gridCasesForWell(RimWellPlotTools::simWellName(m_wellPathName));
const QString simWellName = RimWellPlotTools::simWellName(m_wellPathName);
for (const QDateTime& timeStep : m_selectedTimeSteps())
{
for (const RifWellRftAddress& addr : selectedSources())
for (const RifDataSourceForRftPlt& addr : selectedSources())
{
if (addr.sourceType() == RifWellRftAddress::RFT)
if (addr.sourceType() == RifDataSourceForRftPlt::RFT)
{
for (RimEclipseResultCase* const rftCase : rftCases)
{
@@ -463,7 +463,7 @@ std::set < std::pair<RifWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurv
}
}
}
else if (addr.sourceType() == RifWellRftAddress::GRID)
else if (addr.sourceType() == RifDataSourceForRftPlt::GRID)
{
for (RimEclipseResultCase* const gridCase : gridCases)
{
@@ -475,14 +475,14 @@ std::set < std::pair<RifWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurv
}
}
else
if (addr.sourceType() == RifWellRftAddress::OBSERVED)
if (addr.sourceType() == RifDataSourceForRftPlt::OBSERVED)
{
if (addr.wellLogFile() != nullptr)
{
const QDateTime& wellLogFileTimeStep = RimWellPlotTools::timeStepFromWellLogFile(addr.wellLogFile());
if (wellLogFileTimeStep == timeStep)
{
curveDefs.insert(std::make_pair(RifWellRftAddress(RifWellRftAddress::OBSERVED, addr.wellLogFile()), timeStep));
curveDefs.insert(std::make_pair(RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED, addr.wellLogFile()), timeStep));
}
}
}
@@ -768,7 +768,7 @@ public:
void RimWellPltPlot::syncCurvesFromUiSelection()
{
RimWellLogTrack* plotTrack = m_wellLogPlot->trackByIndex(0);
const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefs = selectedCurveDefs();
const std::set<std::pair<RifDataSourceForRftPlt, QDateTime>>& curveDefs = selectedCurveDefs();
setPlotXAxisTitles(plotTrack);
@@ -785,13 +785,13 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
RimWellPath* wellPath = RimWellPlotTools::wellPathByWellPathNameOrSimWellName(m_wellPathName);
// Add curves
for (const std::pair<RifWellRftAddress, QDateTime>& curveDefToAdd : curveDefs)
for (const std::pair<RifDataSourceForRftPlt, QDateTime>& curveDefToAdd : curveDefs)
{
std::set<FlowPhase> selectedPhases = m_phaseSelectionMode == FLOW_TYPE_PHASE_SPLIT ?
std::set<FlowPhase>(m_phases().begin(), m_phases().end()) :
std::set<FlowPhase>({ FLOW_PHASE_TOTAL });
RifWellRftAddress sourceDef = curveDefToAdd.first;
RifDataSourceForRftPlt sourceDef = curveDefToAdd.first;
QDateTime timeStep = curveDefToAdd.second;
std::unique_ptr<RigResultPointCalculator> resultPointCalc;
@@ -800,17 +800,17 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
{
curveName += sourceDef.eclCase() ? sourceDef.eclCase()->caseUserDescription() : "";
curveName += sourceDef.wellLogFile() ? sourceDef.wellLogFile()->name() : "";
if ( sourceDef.sourceType() == RifWellRftAddress::RFT ) curveName += ", RFT";
if ( sourceDef.sourceType() == RifDataSourceForRftPlt::RFT ) curveName += ", RFT";
curveName += ", " + timeStep.toString();
}
if ( sourceDef.sourceType() == RifWellRftAddress::RFT )
if ( sourceDef.sourceType() == RifDataSourceForRftPlt::RFT )
{
resultPointCalc.reset(new RigRftResultPointCalculator(m_wellPathName,
dynamic_cast<RimEclipseResultCase*>(sourceDef.eclCase()),
timeStep));
}
else if (sourceDef.sourceType() == RifWellRftAddress::GRID)
else if (sourceDef.sourceType() == RifDataSourceForRftPlt::GRID)
{
resultPointCalc.reset(new RigSimWellResultPointCalculator(m_wellPathName,
dynamic_cast<RimEclipseResultCase*>(sourceDef.eclCase()),
@@ -854,7 +854,7 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
}
}
}
else if ( sourceDef.sourceType() == RifWellRftAddress::OBSERVED )
else if ( sourceDef.sourceType() == RifDataSourceForRftPlt::OBSERVED )
{
RimWellLogFile* const wellLogFile = sourceDef.wellLogFile();
if ( wellLogFile )
@@ -919,21 +919,21 @@ void RimWellPltPlot::addStackedCurve(const QString& curveName,
//--------------------------------------------------------------------------------------------------
bool RimWellPltPlot::isOnlyGridSourcesSelected() const
{
const std::vector<RifWellRftAddress>& selSources = m_selectedSources();
return std::find_if(selSources.begin(), selSources.end(), [](const RifWellRftAddress& addr)
const std::vector<RifDataSourceForRftPlt>& selSources = m_selectedSources();
return std::find_if(selSources.begin(), selSources.end(), [](const RifDataSourceForRftPlt& addr)
{
return addr.sourceType() == RifWellRftAddress::RFT || addr.sourceType() == RifWellRftAddress::OBSERVED;
return addr.sourceType() == RifDataSourceForRftPlt::RFT || addr.sourceType() == RifDataSourceForRftPlt::OBSERVED;
}) == selSources.end();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimWellPltPlot::isAnySourceAddressSelected(const std::set<RifWellRftAddress>& addresses) const
bool RimWellPltPlot::isAnySourceAddressSelected(const std::set<RifDataSourceForRftPlt>& addresses) const
{
const std::vector<RifWellRftAddress>& selectedSourcesVector = m_selectedSources();
const auto selectedSources = std::set<RifWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RifWellRftAddress> intersectVector;
const std::vector<RifDataSourceForRftPlt>& selectedSourcesVector = m_selectedSources();
const auto selectedSources = std::set<RifDataSourceForRftPlt>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RifDataSourceForRftPlt> intersectVector;
std::set_intersection(selectedSources.begin(), selectedSources.end(),
addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end()));
@@ -943,16 +943,16 @@ bool RimWellPltPlot::isAnySourceAddressSelected(const std::set<RifWellRftAddress
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RifWellRftAddress> RimWellPltPlot::selectedSources() const
std::vector<RifDataSourceForRftPlt> RimWellPltPlot::selectedSources() const
{
std::vector<RifWellRftAddress> sources;
for (const RifWellRftAddress& addr : m_selectedSources())
std::vector<RifDataSourceForRftPlt> sources;
for (const RifDataSourceForRftPlt& addr : m_selectedSources())
{
if (addr.sourceType() == RifWellRftAddress::OBSERVED)
if (addr.sourceType() == RifDataSourceForRftPlt::OBSERVED)
{
for (RimWellLogFile* const wellLogFile : RimWellPlotTools::wellLogFilesContainingFlow(m_wellPathName))
{
sources.push_back(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile));
sources.push_back(RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED, wellLogFile));
}
}
else
@@ -964,16 +964,16 @@ std::vector<RifWellRftAddress> RimWellPltPlot::selectedSources() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RifWellRftAddress> RimWellPltPlot::selectedSourcesAndTimeSteps() const
std::vector<RifDataSourceForRftPlt> RimWellPltPlot::selectedSourcesAndTimeSteps() const
{
std::vector<RifWellRftAddress> sources;
for (const RifWellRftAddress& addr : m_selectedSources())
std::vector<RifDataSourceForRftPlt> sources;
for (const RifDataSourceForRftPlt& addr : m_selectedSources())
{
if (addr.sourceType() == RifWellRftAddress::OBSERVED)
if (addr.sourceType() == RifDataSourceForRftPlt::OBSERVED)
{
for (const QDateTime& timeStep : m_selectedTimeSteps())
{
for (const RifWellRftAddress& address : m_timeStepsToAddresses.at(timeStep))
for (const RifDataSourceForRftPlt& address : m_timeStepsToAddresses.at(timeStep))
{
sources.push_back(address);
}
@@ -1047,17 +1047,17 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions(const caf::P
}
else if (fieldNeedingOptions == &m_selectedSources)
{
std::set<RifWellRftAddress> optionAddresses;
std::set<RifDataSourceForRftPlt> optionAddresses;
const std::vector<RimEclipseResultCase*> rftCases = RimWellPlotTools::rftCasesForWell(simWellName);
if (rftCases.size() > 0)
{
options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RifWellRftAddress::RFT), true));
options.push_back(caf::PdmOptionItemInfo::createHeader(RifDataSourceForRftPlt::sourceTypeUiText(RifDataSourceForRftPlt::RFT), true));
}
for (const auto& rftCase : rftCases)
{
auto addr = RifWellRftAddress(RifWellRftAddress::RFT, rftCase);
auto addr = RifDataSourceForRftPlt(RifDataSourceForRftPlt::RFT, rftCase);
auto item = caf::PdmOptionItemInfo(rftCase->caseUserDescription(), QVariant::fromValue(addr));
item.setLevel(1);
options.push_back(item);
@@ -1066,12 +1066,12 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions(const caf::P
const std::vector<RimEclipseResultCase*> gridCases = RimWellPlotTools::gridCasesForWell(simWellName);
if (gridCases.size() > 0)
{
options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RifWellRftAddress::GRID), true));
options.push_back(caf::PdmOptionItemInfo::createHeader(RifDataSourceForRftPlt::sourceTypeUiText(RifDataSourceForRftPlt::GRID), true));
}
for (const auto& gridCase : gridCases)
{
auto addr = RifWellRftAddress(RifWellRftAddress::GRID, gridCase);
auto addr = RifDataSourceForRftPlt(RifDataSourceForRftPlt::GRID, gridCase);
auto item = caf::PdmOptionItemInfo(gridCase->caseUserDescription(), QVariant::fromValue(addr));
item.setLevel(1);
options.push_back(item);
@@ -1079,9 +1079,9 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions(const caf::P
if (RimWellPlotTools::wellLogFilesContainingFlow(m_wellPathName).size() > 0)
{
options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RifWellRftAddress::OBSERVED), true));
options.push_back(caf::PdmOptionItemInfo::createHeader(RifDataSourceForRftPlt::sourceTypeUiText(RifDataSourceForRftPlt::OBSERVED), true));
auto addr = RifWellRftAddress(RifWellRftAddress::OBSERVED);
auto addr = RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED);
auto item = caf::PdmOptionItemInfo("Observed Data", QVariant::fromValue(addr));
item.setLevel(1);
options.push_back(item);
@@ -1258,19 +1258,19 @@ void RimWellPltPlot::setupBeforeSave()
//--------------------------------------------------------------------------------------------------
void RimWellPltPlot::initAfterLoad()
{
std::set<RifWellRftAddress> selectedSources;
std::set<RifDataSourceForRftPlt> selectedSources;
for (RimRftAddress* addr : m_selectedSourcesForIo)
{
if (addr->address().sourceType() == RifWellRftAddress::OBSERVED)
if (addr->address().sourceType() == RifDataSourceForRftPlt::OBSERVED)
{
selectedSources.insert(RifWellRftAddress(RifWellRftAddress::OBSERVED));
selectedSources.insert(RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED));
}
else
{
selectedSources.insert(addr->address());
}
}
m_selectedSources = std::vector<RifWellRftAddress>(selectedSources.begin(), selectedSources.end());
m_selectedSources = std::vector<RifDataSourceForRftPlt>(selectedSources.begin(), selectedSources.end());
}
//--------------------------------------------------------------------------------------------------
@@ -1279,7 +1279,7 @@ void RimWellPltPlot::initAfterLoad()
void RimWellPltPlot::syncSourcesIoFieldFromGuiField()
{
m_selectedSourcesForIo.clear();
for (const RifWellRftAddress& addr : selectedSourcesAndTimeSteps())
for (const RifDataSourceForRftPlt& addr : selectedSourcesAndTimeSteps())
{
m_selectedSourcesForIo.push_back(new RimRftAddress(addr));
}
@@ -1288,13 +1288,13 @@ void RimWellPltPlot::syncSourcesIoFieldFromGuiField()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPltPlot::updateTimeStepsToAddresses(const std::vector<RifWellRftAddress>& addressesToKeep)
void RimWellPltPlot::updateTimeStepsToAddresses(const std::vector<RifDataSourceForRftPlt>& addressesToKeep)
{
for (auto& timeStepPair : m_timeStepsToAddresses)
{
std::vector<RifWellRftAddress> addressesToDelete;
std::set<RifWellRftAddress> keepAddresses = std::set<RifWellRftAddress>(addressesToKeep.begin(), addressesToKeep.end());
std::set<RifWellRftAddress>& currentAddresses = timeStepPair.second;
std::vector<RifDataSourceForRftPlt> addressesToDelete;
std::set<RifDataSourceForRftPlt> keepAddresses = std::set<RifDataSourceForRftPlt>(addressesToKeep.begin(), addressesToKeep.end());
std::set<RifDataSourceForRftPlt>& currentAddresses = timeStepPair.second;
std::set_difference(currentAddresses.begin(), currentAddresses.end(),
keepAddresses.begin(), keepAddresses.end(),
@@ -1342,31 +1342,31 @@ void RimWellPltPlot::calculateValueOptionsForWells(QList<caf::PdmOptionItemInfo>
void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellPathNameOrSimWellName, QList<caf::PdmOptionItemInfo>& options)
{
const QString simWellName = RimWellPlotTools::simWellName(m_wellPathName);
std::map<QDateTime, std::set<RifWellRftAddress>> displayTimeStepsMap, obsAndRftTimeStepsMap, gridTimeStepsMap;
std::map<QDateTime, std::set<RifDataSourceForRftPlt>> displayTimeStepsMap, obsAndRftTimeStepsMap, gridTimeStepsMap;
const std::vector<RimEclipseResultCase*> rftCases = RimWellPlotTools::rftCasesForWell(simWellName);
const std::vector<RimEclipseResultCase*> gridCases = RimWellPlotTools::gridCasesForWell(simWellName);
// First update timeSteps to Address 'cache'
std::vector<RifWellRftAddress> selSources = selectedSources();
std::vector<RifDataSourceForRftPlt> selSources = selectedSources();
updateTimeStepsToAddresses(selectedSources());
for (const RifWellRftAddress& selection : selSources)
for (const RifDataSourceForRftPlt& selection : selSources)
{
if (selection.sourceType() == RifWellRftAddress::RFT)
if (selection.sourceType() == RifDataSourceForRftPlt::RFT)
{
for (RimEclipseResultCase* const rftCase : rftCases)
{
RimWellPlotTools::addTimeStepsToMap(obsAndRftTimeStepsMap, RimWellPlotTools::timeStepsMapFromRftCase(rftCase, simWellName));
}
}
else if (selection.sourceType() == RifWellRftAddress::GRID)
else if (selection.sourceType() == RifDataSourceForRftPlt::GRID)
{
for (RimEclipseResultCase* const gridCase : gridCases)
{
RimWellPlotTools::addTimeStepsToMap(gridTimeStepsMap, RimWellPlotTools::timeStepsMapFromGridCase(gridCase));
}
}
else if (selection.sourceType() == RifWellRftAddress::OBSERVED)
else if (selection.sourceType() == RifDataSourceForRftPlt::OBSERVED)
{
if (selection.wellLogFile() != nullptr)
{
@@ -1381,11 +1381,11 @@ void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellPathNa
}
else
{
const auto gridTimeStepsVector = std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>(gridTimeStepsMap.begin(), gridTimeStepsMap.end());
const auto gridTimeStepsVector = std::vector<std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>>(gridTimeStepsMap.begin(), gridTimeStepsMap.end());
for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : obsAndRftTimeStepsMap)
for (const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepPair : obsAndRftTimeStepsMap)
{
const std::map<QDateTime, std::set<RifWellRftAddress>>& adjTimeSteps = RimWellPlotTools::adjacentTimeSteps(gridTimeStepsVector, timeStepPair);
const std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& adjTimeSteps = RimWellPlotTools::adjacentTimeSteps(gridTimeStepsVector, timeStepPair);
RimWellPlotTools::addTimeStepsToMap(displayTimeStepsMap, adjTimeSteps);
}
@@ -1400,7 +1400,7 @@ void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellPathNa
{
if (m_timeStepsToAddresses.count(timeStep) > 0)
{
const std::set<RifWellRftAddress> sourceAddresses = m_timeStepsToAddresses[timeStep];
const std::set<RifDataSourceForRftPlt> sourceAddresses = m_timeStepsToAddresses[timeStep];
if (isAnySourceAddressSelected(sourceAddresses))
{
RimWellPlotTools::addTimeStepToMap(displayTimeStepsMap, std::make_pair(timeStep, m_timeStepsToAddresses[timeStep]));
@@ -1413,13 +1413,13 @@ void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellPathNa
// Create vector of all time steps
std::vector<QDateTime> allTimeSteps;
for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : m_timeStepsToAddresses)
for (const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepPair : m_timeStepsToAddresses)
{
allTimeSteps.push_back(timeStepPair.first);
}
const QString dateFormatString = RimTools::createTimeFormatStringFromDates(allTimeSteps);
for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : displayTimeStepsMap)
for (const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepPair : displayTimeStepsMap)
{
options.push_back(caf::PdmOptionItemInfo(timeStepPair.first.toString(dateFormatString), timeStepPair.first));
}

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

@@ -21,7 +21,7 @@
#include "RigFlowDiagResultAddress.h"
#include "RimRftAddress.h"
#include "RifWellRftAddressQMetaType.h"
#include "RifDataSourceForRftPltQMetaType.h"
#include "RimPlotCurve.h"
#include "RimWellPlotTools.h"
@@ -105,7 +105,7 @@ protected:
void syncSourcesIoFieldFromGuiField();
private:
void updateTimeStepsToAddresses(const std::vector<RifWellRftAddress>& addressesToKeep);
void updateTimeStepsToAddresses(const std::vector<RifDataSourceForRftPlt>& addressesToKeep);
void calculateValueOptionsForWells(QList<caf::PdmOptionItemInfo>& options);
void calculateValueOptionsForTimeSteps(const QString& wellPathNameOrSimWellName, QList<caf::PdmOptionItemInfo>& options);
@@ -113,9 +113,9 @@ private:
void syncCurvesFromUiSelection();
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;
std::set<std::pair<RifDataSourceForRftPlt, QDateTime>> selectedCurveDefs() const;
std::set<std::pair<RifDataSourceForRftPlt, QDateTime>> curveDefsFromCurves() const;
std::pair<RifDataSourceForRftPlt, QDateTime> curveDefFromCurve(const RimWellLogCurve* curve) const;
void addStackedCurve(const QString& tracerName,
const std::vector<double>& depthValues,
const std::vector<double>& accFlow,
@@ -125,9 +125,9 @@ private:
bool doFillCurve);
bool isOnlyGridSourcesSelected() const;
bool isAnySourceAddressSelected(const std::set<RifWellRftAddress>& addresses) const;
std::vector<RifWellRftAddress> selectedSources() const;
std::vector<RifWellRftAddress> selectedSourcesAndTimeSteps() const;
bool isAnySourceAddressSelected(const std::set<RifDataSourceForRftPlt>& addresses) const;
std::vector<RifDataSourceForRftPlt> selectedSources() const;
std::vector<RifDataSourceForRftPlt> selectedSourcesAndTimeSteps() const;
// RimViewWindow overrides
@@ -147,7 +147,7 @@ private:
caf::PdmField<QString> m_wellPathName;
caf::PdmField<std::vector<RifWellRftAddress>> m_selectedSources;
caf::PdmField<std::vector<RifDataSourceForRftPlt>> m_selectedSources;
caf::PdmChildArrayField<RimRftAddress*> m_selectedSourcesForIo;
caf::PdmField<std::vector<QDateTime>> m_selectedTimeSteps;
@@ -156,7 +156,7 @@ private:
caf::PdmChildField<RimWellLogPlot*> m_wellLogPlot;
std::map<QDateTime, std::set<RifWellRftAddress>> m_timeStepsToAddresses;
std::map<QDateTime, std::set<RifDataSourceForRftPlt>> m_timeStepsToAddresses;
caf::PdmField<caf::AppEnum<FlowType>> m_phaseSelectionMode;
caf::PdmField<std::vector<caf::AppEnum<FlowPhase>>> m_phases;

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

@@ -217,7 +217,7 @@ void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
}
// Observed data
currentLineStyle = newCurveDef.address().sourceType() == RifWellRftAddress::OBSERVED
currentLineStyle = newCurveDef.address().sourceType() == RifDataSourceForRftPlt::OBSERVED
? RimPlotCurve::STYLE_NONE : RimPlotCurve::STYLE_SOLID;
newCurve->setColor(currentColor);
@@ -231,15 +231,15 @@ void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
void RimWellRftPlot::updateSelectedTimeStepsFromSelectedSources()
{
std::vector<QDateTime> newTimeStepsSelections;
std::vector<RifWellRftAddress> selectedSourcesVector = selectedSources();
auto selectedSources = std::set<RifWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RifDataSourceForRftPlt> selectedSourcesVector = selectedSources();
auto selectedSources = std::set<RifDataSourceForRftPlt>(selectedSourcesVector.begin(), selectedSourcesVector.end());
for (const QDateTime& timeStep : m_selectedTimeSteps())
{
if(m_timeStepsToAddresses.count(timeStep) > 0)
{
std::vector<RifWellRftAddress> intersectVector;
const std::set<RifWellRftAddress>& addresses = m_timeStepsToAddresses[timeStep];
std::vector<RifDataSourceForRftPlt> intersectVector;
const std::set<RifDataSourceForRftPlt>& addresses = m_timeStepsToAddresses[timeStep];
std::set_intersection(selectedSources.begin(), selectedSources.end(),
addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end()));
if(intersectVector.size() > 0)
@@ -310,7 +310,7 @@ QString RimWellRftPlot::associatedSimWellName() const
//--------------------------------------------------------------------------------------------------
void RimWellRftPlot::applyInitialSelections()
{
std::vector<RifWellRftAddress> sourcesToSelect;
std::vector<RifDataSourceForRftPlt> sourcesToSelect;
std::set<QDateTime> rftTimeSteps;
std::set<QDateTime> observedTimeSteps;
std::set<QDateTime> gridTimeSteps;
@@ -318,20 +318,20 @@ void RimWellRftPlot::applyInitialSelections()
for(RimEclipseResultCase* const rftCase : RimWellPlotTools::rftCasesForWell(simWellName))
{
sourcesToSelect.push_back(RifWellRftAddress(RifWellRftAddress::RFT, rftCase));
sourcesToSelect.push_back(RifDataSourceForRftPlt(RifDataSourceForRftPlt::RFT, rftCase));
RimWellPlotTools::appendSet(rftTimeSteps, RimWellPlotTools::timeStepsFromRftCase(rftCase, simWellName));
}
for (RimEclipseResultCase* const gridCase : RimWellPlotTools::gridCasesForWell(simWellName))
{
sourcesToSelect.push_back(RifWellRftAddress(RifWellRftAddress::GRID, gridCase));
sourcesToSelect.push_back(RifDataSourceForRftPlt(RifDataSourceForRftPlt::GRID, gridCase));
RimWellPlotTools::appendSet(gridTimeSteps, RimWellPlotTools::timeStepsFromGridCase(gridCase));
}
std::vector<RimWellLogFile*> wellLogFiles = RimWellPlotTools::wellLogFilesContainingPressure(simWellName);
if(wellLogFiles.size() > 0)
{
sourcesToSelect.push_back(RifWellRftAddress(RifWellRftAddress::OBSERVED));
sourcesToSelect.push_back(RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED));
for (RimWellLogFile* const wellLogFile : wellLogFiles)
{
observedTimeSteps.insert(RimWellPlotTools::timeStepFromWellLogFile(wellLogFile));
@@ -362,26 +362,26 @@ void RimWellRftPlot::applyInitialSelections()
//--------------------------------------------------------------------------------------------------
void RimWellRftPlot::updateEditorsFromCurves()
{
std::set<RifWellRftAddress> selectedSources;
std::set<RifDataSourceForRftPlt> selectedSources;
std::set<QDateTime> selectedTimeSteps;
std::map<QDateTime, std::set<RifWellRftAddress>> selectedTimeStepsMap;
std::map<QDateTime, std::set<RifDataSourceForRftPlt>> selectedTimeStepsMap;
for (const RiaRftPltCurveDefinition& curveDef : curveDefsFromCurves())
{
if (curveDef.address().sourceType() == RifWellRftAddress::OBSERVED)
selectedSources.insert(RifWellRftAddress(RifWellRftAddress::OBSERVED));
if (curveDef.address().sourceType() == RifDataSourceForRftPlt::OBSERVED)
selectedSources.insert(RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED));
else
selectedSources.insert(curveDef.address());
auto newTimeStepMap = std::map<QDateTime, std::set<RifWellRftAddress>>
auto newTimeStepMap = std::map<QDateTime, std::set<RifDataSourceForRftPlt>>
{
{ curveDef.timeStep(), std::set<RifWellRftAddress> { curveDef.address()} }
{ curveDef.timeStep(), std::set<RifDataSourceForRftPlt> { curveDef.address()} }
};
RimWellPlotTools::addTimeStepsToMap(selectedTimeStepsMap, newTimeStepMap);
selectedTimeSteps.insert(curveDef.timeStep());
}
m_selectedSources = std::vector<RifWellRftAddress>(selectedSources.begin(), selectedSources.end());
m_selectedSources = std::vector<RifDataSourceForRftPlt>(selectedSources.begin(), selectedSources.end());
m_selectedTimeSteps = std::vector<QDateTime>(selectedTimeSteps.begin(), selectedTimeSteps.end());
RimWellPlotTools::addTimeStepsToMap(m_timeStepsToAddresses, selectedTimeStepsMap);
}
@@ -455,9 +455,9 @@ std::set < RiaRftPltCurveDefinition> RimWellRftPlot::selectedCurveDefs() const
for (const QDateTime& timeStep : m_selectedTimeSteps())
{
for (const RifWellRftAddress& addr : selectedSources())
for (const RifDataSourceForRftPlt& addr : selectedSources())
{
if (addr.sourceType() == RifWellRftAddress::RFT)
if (addr.sourceType() == RifDataSourceForRftPlt::RFT)
{
for (RimEclipseResultCase* const rftCase : rftCases)
{
@@ -468,7 +468,7 @@ std::set < RiaRftPltCurveDefinition> RimWellRftPlot::selectedCurveDefs() const
}
}
}
else if (addr.sourceType() == RifWellRftAddress::GRID)
else if (addr.sourceType() == RifDataSourceForRftPlt::GRID)
{
for (RimEclipseResultCase* const gridCase : gridCases)
{
@@ -479,14 +479,14 @@ std::set < RiaRftPltCurveDefinition> RimWellRftPlot::selectedCurveDefs() const
}
}
}
else if (addr.sourceType() == RifWellRftAddress::OBSERVED)
else if (addr.sourceType() == RifDataSourceForRftPlt::OBSERVED)
{
if (addr.wellLogFile() != nullptr)
{
const QDateTime wellLogFileTimeStep = RimWellPlotTools::timeStepFromWellLogFile(addr.wellLogFile());
if (wellLogFileTimeStep == timeStep)
{
curveDefs.insert(RiaRftPltCurveDefinition(RifWellRftAddress(RifWellRftAddress::OBSERVED, addr.wellLogFile()), timeStep));
curveDefs.insert(RiaRftPltCurveDefinition(RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED, addr.wellLogFile()), timeStep));
}
}
}
@@ -529,7 +529,7 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<RiaRftPltCurveDefinition>
// Add new curves
for (const RiaRftPltCurveDefinition& curveDefToAdd : curveDefsToAdd)
{
if (curveDefToAdd.address().sourceType() == RifWellRftAddress::RFT)
if (curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::RFT)
{
auto curve = new RimWellLogRftCurve();
plotTrack->addCurve(curve);
@@ -543,7 +543,7 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<RiaRftPltCurveDefinition>
applyCurveAppearance(curve);
}
else if (curveDefToAdd.address().sourceType() == RifWellRftAddress::GRID)
else if (curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::GRID)
{
auto curve = new RimWellLogExtractionCurve();
plotTrack->addCurve(curve);
@@ -577,7 +577,7 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<RiaRftPltCurveDefinition>
applyCurveAppearance(curve);
}
}
else if (curveDefToAdd.address().sourceType() == RifWellRftAddress::OBSERVED)
else if (curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::OBSERVED)
{
RimWellLogFile* const wellLogFile = curveDefToAdd.address().wellLogFile();
RimWellPath* const wellPath = RimWellPlotTools::wellPathFromWellLogFile(wellLogFile);
@@ -608,21 +608,21 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<RiaRftPltCurveDefinition>
//--------------------------------------------------------------------------------------------------
bool RimWellRftPlot::isOnlyGridSourcesSelected() const
{
const std::vector<RifWellRftAddress>& selSources = m_selectedSources();
return std::find_if(selSources.begin(), selSources.end(), [](const RifWellRftAddress& addr)
const std::vector<RifDataSourceForRftPlt>& selSources = m_selectedSources();
return std::find_if(selSources.begin(), selSources.end(), [](const RifDataSourceForRftPlt& addr)
{
return addr.sourceType() == RifWellRftAddress::RFT || addr.sourceType() == RifWellRftAddress::OBSERVED;
return addr.sourceType() == RifDataSourceForRftPlt::RFT || addr.sourceType() == RifDataSourceForRftPlt::OBSERVED;
}) == selSources.end();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimWellRftPlot::isAnySourceAddressSelected(const std::set<RifWellRftAddress>& addresses) const
bool RimWellRftPlot::isAnySourceAddressSelected(const std::set<RifDataSourceForRftPlt>& addresses) const
{
const std::vector<RifWellRftAddress>& selectedSourcesVector = m_selectedSources();
const auto selectedSources = std::set<RifWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RifWellRftAddress> intersectVector;
const std::vector<RifDataSourceForRftPlt>& selectedSourcesVector = m_selectedSources();
const auto selectedSources = std::set<RifDataSourceForRftPlt>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RifDataSourceForRftPlt> intersectVector;
std::set_intersection(selectedSources.begin(), selectedSources.end(),
addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end()));
@@ -632,16 +632,16 @@ bool RimWellRftPlot::isAnySourceAddressSelected(const std::set<RifWellRftAddress
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RifWellRftAddress> RimWellRftPlot::selectedSources() const
std::vector<RifDataSourceForRftPlt> RimWellRftPlot::selectedSources() const
{
std::vector<RifWellRftAddress> sources;
for (const RifWellRftAddress& addr : m_selectedSources())
std::vector<RifDataSourceForRftPlt> sources;
for (const RifDataSourceForRftPlt& addr : m_selectedSources())
{
if (addr.sourceType() == RifWellRftAddress::OBSERVED)
if (addr.sourceType() == RifDataSourceForRftPlt::OBSERVED)
{
for (RimWellLogFile* const wellLogFile : RimWellPlotTools::wellLogFilesContainingPressure(associatedSimWellName()))
{
sources.push_back(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile));
sources.push_back(RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED, wellLogFile));
}
}
else
@@ -724,11 +724,11 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions(const caf::P
const std::vector<RimEclipseResultCase*> rftCases = RimWellPlotTools::rftCasesForWell(simWellName);
if (rftCases.size() > 0)
{
options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RifWellRftAddress::RFT), true));
options.push_back(caf::PdmOptionItemInfo::createHeader(RifDataSourceForRftPlt::sourceTypeUiText(RifDataSourceForRftPlt::RFT), true));
}
for (const auto& rftCase : rftCases)
{
auto addr = RifWellRftAddress(RifWellRftAddress::RFT, rftCase);
auto addr = RifDataSourceForRftPlt(RifDataSourceForRftPlt::RFT, rftCase);
auto item = caf::PdmOptionItemInfo(rftCase->caseUserDescription(), QVariant::fromValue(addr));
item.setLevel(1);
options.push_back(item);
@@ -737,11 +737,11 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions(const caf::P
const std::vector<RimEclipseResultCase*> gridCases = RimWellPlotTools::gridCasesForWell(simWellName);
if (gridCases.size() > 0)
{
options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RifWellRftAddress::GRID), true));
options.push_back(caf::PdmOptionItemInfo::createHeader(RifDataSourceForRftPlt::sourceTypeUiText(RifDataSourceForRftPlt::GRID), true));
}
for (const auto& gridCase : gridCases)
{
auto addr = RifWellRftAddress(RifWellRftAddress::GRID, gridCase);
auto addr = RifDataSourceForRftPlt(RifDataSourceForRftPlt::GRID, gridCase);
auto item = caf::PdmOptionItemInfo(gridCase->caseUserDescription(), QVariant::fromValue(addr));
item.setLevel(1);
options.push_back(item);
@@ -749,9 +749,9 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions(const caf::P
if (RimWellPlotTools::wellLogFilesContainingPressure(simWellName).size() > 0)
{
options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RifWellRftAddress::OBSERVED), true));
options.push_back(caf::PdmOptionItemInfo::createHeader(RifDataSourceForRftPlt::sourceTypeUiText(RifDataSourceForRftPlt::OBSERVED), true));
auto addr = RifWellRftAddress(RifWellRftAddress::OBSERVED);
auto addr = RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED);
auto item = caf::PdmOptionItemInfo("Observed Data", QVariant::fromValue(addr));
item.setLevel(1);
options.push_back(item);
@@ -946,27 +946,27 @@ void RimWellRftPlot::calculateValueOptionsForTimeSteps(QList<caf::PdmOptionItemI
{
const QString simWellName = associatedSimWellName();
std::map<QDateTime, std::set<RifWellRftAddress>> displayTimeStepsMap, obsAndRftTimeStepsMap, gridTimeStepsMap;
std::map<QDateTime, std::set<RifDataSourceForRftPlt>> displayTimeStepsMap, obsAndRftTimeStepsMap, gridTimeStepsMap;
const std::vector<RimEclipseResultCase*> rftCases = RimWellPlotTools::rftCasesForWell(simWellName);
const std::vector<RimEclipseResultCase*> gridCases = RimWellPlotTools::gridCasesForWell(simWellName);
for (const RifWellRftAddress& selection : selectedSources())
for (const RifDataSourceForRftPlt& selection : selectedSources())
{
if (selection.sourceType() == RifWellRftAddress::RFT)
if (selection.sourceType() == RifDataSourceForRftPlt::RFT)
{
for (RimEclipseResultCase* const rftCase : rftCases)
{
RimWellPlotTools::addTimeStepsToMap(obsAndRftTimeStepsMap, RimWellPlotTools::timeStepsMapFromRftCase(rftCase, simWellName));
}
}
else if (selection.sourceType() == RifWellRftAddress::GRID)
else if (selection.sourceType() == RifDataSourceForRftPlt::GRID)
{
for (RimEclipseResultCase* const gridCase : gridCases)
{
RimWellPlotTools::addTimeStepsToMap(gridTimeStepsMap, RimWellPlotTools::timeStepsMapFromGridCase(gridCase));
}
}
else if (selection.sourceType() == RifWellRftAddress::OBSERVED)
else if (selection.sourceType() == RifDataSourceForRftPlt::OBSERVED)
{
if (selection.wellLogFile() != nullptr)
{
@@ -981,11 +981,11 @@ void RimWellRftPlot::calculateValueOptionsForTimeSteps(QList<caf::PdmOptionItemI
}
else
{
const auto gridTimeStepsVector = std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>(gridTimeStepsMap.begin(), gridTimeStepsMap.end());
const auto gridTimeStepsVector = std::vector<std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>>(gridTimeStepsMap.begin(), gridTimeStepsMap.end());
for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : obsAndRftTimeStepsMap)
for (const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepPair : obsAndRftTimeStepsMap)
{
const std::map<QDateTime, std::set<RifWellRftAddress>>& adjTimeSteps = RimWellPlotTools::adjacentTimeSteps(gridTimeStepsVector, timeStepPair);
const std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& adjTimeSteps = RimWellPlotTools::adjacentTimeSteps(gridTimeStepsVector, timeStepPair);
RimWellPlotTools::addTimeStepsToMap(displayTimeStepsMap, adjTimeSteps);
}
@@ -1000,7 +1000,7 @@ void RimWellRftPlot::calculateValueOptionsForTimeSteps(QList<caf::PdmOptionItemI
{
if (m_timeStepsToAddresses.count(timeStep) > 0)
{
const std::set<RifWellRftAddress> sourceAddresses = m_timeStepsToAddresses[timeStep];
const std::set<RifDataSourceForRftPlt> sourceAddresses = m_timeStepsToAddresses[timeStep];
if (isAnySourceAddressSelected(sourceAddresses))
{
RimWellPlotTools::addTimeStepToMap(displayTimeStepsMap, std::make_pair(timeStep, m_timeStepsToAddresses[timeStep]));
@@ -1013,13 +1013,13 @@ void RimWellRftPlot::calculateValueOptionsForTimeSteps(QList<caf::PdmOptionItemI
// Create vector of all time steps
std::vector<QDateTime> allTimeSteps;
for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : m_timeStepsToAddresses)
for (const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepPair : m_timeStepsToAddresses)
{
allTimeSteps.push_back(timeStepPair.first);
}
const QString dateFormatString = RimTools::createTimeFormatStringFromDates(allTimeSteps);
for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : displayTimeStepsMap)
for (const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepPair : displayTimeStepsMap)
{
options.push_back(caf::PdmOptionItemInfo(timeStepPair.first.toString(dateFormatString), timeStepPair.first));
}

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

@@ -26,7 +26,7 @@
#include "RimCase.h"
#include "RimPlotCurve.h"
#include "RifWellRftAddressQMetaType.h"
#include "RifDataSourceForRftPltQMetaType.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
@@ -119,8 +119,8 @@ private:
const std::set<RiaRftPltCurveDefinition>& curveDefsToAdd,
const std::set<RimWellLogCurve*>& curvesToDelete);
bool isOnlyGridSourcesSelected() const;
bool isAnySourceAddressSelected(const std::set<RifWellRftAddress>& addresses) const;
std::vector<RifWellRftAddress> selectedSources() const;
bool isAnySourceAddressSelected(const std::set<RifDataSourceForRftPlt>& addresses) const;
std::vector<RifDataSourceForRftPlt> selectedSources() const;
// RimViewWindow overrides
@@ -139,7 +139,7 @@ private:
caf::PdmField<QString> m_wellPathNameOrSimWellName;
caf::PdmField<int> m_branchIndex;
caf::PdmField<std::vector<RifWellRftAddress>> m_selectedSources;
caf::PdmField<std::vector<RifDataSourceForRftPlt>> m_selectedSources;
caf::PdmField<std::vector<QDateTime>> m_selectedTimeSteps;
@@ -147,7 +147,7 @@ private:
caf::PdmChildField<RimWellLogPlot*> m_wellLogPlot;
std::map<QDateTime, std::set<RifWellRftAddress>> m_timeStepsToAddresses;
std::map<QDateTime, std::set<RifDataSourceForRftPlt>> m_timeStepsToAddresses;
bool m_selectedSourcesOrTimeStepsFieldsChanged;
bool m_isOnLoad;