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

#1998 RFT plot. Support for multiple LAS files per well path

Browse Source
This commit is contained in:
Bjørn Erik Jensen
2017-10-19 16:12:22 +02:00
parent 5a9af2bba6
commit b99f12b3e4
12 changed files with 369 additions and 258 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/Commands/RicWellLogTools.cpp
View File

@@ -137,7 +137,7 @@ RimWellPath* RicWellLogTools::selectedWellPathWithLogFile()
if (selection.size() > 0) if (selection.size() > 0)
{ {
RimWellPath* wellPath = selection[0]; RimWellPath* wellPath = selection[0];
if (wellPath->wellLogFile()) if (wellPath->wellLogFiles().size() > 0)
{ {
return wellPath; return wellPath;
} }

8
ApplicationCode/Commands/WellLogCommands/RicNewRftPlotFeature.cpp
View File

@@ -57,8 +57,6 @@ bool RicNewRftPlotFeature::isCommandEnabled()
{ {
if (RicWellLogPlotCurveFeatureImpl::parentWellAllocationPlot()) return false; if (RicWellLogPlotCurveFeatureImpl::parentWellAllocationPlot()) return false;
//int branchIndex;
RimSimWellInView* simWell = caf::firstAncestorOfTypeFromSelectedObject<RimSimWellInView*>(); RimSimWellInView* simWell = caf::firstAncestorOfTypeFromSelectedObject<RimSimWellInView*>();
RimWellPath* rimWellPath = simWell == nullptr ? caf::firstAncestorOfTypeFromSelectedObject<RimWellPath*>() : nullptr; RimWellPath* rimWellPath = simWell == nullptr ? caf::firstAncestorOfTypeFromSelectedObject<RimWellPath*>() : nullptr;
@@ -73,11 +71,7 @@ bool RicNewRftPlotFeature::isCommandEnabled()
} }
else if (rimWellPath) else if (rimWellPath)
{ {
auto wellLogFile = rimWellPath->wellLogFile(); enable &= RimWellRftPlot::hasPressureData(rimWellPath);
if (wellLogFile != nullptr)
{
enable &= RimWellRftPlot::hasPressureData(wellLogFile);
}
} }
return enable; return enable;
} }

7
ApplicationCode/Commands/WellLogCommands/RicNewWellLogFileCurveFeature.cpp
View File

@@ -97,12 +97,9 @@ bool RicNewWellLogFileCurveFeature::wellLogFilesAvailable() const
for (size_t i = 0; i < wellPaths.size(); i++) for (size_t i = 0; i < wellPaths.size(); i++)
{ {
if (wellPaths[i]->wellLogFile()) if (wellPaths[i]->wellLogFiles().size() > 0)
{ {
if (wellPaths[i]->wellLogFile()->wellLogFile()) return true;
{
return true;
}
} }
} }
} }

76
ApplicationCode/ProjectDataModel/Flow/RimWellRftAddress.cpp
View File

