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

#2126, #2139 Rftplot alignment with PLT plot. Move two new static methods to WellPlotTool

Browse Source
This commit is contained in:
Jacob Støren 2017-11-16 16:35:55 +01:00
parent 6b2231478c
commit 1808745ea0
6 changed files with 251 additions and 389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -40,6 +40,7 @@
#include "RimWellPathCollection.h"
#include <regex>
#include "RimTools.h"
//--------------------------------------------------------------------------------------------------
@ -691,3 +692,226 @@ bool RimWellPlotTools::tryMatchChannelName(const std::set<QString>& channelNames
});
return itr != channelNames.end();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set < RiaRftPltCurveDefinition > RimWellPlotTools::curveDefsFromTimesteps(const QString& simWellName,
const std::vector<QDateTime>& selectedTimeSteps,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults,
const std::vector<RifDataSourceForRftPlt>& selectedSourcesExpanded)
{
std::set<RiaRftPltCurveDefinition> curveDefs;
std::set<QDateTime> selectedTimeStepSet(selectedTimeSteps.begin(), selectedTimeSteps.end());
for ( const RifDataSourceForRftPlt& addr : selectedSourcesExpanded )
{
if ( addr.rftReader() )
{
std::set<QDateTime> rftTimes = addr.rftReader()->availableTimeSteps(simWellName, { RifEclipseRftAddress::ORAT,
RifEclipseRftAddress::WRAT,
RifEclipseRftAddress::GRAT });
for ( const QDateTime& time : rftTimes )
{
if ( selectedTimeStepSet.count(time) )
{
curveDefs.insert(RiaRftPltCurveDefinition(addr, time));
}
}
}
else if ( addr.sourceType() == RifDataSourceForRftPlt::GRID && addr.eclCase() )
{
std::set<QDateTime> timeSteps = RimWellPlotTools::availableSimWellTimesteps(addr.eclCase(), simWellName);
for ( const QDateTime& time : timeSteps )
{
if ( selectedTimeStepSet.count(time) )
{
curveDefs.insert(RiaRftPltCurveDefinition(addr, time));
}
}
}
else if ( addr.sourceType() == RifDataSourceForRftPlt::OBSERVED )
{
if ( addr.wellLogFile() )
{
if ( selectedTimeStepSet.count(addr.wellLogFile()->date()) )
{
curveDefs.insert(RiaRftPltCurveDefinition(addr, addr.wellLogFile()->date()));
}
}
}
}
return curveDefs;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPlotTools::calculateValueOptionsForTimeSteps(const QString& simWellName,
const std::vector<RifDataSourceForRftPlt>& selSources,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults,
QList<caf::PdmOptionItemInfo>& options)
{
//std::vector<RifDataSourceForRftPlt> selSources = selectedSourcesExpanded();
bool hasObservedData = false;
bool hasRftData = false;
bool hasGridData = false;
for (const auto& source : selSources )
{
switch (source.sourceType())
{
case RifDataSourceForRftPlt::RFT:
hasRftData = true;
break;
case RifDataSourceForRftPlt::GRID:
hasGridData = true;
break;
case RifDataSourceForRftPlt::OBSERVED:
hasObservedData = true;
break;
}
}
std::map<QDateTime, std::set<RifDataSourceForRftPlt> > observedTimeStepsWithSources;
std::map<QDateTime, std::set<RifDataSourceForRftPlt> > rftTimeStepsWithSources;
std::map<QDateTime, std::set<RifDataSourceForRftPlt> > gridTimestepsWithSources;
if (hasObservedData)
{
for (const auto& source : selSources )
{
if (source.sourceType() == RifDataSourceForRftPlt::OBSERVED && source.wellLogFile())
{
observedTimeStepsWithSources[source.wellLogFile()->date()].insert(source);
}
}
}
if (hasRftData)
{
for (const auto& source : selSources )
{
if (source.sourceType() == RifDataSourceForRftPlt::RFT && source.rftReader())
{
std::set<QDateTime> rftTimes = source.rftReader()->availableTimeSteps(simWellName, interestingRFTResults );
for ( const QDateTime& date: rftTimes)
{
rftTimeStepsWithSources[date].insert(source);
}
}
}
}
if ( hasGridData )
{
for ( const auto& source : selSources )
{
if ( source.sourceType() == RifDataSourceForRftPlt::GRID && source.eclCase() )
{
std::set<QDateTime> wellTimeSteps = RimWellPlotTools::availableSimWellTimesteps(source.eclCase(), simWellName);
for ( const QDateTime& date: wellTimeSteps)
{
gridTimestepsWithSources[date].insert(source);
}
}
}
}
// If we have a time baseline add the equal or adjacent grid timesteps
std::map<QDateTime, std::set<RifDataSourceForRftPlt> > timestepsToShowWithSources;
std::map<QDateTime, std::set<RifDataSourceForRftPlt> >* timeBaseline = nullptr;
if (hasObservedData)
{
timeBaseline = &observedTimeStepsWithSources;
}
else if (hasRftData)
{
timeBaseline = &rftTimeStepsWithSources;
}
if (timeBaseline)
{
std::set<QDateTime> baseTimeSteps;
for (const auto& dateSourceSetPair: *timeBaseline) baseTimeSteps.insert(dateSourceSetPair.first);
std::set<QDateTime> rftTimeSteps;
for (const auto& dateSourceSetPair: rftTimeStepsWithSources) rftTimeSteps.insert(dateSourceSetPair.first);
std::set<QDateTime> gridTimeSteps;
for (const auto& dateSourceSetPair: gridTimestepsWithSources) gridTimeSteps.insert(dateSourceSetPair.first);
std::set<QDateTime> filteredRftTimeSteps = RimWellPlotTools::findMatchingOrAdjacentTimeSteps(baseTimeSteps, rftTimeSteps);
std::set<QDateTime> filteredGridTimeSteps = RimWellPlotTools::findMatchingOrAdjacentTimeSteps(baseTimeSteps, gridTimeSteps);
// Fill final map
timestepsToShowWithSources = observedTimeStepsWithSources;
std::set<QDateTime>& allFilteredTimesteps = filteredRftTimeSteps;
allFilteredTimesteps.insert(filteredGridTimeSteps.begin(), filteredGridTimeSteps.end());
for (const QDateTime& time: allFilteredTimesteps)
{
auto rftTimeSourceSetIt = rftTimeStepsWithSources.find(time);
if ( rftTimeSourceSetIt != rftTimeStepsWithSources.end() )
{
std::set<RifDataSourceForRftPlt>& sourceSet = rftTimeSourceSetIt->second;
timestepsToShowWithSources[time].insert(sourceSet.begin(), sourceSet.end());
}
auto gridTimeSourceSetIt = gridTimestepsWithSources.find(time);
if ( gridTimeSourceSetIt != gridTimestepsWithSources.end() )
{
std::set<RifDataSourceForRftPlt>& sourceSet = gridTimeSourceSetIt->second;
timestepsToShowWithSources[time].insert(sourceSet.begin(), sourceSet.end());
}
}
}
else
{
timestepsToShowWithSources = gridTimestepsWithSources;
}
// Create formatted options of all the timesteps
std::vector<QDateTime> allTimeSteps;
for (const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepPair : timestepsToShowWithSources)
{
allTimeSteps.push_back(timeStepPair.first);
}
const QString dateFormatString = RimTools::createTimeFormatStringFromDates(allTimeSteps);
for (const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepPair : timestepsToShowWithSources)
{
QString optionText = timeStepPair.first.toString(dateFormatString);
bool hasObs = false;
bool hasRft = false;
bool hasGrid = false;
for (const auto& source : timeStepPair.second)
{
switch (source.sourceType()){
case RifDataSourceForRftPlt::OBSERVED: hasObs = true; break;
case RifDataSourceForRftPlt::RFT : hasRft = true; break;
case RifDataSourceForRftPlt::GRID : hasGrid = true; break;
}
}
optionText += " \t[ ";
if (hasObs) optionText += "O ";
if (hasRft) optionText += "R ";
if (hasGrid) optionText += "G";
optionText += " ]";
options.push_back(caf::PdmOptionItemInfo(optionText, timeStepPair.first));
}
}

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

@ -26,6 +26,7 @@
#include <map>
#include <set>
#include "RifEclipseRftAddress.h"
class RimEclipseCase;
class RimEclipseResultCase;
@ -106,6 +107,15 @@ public:
static std::vector<RimEclipseResultCase*> rftCasesForWell(const QString& simWellName);
static QString simWellName(const QString& wellPathNameOrSimWellName);
static void calculateValueOptionsForTimeSteps(const QString& wellPathNameOrSimWellName,
const std::vector<RifDataSourceForRftPlt>& selSources,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults,
QList<caf::PdmOptionItemInfo>& options);
static std::set < RiaRftPltCurveDefinition > curveDefsFromTimesteps(const QString& simWellName,
const std::vector<QDateTime>& selectedTimeStepVector,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults,
const std::vector<RifDataSourceForRftPlt>& selectedSourcesExpanded);
friend class StaticFieldsInitializer;
};

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

