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

#1112, #1106 Added and removed fields to make the allocation plot have the needed data to do its calculation. Refacord the CenterLine calculation interface yet again to make it usable.

Browse Source
This commit is contained in:
Jacob Støren
2017-01-23 11:10:09 +01:00
parent b4308a857c
commit 825c505443
9 changed files with 148 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/Commands/FlowCommands/RicShowWellAllocationPlotFeature.cpp
View File

@@ -59,7 +59,7 @@ void RicShowWellAllocationPlotFeature::onActionTriggered(bool isChecked)
RimFlowPlotCollection* flowPlotColl = RiaApplication::instance()->project()->mainPlotCollection->flowPlotCollection();
if (flowPlotColl)
{
flowPlotColl->defaultPlot->setSimulationWell(eclWell);
flowPlotColl->defaultPlot->setFromSimulationWell(eclWell);
flowPlotColl->defaultPlot->updateConnectedEditors();
// Make sure the summary plot window is created and visible

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

@@ -29,7 +29,12 @@
#include "RimWellLogPlot.h"
#include "RimWellLogTrack.h"
#include "RigSingleWellResultsData.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseCellColors.h"
#include "RimFlowDiagSolution.h"
#include "RimEclipseCase.h"
#include "RigEclipseCaseData.h"
#include "RigSimulationWellCenterLineCalculator.h"
CAF_PDM_SOURCE_INIT(RimWellAllocationPlot, "WellAllocationPlot");
@@ -45,12 +50,18 @@ RimWellAllocationPlot::RimWellAllocationPlot()
m_userName.uiCapability()->setUiReadOnly(true);
CAF_PDM_InitField(&m_showPlotTitle, "ShowPlotTitle", true, "Show Plot Title", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_simulationWell, "SimulationWell", "Simulation Well", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_case, "CurveCase", "Case", "", "", "");
m_case.uiCapability()->setUiTreeChildrenHidden(true);
CAF_PDM_InitField(&m_timeStep, "PlotTimeStep", 0, "Time Step", "", "", "");
CAF_PDM_InitField(&m_wellName, "WellName", QString("None"), "Well", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_flowDiagSolution, "FlowDiagSolution", "Flow Diag Solution", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_accumulatedWellFlowPlot, "AccumulatedWellFlowPlot", "Accumulated Well Flow", "", "", "");
m_accumulatedWellFlowPlot.uiCapability()->setUiHidden(true);
m_accumulatedWellFlowPlot = new RimWellLogPlot;
this->setAsPlotMdiWindow();
}
@@ -69,9 +80,18 @@ RimWellAllocationPlot::~RimWellAllocationPlot()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellAllocationPlot::setSimulationWell(RimEclipseWell* simWell)
void RimWellAllocationPlot::setFromSimulationWell(RimEclipseWell* simWell)
{
m_simulationWell = simWell;
RimEclipseView* eclView;
simWell->firstAncestorOrThisOfType(eclView);
RimEclipseResultCase* eclCase;
simWell->firstAncestorOrThisOfType(eclCase);
m_case = eclCase;
m_wellName = simWell->wellResults()->m_wellName;
m_timeStep = eclView->currentTimeStep();
m_flowDiagSolution = eclView->cellResult()->flowDiagSolution();
updateFromWell();
}
@@ -93,27 +113,31 @@ void RimWellAllocationPlot::deleteViewWidget()
//--------------------------------------------------------------------------------------------------
void RimWellAllocationPlot::updateFromWell()
{
QString simName = "None";
if (!m_case) return;
const RigSingleWellResultsData* wellResults = nullptr;
wellResults = m_case->reservoirData()->findWellResult(m_wellName);
if (!wellResults) return;
int branchCount = 0;
const RigWellResultFrame* wellResultFrame = nullptr;
std::vector< std::vector <cvf::Vec3d> > pipeBranchesCLCoords;
std::vector< std::vector <RigWellResultPoint> > pipeBranchesCellIds;
if (m_simulationWell && m_simulationWell->wellResults() )// && Timestep Ok )
{
simName = m_simulationWell->name();
wellResultFrame = &(m_simulationWell->wellResults()->wellResultFrame(1));
branchCount = static_cast<int>( wellResultFrame->m_wellResultBranches.size());
// // Todo : Use this instead, and use to calculate accumulated flow
//
// size_t timeStep = 0; // make field
// std::vector< std::vector <cvf::Vec3d> > pipeBranchesCLCoords;
// std::vector< std::vector <RigWellResultPoint> > pipeBranchesCellIds;
// m_simulationWell->calculateWellPipeDynamicCenterLine(timeStep, pipeBranchesCLCoords, pipeBranchesCellIds);
// branchCount = static_cast<int>( pipeBranchesCLCoords.size());
}
RigSimulationWellCenterLineCalculator::calculateWellPipeCenterlineFromWellFrame(m_case->reservoirData(),
wellResults,
m_timeStep,
true,
true,
pipeBranchesCLCoords,
pipeBranchesCellIds);
branchCount = static_cast<int>(pipeBranchesCLCoords.size());
int existingTrackCount = static_cast<int>(accumulatedWellFlowPlot()->trackCount());
accumulatedWellFlowPlot()->setDescription("Accumulated Well Flow (" + simName + ")");
accumulatedWellFlowPlot()->setDescription("Accumulated Well Flow (" + m_wellName + ")");
int neededExtraTrackCount = branchCount - existingTrackCount;
for (int etc = 0; etc < neededExtraTrackCount; ++etc)
@@ -136,7 +160,9 @@ void RimWellAllocationPlot::updateFromWell()
}
setDescription("Well Allocation (" + simName + ")");
// Todo: Calculate curve data
setDescription("Well Allocation (" + m_wellName + ")");
accumulatedWellFlowPlot()->updateConnectedEditors();
}
@@ -170,29 +196,44 @@ QList<caf::PdmOptionItemInfo> RimWellAllocationPlot::calculateValueOptions(const
{
QList<caf::PdmOptionItemInfo> options;
if (fieldNeedingOptions == &m_simulationWell)
if (fieldNeedingOptions == &m_wellName)
{
RimView* activeView = RiaApplication::instance()->activeReservoirView();
RimEclipseView* eclView = dynamic_cast<RimEclipseView*>(activeView);
if (eclView && eclView->wellCollection())
std::set<QString> sortedWellNames;
if ( m_case )
{
RimEclipseWellCollection* coll = eclView->wellCollection();
const cvf::Collection<RigSingleWellResultsData>& wellRes = m_case->reservoirData()->wellResults();
caf::PdmChildArrayField<RimEclipseWell*>& eclWells = coll->wells;
QIcon simWellIcon(":/Well.png");
for (RimEclipseWell* eclWell : eclWells)
for ( size_t wIdx = 0; wIdx < wellRes.size(); ++wIdx )
{
options.push_back(caf::PdmOptionItemInfo(eclWell->name(), eclWell, false, simWellIcon));
sortedWellNames.insert(wellRes[wIdx]->m_wellName);
}
}
QIcon simWellIcon(":/Well.png");
for ( const QString& wname: sortedWellNames )
{
options.push_back(caf::PdmOptionItemInfo(wname, wname, false, simWellIcon));
}
if (options.size() == 0)
{
options.push_front(caf::PdmOptionItemInfo("None", nullptr));
}
}
else if (fieldNeedingOptions == &m_timeStep)
{
QStringList timeStepNames;
if (m_case)
{
timeStepNames = m_case->timeStepStrings();
}
for (int i = 0; i < timeStepNames.size(); i++)
{
options.push_back(caf::PdmOptionItemInfo(timeStepNames[i], i));
}
}
return options;
}
@@ -209,7 +250,7 @@ void RimWellAllocationPlot::fieldChangedByUi(const caf::PdmFieldHandle* changedF
{
updateMdiWindowTitle();
}
else if (changedField == &m_simulationWell)
else if (changedField == &m_wellName)
{
updateFromWell();
}

9
ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.h
View File

@@ -30,6 +30,7 @@
class RiuWellAllocationPlot;
class RimEclipseWell;
class RimWellLogPlot;
class RimEclipseResultCase;
namespace caf {
class PdmOptionItemInfo;
@@ -48,7 +49,7 @@ public:
RimWellAllocationPlot();
virtual ~RimWellAllocationPlot();
void setSimulationWell(RimEclipseWell* simWell);
void setFromSimulationWell(RimEclipseWell* simWell);
void setDescription(const QString& description);
QString description() const;
@@ -81,9 +82,11 @@ private:
private:
caf::PdmField<bool> m_showPlotTitle;
caf::PdmField<QString> m_userName;
//caf::PdmField<bool> m_showAccWellFlowPlot;
caf::PdmPtrField<RimEclipseWell*> m_simulationWell;
caf::PdmPtrField<RimEclipseResultCase*> m_case;
caf::PdmField<QString> m_wellName;
caf::PdmField<int> m_timeStep;
caf::PdmPtrField<RimFlowDiagSolution*> m_flowDiagSolution;
QPointer<RiuWellAllocationPlot> m_wellAllocationPlotWidget;

14
ApplicationCode/ReservoirDataModel/RigEclipseCaseData.cpp
View File

@@ -262,6 +262,20 @@ void RigEclipseCaseData::setWellResults(const cvf::Collection<RigSingleWellResul
computeWellCellsPrGrid();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigSingleWellResultsData* RigEclipseCaseData::findWellResult(QString wellName) const
{
for (size_t wIdx = 0; wIdx < m_wellResults.size(); ++wIdx)
{
if (m_wellResults[wIdx]->m_wellName == wellName) return m_wellResults[wIdx].p();
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

3
ApplicationCode/ReservoirDataModel/RigEclipseCaseData.h
View File

@@ -82,7 +82,8 @@ public:
void setWellResults(const cvf::Collection<RigSingleWellResultsData>& data);
const cvf::Collection<RigSingleWellResultsData>& wellResults() { return m_wellResults; }
const RigSingleWellResultsData* findWellResult(QString wellName) const;
const cvf::UByteArray* wellCellsInGrid(size_t gridIndex);
const cvf::UIntArray* gridCellToResultWellIndex(size_t gridIndex);

95
ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.cpp
View File

@@ -38,39 +38,7 @@ void RigSimulationWellCenterLineCalculator::calculateWellPipeStaticCenterline(Ri
std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds)
{
bool isAutoDetectBranches = false;
RigEclipseCaseData* eclipseCaseData = NULL;
RigSingleWellResultsData* wellResults = NULL;
{
CVF_ASSERT(rimWell);
RimEclipseView* eclipseView;
rimWell->firstAncestorOrThisOfType(eclipseView);
CVF_ASSERT(eclipseView);
isAutoDetectBranches = eclipseView->wellCollection()->isAutoDetectingBranches();
eclipseCaseData = eclipseView->eclipseCase()->reservoirData();
wellResults = rimWell->wellResults();
}
// Make sure we have computed the static representation of the well
if (wellResults->m_staticWellCells.m_wellResultBranches.size() == 0)
{
wellResults->computeStaticWellCellPath();
}
const RigWellResultFrame& staticWellFrame = wellResults->m_staticWellCells;
bool isMultiSegmentWell = wellResults->isMultiSegmentWell();
bool useAllCellCenters = rimWell->isUsingCellCenterForPipe();
calculateWellPipeCenterlineFromWellFrame(staticWellFrame,
eclipseCaseData,
isMultiSegmentWell,
isAutoDetectBranches,
useAllCellCenters,
pipeBranchesCLCoords,
pipeBranchesCellIds);
return;
calculateWellPipeDynamicCenterline(rimWell, -1, pipeBranchesCLCoords, pipeBranchesCellIds);
}
@@ -82,31 +50,23 @@ void RigSimulationWellCenterLineCalculator::calculateWellPipeDynamicCenterline(R
std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds)
{
bool isAutoDetectBranches = false;
RigEclipseCaseData* eclipseCaseData = NULL;
RigSingleWellResultsData* wellResults = NULL;
CVF_ASSERT(rimWell);
{
CVF_ASSERT(rimWell);
RimEclipseView* eclipseView;
rimWell->firstAncestorOrThisOfType(eclipseView);
CVF_ASSERT(eclipseView);
RigSingleWellResultsData* wellResults = rimWell->wellResults();
isAutoDetectBranches = eclipseView->wellCollection()->isAutoDetectingBranches();
eclipseCaseData = eclipseView->eclipseCase()->reservoirData();
wellResults = rimWell->wellResults();
RimEclipseView* eclipseView;
rimWell->firstAncestorOrThisOfType(eclipseView);
if ( !wellResults || !wellResults->hasWellResult(timeStepIndex) ) return;
}
CVF_ASSERT(eclipseView);
const RigWellResultFrame& wellFrame = wellResults->wellResultFrame(timeStepIndex);
bool isMultiSegmentWell = wellResults->isMultiSegmentWell();
bool useAllCellCenters = rimWell->isUsingCellCenterForPipe();
RigEclipseCaseData* eclipseCaseData = eclipseView->eclipseCase()->reservoirData();
bool isAutoDetectBranches = eclipseView->wellCollection()->isAutoDetectingBranches();
calculateWellPipeCenterlineFromWellFrame(wellFrame,
eclipseCaseData,
isMultiSegmentWell,
bool useAllCellCenters = rimWell->isUsingCellCenterForPipe();
calculateWellPipeCenterlineFromWellFrame(eclipseCaseData,
wellResults,
static_cast<int>(timeStepIndex),
isAutoDetectBranches,
useAllCellCenters,
pipeBranchesCLCoords,
@@ -118,14 +78,37 @@ void RigSimulationWellCenterLineCalculator::calculateWellPipeDynamicCenterline(R
/// The returned CellIds is one less than the number of centerline points,
/// and are describing the lines between the points, starting with the first line
//--------------------------------------------------------------------------------------------------
void RigSimulationWellCenterLineCalculator::calculateWellPipeCenterlineFromWellFrame(const RigWellResultFrame &wellFrame,
const RigEclipseCaseData* eclipseCaseData,
bool isMultiSegmentWell,
void RigSimulationWellCenterLineCalculator::calculateWellPipeCenterlineFromWellFrame(const RigEclipseCaseData* eclipseCaseData,
const RigSingleWellResultsData* wellResults,
int timeStepIndex,
bool isAutoDetectBranches,
bool useAllCellCenters,
std::vector<std::vector<cvf::Vec3d>> &pipeBranchesCLCoords,
std::vector<std::vector<RigWellResultPoint>> &pipeBranchesCellIds)
{
if ( !wellResults) return;
if ( timeStepIndex >= 0 && !wellResults->hasWellResult(timeStepIndex) ) return;
const RigWellResultFrame* wellFramePtr = nullptr;
if (timeStepIndex < 0)
{
// Make sure we have computed the static representation of the well
if (wellResults->m_staticWellCells.m_wellResultBranches.size() == 0)
{
wellResults->computeStaticWellCellPath();
}
wellFramePtr = &wellResults->m_staticWellCells;
}
else
{
wellFramePtr = &(wellResults->wellResultFrame(timeStepIndex));
}
const RigWellResultFrame& wellFrame = *wellFramePtr;
bool isMultiSegmentWell = wellResults->isMultiSegmentWell();
// Initialize the return arrays
pipeBranchesCLCoords.clear();
pipeBranchesCellIds.clear();

14
ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.h
View File

@@ -38,14 +38,14 @@ public:
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds) ;
private:
static void calculateWellPipeCenterlineFromWellFrame(const RigWellResultFrame& wellFrame,
const RigEclipseCaseData* eclipseCaseData,
bool isMultiSegmentWell,
bool isAutoDetectBranches,
static void calculateWellPipeCenterlineFromWellFrame(const RigEclipseCaseData* eclipseCaseData,
const RigSingleWellResultsData* wellResults,
int timeStepIndex,
bool isAutoDetectBranches,
bool useAllCellCenters,
std::vector<std::vector<cvf::Vec3d>> & pipeBranchesCLCoords,
std::vector<std::vector<RigWellResultPoint>> & pipeBranchesCellIds);
std::vector<std::vector<cvf::Vec3d>> &pipeBranchesCLCoords,
std::vector<std::vector<RigWellResultPoint>> &pipeBranchesCellIds);
private:
static bool hasAnyResultCells(const std::vector<RigWellResultBranch> &resBranches);
static bool hasAnyValidDataCells(const RigWellResultBranch& branch);

6
ApplicationCode/ReservoirDataModel/RigSingleWellResultsData.cpp
View File

@@ -121,7 +121,7 @@ bool operator== (const RigWellResultPoint& p1, const RigWellResultPoint& p2)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigSingleWellResultsData::computeStaticWellCellPath()
void RigSingleWellResultsData::computeStaticWellCellPath() const
{
if (m_wellCellsTimeSteps.size() == 0) return;
@@ -133,7 +133,7 @@ void RigSingleWellResultsData::computeStaticWellCellPath()
for (size_t bIdx = 0; bIdx < m_wellCellsTimeSteps[0].m_wellResultBranches.size(); ++bIdx)
{
int branchErtId = m_wellCellsTimeSteps[0].m_wellResultBranches[bIdx].m_ertBranchId;
std::vector<RigWellResultPoint>& frameCells = m_wellCellsTimeSteps[0].m_wellResultBranches[bIdx].m_branchResultPoints;
const std::vector<RigWellResultPoint>& frameCells = m_wellCellsTimeSteps[0].m_wellResultBranches[bIdx].m_branchResultPoints;
std::list< RigWellResultPoint >& branch = staticWellBranches[branchErtId];
@@ -152,7 +152,7 @@ void RigSingleWellResultsData::computeStaticWellCellPath()
for (size_t bIdx = 0; bIdx < m_wellCellsTimeSteps[tIdx].m_wellResultBranches.size(); ++bIdx)
{
int branchId = m_wellCellsTimeSteps[tIdx].m_wellResultBranches[bIdx].m_ertBranchId;
std::vector<RigWellResultPoint>& resBranch = m_wellCellsTimeSteps[tIdx].m_wellResultBranches[bIdx].m_branchResultPoints;
const std::vector<RigWellResultPoint>& resBranch = m_wellCellsTimeSteps[tIdx].m_wellResultBranches[bIdx].m_branchResultPoints;
std::list< RigWellResultPoint >& stBranch = staticWellBranches[branchId];
std::list< RigWellResultPoint >::iterator sEndIt;

4
ApplicationCode/ReservoirDataModel/RigSingleWellResultsData.h
View File

@@ -127,7 +127,7 @@ public:
const RigWellResultFrame& wellResultFrame(size_t resultTimeStepIndex) const;
void computeStaticWellCellPath();
void computeStaticWellCellPath() const ;
void computeMappingFromResultTimeIndicesToWellTimeIndices(const std::vector<QDateTime>& resultTimes);
@@ -137,6 +137,6 @@ public:
std::vector<size_t> m_resultTimeStepIndexToWellTimeStepIndex; // Well result timesteps may differ from result timesteps
std::vector< RigWellResultFrame > m_wellCellsTimeSteps;
RigWellResultFrame m_staticWellCells;
mutable RigWellResultFrame m_staticWellCells;
};