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

#2901 RFT Plot : Initialize default time step selection based on all sources

Browse Source
This commit is contained in:
Magne Sjaastad
2018-05-11 14:18:13 +02:00
parent e1abaa1b6c
commit bf2f524d34
3 changed files with 76 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -792,78 +792,76 @@ QString RimWellPlotTools::curveUnitText(RimWellLogFile::WellFlowCondition condit
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPlotTools::calculateValueOptionsForTimeSteps(const QString& simWellName, std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculateRelevantTimeStepsFromCases(
const std::vector<RifDataSourceForRftPlt>& selSources, const QString& wellPathNameOrSimWellName,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults, const std::vector<RifDataSourceForRftPlt>& selSources,
QList<caf::PdmOptionItemInfo>& options) const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults)
{ {
//std::vector<RifDataSourceForRftPlt> selSources = selectedSourcesExpanded();
bool addFirstTimestep = (interestingRFTResults.count(RifEclipseRftAddress::PRESSURE) == 1); bool addFirstTimestep = (interestingRFTResults.count(RifEclipseRftAddress::PRESSURE) == 1);
bool hasObservedData = false; bool hasObservedData = false;
bool hasRftData = false; bool hasRftData = false;
bool hasGridData = false; bool hasGridData = false;
for (const auto& source : selSources ) for (const auto& source : selSources)
{ {
switch (source.sourceType()) switch (source.sourceType())
{ {
case RifDataSourceForRftPlt::RFT: case RifDataSourceForRftPlt::RFT:
hasRftData = true; hasRftData = true;
break; break;
case RifDataSourceForRftPlt::GRID: case RifDataSourceForRftPlt::GRID:
hasGridData = true; hasGridData = true;
break; break;
case RifDataSourceForRftPlt::OBSERVED: case RifDataSourceForRftPlt::OBSERVED:
hasObservedData = true; hasObservedData = true;
break; break;
} }
} }
std::map<QDateTime, std::set<RifDataSourceForRftPlt> > observedTimeStepsWithSources; std::map<QDateTime, std::set<RifDataSourceForRftPlt>> observedTimeStepsWithSources;
std::map<QDateTime, std::set<RifDataSourceForRftPlt> > rftTimeStepsWithSources; std::map<QDateTime, std::set<RifDataSourceForRftPlt>> rftTimeStepsWithSources;
std::map<QDateTime, std::set<RifDataSourceForRftPlt> > gridTimestepsWithSources; std::map<QDateTime, std::set<RifDataSourceForRftPlt>> gridTimestepsWithSources;
if (hasObservedData) if (hasObservedData)
{ {
for (const auto& source : selSources ) for (const auto& source : selSources)
{ {
if (source.sourceType() == RifDataSourceForRftPlt::OBSERVED && source.wellLogFile()) if (source.sourceType() == RifDataSourceForRftPlt::OBSERVED && source.wellLogFile())
{ {
observedTimeStepsWithSources[source.wellLogFile()->date()].insert(source); observedTimeStepsWithSources[source.wellLogFile()->date()].insert(source);
} }
} }
} }
if (hasRftData) if (hasRftData)
{ {
for (const auto& source : selSources ) for (const auto& source : selSources)
{ {
if (source.sourceType() == RifDataSourceForRftPlt::RFT && source.rftReader()) if (source.sourceType() == RifDataSourceForRftPlt::RFT && source.rftReader())
{ {
std::set<QDateTime> rftTimes = source.rftReader()->availableTimeSteps(simWellName, interestingRFTResults ); std::set<QDateTime> rftTimes =
for ( const QDateTime& date: rftTimes) source.rftReader()->availableTimeSteps(wellPathNameOrSimWellName, interestingRFTResults);
for (const QDateTime& date : rftTimes)
{ {
rftTimeStepsWithSources[date].insert(source); rftTimeStepsWithSources[date].insert(source);
} }
} }
} }
} }
if ( hasGridData ) if (hasGridData)
{ {
for ( const auto& source : selSources ) for (const auto& source : selSources)
{ {
if ( source.sourceType() == RifDataSourceForRftPlt::GRID && source.eclCase() ) if (source.sourceType() == RifDataSourceForRftPlt::GRID && source.eclCase())
{ {
std::set<QDateTime> wellTimeSteps = RimWellPlotTools::availableSimWellTimesteps(source.eclCase(), simWellName, addFirstTimestep); std::set<QDateTime> wellTimeSteps =
RimWellPlotTools::availableSimWellTimesteps(source.eclCase(), wellPathNameOrSimWellName, addFirstTimestep);
for ( const QDateTime& date: wellTimeSteps) for (const QDateTime& date : wellTimeSteps)
{ {
gridTimestepsWithSources[date].insert(source); gridTimestepsWithSources[date].insert(source);
} }
@@ -873,8 +871,8 @@ void RimWellPlotTools::calculateValueOptionsForTimeSteps(const QString& simWellN
// If we have a time baseline add the equal or adjacent grid timesteps // 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>> timestepsToShowWithSources;
std::map<QDateTime, std::set<RifDataSourceForRftPlt> >* timeBaseline = nullptr; std::map<QDateTime, std::set<RifDataSourceForRftPlt>>* timeBaseline = nullptr;
if (hasObservedData) if (hasObservedData)
{ {
@@ -888,39 +886,43 @@ void RimWellPlotTools::calculateValueOptionsForTimeSteps(const QString& simWellN
if (timeBaseline) if (timeBaseline)
{ {
std::set<QDateTime> baseTimeSteps; std::set<QDateTime> baseTimeSteps;
for (const auto& dateSourceSetPair: *timeBaseline) baseTimeSteps.insert(dateSourceSetPair.first); for (const auto& dateSourceSetPair : *timeBaseline)
baseTimeSteps.insert(dateSourceSetPair.first);
std::set<QDateTime> rftTimeSteps; std::set<QDateTime> rftTimeSteps;
for (const auto& dateSourceSetPair: rftTimeStepsWithSources) rftTimeSteps.insert(dateSourceSetPair.first); for (const auto& dateSourceSetPair : rftTimeStepsWithSources)
rftTimeSteps.insert(dateSourceSetPair.first);
std::set<QDateTime> gridTimeSteps; std::set<QDateTime> gridTimeSteps;
for (const auto& dateSourceSetPair: gridTimestepsWithSources) gridTimeSteps.insert(dateSourceSetPair.first); for (const auto& dateSourceSetPair : gridTimestepsWithSources)
gridTimeSteps.insert(dateSourceSetPair.first);
std::set<QDateTime> filteredRftTimeSteps = RimWellPlotTools::findMatchingOrAdjacentTimeSteps(baseTimeSteps, rftTimeSteps); std::set<QDateTime> filteredRftTimeSteps = RimWellPlotTools::findMatchingOrAdjacentTimeSteps(baseTimeSteps, rftTimeSteps);
std::set<QDateTime> filteredGridTimeSteps = RimWellPlotTools::findMatchingOrAdjacentTimeSteps(baseTimeSteps, gridTimeSteps); std::set<QDateTime> filteredGridTimeSteps =
RimWellPlotTools::findMatchingOrAdjacentTimeSteps(baseTimeSteps, gridTimeSteps);
if (addFirstTimestep && gridTimeSteps.size()) if (addFirstTimestep && gridTimeSteps.size())
{ {
filteredGridTimeSteps.insert(*gridTimeSteps.begin()); filteredGridTimeSteps.insert(*gridTimeSteps.begin());
} }
// Fill final map // Fill final map
timestepsToShowWithSources = observedTimeStepsWithSources; timestepsToShowWithSources = observedTimeStepsWithSources;
std::set<QDateTime>& allFilteredTimesteps = filteredRftTimeSteps; std::set<QDateTime>& allFilteredTimesteps = filteredRftTimeSteps;
allFilteredTimesteps.insert(filteredGridTimeSteps.begin(), filteredGridTimeSteps.end()); allFilteredTimesteps.insert(filteredGridTimeSteps.begin(), filteredGridTimeSteps.end());
for (const QDateTime& time: allFilteredTimesteps) for (const QDateTime& time : allFilteredTimesteps)
{ {
auto rftTimeSourceSetIt = rftTimeStepsWithSources.find(time); auto rftTimeSourceSetIt = rftTimeStepsWithSources.find(time);
if ( rftTimeSourceSetIt != rftTimeStepsWithSources.end() ) if (rftTimeSourceSetIt != rftTimeStepsWithSources.end())
{ {
std::set<RifDataSourceForRftPlt>& sourceSet = rftTimeSourceSetIt->second; std::set<RifDataSourceForRftPlt>& sourceSet = rftTimeSourceSetIt->second;
timestepsToShowWithSources[time].insert(sourceSet.begin(), sourceSet.end()); timestepsToShowWithSources[time].insert(sourceSet.begin(), sourceSet.end());
} }
auto gridTimeSourceSetIt = gridTimestepsWithSources.find(time); auto gridTimeSourceSetIt = gridTimestepsWithSources.find(time);
if ( gridTimeSourceSetIt != gridTimestepsWithSources.end() ) if (gridTimeSourceSetIt != gridTimestepsWithSources.end())
{ {
std::set<RifDataSourceForRftPlt>& sourceSet = gridTimeSourceSetIt->second; std::set<RifDataSourceForRftPlt>& sourceSet = gridTimeSourceSetIt->second;
timestepsToShowWithSources[time].insert(sourceSet.begin(), sourceSet.end()); timestepsToShowWithSources[time].insert(sourceSet.begin(), sourceSet.end());
@@ -932,7 +934,20 @@ void RimWellPlotTools::calculateValueOptionsForTimeSteps(const QString& simWellN
timestepsToShowWithSources = gridTimestepsWithSources; timestepsToShowWithSources = gridTimestepsWithSources;
} }
// Create formatted options of all the timesteps return timestepsToShowWithSources;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPlotTools::calculateValueOptionsForTimeSteps(const QString& wellPathNameOrSimWellName,
const std::vector<RifDataSourceForRftPlt>& selSources,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults,
QList<caf::PdmOptionItemInfo>& options)
{
auto timestepsToShowWithSources = calculateRelevantTimeStepsFromCases(wellPathNameOrSimWellName, selSources, interestingRFTResults);
// Create formatted options of all the time steps
QString dateFormatString; QString dateFormatString;
{ {
std::vector<QDateTime> allTimeSteps; std::vector<QDateTime> allTimeSteps;

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

@@ -86,10 +86,16 @@ public:
static std::vector<RimEclipseResultCase*> rftCasesForWell(const QString& simWellName); static std::vector<RimEclipseResultCase*> rftCasesForWell(const QString& simWellName);
static QString simWellName(const QString& wellPathNameOrSimWellName); static QString simWellName(const QString& wellPathNameOrSimWellName);
static std::map<QDateTime, std::set<RifDataSourceForRftPlt>>
calculateRelevantTimeStepsFromCases(const QString& wellPathNameOrSimWellName,
const std::vector<RifDataSourceForRftPlt>& selSources,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults);
static void calculateValueOptionsForTimeSteps(const QString& wellPathNameOrSimWellName, static void calculateValueOptionsForTimeSteps(const QString& wellPathNameOrSimWellName,
const std::vector<RifDataSourceForRftPlt>& selSources, const std::vector<RifDataSourceForRftPlt>& selSources,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults, const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults,
QList<caf::PdmOptionItemInfo>& options); QList<caf::PdmOptionItemInfo>& options);
static std::set < RiaRftPltCurveDefinition > curveDefsFromTimesteps(const QString& simWellName, static std::set < RiaRftPltCurveDefinition > curveDefsFromTimesteps(const QString& simWellName,
const std::vector<QDateTime>& selectedTimeStepVector, const std::vector<QDateTime>& selectedTimeStepVector,
bool firstReportTimeStepIsValid, bool firstReportTimeStepIsValid,

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

@@ -278,47 +278,39 @@ QString RimWellRftPlot::associatedSimWellName() const
void RimWellRftPlot::applyInitialSelections() void RimWellRftPlot::applyInitialSelections()
{ {
std::vector<RifDataSourceForRftPlt> sourcesToSelect; std::vector<RifDataSourceForRftPlt> sourcesToSelect;
std::set<QDateTime> rftTimeSteps;
std::set<QDateTime> observedTimeSteps;
std::set<QDateTime> gridTimeSteps;
const QString simWellName = associatedSimWellName(); const QString simWellName = associatedSimWellName();
for (RimEclipseResultCase* const rftCase : RimWellPlotTools::rftCasesForWell(simWellName)) for (RimEclipseResultCase* const rftCase : RimWellPlotTools::rftCasesForWell(simWellName))
{ {
sourcesToSelect.push_back(RifDataSourceForRftPlt(RifDataSourceForRftPlt::RFT, rftCase)); sourcesToSelect.push_back(RifDataSourceForRftPlt(RifDataSourceForRftPlt::RFT, rftCase));
RimWellPlotTools::appendSet(rftTimeSteps, RimWellPlotTools::timeStepsFromRftCase(rftCase, simWellName));
} }
for (RimEclipseResultCase* const gridCase : RimWellPlotTools::gridCasesForWell(simWellName)) for (RimEclipseResultCase* const gridCase : RimWellPlotTools::gridCasesForWell(simWellName))
{ {
sourcesToSelect.push_back(RifDataSourceForRftPlt(RifDataSourceForRftPlt::GRID, gridCase)); sourcesToSelect.push_back(RifDataSourceForRftPlt(RifDataSourceForRftPlt::GRID, gridCase));
RimWellPlotTools::appendSet(gridTimeSteps, RimWellPlotTools::timeStepsFromGridCase(gridCase));
} }
std::vector<RimWellLogFile*> wellLogFiles = RimWellPlotTools::wellLogFilesContainingPressure(m_wellPathNameOrSimWellName); std::vector<RimWellLogFile*> wellLogFiles = RimWellPlotTools::wellLogFilesContainingPressure(m_wellPathNameOrSimWellName);
if (!wellLogFiles.empty()) if (!wellLogFiles.empty())
{ {
sourcesToSelect.push_back(RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED));
for (RimWellLogFile* const wellLogFile : wellLogFiles) for (RimWellLogFile* const wellLogFile : wellLogFiles)
{ {
observedTimeSteps.insert(RimWellPlotTools::timeStepFromWellLogFile(wellLogFile)); sourcesToSelect.push_back(RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED, wellLogFile));
} }
} }
m_selectedSources = sourcesToSelect; m_selectedSources = sourcesToSelect;
std::set<QDateTime> timeStepsToSelect;
for (const QDateTime& timeStep : rftTimeSteps)
{ {
timeStepsToSelect.insert(timeStep); auto relevantTimeSteps = RimWellPlotTools::calculateRelevantTimeStepsFromCases(
} associatedSimWellName(), m_selectedSources, {RifEclipseRftAddress::PRESSURE});
for (const QDateTime& timeStep : observedTimeSteps)
{
timeStepsToSelect.insert(timeStep);
}
if (!gridTimeSteps.empty()) timeStepsToSelect.insert(*gridTimeSteps.begin());
m_selectedTimeSteps = std::vector<QDateTime>(timeStepsToSelect.begin(), timeStepsToSelect.end()); std::vector<QDateTime> timeStepVector;
for (const auto& item : relevantTimeSteps)
timeStepVector.push_back(item.first);
m_selectedTimeSteps = timeStepVector;
}
syncCurvesFromUiSelection(); syncCurvesFromUiSelection();
} }