@ -263,72 +263,17 @@ void RimWellPltPlot::updateWidgetTitleWindowTitle()
//--------------------------------------------------------------------------------------------------
std::set < RiaRftPltCurveDefinition > RimWellPltPlot::selectedCurveDefs() const
{
return curveDefsFromTimesteps(RimWellPlotTools::simWellName(m_wellPathName),
m_selectedTimeSteps.v(),
{RifEclipseRftAddress::ORAT,
RifEclipseRftAddress::WRAT,
RifEclipseRftAddress::GRAT},
selectedSourcesExpanded());
return RimWellPlotTools::curveDefsFromTimesteps(RimWellPlotTools::simWellName(m_wellPathName),
m_selectedTimeSteps.v(),
{ RifEclipseRftAddress::ORAT,
RifEclipseRftAddress::WRAT,
RifEclipseRftAddress::GRAT },
selectedSourcesExpanded());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set < RiaRftPltCurveDefinition > RimWellPltPlot::curveDefsFromTimesteps(const QString& simWellName,
const std::vector<QDateTime>& selectedTimeSteps,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults,
const std::vector<RifDataSourceForRftPlt>& selectedSourcesExpanded)
{
std::set<RiaRftPltCurveDefinition> curveDefs;
std::set<QDateTime> selectedTimeStepSet(selectedTimeSteps.begin(), selectedTimeSteps.end());
for ( const RifDataSourceForRftPlt& addr : selectedSourcesExpanded )
{
if ( addr.rftReader() )
{
std::set<QDateTime> rftTimes = addr.rftReader()->availableTimeSteps(simWellName, { RifEclipseRftAddress::ORAT,
RifEclipseRftAddress::WRAT,
RifEclipseRftAddress::GRAT });
for ( const QDateTime& time : rftTimes )
{
if ( selectedTimeStepSet.count(time) )
{
curveDefs.insert(RiaRftPltCurveDefinition(addr, time));
}
}
}
else if ( addr.sourceType() == RifDataSourceForRftPlt::GRID && addr.eclCase() )
{
std::set<QDateTime> timeSteps = RimWellPlotTools::availableSimWellTimesteps(addr.eclCase(), simWellName);
for ( const QDateTime& time : timeSteps )
{
if ( selectedTimeStepSet.count(time) )
{
curveDefs.insert(RiaRftPltCurveDefinition(addr, time));
}
}
}
else if ( addr.sourceType() == RifDataSourceForRftPlt::OBSERVED )
{
if ( addr.wellLogFile() )
{
if ( selectedTimeStepSet.count(addr.wellLogFile()->date()) )
{
curveDefs.insert(RiaRftPltCurveDefinition(addr, addr.wellLogFile()->date()));
}
}
}
}
return curveDefs;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
class RigResultPointCalculator
{
public:
@ -814,12 +759,12 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions(const caf::P
}
else if (fieldNeedingOptions == &m_selectedTimeSteps)
{
calculateValueOptionsForTimeSteps( RimWellPlotTools::simWellName(m_wellPathName),
selectedSourcesExpanded(),
std::set<RifEclipseRftAddress::RftWellLogChannelType>({ RifEclipseRftAddress::ORAT,
RifEclipseRftAddress::WRAT,
RifEclipseRftAddress::GRAT }),
options);
RimWellPlotTools::calculateValueOptionsForTimeSteps(RimWellPlotTools::simWellName(m_wellPathName),
selectedSourcesExpanded(),
{ RifEclipseRftAddress::ORAT,
RifEclipseRftAddress::WRAT,
RifEclipseRftAddress::GRAT },
options);
}
if (fieldNeedingOptions == &m_phaseSelectionMode)
@ -1033,173 +978,6 @@ void RimWellPltPlot::calculateValueOptionsForWells(QList<caf::PdmOptionItemInfo>
options.push_back(caf::PdmOptionItemInfo("None", ""));
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& simWellName,
const std::vector<RifDataSourceForRftPlt>& selSources,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults,
QList<caf::PdmOptionItemInfo>& options)
{
//std::vector<RifDataSourceForRftPlt> selSources = selectedSourcesExpanded();
bool hasObservedData = false;
bool hasRftData = false;
bool hasGridData = false;
for (const auto& source : selSources )
{
switch (source.sourceType())
{
case RifDataSourceForRftPlt::RFT:
hasRftData = true;
break;
case RifDataSourceForRftPlt::GRID:
hasGridData = true;
break;
case RifDataSourceForRftPlt::OBSERVED:
hasObservedData = true;
break;
}
}
std::map<QDateTime, std::set<RifDataSourceForRftPlt> > observedTimeStepsWithSources;
std::map<QDateTime, std::set<RifDataSourceForRftPlt> > rftTimeStepsWithSources;
std::map<QDateTime, std::set<RifDataSourceForRftPlt> > gridTimestepsWithSources;
if (hasObservedData)
{
for (const auto& source : selSources )
{
if (source.sourceType() == RifDataSourceForRftPlt::OBSERVED && source.wellLogFile())
{
observedTimeStepsWithSources[source.wellLogFile()->date()].insert(source);
}
}
}
if (hasRftData)
{
for (const auto& source : selSources )
{
if (source.sourceType() == RifDataSourceForRftPlt::RFT && source.rftReader())
{
std::set<QDateTime> rftTimes = source.rftReader()->availableTimeSteps(simWellName, interestingRFTResults );
for ( const QDateTime& date: rftTimes)
{
rftTimeStepsWithSources[date].insert(source);
}
}
}
}
if ( hasGridData )
{
for ( const auto& source : selSources )
{
if ( source.sourceType() == RifDataSourceForRftPlt::GRID && source.eclCase() )
{
std::set<QDateTime> wellTimeSteps = RimWellPlotTools::availableSimWellTimesteps(source.eclCase(), simWellName);
for ( const QDateTime& date: wellTimeSteps)
{
gridTimestepsWithSources[date].insert(source);
}
}
}
}
// If we have a time baseline add the equal or adjacent grid timesteps
std::map<QDateTime, std::set<RifDataSourceForRftPlt> > timestepsToShowWithSources;
std::map<QDateTime, std::set<RifDataSourceForRftPlt> >* timeBaseline = nullptr;
if (hasObservedData)
{
timeBaseline = &observedTimeStepsWithSources;
}
else if (hasRftData)
{
timeBaseline = &rftTimeStepsWithSources;
}
if (timeBaseline)
{
std::set<QDateTime> baseTimeSteps;
for (const auto& dateSourceSetPair: *timeBaseline) baseTimeSteps.insert(dateSourceSetPair.first);
std::set<QDateTime> rftTimeSteps;
for (const auto& dateSourceSetPair: rftTimeStepsWithSources) rftTimeSteps.insert(dateSourceSetPair.first);
std::set<QDateTime> gridTimeSteps;
for (const auto& dateSourceSetPair: gridTimestepsWithSources) gridTimeSteps.insert(dateSourceSetPair.first);
std::set<QDateTime> filteredRftTimeSteps = RimWellPlotTools::findMatchingOrAdjacentTimeSteps(baseTimeSteps, rftTimeSteps);
std::set<QDateTime> filteredGridTimeSteps = RimWellPlotTools::findMatchingOrAdjacentTimeSteps(baseTimeSteps, gridTimeSteps);
// Fill final map
timestepsToShowWithSources = observedTimeStepsWithSources;
std::set<QDateTime>& allFilteredTimesteps = filteredRftTimeSteps;
allFilteredTimesteps.insert(filteredGridTimeSteps.begin(), filteredGridTimeSteps.end());
for (const QDateTime& time: allFilteredTimesteps)
{
auto rftTimeSourceSetIt = rftTimeStepsWithSources.find(time);
if ( rftTimeSourceSetIt != rftTimeStepsWithSources.end() )
{
std::set<RifDataSourceForRftPlt>& sourceSet = rftTimeSourceSetIt->second;
timestepsToShowWithSources[time].insert(sourceSet.begin(), sourceSet.end());
}
auto gridTimeSourceSetIt = gridTimestepsWithSources.find(time);
if ( gridTimeSourceSetIt != gridTimestepsWithSources.end() )
{
std::set<RifDataSourceForRftPlt>& sourceSet = gridTimeSourceSetIt->second;
timestepsToShowWithSources[time].insert(sourceSet.begin(), sourceSet.end());
}
}
}
else
{
timestepsToShowWithSources = gridTimestepsWithSources;
}
// Create formatted options of all the timesteps
std::vector<QDateTime> allTimeSteps;
for (const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepPair : timestepsToShowWithSources)
{
allTimeSteps.push_back(timeStepPair.first);
}
const QString dateFormatString = RimTools::createTimeFormatStringFromDates(allTimeSteps);
for (const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepPair : timestepsToShowWithSources)
{
QString optionText = timeStepPair.first.toString(dateFormatString);
bool hasObs = false;
bool hasRft = false;
bool hasGrid = false;
for (const auto& source : timeStepPair.second)
{
switch (source.sourceType()){
case RifDataSourceForRftPlt::OBSERVED: hasObs = true; break;
case RifDataSourceForRftPlt::RFT : hasRft = true; break;
case RifDataSourceForRftPlt::GRID : hasGrid = true; break;
}
}
optionText += " \t[ ";
if (hasObs) optionText += "O ";
if (hasRft) optionText += "R ";
if (hasGrid) optionText += "G";
optionText += " ]";
options.push_back(caf::PdmOptionItemInfo(optionText, timeStepPair.first));
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

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

@ -83,14 +83,6 @@ public:
static const char* plotNameFormatString();
static void calculateValueOptionsForTimeSteps(const QString& wellPathNameOrSimWellName,
const std::vector<RifDataSourceForRftPlt>& selSources,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults,
QList<caf::PdmOptionItemInfo>& options);
static std::set < RiaRftPltCurveDefinition > curveDefsFromTimesteps(const QString& simWellName,
const std::vector<QDateTime>& selectedTimeStepVector,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults,
const std::vector<RifDataSourceForRftPlt>& selectedSourcesExpanded);
protected:
// Overridden PDM methods

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

@ -429,66 +429,12 @@ void RimWellRftPlot::syncCurvesFromUiSelection()
//--------------------------------------------------------------------------------------------------
std::set < RiaRftPltCurveDefinition > RimWellRftPlot::selectedCurveDefs() const
{
return RimWellPltPlot::curveDefsFromTimesteps(associatedSimWellName(),
return RimWellPlotTools::curveDefsFromTimesteps(associatedSimWellName(),
m_selectedTimeSteps.v(),
{ RifEclipseRftAddress::PRESSURE },
selectedSourcesExpanded());
}
#if 0
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set < RiaRftPltCurveDefinition> RimWellRftPlot::selectedCurveDefs() const
{
std::set<RiaRftPltCurveDefinition> curveDefs;
const QString simWellName = associatedSimWellName();
std::set<QDateTime> selectedTimeSteps(m_selectedTimeSteps.v().begin(), m_selectedTimeSteps.v().end());
for ( const RifDataSourceForRftPlt& addr : selectedSourcesExpanded() )
{
if ( addr.rftReader() )
{
std::set<QDateTime> rftTimes = addr.rftReader()->availableTimeSteps(simWellName,
std::set<RifEclipseRftAddress::RftWellLogChannelType>({ RifEclipseRftAddress::PRESSURE} ));
for ( const QDateTime& time : rftTimes )
{
if ( selectedTimeSteps.count(time) )
{
curveDefs.insert(RiaRftPltCurveDefinition(addr, time));
}
}
}
else if ( addr.sourceType() == RifDataSourceForRftPlt::GRID && addr.eclCase() )
{
std::set<QDateTime> timeSteps = RimWellPlotTools::availableSimWellTimesteps(addr.eclCase(), simWellName);
for ( const QDateTime& time : timeSteps )
{
if ( selectedTimeSteps.count(time) )
{
curveDefs.insert(RiaRftPltCurveDefinition(addr, time));
}
}
}
else if ( addr.sourceType() == RifDataSourceForRftPlt::OBSERVED )
{
if ( addr.wellLogFile() )
{
if ( selectedTimeSteps.count(addr.wellLogFile()->date()) )
{
curveDefs.insert(RiaRftPltCurveDefinition(addr, addr.wellLogFile()->date()));
}
}
}
}
return curveDefs;
}
#endif
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -725,7 +671,10 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions(const caf::P
}
else if (fieldNeedingOptions == &m_selectedTimeSteps)
{
calculateValueOptionsForTimeSteps(options);
RimWellPlotTools::calculateValueOptionsForTimeSteps( associatedSimWellName(),
selectedSourcesExpanded(),
{ RifEclipseRftAddress::PRESSURE },
options);
}
else if (fieldNeedingOptions == &m_branchIndex)
{
@ -897,96 +846,6 @@ void RimWellRftPlot::calculateValueOptionsForWells(QList<caf::PdmOptionItemInfo>
options.push_back(caf::PdmOptionItemInfo("None", "None"));
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellRftPlot::calculateValueOptionsForTimeSteps(QList<caf::PdmOptionItemInfo>& options)
{
const QString simWellName = associatedSimWellName();
RimWellPltPlot::calculateValueOptionsForTimeSteps(simWellName, selectedSourcesExpanded(), { RifEclipseRftAddress::PRESSURE }, options);
#if 0
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 RifDataSourceForRftPlt& selection : selectedSourcesExpanded())
{
if (selection.sourceType() == RifDataSourceForRftPlt::RFT)
{
for (RimEclipseResultCase* const rftCase : rftCases)
{
RimWellPlotTools::addTimeStepsToMap(obsAndRftTimeStepsMap, RimWellPlotTools::timeStepsMapFromRftCase(rftCase, simWellName));
}
}
else if (selection.sourceType() == RifDataSourceForRftPlt::GRID)
{
for (RimEclipseResultCase* const gridCase : gridCases)
{
RimWellPlotTools::addTimeStepsToMap(gridTimeStepsMap, RimWellPlotTools::timeStepsMapFromGridCase(gridCase));
}
}
else if (selection.sourceType() == RifDataSourceForRftPlt::OBSERVED)
{
if (selection.wellLogFile() != nullptr)
{
RimWellPlotTools::addTimeStepsToMap(obsAndRftTimeStepsMap, RimWellPlotTools::timeStepsMapFromWellLogFile(selection.wellLogFile()));
}
}
}
if (isOnlyGridSourcesSelected())
{
displayTimeStepsMap = gridTimeStepsMap;
}
else
{
const auto gridTimeStepsVector = std::vector<std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>>(gridTimeStepsMap.begin(), gridTimeStepsMap.end());
for (const std::pair<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepPair : obsAndRftTimeStepsMap)
{
const std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& adjTimeSteps = RimWellPlotTools::adjacentTimeSteps(gridTimeStepsVector, timeStepPair);
RimWellPlotTools::addTimeStepsToMap(displayTimeStepsMap, adjTimeSteps);
}
// Add the first grid time step (from the total grid time steps list)
if (gridTimeStepsVector.size() > 0)
{
RimWellPlotTools::addTimeStepToMap(displayTimeStepsMap, gridTimeStepsVector.front());
}
// Add already selected time steps
for (const QDateTime& timeStep : m_selectedTimeSteps())
{
if (m_timeStepsToAddresses.count(timeStep) > 0)
{
const std::set<RifDataSourceForRftPlt> sourceAddresses = m_timeStepsToAddresses[timeStep];
if (isAnySourceAddressSelected(sourceAddresses))
{
RimWellPlotTools::addTimeStepToMap(displayTimeStepsMap, std::make_pair(timeStep, m_timeStepsToAddresses[timeStep]));
}
}
}
}
RimWellPlotTools::addTimeStepsToMap(m_timeStepsToAddresses, displayTimeStepsMap);
// Create vector of all time steps
std::vector<QDateTime> allTimeSteps;
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<RifDataSourceForRftPlt>>& timeStepPair : displayTimeStepsMap)
{
options.push_back(caf::PdmOptionItemInfo(timeStepPair.first.toString(dateFormatString), timeStepPair.first));
}
#endif
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

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

@ -105,7 +105,6 @@ protected:
private:
void calculateValueOptionsForWells(QList<caf::PdmOptionItemInfo>& options);
void calculateValueOptionsForTimeSteps(QList<caf::PdmOptionItemInfo>& options);
void updateEditorsFromCurves();
void updateWidgetTitleWindowTitle();