@@ -17,7 +17,11 @@
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
#include "RimWellRftAddress.h" #include "RimWellRftAddress.h"
#include "RimEclipseCase.h"
#include "RimWellLogFile.h"
#include "cafAppEnum.h" #include "cafAppEnum.h"
#include "cvfAssert.h"
#include <QString> #include <QString>
#include <QTextStream> #include <QTextStream>
@@ -34,10 +38,34 @@ namespace caf
} }
} }
RimWellRftAddress::RimWellRftAddress(RftSourceType sourceType , int caseId) //--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellRftAddress::RimWellRftAddress() : m_sourceType(RftSourceType::NONE)
{ {
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellRftAddress::RimWellRftAddress(RftSourceType sourceType, RimEclipseCase* eclCase)
{
CVF_ASSERT(sourceType == RftSourceType::RFT || sourceType == RftSourceType::GRID);
CVF_ASSERT(eclCase != nullptr);
m_sourceType = sourceType; m_sourceType = sourceType;
m_caseId = caseId; m_eclCase = eclCase;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellRftAddress::RimWellRftAddress(RftSourceType sourceType, RimWellLogFile* wellLogFile)
{
CVF_ASSERT(sourceType == RftSourceType::OBSERVED);
m_sourceType = sourceType;
m_wellLogFile = wellLogFile;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -51,19 +79,17 @@ RftSourceType RimWellRftAddress::sourceType() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
int RimWellRftAddress::caseId() const RimEclipseCase* RimWellRftAddress::eclCase() const
{ {
return m_caseId; return m_eclCase;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QString RimWellRftAddress::uiText() const RimWellLogFile* RimWellRftAddress::wellLogFile() const
{ {
return m_caseId >= 0 ? return m_wellLogFile;
QString("%1 %2").arg(sourceTypeUiText(m_sourceType), QString::number(m_caseId)) :
QString("%1").arg(sourceTypeUiText(m_sourceType));
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -85,7 +111,9 @@ QString RimWellRftAddress::sourceTypeUiText(RftSourceType sourceType)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool operator==(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2) bool operator==(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2)
{ {
return addr1.sourceType() == addr2.sourceType() && addr1.caseId() == addr2.caseId(); return addr1.sourceType() == addr2.sourceType()
&& addr1.eclCase() == addr2.eclCase()
&& addr1.wellLogFile() == addr2.wellLogFile();
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -93,7 +121,8 @@ bool operator==(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QTextStream& operator << (QTextStream& str, const RimWellRftAddress& addr) QTextStream& operator << (QTextStream& str, const RimWellRftAddress& addr)
{ {
str << RimWellRftAddress::sourceTypeUiText(addr.sourceType()) << " " << addr.caseId(); // Not implemented
CVF_ASSERT(false);
return str; return str;
} }
@@ -102,25 +131,8 @@ QTextStream& operator << (QTextStream& str, const RimWellRftAddress& addr)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QTextStream& operator >> (QTextStream& str, RimWellRftAddress& source) QTextStream& operator >> (QTextStream& str, RimWellRftAddress& source)
{ {
QString sourceTypeString; // Not implemented
int caseId; CVF_ASSERT(false);
str >> sourceTypeString;
str >> caseId;
if (QString::compare(sourceTypeString, RimWellRftAddress::sourceTypeUiText(RftSourceType::RFT)) == 0)
{
source.m_sourceType = RftSourceType::RFT;
}
else if (QString::compare(sourceTypeString, RimWellRftAddress::sourceTypeUiText(RftSourceType::GRID)) == 0)
{
source.m_sourceType = RftSourceType::GRID;
}
else if (QString::compare(sourceTypeString, RimWellRftAddress::sourceTypeUiText(RftSourceType::OBSERVED)) == 0)
{
source.m_sourceType = RftSourceType::OBSERVED;
}
source.m_caseId = caseId;
return str; return str;
} }
@@ -130,6 +142,8 @@ QTextStream& operator >> (QTextStream& str, RimWellRftAddress& source)
bool operator<(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2) bool operator<(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2)
{ {
return (addr1.m_sourceType < addr2.m_sourceType) || return (addr1.m_sourceType < addr2.m_sourceType) ||
(addr1.m_sourceType == addr2.m_sourceType && addr1.m_caseId < addr2.m_caseId); (addr1.m_sourceType == addr2.m_sourceType &&
addr1.eclCase() != nullptr && addr2.eclCase() != nullptr ? addr1.eclCase()->caseId() < addr2.eclCase()->caseId() :
addr1.wellLogFile() != nullptr && addr2.wellLogFile() != nullptr ? addr1.wellLogFile()->fileName() < addr2.wellLogFile()->fileName() :
addr1.wellLogFile() < addr2.wellLogFile());
} }

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

@@ -24,12 +24,15 @@
#include "cafPdmField.h" #include "cafPdmField.h"
#include "cafPdmObject.h" #include "cafPdmObject.h"
#include "cafPdmPtrField.h" #include "cafPdmPtrField.h"
#include "cafPdmPointer.h"
#include <QPointer> #include <QPointer>
#include <QDate> #include <QDate>
#include <QMetaType> #include <QMetaType>
class RimWellLogFile; class RimWellLogFile;
class RimEclipseCase;
//================================================================================================== //==================================================================================================
/// ///
@@ -43,28 +46,27 @@ enum class RftSourceType
OBSERVED OBSERVED
}; };
class RimWellRftAddress class RimWellRftAddress
{ {
public: public:
RimWellRftAddress() : m_sourceType(RftSourceType::NONE), m_caseId(-1) RimWellRftAddress();
{ RimWellRftAddress(RftSourceType sourceType, RimEclipseCase* eclCase);
} RimWellRftAddress(RftSourceType sourceType, RimWellLogFile* wellLogFile = nullptr);
RimWellRftAddress(RftSourceType sourceType, int caseId = -1);
RftSourceType sourceType() const; RftSourceType sourceType() const;
int caseId() const; RimEclipseCase* eclCase() const;
RimWellLogFile* wellLogFile() const;
QString uiText() const;
static QString sourceTypeUiText(RftSourceType sourceType); static QString sourceTypeUiText(RftSourceType sourceType);
friend QTextStream& operator >> (QTextStream& str, RimWellRftAddress& addr); friend QTextStream& operator >> (QTextStream& str, RimWellRftAddress& addr);
friend bool operator<(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2); friend bool operator<(const RimWellRftAddress& addr1, const RimWellRftAddress& addr2);
private: private:
RftSourceType m_sourceType; RftSourceType m_sourceType;
int m_caseId; caf::PdmPointer<RimEclipseCase> m_eclCase;
caf::PdmPointer<RimWellLogFile> m_wellLogFile;
}; };
Q_DECLARE_METATYPE(RimWellRftAddress); Q_DECLARE_METATYPE(RimWellRftAddress);

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

@@ -89,6 +89,7 @@ RimWellRftPlot::RimWellRftPlot()
m_selectedTimeSteps.uiCapability()->setAutoAddingOptionFromValue(false); m_selectedTimeSteps.uiCapability()->setAutoAddingOptionFromValue(false);
this->setAsPlotMdiWindow(); this->setAsPlotMdiWindow();
m_selectedSourcesOrTimeStepsFieldsChanged = false;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -223,7 +224,7 @@ void RimWellRftPlot::updateSelectedTimeStepsFromSelectedSources()
{ {
std::vector<QDateTime> selectedTimeSteps = m_selectedTimeSteps; std::vector<QDateTime> selectedTimeSteps = m_selectedTimeSteps;
std::vector<QDateTime> newTimeStepsSelections; std::vector<QDateTime> newTimeStepsSelections;
std::vector<RimWellRftAddress> selectedSourcesVector = m_selectedSources; std::vector<RimWellRftAddress> selectedSourcesVector = selectedSources();
auto selectedSources = std::set<RimWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end()); auto selectedSources = std::set<RimWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
for (const QDateTime& timeStep : m_selectedTimeSteps()) for (const QDateTime& timeStep : m_selectedTimeSteps())
@@ -257,21 +258,24 @@ void RimWellRftPlot::applyInitialSelections()
for(RimEclipseResultCase* const rftCase : rftCasesFromEclipseCases(eclCaseTuples)) for(RimEclipseResultCase* const rftCase : rftCasesFromEclipseCases(eclCaseTuples))
{ {
sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::RFT, rftCase->caseId())); sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::RFT, rftCase));
addTimeStepsToMap(rftTimeStepsMap, timeStepsFromRftCase(rftCase)); addTimeStepsToMap(rftTimeStepsMap, timeStepsFromRftCase(rftCase));
} }
for (RimEclipseResultCase* const gridCase : gridCasesFromEclipseCases(eclCaseTuples)) for (RimEclipseResultCase* const gridCase : gridCasesFromEclipseCases(eclCaseTuples))
{ {
sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::GRID, gridCase->caseId())); sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::GRID, gridCase));
addTimeStepsToMap(gridTimeStepsMap, timeStepsFromGridCase(gridCase)); addTimeStepsToMap(gridTimeStepsMap, timeStepsFromGridCase(gridCase));
} }
std::vector<RimWellPath*> wellPaths = wellPathsContainingPressure(m_wellName); std::vector<RimWellLogFile*> wellLogFiles = wellLogFilesContainingPressure(m_wellName);
if(wellPaths.size() > 0) if(wellLogFiles.size() > 0)
{ {
sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::OBSERVED)); sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::OBSERVED));
addTimeStepsToMap(observedTimeStepsMap, timeStepsFromWellPaths(wellPaths)); for (RimWellLogFile* const wellLogFile : wellLogFiles)
{
addTimeStepsToMap(observedTimeStepsMap, timeStepsFromWellLogFile(wellLogFile));
}
} }
m_selectedSources = sourcesToSelect; m_selectedSources = sourcesToSelect;
@@ -304,7 +308,10 @@ void RimWellRftPlot::updateEditorsFromCurves()
for (const std::pair<RimWellRftAddress, QDateTime>& curveDef : curveDefsFromCurves()) for (const std::pair<RimWellRftAddress, QDateTime>& curveDef : curveDefsFromCurves())
{ {
selectedSources.insert(curveDef.first); if (curveDef.first.sourceType() == RftSourceType::OBSERVED)
selectedSources.insert(RimWellRftAddress(RftSourceType::OBSERVED));
else
selectedSources.insert(curveDef.first);
auto newTimeStepMap = std::map<QDateTime, std::set<RimWellRftAddress>> auto newTimeStepMap = std::map<QDateTime, std::set<RimWellRftAddress>>
{ {
@@ -378,83 +385,77 @@ void RimWellRftPlot::syncCurvesFromUiSelection()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<RimWellPath*> RimWellRftPlot::wellPathsContainingPressure(const QString& wellName) const std::vector<RimWellLogFile*> RimWellRftPlot::wellLogFilesContainingPressure(const QString& wellName) const
{ {
std::vector<RimWellPath*> wellPaths; std::vector<RimWellLogFile*> wellLogFiles;
const RimProject* const project = RiaApplication::instance()->project(); const RimProject* const project = RiaApplication::instance()->project();
for (const auto& oilField : project->oilFields) for (const auto& oilField : project->oilFields)
{ {
auto wellPathsVector = std::vector<RimWellPath*>(oilField->wellPathCollection()->wellPaths.begin(), oilField->wellPathCollection()->wellPaths.end()); auto wellPathsVector = std::vector<RimWellPath*>(oilField->wellPathCollection()->wellPaths.begin(), oilField->wellPathCollection()->wellPaths.end());
size_t timeStepCount = timeStepsFromWellPaths(wellPathsVector).size();
if (timeStepCount == 0) continue;
for (const auto& wellPath : wellPathsVector) for (const auto& wellPath : wellPathsVector)
{ {
bool hasPressure = false; bool hasPressure = false;
RimWellLogFile* const wellLogFile = wellPath->wellLogFile(); const std::vector<RimWellLogFile*> files = wellPath->wellLogFiles();
if (wellLogFile == nullptr || QString::compare(wellLogFile->wellName(), wellName) != 0) continue; for (RimWellLogFile* const file : files)
{
size_t timeStepCount = timeStepsFromWellLogFile(file).size();
if (hasPressureData(wellLogFile)) if (timeStepCount == 0) continue;
wellPaths.push_back(wellPath); if (QString::compare(file->wellName(), wellName) != 0) continue;
if (hasPressureData(file))
{
wellLogFiles.push_back(file);
}
}
} }
} }
return wellPaths; return wellLogFiles;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<RimWellLogFileChannel*> RimWellRftPlot::getPressureChannelsFromWellPath(const RimWellPath* wellPath) const RimWellLogFileChannel* RimWellRftPlot::getPressureChannelFromWellFile(const RimWellLogFile* wellLogFile) const
{ {
std::vector<RimWellLogFileChannel*> channels; if(wellLogFile != nullptr)
const RimWellLogFile* const wellLogFile = wellPath->wellLogFile();
if (wellLogFile != nullptr)
{ {
for (RimWellLogFileChannel* const channel : wellLogFile->wellLogChannels()) for (RimWellLogFileChannel* const channel : wellLogFile->wellLogChannels())
{ {
if (hasPressureData(channel)) if (isPressureChannel(channel))
{ {
channels.push_back(channel); return channel;
} }
} }
} }
return channels; return nullptr;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimEclipseCase* RimWellRftPlot::eclipseCaseFromCaseId(int caseId) RimWellPath* RimWellRftPlot::wellPathFromWellLogFile(const RimWellLogFile* wellLogFile) const
{ {
const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCases = eclipseCasesForWell(m_wellName); RimProject* const project = RiaApplication::instance()->project();
auto itr = std::find_if(eclipseCases.begin(), eclipseCases.end(), for (const auto& oilField : project->oilFields)
[caseId](std::tuple<RimEclipseResultCase*,bool,bool> eclCase) { return std::get<0>(eclCase)->caseId == caseId; });
return itr != eclipseCases.end() ? std::get<0>(*itr) : nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellPath* RimWellRftPlot::wellPathForObservedData(const QString& wellName, const QDateTime& date) const
{
std::vector<RimWellPath*> wellPaths = wellPathsContainingPressure(wellName);
for (const auto& wellPath : wellPaths)
{ {
RimWellLogFile* const wellLogFile = wellPath->wellLogFile(); auto wellPaths = std::vector<RimWellPath*>(oilField->wellPathCollection()->wellPaths.begin(), oilField->wellPathCollection()->wellPaths.end());
if (wellLogFile != nullptr)
for (const auto& wellPath : wellPaths)
{ {
const QString& wName = wellLogFile->wellName(); for (RimWellLogFile* const file : wellPath->wellLogFiles())
const QDateTime wDate = RiaDateStringParser::parseDateString(wellLogFile->date());
if (wName == wellName && wDate == date)
{ {
return wellPath; if (file == wellLogFile)
{
return wellPath;
}
} }
} }
} }
return nullptr; return nullptr;
} }
@@ -545,7 +546,7 @@ std::map<QDateTime, std::set<RimWellRftAddress>> RimWellRftPlot::timeStepsFromRf
{ {
timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>())); timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>()));
} }
timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::RFT, rftCase->caseId)); timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::RFT, rftCase));
} }
} }
return timeStepsMap; return timeStepsMap;
@@ -554,7 +555,7 @@ std::map<QDateTime, std::set<RimWellRftAddress>> RimWellRftPlot::timeStepsFromRf
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RimWellRftAddress>> RimWellRftPlot::timeStepsFromGridCase(const RimEclipseCase* gridCase) const std::map<QDateTime, std::set<RimWellRftAddress>> RimWellRftPlot::timeStepsFromGridCase(RimEclipseCase* gridCase) const
{ {
const RigEclipseCaseData* const eclipseCaseData = gridCase->eclipseCaseData(); const RigEclipseCaseData* const eclipseCaseData = gridCase->eclipseCaseData();
size_t resultIndex = eclipseCaseData != nullptr ? size_t resultIndex = eclipseCaseData != nullptr ?
@@ -570,7 +571,7 @@ std::map<QDateTime, std::set<RimWellRftAddress>> RimWellRftPlot::timeStepsFromGr
{ {
timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>())); timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>()));
} }
timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::GRID, gridCase->caseId)); timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::GRID, gridCase));
} }
} }
return timeStepsMap; return timeStepsMap;
@@ -579,24 +580,18 @@ std::map<QDateTime, std::set<RimWellRftAddress>> RimWellRftPlot::timeStepsFromGr
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RimWellRftAddress> > RimWellRftPlot::timeStepsFromWellPaths(const std::vector<RimWellPath*> wellPaths) const std::map<QDateTime, std::set<RimWellRftAddress> > RimWellRftPlot::timeStepsFromWellLogFile(RimWellLogFile* wellLogFile) const
{ {
std::map<QDateTime, std::set<RimWellRftAddress> > timeStepsMap; std::map<QDateTime, std::set<RimWellRftAddress> > timeStepsMap;
for (const RimWellPath* const wellPath : wellPaths)
QDateTime timeStep = RiaDateStringParser::parseDateString(wellLogFile->date());
if (timeStepsMap.count(timeStep) == 0)
{ {
const RimWellLogFile* wellLogFile = wellPath->wellLogFile(); timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>()));
if (wellLogFile != nullptr)
{
QDateTime timeStep = RiaDateStringParser::parseDateString(wellLogFile->date());
if ( timeStepsMap.count(timeStep) == 0 )
{
timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>()));
}
timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::OBSERVED));
}
} }
timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::OBSERVED, wellLogFile));
return timeStepsMap; return timeStepsMap;
} }
@@ -651,40 +646,43 @@ std::set < std::pair<RimWellRftAddress, QDateTime>> RimWellRftPlot::selectedCurv
const std::vector<std::tuple<RimEclipseResultCase*,bool,bool>>& eclipseCases = eclipseCasesForWell(m_wellName); const std::vector<std::tuple<RimEclipseResultCase*,bool,bool>>& eclipseCases = eclipseCasesForWell(m_wellName);
const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases); const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases); const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
const std::vector<RimWellPath*> wellPaths = wellPathsContainingPressure(m_wellName); const std::vector<RimWellLogFile*> wellLogFiles = wellLogFilesContainingPressure(m_wellName);
for (const QDateTime& timeStep : m_selectedTimeSteps()) for (const QDateTime& timeStep : m_selectedTimeSteps())
{ {
for (const RimWellRftAddress& rftAddr : m_selectedSources()) for (const RimWellRftAddress& addr : selectedSources())
{ {
if (rftAddr.sourceType() == RftSourceType::RFT) if (addr.sourceType() == RftSourceType::RFT)
{ {
for (RimEclipseResultCase* const rftCase : rftCases) for (RimEclipseResultCase* const rftCase : rftCases)
{ {
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromRftCase(rftCase); const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromRftCase(rftCase);
if (mapContainsTimeStep(timeStepsMap , timeStep)) if (mapContainsTimeStep(timeStepsMap , timeStep))
{ {
curveDefs.insert(std::make_pair(rftAddr, timeStep)); curveDefs.insert(std::make_pair(addr, timeStep));
} }
} }
} }
else if (rftAddr.sourceType() == RftSourceType::GRID) else if (addr.sourceType() == RftSourceType::GRID)
{ {
for (RimEclipseResultCase* const gridCase : gridCases) for (RimEclipseResultCase* const gridCase : gridCases)
{ {
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase); const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
if (mapContainsTimeStep(timeStepsMap, timeStep)) if (mapContainsTimeStep(timeStepsMap, timeStep))
{ {
curveDefs.insert(std::make_pair(rftAddr, timeStep)); curveDefs.insert(std::make_pair(addr, timeStep));
} }
} }
} }
else if (rftAddr.sourceType() == RftSourceType::OBSERVED) else if (addr.sourceType() == RftSourceType::OBSERVED)
{ {
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromWellPaths(wellPaths); if (addr.wellLogFile() != nullptr)
if (mapContainsTimeStep(timeStepsMap, timeStep))
{ {
curveDefs.insert(std::make_pair(rftAddr, timeStep)); const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromWellLogFile(addr.wellLogFile());
if (mapContainsTimeStep(timeStepsMap, timeStep))
{
curveDefs.insert(std::make_pair(RimWellRftAddress(RftSourceType::OBSERVED, addr.wellLogFile()), timeStep));
}
} }
} }
} }
@@ -718,17 +716,17 @@ std::pair<RimWellRftAddress, QDateTime> RimWellRftPlot::curveDefFromCurve(const
if (rftCurve != nullptr) if (rftCurve != nullptr)
{ {
const RimEclipseResultCase* rftCase = dynamic_cast<const RimEclipseResultCase*>(rftCurve->eclipseResultCase()); RimEclipseResultCase* rftCase = dynamic_cast<RimEclipseResultCase*>(rftCurve->eclipseResultCase());
if (rftCase != nullptr) if (rftCase != nullptr)
{ {
const RifEclipseRftAddress rftAddress = rftCurve->rftAddress(); const RifEclipseRftAddress rftAddress = rftCurve->rftAddress();
const QDateTime timeStep = rftAddress.timeStep(); const QDateTime timeStep = rftAddress.timeStep();
return std::make_pair(RimWellRftAddress(RftSourceType::RFT, rftCase->caseId), timeStep); return std::make_pair(RimWellRftAddress(RftSourceType::RFT, rftCase), timeStep);
} }
} }
else if (gridCurve != nullptr) else if (gridCurve != nullptr)
{ {
const RimEclipseResultCase* gridCase = dynamic_cast<const RimEclipseResultCase*>(gridCurve->rimCase()); RimEclipseResultCase* gridCase = dynamic_cast<RimEclipseResultCase*>(gridCurve->rimCase());
if (gridCase != nullptr) if (gridCase != nullptr)
{ {
size_t timeStepIndex = gridCurve->currentTimeStep(); size_t timeStepIndex = gridCurve->currentTimeStep();
@@ -737,7 +735,7 @@ std::pair<RimWellRftAddress, QDateTime> RimWellRftPlot::curveDefFromCurve(const
timeStepsMap.begin(), timeStepsMap.end()); timeStepsMap.begin(), timeStepsMap.end());
if (timeStepIndex < timeStepsMap.size()) if (timeStepIndex < timeStepsMap.size())
{ {
return std::make_pair(RimWellRftAddress(RftSourceType::GRID, gridCase->caseId), return std::make_pair(RimWellRftAddress(RftSourceType::GRID, gridCase),
timeStepsVector[timeStepIndex].first); timeStepsVector[timeStepIndex].first);
} }
} }
@@ -745,7 +743,7 @@ std::pair<RimWellRftAddress, QDateTime> RimWellRftPlot::curveDefFromCurve(const
else if (wellLogFileCurve != nullptr) else if (wellLogFileCurve != nullptr)
{ {
const RimWellPath* const wellPath = wellLogFileCurve->wellPath(); const RimWellPath* const wellPath = wellLogFileCurve->wellPath();
const RimWellLogFile* const wellLogFile = wellPath->wellLogFile(); RimWellLogFile* const wellLogFile = wellLogFileCurve->wellLogFile();
if (wellLogFile != nullptr) if (wellLogFile != nullptr)
{ {
@@ -753,11 +751,11 @@ std::pair<RimWellRftAddress, QDateTime> RimWellRftPlot::curveDefFromCurve(const
if (date.isValid()) if (date.isValid())
{ {
return std::make_pair(RimWellRftAddress(RftSourceType::OBSERVED), date); return std::make_pair(RimWellRftAddress(RftSourceType::OBSERVED, wellLogFile), date);
} }
} }
} }
return std::make_pair(RimWellRftAddress(RftSourceType::NONE), QDateTime()); return std::make_pair(RimWellRftAddress(), QDateTime());
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -783,7 +781,7 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
auto curve = new RimWellLogRftCurve(); auto curve = new RimWellLogRftCurve();
plotTrack->addCurve(curve); plotTrack->addCurve(curve);
auto rftCase = eclipseCaseFromCaseId(curveDefToAdd.first.caseId()); auto rftCase = curveDefToAdd.first.eclCase();
curve->setEclipseResultCase(dynamic_cast<RimEclipseResultCase*>(rftCase)); curve->setEclipseResultCase(dynamic_cast<RimEclipseResultCase*>(rftCase));
RifEclipseRftAddress address(m_wellName, curveDefToAdd.second, RifEclipseRftAddress::PRESSURE); RifEclipseRftAddress address(m_wellName, curveDefToAdd.second, RifEclipseRftAddress::PRESSURE);
@@ -803,7 +801,7 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
curve->setFromSimulationWellName(m_wellName, m_branchIndex); curve->setFromSimulationWellName(m_wellName, m_branchIndex);
// Fetch cases and time steps // Fetch cases and time steps
auto gridCase = eclipseCaseFromCaseId(curveDefToAdd.first.caseId()); auto gridCase = curveDefToAdd.first.eclCase();
if (gridCase != nullptr) if (gridCase != nullptr)
{ {
// Case // Case
@@ -828,14 +826,16 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
} }
else if (curveDefToAdd.first.sourceType() == RftSourceType::OBSERVED) else if (curveDefToAdd.first.sourceType() == RftSourceType::OBSERVED)
{ {
auto wellPath = wellPathForObservedData(m_wellName, curveDefToAdd.second); RimWellLogFile* const wellLogFile = curveDefToAdd.first.wellLogFile();
if (wellPath != nullptr) RimWellPath* const wellPath = wellPathFromWellLogFile(wellLogFile);
if(wellLogFile!= nullptr)
{ {
const std::vector<RimWellLogFileChannel*> pressureChannels = getPressureChannelsFromWellPath(wellPath); RimWellLogFileChannel* pressureChannel = getPressureChannelFromWellFile(wellLogFile);
auto curve = new RimWellLogFileCurve(); auto curve = new RimWellLogFileCurve();
plotTrack->addCurve(curve); plotTrack->addCurve(curve);
curve->setWellPath(wellPath); curve->setWellPath(wellPath);
curve->setWellLogChannelName(pressureChannels.front()->name()); curve->setWellLogFile(wellLogFile);
curve->setWellLogChannelName(pressureChannel->name());
curve->setZOrder(2); curve->setZOrder(2);
applyCurveAppearance(curve); applyCurveAppearance(curve);
@@ -871,6 +871,27 @@ bool RimWellRftPlot::isAnySourceAddressSelected(const std::set<RimWellRftAddress
return intersectVector.size() > 0; return intersectVector.size() > 0;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimWellRftAddress> RimWellRftPlot::selectedSources() const
{
std::vector<RimWellRftAddress> sources;
for (const RimWellRftAddress& addr : m_selectedSources())
{
if (addr.sourceType() == RftSourceType::OBSERVED)
{
for (RimWellLogFile* const wellLogFile : wellLogFilesContainingPressure(m_wellName))
{
sources.push_back(RimWellRftAddress(RftSourceType::OBSERVED, wellLogFile));
}
}
else
sources.push_back(addr);
}
return sources;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -914,11 +935,11 @@ QString RimWellRftPlot::currentWellName() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimWellRftPlot::hasPressureData(RimWellLogFile* wellLogFile) bool RimWellRftPlot::hasPressureData(const RimWellLogFile* wellLogFile)
{ {
for (RimWellLogFileChannel* const wellLogChannel : wellLogFile->wellLogChannels()) for (RimWellLogFileChannel* const wellLogChannel : wellLogFile->wellLogChannels())
{ {
if (hasPressureData(wellLogChannel)) return true; if (isPressureChannel(wellLogChannel)) return true;
} }
return false; return false;
} }
@@ -926,7 +947,22 @@ bool RimWellRftPlot::hasPressureData(RimWellLogFile* wellLogFile)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimWellRftPlot::hasPressureData(RimWellLogFileChannel* channel) bool RimWellRftPlot::hasPressureData(RimWellPath* wellPath)
{
for (RimWellLogFile* const wellLogFile : wellPath->wellLogFiles())
{
if (hasPressureData(wellLogFile))
{
return true;
}
}
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimWellRftPlot::isPressureChannel(RimWellLogFileChannel* channel)
{ {
// Todo: read pressure channel names from config/defines // Todo: read pressure channel names from config/defines
return QString::compare(channel->name(), PRESSURE_DATA_NAME) == 0; return QString::compare(channel->name(), PRESSURE_DATA_NAME) == 0;
@@ -973,7 +1009,7 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions(const caf::P
} }
for (const auto& rftCase : rftCases) for (const auto& rftCase : rftCases)
{ {
auto addr = RimWellRftAddress(RftSourceType::RFT, rftCase->caseId); auto addr = RimWellRftAddress(RftSourceType::RFT, rftCase);
auto item = caf::PdmOptionItemInfo(rftCase->caseUserDescription(), QVariant::fromValue(addr)); auto item = caf::PdmOptionItemInfo(rftCase->caseUserDescription(), QVariant::fromValue(addr));
item.setLevel(1); item.setLevel(1);
options.push_back(item); options.push_back(item);
@@ -986,18 +1022,18 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions(const caf::P
} }
for (const auto& gridCase : gridCases) for (const auto& gridCase : gridCases)
{ {
auto addr = RimWellRftAddress(RftSourceType::GRID, gridCase->caseId); auto addr = RimWellRftAddress(RftSourceType::GRID, gridCase);
auto item = caf::PdmOptionItemInfo(gridCase->caseUserDescription(), QVariant::fromValue(addr)); auto item = caf::PdmOptionItemInfo(gridCase->caseUserDescription(), QVariant::fromValue(addr));
item.setLevel(1); item.setLevel(1);
options.push_back(item); options.push_back(item);
} }
if (wellPathsContainingPressure(m_wellName).size() > 0) if (wellLogFilesContainingPressure(m_wellName).size() > 0)
{ {
options.push_back(caf::PdmOptionItemInfo::createHeader(RimWellRftAddress::sourceTypeUiText(RftSourceType::OBSERVED), true)); options.push_back(caf::PdmOptionItemInfo::createHeader(RimWellRftAddress::sourceTypeUiText(RftSourceType::OBSERVED), true));
auto addr = RimWellRftAddress(RftSourceType::OBSERVED); auto addr = RimWellRftAddress(RftSourceType::OBSERVED);
auto item = caf::PdmOptionItemInfo(addr.uiText(), QVariant::fromValue(addr)); auto item = caf::PdmOptionItemInfo("Observed Data", QVariant::fromValue(addr));
item.setLevel(1); item.setLevel(1);
options.push_back(item); options.push_back(item);
} }
@@ -1058,6 +1094,7 @@ void RimWellRftPlot::fieldChangedByUi(const caf::PdmFieldHandle* changedField, c
changedField == &m_selectedTimeSteps) changedField == &m_selectedTimeSteps)
{ {
syncCurvesFromUiSelection(); syncCurvesFromUiSelection();
m_selectedSourcesOrTimeStepsFieldsChanged = true;
} }
else if (changedField == &m_showPlotTitle) else if (changedField == &m_showPlotTitle)
{ {
@@ -1086,6 +1123,12 @@ QImage RimWellRftPlot::snapshotWindowContent()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellRftPlot::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) void RimWellRftPlot::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{ {
if (!m_selectedSourcesOrTimeStepsFieldsChanged)
{
updateEditorsFromCurves();
}
m_selectedSourcesOrTimeStepsFieldsChanged = false;
uiOrdering.add(&m_userName); uiOrdering.add(&m_userName);
uiOrdering.add(&m_wellName); uiOrdering.add(&m_wellName);
@@ -1175,27 +1218,30 @@ void RimWellRftPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCases = eclipseCasesForWell(wellName); const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCases = eclipseCasesForWell(wellName);
const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases); const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases); const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
const std::vector<RimWellPath*> observedWellPaths = wellPathsContainingPressure(m_wellName); const std::vector<RimWellLogFile*> wellLogFiles = wellLogFilesContainingPressure(m_wellName);
for (const RimWellRftAddress& selection : m_selectedSources()) for (const RimWellRftAddress& selection : selectedSources())
{ {
if (selection.sourceType() == RimWellRftAddress(RftSourceType::RFT)) if (selection.sourceType() == RftSourceType::RFT)
{ {
for (RimEclipseResultCase* const rftCase : rftCases) for (RimEclipseResultCase* const rftCase : rftCases)
{ {
addTimeStepsToMap(obsAndRftTimeStepsMap, timeStepsFromRftCase(rftCase)); addTimeStepsToMap(obsAndRftTimeStepsMap, timeStepsFromRftCase(rftCase));
} }
} }
else if (selection.sourceType() == RimWellRftAddress(RftSourceType::GRID)) else if (selection.sourceType() == RftSourceType::GRID)
{ {
for (RimEclipseResultCase* const gridCase : gridCases) for (RimEclipseResultCase* const gridCase : gridCases)
{ {
addTimeStepsToMap(gridTimeStepsMap, timeStepsFromGridCase(gridCase)); addTimeStepsToMap(gridTimeStepsMap, timeStepsFromGridCase(gridCase));
} }
} }
else if (selection.sourceType() == RimWellRftAddress(RftSourceType::OBSERVED)) else if (selection.sourceType() == RftSourceType::OBSERVED)
{ {
addTimeStepsToMap(obsAndRftTimeStepsMap, timeStepsFromWellPaths(observedWellPaths)); if (selection.wellLogFile() != nullptr)
{
addTimeStepsToMap(obsAndRftTimeStepsMap, timeStepsFromWellLogFile(selection.wellLogFile()));
}
} }
} }

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

@@ -79,9 +79,10 @@ public:
void setCurrentWellName(const QString& currWellName); void setCurrentWellName(const QString& currWellName);
QString currentWellName() const; QString currentWellName() const;
static bool hasPressureData(RimWellLogFile* wellLogFile); static bool hasPressureData(const RimWellLogFile* wellLogFile);
static bool hasPressureData(RimWellLogFileChannel* channel); static bool isPressureChannel(RimWellLogFileChannel* channel);
static bool hasPressureData(RimEclipseResultCase* gridCase); static bool hasPressureData(RimEclipseResultCase* gridCase);
static bool hasPressureData(RimWellPath* wellPath);
static const char* plotNameFormatString(); static const char* plotNameFormatString();
void applyInitialSelections(); void applyInitialSelections();
@@ -111,18 +112,17 @@ private:
void syncCurvesFromUiSelection(); void syncCurvesFromUiSelection();
std::vector<RimWellPath*> wellPathsContainingPressure(const QString& wellName) const; std::vector<RimWellLogFile*> wellLogFilesContainingPressure(const QString& wellName) const;
std::vector<RimWellLogFileChannel*> getPressureChannelsFromWellPath(const RimWellPath* wellPath) const; RimWellLogFileChannel* getPressureChannelFromWellFile(const RimWellLogFile* wellLogFile) const;
RimEclipseCase* eclipseCaseFromCaseId(int caseId);
RimWellPath* wellPathForObservedData(const QString& wellName, const QDateTime& date) const;
RimWellPath* wellPathFromWellLogFile(const RimWellLogFile* wellLogFile) const;
std::vector<std::tuple<RimEclipseResultCase*, bool, bool>> eclipseCasesForWell(const QString& wellName) const; std::vector<std::tuple<RimEclipseResultCase*, bool, bool>> eclipseCasesForWell(const QString& wellName) const;
std::vector<RimEclipseResultCase*> gridCasesFromEclipseCases(const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCasesTuple) const; std::vector<RimEclipseResultCase*> gridCasesFromEclipseCases(const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCasesTuple) const;
std::vector<RimEclipseResultCase*> rftCasesFromEclipseCases(const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCasesTuple) const; std::vector<RimEclipseResultCase*> rftCasesFromEclipseCases(const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCasesTuple) const;
std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsFromRftCase(RimEclipseResultCase* gridCase) const; std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsFromRftCase(RimEclipseResultCase* gridCase) const;
std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsFromGridCase(const RimEclipseCase* gridCase) const; std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsFromGridCase(RimEclipseCase* gridCase) const;
std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsFromWellPaths(const std::vector<RimWellPath*> wellPaths) 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, 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); const std::pair<QDateTime, std::set<RimWellRftAddress>>& searchTimeStepPair);
static bool mapContainsTimeStep(const std::map<QDateTime, std::set<RimWellRftAddress>>& map, const QDateTime& timeStep); static bool mapContainsTimeStep(const std::map<QDateTime, std::set<RimWellRftAddress>>& map, const QDateTime& timeStep);
@@ -135,6 +135,7 @@ private:
const std::set<RimWellLogCurve*>& curvesToDelete); const std::set<RimWellLogCurve*>& curvesToDelete);
bool isOnlyGridSourcesSelected() const; bool isOnlyGridSourcesSelected() const;
bool isAnySourceAddressSelected(const std::set<RimWellRftAddress>& addresses) const; bool isAnySourceAddressSelected(const std::set<RimWellRftAddress>& addresses) const;
std::vector<RimWellRftAddress> selectedSources() const;
// RimViewWindow overrides // RimViewWindow overrides
@@ -159,4 +160,6 @@ private:
caf::PdmChildField<RimWellLogPlot*> m_wellLogPlot; caf::PdmChildField<RimWellLogPlot*> m_wellLogPlot;
std::map<QDateTime, std::set<RimWellRftAddress>> m_timeStepsToAddresses; std::map<QDateTime, std::set<RimWellRftAddress>> m_timeStepsToAddresses;
bool m_selectedSourcesOrTimeStepsFieldsChanged;
}; };

150
ApplicationCode/ProjectDataModel/RimWellLogFileCurve.cpp
View File

@@ -30,6 +30,7 @@
#include "RimWellLogTrack.h" #include "RimWellLogTrack.h"
#include "RimWellPath.h" #include "RimWellPath.h"
#include "RimWellPathCollection.h" #include "RimWellPathCollection.h"
#include "RimWellRftPlot.h"
#include "RiuLineSegmentQwtPlotCurve.h" #include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuWellLogTrack.h" #include "RiuWellLogTrack.h"
@@ -40,6 +41,7 @@
#include "cafPdmUiTreeOrdering.h" #include "cafPdmUiTreeOrdering.h"
#include <QMessageBox> #include <QMessageBox>
#include <QFileInfo>
CAF_PDM_SOURCE_INIT(RimWellLogFileCurve, "WellLogFileCurve"); CAF_PDM_SOURCE_INIT(RimWellLogFileCurve, "WellLogFileCurve");
@@ -56,6 +58,8 @@ RimWellLogFileCurve::RimWellLogFileCurve()
CAF_PDM_InitFieldNoDefault(&m_wellLogChannnelName, "CurveWellLogChannel", "Well Log Channel", "", "", ""); CAF_PDM_InitFieldNoDefault(&m_wellLogChannnelName, "CurveWellLogChannel", "Well Log Channel", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_wellLogFile, "WellLogFile", "Well Log File", "", "", "");
m_wellPath = nullptr; m_wellPath = nullptr;
} }
@@ -81,77 +85,72 @@ void RimWellLogFileCurve::onLoadDataAndUpdate(bool updateParentPlot)
firstAncestorOrThisOfType(wellLogPlot); firstAncestorOrThisOfType(wellLogPlot);
CVF_ASSERT(wellLogPlot); CVF_ASSERT(wellLogPlot);
if (m_wellPath) if (m_wellPath && m_wellLogFile)
{ {
RimWellLogFile* logFileInfo = m_wellPath->wellLogFile(); RigWellLogFile* wellLogFile = m_wellLogFile->wellLogFile();
if (logFileInfo) if (wellLogFile)
{ {
RigWellLogFile* wellLogFile = logFileInfo->wellLogFile(); std::vector<double> values = wellLogFile->values(m_wellLogChannnelName);
if (wellLogFile) std::vector<double> measuredDepthValues = wellLogFile->depthValues();
if (wellLogPlot && wellLogPlot->depthType() == RimWellLogPlot::TRUE_VERTICAL_DEPTH)
{ {
std::vector<double> values = wellLogFile->values(m_wellLogChannnelName); bool canUseTvd = false;
std::vector<double> measuredDepthValues = wellLogFile->depthValues(); if (wellLogFile->hasTvdChannel())
if (wellLogPlot && wellLogPlot->depthType() == RimWellLogPlot::TRUE_VERTICAL_DEPTH)
{ {
bool canUseTvd = false; std::vector<double> tvdMslValues = wellLogFile->tvdMslValues();
if (wellLogFile->hasTvdChannel())
{
std::vector<double> tvdMslValues = wellLogFile->tvdMslValues();
if (values.size() == measuredDepthValues.size() && values.size() == tvdMslValues.size()) if (values.size() == measuredDepthValues.size() && values.size() == tvdMslValues.size())
{
m_curveData->setValuesWithTVD(values, measuredDepthValues, tvdMslValues, wellLogFile->depthUnit(), false);
canUseTvd = true;
}
}
if (!canUseTvd)
{
RigWellPath* rigWellPath = m_wellPath->wellPathGeometry();
if (rigWellPath)
{
std::vector<double> trueVerticeldepthValues;
for (double measuredDepthValue : measuredDepthValues)
{ {
m_curveData->setValuesWithTVD(values, measuredDepthValues, tvdMslValues, wellLogFile->depthUnit(), false); trueVerticeldepthValues.push_back(-rigWellPath->interpolatedPointAlongWellPath(measuredDepthValue).z());
}
if (values.size() == trueVerticeldepthValues.size() && values.size() == measuredDepthValues.size())
{
m_curveData->setValuesWithTVD(values, measuredDepthValues, trueVerticeldepthValues, wellLogFile->depthUnit(), false);
canUseTvd = true; canUseTvd = true;
} }
} }
if (!canUseTvd)
{
RigWellPath* rigWellPath = m_wellPath->wellPathGeometry();
if (rigWellPath)
{
std::vector<double> trueVerticeldepthValues;
for (double measuredDepthValue : measuredDepthValues)
{
trueVerticeldepthValues.push_back(-rigWellPath->interpolatedPointAlongWellPath(measuredDepthValue).z());
}
if (values.size() == trueVerticeldepthValues.size() && values.size() == measuredDepthValues.size())
{
m_curveData->setValuesWithTVD(values, measuredDepthValues, trueVerticeldepthValues, wellLogFile->depthUnit(), false);
canUseTvd = true;
}
}
}
if (!canUseTvd)
{
if (RiaApplication::instance()->preferences()->showLasCurveWithoutTvdWarning())
{
QString tmp = QString("Display of True Vertical Depth (TVD) for LAS curves is not possible without a well log path, and the LAS curve will be hidden in this mode.\n\n");
tmp += "Control display of this warning from \"Preferences->Show LAS curve without TVD warning\"";
QMessageBox::warning(nullptr, "LAS curve without TVD", tmp);
}
}
} }
else
if (!canUseTvd)
{ {
if (values.size() == measuredDepthValues.size()) if (RiaApplication::instance()->preferences()->showLasCurveWithoutTvdWarning())
{ {
m_curveData->setValuesAndMD(values, measuredDepthValues, wellLogFile->depthUnit(), false); QString tmp = QString("Display of True Vertical Depth (TVD) for LAS curves is not possible without a well log path, and the LAS curve will be hidden in this mode.\n\n");
tmp += "Control display of this warning from \"Preferences->Show LAS curve without TVD warning\"";
QMessageBox::warning(nullptr, "LAS curve without TVD", tmp);
} }
} }
} }
else
if (m_isUsingAutoName)
{ {
m_qwtPlotCurve->setTitle(createCurveAutoName()); if (values.size() == measuredDepthValues.size())
{
m_curveData->setValuesAndMD(values, measuredDepthValues, wellLogFile->depthUnit(), false);
}
} }
} }
}
if (m_isUsingAutoName)
{
m_qwtPlotCurve->setTitle(createCurveAutoName());
}
}
RiaDefines::DepthUnitType displayUnit = RiaDefines::UNIT_METER; RiaDefines::DepthUnitType displayUnit = RiaDefines::UNIT_METER;
if (wellLogPlot) if (wellLogPlot)
@@ -198,6 +197,14 @@ void RimWellLogFileCurve::setWellLogChannelName(const QString& name)
m_wellLogChannnelName = name; m_wellLogChannnelName = name;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogFileCurve::setWellLogFile(RimWellLogFile* wellLogFile)
{
m_wellLogFile = wellLogFile;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -213,7 +220,10 @@ void RimWellLogFileCurve::fieldChangedByUi(const caf::PdmFieldHandle* changedFie
{ {
this->loadDataAndUpdate(true); this->loadDataAndUpdate(true);
} }
else if (changedField == &m_wellLogFile)
{
this->loadDataAndUpdate(true);
}
if (m_parentQwtPlot) m_parentQwtPlot->replot(); if (m_parentQwtPlot) m_parentQwtPlot->replot();
} }
@@ -227,6 +237,7 @@ void RimWellLogFileCurve::defineUiOrdering(QString uiConfigName, caf::PdmUiOrder
caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroup("Curve Data"); caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroup("Curve Data");
curveDataGroup->add(&m_wellPath); curveDataGroup->add(&m_wellPath);
curveDataGroup->add(&m_wellLogChannnelName); curveDataGroup->add(&m_wellLogChannnelName);
curveDataGroup->add(&m_wellLogFile);
caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup("Appearance"); caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup("Appearance");
RimPlotCurve::appearanceUiOrdering(*appearanceGroup); RimPlotCurve::appearanceUiOrdering(*appearanceGroup);
@@ -265,7 +276,7 @@ QList<caf::PdmOptionItemInfo> RimWellLogFileCurve::calculateValueOptions(const c
for (size_t i = 0; i < wellPaths.size(); i++) for (size_t i = 0; i < wellPaths.size(); i++)
{ {
// Only include well paths coming from a well log file // Only include well paths coming from a well log file
if (wellPaths[i]->wellLogFile()) if (wellPaths[i]->wellLogFiles().size() > 0)
{ {
options.push_back(caf::PdmOptionItemInfo(wellPaths[i]->name(), wellPaths[i])); options.push_back(caf::PdmOptionItemInfo(wellPaths[i]->name(), wellPaths[i]));
} }
@@ -282,10 +293,9 @@ QList<caf::PdmOptionItemInfo> RimWellLogFileCurve::calculateValueOptions(const c
{ {
if (m_wellPath()) if (m_wellPath())
{ {
RimWellLogFile* wellLogFile = m_wellPath->wellLogFile(); if (m_wellLogFile)
if (wellLogFile)
{ {
std::vector<RimWellLogFileChannel*> fileLogs = wellLogFile->wellLogChannels(); std::vector<RimWellLogFileChannel*> fileLogs = m_wellLogFile->wellLogChannels();
for (size_t i = 0; i < fileLogs.size(); i++) for (size_t i = 0; i < fileLogs.size(); i++)
{ {
@@ -301,6 +311,21 @@ QList<caf::PdmOptionItemInfo> RimWellLogFileCurve::calculateValueOptions(const c
} }
} }
if (fieldNeedingOptions == &m_wellLogFile)
{
if (m_wellPath() && m_wellPath->wellLogFiles().size() > 0)
{
for (RimWellLogFile* const wellLogFile : m_wellPath->wellLogFiles())
{
if (RimWellRftPlot::hasPressureData(wellLogFile))
{
QFileInfo fileInfo(wellLogFile->fileName());
options.push_back(caf::PdmOptionItemInfo(fileInfo.baseName(), wellLogFile));
}
}
}
}
return options; return options;
} }
@@ -317,8 +342,7 @@ QString RimWellLogFileCurve::createCurveAutoName()
txt += " : "; txt += " : ";
txt += m_wellLogChannnelName; txt += m_wellLogChannnelName;
RimWellLogFile* logFileInfo = m_wellPath->wellLogFile(); RigWellLogFile* wellLogFile = m_wellLogFile ? m_wellLogFile->wellLogFile() : nullptr;
RigWellLogFile* wellLogFile = logFileInfo ? logFileInfo->wellLogFile() : nullptr;
if (wellLogFile) if (wellLogFile)
{ {
RimWellLogPlot* wellLogPlot; RimWellLogPlot* wellLogPlot;
@@ -346,6 +370,14 @@ QString RimWellLogFileCurve::wellLogChannelName() const
return m_wellLogChannnelName; return m_wellLogChannnelName;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellLogFile* RimWellLogFileCurve::wellLogFile() const
{
return m_wellLogFile();
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

12
ApplicationCode/ProjectDataModel/RimWellLogFileCurve.h
View File

@@ -28,6 +28,7 @@
class RimWellPath; class RimWellPath;
class RimWellLogFileChannel; class RimWellLogFileChannel;
class RimWellLogFile;
//================================================================================================== //==================================================================================================
/// ///
@@ -44,10 +45,12 @@ public:
void setWellPath(RimWellPath* wellPath); void setWellPath(RimWellPath* wellPath);
RimWellPath* wellPath() const; RimWellPath* wellPath() const;
void setWellLogChannelName(const QString& name); void setWellLogChannelName(const QString& name);
void setWellLogFile(RimWellLogFile* wellLogFile);
// Overrides from RimWellLogPlotCurve // Overrides from RimWellLogPlotCurve
virtual QString wellName() const; virtual QString wellName() const;
virtual QString wellLogChannelName() const; virtual QString wellLogChannelName() const;
virtual RimWellLogFile* wellLogFile() const;
protected: protected:
// Overrides from RimWellLogPlotCurve // Overrides from RimWellLogPlotCurve
@@ -61,9 +64,10 @@ protected:
virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly); virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly);
protected: protected:
caf::PdmPtrField<RimWellPath*> m_wellPath; caf::PdmPtrField<RimWellPath*> m_wellPath;
caf::PdmField<QString> m_wellLogChannnelName; caf::PdmPtrField<RimWellLogFile*> m_wellLogFile;
caf::PdmField<QString> m_wellLogChannnelUnit; caf::PdmField<QString> m_wellLogChannnelName;
caf::PdmField<QString> m_wellLogChannnelUnit;
}; };

48
ApplicationCode/ProjectDataModel/RimWellPath.cpp
View File

@@ -124,8 +124,12 @@ RimWellPath::RimWellPath()
m_completions = new RimWellPathCompletions; m_completions = new RimWellPathCompletions;
m_completions.uiCapability()->setUiTreeHidden(true); m_completions.uiCapability()->setUiTreeHidden(true);
CAF_PDM_InitFieldNoDefault(&m_wellLogFile, "WellLogFile", "Well Log File", "", "", ""); CAF_PDM_InitFieldNoDefault(&m_wellLogFiles, "WellLogFiles", "Well Log Files", "", "", "");
m_wellLogFile.uiCapability()->setUiHidden(true); m_wellLogFiles.uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_wellLogFile_OBSOLETE, "WellLogFile", "Well Log File", "", "", "");
m_wellLogFile_OBSOLETE.uiCapability()->setUiHidden(true);
m_wellLogFile_OBSOLETE.xmlCapability()->setIOWritable(false);
m_wellPath = NULL; m_wellPath = NULL;
} }
@@ -136,9 +140,14 @@ RimWellPath::RimWellPath()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimWellPath::~RimWellPath() RimWellPath::~RimWellPath()
{ {
if (m_wellLogFile()) if (m_wellLogFile_OBSOLETE())
{ {
delete m_wellLogFile; delete m_wellLogFile_OBSOLETE;
}
for(const auto& file : m_wellLogFiles())
{
delete file;
} }
RimProject* project; RimProject* project;
@@ -354,9 +363,9 @@ void RimWellPath::setName(const QString& name)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimWellLogFile* RimWellPath::wellLogFile() const std::vector<RimWellLogFile*> RimWellPath::wellLogFiles() const
{ {
return m_wellLogFile; return std::vector<RimWellLogFile*>(m_wellLogFiles.begin(), m_wellLogFiles.end());
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -459,7 +468,7 @@ void RimWellPath::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiO
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPath::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName) void RimWellPath::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName)
{ {
uiTreeOrdering.add(&m_wellLogFile); uiTreeOrdering.add(&m_wellLogFiles);
if (m_completions->hasCompletions()) if (m_completions->hasCompletions())
{ {
@@ -594,17 +603,24 @@ RiaEclipseUnitTools::UnitSystem RimWellPath::unitSystem() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPath::setLogFileInfo(RimWellLogFile* logFileInfo) void RimWellPath::addWellLogFile(RimWellLogFile* logFileInfo)
{ {
if (m_wellLogFile()) auto itr = std::find_if(m_wellLogFiles.begin(), m_wellLogFiles.end(), [&](const RimWellLogFile* file)
{
return QString::compare(file->fileName(), logFileInfo->fileName(), Qt::CaseInsensitive) == 0;
});
// Todo: Verify well name to ensure all well log files having the same well name
if (itr == m_wellLogFiles.end())
{ {
delete m_wellLogFile; m_wellLogFiles.push_back(logFileInfo);
if (m_wellLogFiles.size() == 1)
{
setName(m_wellLogFiles[0]->wellName());
}
} }
m_wellLogFile = logFileInfo;
m_wellLogFile->uiCapability()->setUiHidden(true);
setName(m_wellLogFile->wellName());
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -616,7 +632,7 @@ RimWellPath* RimWellPath::fromFilePath(QString filePath)
if (logFileInfo) if (logFileInfo)
{ {
auto wellPath = new RimWellPath(); auto wellPath = new RimWellPath();
wellPath->setLogFileInfo(logFileInfo); wellPath->addWellLogFile(logFileInfo);
return wellPath; return wellPath;
} }
return nullptr; return nullptr;

8
ApplicationCode/ProjectDataModel/RimWellPath.h
View File

@@ -64,7 +64,7 @@ public:
RimWellPath(); RimWellPath();
virtual ~RimWellPath(); virtual ~RimWellPath();
void setLogFileInfo(RimWellLogFile* logFileInfo); void addWellLogFile(RimWellLogFile* logFileInfo);
virtual caf::PdmFieldHandle* userDescriptionField(); virtual caf::PdmFieldHandle* userDescriptionField();
virtual caf::PdmFieldHandle* objectToggleField(); virtual caf::PdmFieldHandle* objectToggleField();
@@ -75,7 +75,7 @@ public:
QString name() const; QString name() const;
void setName(const QString& name); void setName(const QString& name);
RimWellLogFile* wellLogFile() const; std::vector<RimWellLogFile*> wellLogFiles() const;
caf::PdmField<QString> filepath; caf::PdmField<QString> filepath;
caf::PdmField<int> wellPathIndexInFile; // -1 means none. caf::PdmField<int> wellPathIndexInFile; // -1 means none.
@@ -152,6 +152,8 @@ private:
cvf::ref<RivWellPathPartMgr> m_wellPathPartMgr; cvf::ref<RivWellPathPartMgr> m_wellPathPartMgr;
caf::PdmField<QString> m_name; caf::PdmField<QString> m_name;
caf::PdmChildField<RimWellLogFile*> m_wellLogFile; caf::PdmChildArrayField<RimWellLogFile*> m_wellLogFiles;
caf::PdmChildField<RimWellLogFile*> m_wellLogFile_OBSOLETE;
}; };

31
ApplicationCode/ProjectDataModel/RimWellPathCollection.cpp
View File

@@ -137,26 +137,27 @@ void RimWellPathCollection::readWellPathFiles()
} }
} }
RimWellLogFile* wellLogFile = wellPaths[wpIdx]->wellLogFile(); for (RimWellLogFile* const wellLogFile : wellPaths[wpIdx]->wellLogFiles())
if (wellLogFile)
{ {
QString errorMessage; if (wellLogFile)
if (!wellLogFile->readFile(&errorMessage))
{ {
QString displayMessage = "Could not open the well log file: \n" + wellLogFile->fileName(); QString errorMessage;
if (!wellLogFile->readFile(&errorMessage))
if (!errorMessage.isEmpty())
{ {
displayMessage += "\n\n"; QString displayMessage = "Could not open the well log file: \n" + wellLogFile->fileName();
displayMessage += errorMessage;
}
QMessageBox::warning(RiuMainWindow::instance(), if (!errorMessage.isEmpty())
"File open error", {
displayMessage); displayMessage += "\n\n";
displayMessage += errorMessage;
}
QMessageBox::warning(RiuMainWindow::instance(),
"File open error",
displayMessage);
}
} }
} }
progress.setProgressDescription(QString("Reading file %1").arg(wellPaths[wpIdx]->name())); progress.setProgressDescription(QString("Reading file %1").arg(wellPaths[wpIdx]->name()));
progress.incrementProgress(); progress.incrementProgress();
} }
@@ -300,7 +301,7 @@ void RimWellPathCollection::addWellLogs(const QStringList& filePaths)
wellPaths.push_back(wellPath); wellPaths.push_back(wellPath);
} }
wellPath->setLogFileInfo(logFileInfo); wellPath->addWellLogFile(logFileInfo);
} }
} }