mirror of
https://github.com/OPM/ResInsight.git
synced 2025-01-08 15:14:07 -06:00
574 lines
21 KiB
C++
574 lines
21 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2019- Equinor ASA
|
|
//
|
|
// ResInsight is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
// FITNESS FOR A PARTICULAR PURPOSE.
|
|
//
|
|
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
|
|
// for more details.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "RimWellDistributionPlot.h"
|
|
#include "RimEclipseResultCase.h"
|
|
#include "RimFlowDiagSolution.h"
|
|
#include "RimProject.h"
|
|
#include "RimTools.h"
|
|
|
|
#include "RigEclipseCaseData.h"
|
|
#include "RigTofWellDistributionCalculator.h"
|
|
|
|
#include "RiaColorTools.h"
|
|
|
|
#include "RiuQwtPlotWidget.h"
|
|
|
|
#include "qwt_legend.h"
|
|
#include "qwt_legend_label.h"
|
|
#include "qwt_plot.h"
|
|
#include "qwt_plot_curve.h"
|
|
|
|
#include <QGridLayout>
|
|
#include <QTextBrowser>
|
|
#include <QWidget>
|
|
|
|
//#include "cvfBase.h"
|
|
//#include "cvfTrace.h"
|
|
//#include "cvfDebugTimer.h"
|
|
|
|
#include <array>
|
|
|
|
//==================================================================================================
|
|
//
|
|
//
|
|
//
|
|
//==================================================================================================
|
|
|
|
CAF_PDM_SOURCE_INIT( RimWellDistributionPlot, "WellDistributionPlot" );
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimWellDistributionPlot::RimWellDistributionPlot( RiaDefines::PhaseType phase )
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::RimWellDistributionPlot()");
|
|
|
|
CAF_PDM_InitObject( "Cumulative Phase Distribution Plot", "", "", "" );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_case, "Case", "Case", "", "", "" );
|
|
CAF_PDM_InitField( &m_timeStepIndex, "TimeStepIndex", -1, "Time Step", "", "", "" );
|
|
CAF_PDM_InitField( &m_wellName, "WellName", QString( "None" ), "Well", "", "", "" );
|
|
CAF_PDM_InitField( &m_phase, "Phase", caf::AppEnum<RiaDefines::PhaseType>( phase ), "Phase", "", "", "" );
|
|
CAF_PDM_InitField( &m_groupSmallContributions, "GroupSmallContributions", true, "Group Small Contributions", "", "", "" );
|
|
CAF_PDM_InitField( &m_smallContributionsRelativeThreshold,
|
|
"SmallContributionsRelativeThreshold",
|
|
0.005,
|
|
"Relative Threshold [0, 1]",
|
|
"",
|
|
"",
|
|
"" );
|
|
|
|
CAF_PDM_InitField( &m_maximumTof, "MaximumTOF", 20.0, "Maximum Time of Flight [0, 200]", "", "", "" );
|
|
|
|
m_showWindow = false;
|
|
m_showPlotLegends = true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimWellDistributionPlot::~RimWellDistributionPlot()
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::setDataSourceParameters( RimEclipseResultCase* eclipseResultCase,
|
|
int timeStepIndex,
|
|
QString targetWellName )
|
|
{
|
|
m_case = eclipseResultCase;
|
|
m_timeStepIndex = timeStepIndex;
|
|
m_wellName = targetWellName;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::setPlotOptions( bool groupSmallContributions,
|
|
double smallContributionsRelativeThreshold,
|
|
double maximumTof )
|
|
{
|
|
m_groupSmallContributions = groupSmallContributions;
|
|
m_smallContributionsRelativeThreshold = smallContributionsRelativeThreshold;
|
|
m_maximumTof = maximumTof;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RiaDefines::PhaseType RimWellDistributionPlot::phase() const
|
|
{
|
|
return m_phase();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RiuQwtPlotWidget* RimWellDistributionPlot::viewer()
|
|
{
|
|
return m_plotWidget;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::setAutoScaleXEnabled( bool /*enabled*/ )
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::setAutoScaleXEnabled()");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::setAutoScaleYEnabled( bool /*enabled*/ )
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::setAutoScaleYEnabled()");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::updateAxes()
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::updateAxes()");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::updateLegend()
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::updateLegend()");
|
|
|
|
if ( !m_plotWidget )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Hide the legend when in multiplot mode, as the legend is handeled by the multi plot grid layout
|
|
bool doShowLegend = false;
|
|
if ( isMdiWindow() )
|
|
{
|
|
doShowLegend = m_showPlotLegends;
|
|
}
|
|
|
|
if ( doShowLegend )
|
|
{
|
|
QwtLegend* legend = new QwtLegend( m_plotWidget );
|
|
m_plotWidget->insertLegend( legend, QwtPlot::BottomLegend );
|
|
}
|
|
else
|
|
{
|
|
m_plotWidget->insertLegend( nullptr );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::updateZoomInQwt()
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::updateZoomInQwt()");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::updateZoomFromQwt()
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::updateZoomFromQwt()");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RimWellDistributionPlot::asciiDataForPlotExport() const
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::asciiDataForPlotExport()");
|
|
return QString();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::reattachAllCurves()
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::reattachAllCurves()");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::detachAllCurves()
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::detachAllCurves()");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
caf::PdmObject* RimWellDistributionPlot::findPdmObjectFromQwtCurve( const QwtPlotCurve* /*curve*/ ) const
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::findPdmObjectFromQwtCurve()");
|
|
return nullptr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::onAxisSelected( int /*axis*/, bool /*toggle*/ )
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::onAxisSelected()");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RimWellDistributionPlot::description() const
|
|
{
|
|
return uiName();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QWidget* RimWellDistributionPlot::viewWidget()
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::viewWidget()");
|
|
return m_plotWidget;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QImage RimWellDistributionPlot::snapshotWindowContent()
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::snapshotWindowContent()");
|
|
|
|
QImage image;
|
|
|
|
if ( m_plotWidget )
|
|
{
|
|
QPixmap pix = m_plotWidget->grab();
|
|
image = pix.toImage();
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::zoomAll()
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::zoomAll()");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RiuQwtPlotWidget* RimWellDistributionPlot::doCreatePlotViewWidget( QWidget* mainWindowParent )
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::createViewWidget()");
|
|
|
|
// It seems we risk being called multiple times
|
|
if ( m_plotWidget )
|
|
{
|
|
return m_plotWidget;
|
|
}
|
|
|
|
m_plotWidget = new RiuQwtPlotWidget( this, mainWindowParent );
|
|
|
|
m_plotWidget->setAutoReplot( false );
|
|
|
|
updateLegend();
|
|
onLoadDataAndUpdate();
|
|
|
|
return m_plotWidget;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::deleteViewWidget()
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::deleteViewWidget()");
|
|
|
|
if ( m_plotWidget )
|
|
{
|
|
m_plotWidget->setParent( nullptr );
|
|
delete m_plotWidget;
|
|
m_plotWidget = nullptr;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::onLoadDataAndUpdate()
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::onLoadDataAndUpdate()");
|
|
// cvf::DebugTimer tim("RimWellDistributionPlot::onLoadDataAndUpdate()");
|
|
|
|
if ( isMdiWindow() )
|
|
{
|
|
updateMdiWindowVisibility();
|
|
}
|
|
else
|
|
{
|
|
updateParentLayout();
|
|
}
|
|
|
|
if ( !m_plotWidget )
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_plotWidget->detachItems( QwtPlotItem::Rtti_PlotCurve );
|
|
|
|
updateLegend();
|
|
|
|
if ( m_case && m_case->ensureReservoirCaseIsOpen() )
|
|
{
|
|
// tim.reportLapTimeMS("about to start calc");
|
|
RigTofWellDistributionCalculator calc( m_case, m_wellName, m_timeStepIndex, m_phase() );
|
|
// tim.reportLapTimeMS("calc");
|
|
|
|
if ( m_groupSmallContributions )
|
|
{
|
|
calc.groupSmallContributions( m_smallContributionsRelativeThreshold );
|
|
// tim.reportLapTimeMS("group");
|
|
}
|
|
|
|
const RimFlowDiagSolution* flowDiagSolution = m_case->defaultFlowDiagSolution();
|
|
|
|
// cvf::Trace::show("Populating plot for phase '%s'", m_phase == RiaDefines::OIL_PHASE ? "oil" : (m_phase ==
|
|
// RiaDefines::GAS_PHASE ? "gas" : "water"));
|
|
populatePlotWidgetWithCurveData( calc, *flowDiagSolution, m_plotWidget, m_maximumTof );
|
|
}
|
|
|
|
QString phaseString = "N/A";
|
|
if ( m_phase == RiaDefines::PhaseType::OIL_PHASE )
|
|
phaseString = "Oil";
|
|
else if ( m_phase == RiaDefines::PhaseType::GAS_PHASE )
|
|
phaseString = "Gas";
|
|
else if ( m_phase == RiaDefines::PhaseType::WATER_PHASE )
|
|
phaseString = "Water";
|
|
|
|
const QString timeStepName = m_case ? m_case->timeStepName( m_timeStepIndex ) : "N/A";
|
|
|
|
const QString plotTitleStr =
|
|
QString( "%1 Distribution: %2, %3" ).arg( phaseString ).arg( m_wellName ).arg( timeStepName );
|
|
m_plotWidget->setTitle( plotTitleStr );
|
|
|
|
m_plotWidget->setAxisTitleText( QwtPlot::xBottom, "TOF [years]" );
|
|
m_plotWidget->setAxisTitleText( QwtPlot::yLeft, "Reservoir Volume [m3]" );
|
|
m_plotWidget->setAxisTitleEnabled( QwtPlot::xBottom, true );
|
|
m_plotWidget->setAxisTitleEnabled( QwtPlot::yLeft, true );
|
|
|
|
m_plotWidget->scheduleReplot();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::populatePlotWidgetWithCurveData( const RigTofWellDistributionCalculator& calculator,
|
|
const RimFlowDiagSolution& flowDiagSolution,
|
|
RiuQwtPlotWidget* plotWidget,
|
|
double maximumTof )
|
|
{
|
|
// cvf::Trace::show("RimWellDistributionPlot::populatePlotWidgetWithCurves()");
|
|
|
|
// Currently select this value so that the grid appears on top of the curves
|
|
const double baseCurveZValue = 9.5;
|
|
|
|
plotWidget->detachItems( QwtPlotItem::Rtti_PlotCurve );
|
|
plotWidget->setAxisScale( QwtPlot::xBottom, 0, 1 );
|
|
plotWidget->setAxisScale( QwtPlot::yLeft, 0, 1 );
|
|
plotWidget->setAxisAutoScale( QwtPlot::xBottom, true );
|
|
plotWidget->setAxisAutoScale( QwtPlot::yLeft, true );
|
|
|
|
const std::vector<double>& tofValuesDays = calculator.sortedUniqueTofValues();
|
|
if ( tofValuesDays.size() == 0 )
|
|
{
|
|
// cvf::Trace::show("No TOF values!");
|
|
return;
|
|
}
|
|
|
|
std::vector<double> tofValuesYears;
|
|
for ( double tofDays : tofValuesDays )
|
|
{
|
|
const double tofYears = tofDays / 365.2425;
|
|
|
|
if ( tofYears > maximumTof ) continue;
|
|
|
|
tofValuesYears.push_back( tofYears );
|
|
}
|
|
|
|
// cvf::Trace::show("numTofValues: %d (min, max: %f, %f)", static_cast<int>(tofValuesYears.size()),
|
|
// tofValuesYears.front(), tofValuesYears.back());
|
|
|
|
const size_t numWells = calculator.contributingWellCount();
|
|
// cvf::Trace::show("numContribWells: %d", static_cast<int>(numWells));
|
|
|
|
std::vector<double> yVals( tofValuesYears.size(), 0 );
|
|
|
|
for ( size_t i = 0; i < numWells; i++ )
|
|
{
|
|
const QString& wellName = calculator.contributingWellName( i );
|
|
const std::vector<double>& volArr = calculator.accumulatedVolumeForContributingWell( i );
|
|
|
|
cvf::Color3f cvfClr = flowDiagSolution.tracerColor( wellName );
|
|
QColor qtClr = RiaColorTools::toQColor( cvfClr );
|
|
|
|
for ( size_t j = 0; j < yVals.size(); j++ )
|
|
{
|
|
yVals[j] += volArr[j];
|
|
}
|
|
|
|
// cvf::Trace::show("wellName min, max: %15s %12.3f, %12.3f maxAggrY: %12.3f",
|
|
// wellName.toStdString().c_str(), volArr.front(), volArr.back(), yVals.back());
|
|
|
|
QwtPlotCurve* curve = new QwtPlotCurve;
|
|
curve->setTitle( wellName );
|
|
curve->setBrush( qtClr );
|
|
curve->setZ( baseCurveZValue - i * 0.0001 );
|
|
curve->setSamples( tofValuesYears.data(), yVals.data(), static_cast<int>( tofValuesYears.size() ) );
|
|
curve->attach( plotWidget );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
|
|
{
|
|
uiOrdering.add( &m_case );
|
|
uiOrdering.add( &m_timeStepIndex );
|
|
uiOrdering.add( &m_wellName );
|
|
uiOrdering.add( &m_phase );
|
|
uiOrdering.add( &m_groupSmallContributions );
|
|
uiOrdering.add( &m_smallContributionsRelativeThreshold );
|
|
|
|
m_smallContributionsRelativeThreshold.uiCapability()->setUiReadOnly( m_groupSmallContributions == false );
|
|
|
|
RimPlot::defineUiOrdering( uiConfigName, uiOrdering );
|
|
// uiOrdering.skipRemainingFields();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QList<caf::PdmOptionItemInfo>
|
|
RimWellDistributionPlot::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly )
|
|
{
|
|
QList<caf::PdmOptionItemInfo> options = RimPlot::calculateValueOptions( fieldNeedingOptions, useOptionsOnly );
|
|
|
|
if ( fieldNeedingOptions == &m_case )
|
|
{
|
|
RimProject* ownerProj = nullptr;
|
|
firstAncestorOrThisOfType( ownerProj );
|
|
if ( ownerProj )
|
|
{
|
|
std::vector<RimEclipseResultCase*> caseArr;
|
|
ownerProj->descendantsIncludingThisOfType( caseArr );
|
|
for ( RimEclipseResultCase* c : caseArr )
|
|
{
|
|
options.push_back( caf::PdmOptionItemInfo( c->caseUserDescription(), c, true, c->uiIconProvider() ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
else if ( fieldNeedingOptions == &m_timeStepIndex )
|
|
{
|
|
RimTools::timeStepsForCase( m_case, &options );
|
|
|
|
if ( options.size() == 0 )
|
|
{
|
|
options.push_back( caf::PdmOptionItemInfo( "None", -1 ) );
|
|
}
|
|
}
|
|
|
|
else if ( fieldNeedingOptions == &m_wellName )
|
|
{
|
|
if ( m_case && m_case->eclipseCaseData() )
|
|
{
|
|
caf::IconProvider simWellIcon( ":/Well.svg" );
|
|
const std::set<QString> sortedWellNameSet = m_case->eclipseCaseData()->findSortedWellNames();
|
|
for ( const QString& name : sortedWellNameSet )
|
|
{
|
|
options.push_back( caf::PdmOptionItemInfo( name, name, true, simWellIcon ) );
|
|
}
|
|
}
|
|
|
|
if ( options.size() == 0 )
|
|
{
|
|
options.push_back( caf::PdmOptionItemInfo( "None", QVariant() ) );
|
|
}
|
|
}
|
|
|
|
return options;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
|
|
const QVariant& oldValue,
|
|
const QVariant& newValue )
|
|
{
|
|
RimPlot::fieldChangedByUi( changedField, oldValue, newValue );
|
|
|
|
if ( changedField == &m_case )
|
|
{
|
|
fixupDependentFieldsAfterCaseChange();
|
|
}
|
|
|
|
loadDataAndUpdate();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimWellDistributionPlot::fixupDependentFieldsAfterCaseChange()
|
|
{
|
|
int newTimeStepIndex = -1;
|
|
QString newWellName;
|
|
|
|
if ( m_case )
|
|
{
|
|
const int timeStepCount = m_case->timeStepStrings().size();
|
|
if ( timeStepCount > 0 )
|
|
{
|
|
newTimeStepIndex = timeStepCount - 1;
|
|
}
|
|
|
|
const std::set<QString> sortedWellNameSet = m_case->eclipseCaseData()->findSortedWellNames();
|
|
if ( sortedWellNameSet.size() > 0 )
|
|
{
|
|
newWellName = *sortedWellNameSet.begin();
|
|
}
|
|
}
|
|
|
|
m_timeStepIndex = newTimeStepIndex;
|
|
m_wellName = newWellName;
|
|
}
|