OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-03 12:10:57 -06:00
Code Issues Packages Projects Releases Wiki Activity

#10360 Decline Curve: allow selecting subset of time range

Browse Source 
Fixes #10360.
This commit is contained in:
Kristian Bendiksen 2023-06-08 09:20:54 +02:00
parent f1794abff2
commit 3b4244bdbf
3 changed files with 179 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
ApplicationLibCode/Commands/SummaryPlotCommands/RicCreateDeclineCurvesFeature.cpp
View File

@ -105,6 +105,7 @@ RimSummaryDeclineCurve* RicCreateDeclineCurvesFeature::createDeclineCurveAndAddT
summaryPlot->addCurveAndUpdate( newCurve );
newCurve->updateDefaultValues();
newCurve->loadDataAndUpdate( true );
newCurve->updateConnectedEditors();

179
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryDeclineCurve.cpp
View File

@ -25,9 +25,11 @@
#include "RigDeclineCurveCalculator.h"
#include "RimSummaryPlot.h"
#include "RimTimeAxisAnnotation.h"
#include "cafPdmUiDoubleSliderEditor.h"
#include "cafPdmUiLineEditor.h"
#include "cafPdmUiSliderEditor.h"
#include <QDateTime>
@ -58,6 +60,14 @@ RimSummaryDeclineCurve::RimSummaryDeclineCurve()
CAF_PDM_InitField( &m_predictionYears, "PredictionYears", 5, "Years" );
CAF_PDM_InitField( &m_hyperbolicDeclineConstant, "HyperbolicDeclineConstant", 0.5, "Decline Constant" );
m_hyperbolicDeclineConstant.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleSliderEditor::uiEditorTypeName() );
CAF_PDM_InitFieldNoDefault( &m_minTimeStep, "MinTimeStep", "From" );
m_minTimeStep.uiCapability()->setUiEditorTypeName( caf::PdmUiSliderEditor::uiEditorTypeName() );
CAF_PDM_InitFieldNoDefault( &m_maxTimeStep, "MaxTimeStep", "To" );
m_maxTimeStep.uiCapability()->setUiEditorTypeName( caf::PdmUiSliderEditor::uiEditorTypeName() );
CAF_PDM_InitField( &m_showTimeSelectionInPlot, "ShowTimeSelectionInPlot", true, "Show In Plot" );
}
//--------------------------------------------------------------------------------------------------
@ -65,6 +75,8 @@ RimSummaryDeclineCurve::RimSummaryDeclineCurve()
//--------------------------------------------------------------------------------------------------
RimSummaryDeclineCurve::~RimSummaryDeclineCurve()
{
auto plot = firstAncestorOrThisOfType<RimSummaryPlot>();
if ( plot && m_timeRangeAnnotation ) plot->removeTimeAnnotation( m_timeRangeAnnotation );
}
//--------------------------------------------------------------------------------------------------
@ -74,6 +86,8 @@ std::vector<double> RimSummaryDeclineCurve::valuesY() const
{
return createDeclineCurveValues( RimSummaryCurve::valuesY(),
RimSummaryCurve::timeStepsY(),
m_minTimeStep,
m_maxTimeStep,
RiaSummaryTools::hasAccumulatedData( summaryAddressY() ) );
}
@ -84,6 +98,8 @@ std::vector<double> RimSummaryDeclineCurve::valuesX() const
{
return createDeclineCurveValues( RimSummaryCurve::valuesX(),
RimSummaryCurve::timeStepsX(),
m_minTimeStep,
m_maxTimeStep,
RiaSummaryTools::hasAccumulatedData( summaryAddressX() ) );
}
@ -92,7 +108,7 @@ std::vector<double> RimSummaryDeclineCurve::valuesX() const
//--------------------------------------------------------------------------------------------------
std::vector<time_t> RimSummaryDeclineCurve::timeStepsY() const
{
std::vector<time_t> timeSteps = RimSummaryCurve::timeStepsY();
std::vector<time_t> timeSteps = getTimeStepsInRange( RimSummaryCurve::timeStepsY(), m_minTimeStep, m_maxTimeStep );
appendFutureTimeSteps( timeSteps );
return timeSteps;
}
@ -102,7 +118,7 @@ std::vector<time_t> RimSummaryDeclineCurve::timeStepsY() const
//--------------------------------------------------------------------------------------------------
std::vector<time_t> RimSummaryDeclineCurve::timeStepsX() const
{
std::vector<time_t> timeSteps = RimSummaryCurve::timeStepsX();
std::vector<time_t> timeSteps = getTimeStepsInRange( RimSummaryCurve::timeStepsX(), m_minTimeStep, m_maxTimeStep );
appendFutureTimeSteps( timeSteps );
return timeSteps;
}
@ -112,27 +128,34 @@ std::vector<time_t> RimSummaryDeclineCurve::timeStepsX() const
//--------------------------------------------------------------------------------------------------
std::vector<double> RimSummaryDeclineCurve::createDeclineCurveValues( const std::vector<double>& values,
const std::vector<time_t>& timeSteps,
time_t minTimeStep,
time_t maxTimeStep,
bool isAccumulatedResult ) const
{
if ( values.empty() ) return values;
if ( timeSteps.empty() ) return values;
if ( values.empty() || timeSteps.empty() ) return values;
auto [initialProductionRate, initialDeclineRate] = computeInitialProductionAndDeclineRate( values, timeSteps, isAccumulatedResult );
// Use only the values inside the range specified
auto [timeStepsInRange, valuesInRange] = getInRangeValues( timeSteps, values, m_minTimeStep, m_maxTimeStep );
if ( timeStepsInRange.empty() || valuesInRange.empty() ) return values;
auto [initialProductionRate, initialDeclineRate] =
computeInitialProductionAndDeclineRate( valuesInRange, timeStepsInRange, isAccumulatedResult );
if ( std::isinf( initialProductionRate ) || std::isnan( initialProductionRate ) || std::isinf( initialDeclineRate ) ||
std::isnan( initialDeclineRate ) )
{
return values;
}
QDateTime initialTime = RiaQDateTimeTools::fromTime_t( timeSteps.back() );
QDateTime initialTime = RiaQDateTimeTools::fromTime_t( timeStepsInRange.back() );
std::set<QDateTime> futureTimeSteps = createFutureTimeSteps( timeSteps );
std::vector<double> outValues = values;
std::set<QDateTime> futureTimeSteps = createFutureTimeSteps( timeStepsInRange );
std::vector<double> outValues = valuesInRange;
for ( const QDateTime& futureTime : futureTimeSteps )
{
double timeSinceStart = futureTime.toSecsSinceEpoch() - initialTime.toSecsSinceEpoch();
double predictedValue = computePredictedValue( initialProductionRate, initialDeclineRate, timeSinceStart, isAccumulatedResult );
if ( isAccumulatedResult ) predictedValue += values.back();
if ( isAccumulatedResult ) predictedValue += valuesInRange.back();
outValues.push_back( predictedValue );
}
@ -143,21 +166,20 @@ std::pair<double, double> RimSummaryDeclineCurve::computeInitialProductionAndDec
const std::vector<time_t>& timeSteps,
bool isAccumulatedResult )
{
CAF_ASSERT( values.size() == timeSteps.size() );
auto computeProductionRate = []( double t0, double v0, double t1, double v1 ) { return ( v1 - v0 ) / ( t1 - t0 ); };
const double historyStep = 0.25;
// Select a point a 1/4 back in the existing curve.
const size_t idx0 = static_cast<size_t>( timeSteps.size() * ( 1.0 - historyStep ) );
const QDateTime t0 = RiaQDateTimeTools::fromTime_t( timeSteps[idx0] );
const double v0 = values[idx0];
const QDateTime initialTime = RiaQDateTimeTools::fromTime_t( timeSteps.back() );
if ( !isAccumulatedResult )
{
// Last point on the existing curve is the initial production rate (for non-accumulated data).
double initialProductionRate = values.back();
// Use the first (time step, value) pair as t0
const size_t idx0 = 0;
const QDateTime t0 = RiaQDateTimeTools::fromTime_t( timeSteps[idx0] );
const double v0 = values[idx0];
// Last point on the existing curve (within user-specified range) is the initial production rate (for non-accumulated data).
const QDateTime initialTime = RiaQDateTimeTools::fromTime_t( timeSteps.back() );
const double initialProductionRate = values.back();
// Compute the decline rate using the rates at the two points
double initialDeclineRate =
@ -166,11 +188,18 @@ std::pair<double, double> RimSummaryDeclineCurve::computeInitialProductionAndDec
}
else
{
// Select a point (t0) 1/4 into the user-specified range
const double historyStep = 0.25;
const size_t idx0 = static_cast<size_t>( timeSteps.size() * historyStep );
const QDateTime t0 = RiaQDateTimeTools::fromTime_t( timeSteps[idx0] );
const double v0 = values[idx0];
// For accumulated result: compute the initial production rate from the two points.
const QDateTime initialTime = RiaQDateTimeTools::fromTime_t( timeSteps.back() );
double initialProductionRate = computeProductionRate( t0.toSecsSinceEpoch(), v0, initialTime.toSecsSinceEpoch(), values.back() );
// Compute the at production rate at time t0 by using a point even further back in the existing curve.
size_t idxX = static_cast<size_t>( timeSteps.size() * ( 1.0 - ( historyStep * 2 ) ) );
// Compute the at production rate at time t0 by using a point even further back in the existing curve (tx).
size_t idxX = 0;
QDateTime tx = RiaQDateTimeTools::fromTime_t( timeSteps[idxX] );
double vx = values[idxX];
double productionRate0 = computeProductionRate( tx.toSecsSinceEpoch(), vx, t0.toSecsSinceEpoch(), v0 );
@ -285,6 +314,11 @@ void RimSummaryDeclineCurve::defineUiOrdering( QString uiConfigName, caf::PdmUiO
declineCurveGroup->add( &m_hyperbolicDeclineConstant );
}
caf::PdmUiGroup* timeSelectionGroup = uiOrdering.addNewGroup( "Time Selection" );
timeSelectionGroup->add( &m_minTimeStep );
timeSelectionGroup->add( &m_maxTimeStep );
timeSelectionGroup->add( &m_showTimeSelectionInPlot );
RimSummaryCurve::defineUiOrdering( uiConfigName, uiOrdering );
}
@ -293,8 +327,19 @@ void RimSummaryDeclineCurve::defineUiOrdering( QString uiConfigName, caf::PdmUiO
//--------------------------------------------------------------------------------------------------
void RimSummaryDeclineCurve::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
{
if ( &m_minTimeStep == changedField && m_minTimeStep > m_maxTimeStep )
{
m_maxTimeStep = m_minTimeStep;
}
if ( &m_maxTimeStep == changedField && m_maxTimeStep < m_minTimeStep )
{
m_minTimeStep = m_maxTimeStep;
}
RimSummaryCurve::fieldChangedByUi( changedField, oldValue, newValue );
if ( changedField == &m_declineCurveType || changedField == &m_predictionYears || changedField == &m_hyperbolicDeclineConstant )
if ( changedField == &m_declineCurveType || changedField == &m_predictionYears || changedField == &m_hyperbolicDeclineConstant ||
changedField == &m_minTimeStep || changedField == &m_maxTimeStep || changedField == &m_showTimeSelectionInPlot )
{
loadAndUpdateDataAndPlot();
auto plot = firstAncestorOrThisOfTypeAsserted<RimSummaryPlot>();
@ -328,6 +373,19 @@ void RimSummaryDeclineCurve::defineEditorAttribute( const caf::PdmFieldHandle* f
myAttr->m_decimals = 2;
}
}
else if ( field == &m_minTimeStep || field == &m_maxTimeStep )
{
if ( auto* myAttr = dynamic_cast<caf::PdmUiSliderEditorAttribute*>( attribute ) )
{
auto timeSteps = RimSummaryCurve::timeStepsY();
if ( !timeSteps.empty() )
{
myAttr->m_minimum = *timeSteps.begin();
myAttr->m_maximum = *timeSteps.rbegin();
}
myAttr->m_showSpinBox = false;
}
}
}
//--------------------------------------------------------------------------------------------------
@ -353,3 +411,78 @@ QString RimSummaryDeclineCurve::curveExportDescription( const RifEclipseSummaryA
{
return RimSummaryCurve::curveExportDescription() + "." + m_declineCurveType().uiText() + "_Decline";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryDeclineCurve::updateTimeAnnotations()
{
auto plot = firstAncestorOrThisOfTypeAsserted<RimSummaryPlot>();
if ( m_timeRangeAnnotation ) plot->removeTimeAnnotation( m_timeRangeAnnotation );
if ( m_showTimeSelectionInPlot )
{
m_timeRangeAnnotation = plot->addTimeRangeAnnotation( m_minTimeStep, m_maxTimeStep );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryDeclineCurve::updateDefaultValues()
{
auto timeSteps = RimSummaryCurve::timeStepsY();
if ( !timeSteps.empty() )
{
// Default min time step is 3/4 into the data
const double historyStep = 0.75;
const size_t idx = static_cast<size_t>( timeSteps.size() * historyStep );
m_minTimeStep = timeSteps[idx];
m_maxTimeStep = timeSteps.back();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<std::vector<time_t>, std::vector<double>> RimSummaryDeclineCurve::getInRangeValues( const std::vector<time_t>& timeSteps,
const std::vector<double>& values,
time_t minTimeStep,
time_t maxTimeStep )
{
// TODO: duplicated with RimSummarRegressionAnalysisCurve
CAF_ASSERT( timeSteps.size() == values.size() );
std::vector<time_t> filteredTimeSteps;
std::vector<double> filteredValues;
for ( size_t i = 0; i < timeSteps.size(); i++ )
{
time_t timeStep = timeSteps[i];
if ( timeStep >= minTimeStep && timeStep <= maxTimeStep )
{
filteredTimeSteps.push_back( timeStep );
filteredValues.push_back( values[i] );
}
}
return std::make_pair( filteredTimeSteps, filteredValues );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<time_t> RimSummaryDeclineCurve::getTimeStepsInRange( const std::vector<time_t>& timeSteps, time_t minTimeStep, time_t maxTimeStep )
{
std::vector<time_t> filteredTimeSteps;
for ( size_t i = 0; i < timeSteps.size(); i++ )
{
time_t timeStep = timeSteps[i];
if ( timeStep >= minTimeStep && timeStep <= maxTimeStep )
{
filteredTimeSteps.push_back( timeStep );
}
}
return filteredTimeSteps;
}

26
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryDeclineCurve.h
View File

@ -18,15 +18,16 @@
#pragma once
#include "cafAppEnum.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "RimSummaryCurve.h"
#include "cafAppEnum.h"
#include <utility>
class RimTimeAxisAnnotation;
//==================================================================================================
///
///
@ -55,6 +56,11 @@ public:
// X Axis functions
std::vector<double> valuesX() const override;
void updateDefaultValues();
protected:
void updateTimeAnnotations() override;
private:
QString createCurveAutoName() override;
QString curveExportDescription( const RifEclipseSummaryAddress& address ) const override;
@ -68,8 +74,15 @@ private:
void appendFutureTimeSteps( std::vector<time_t>& timeSteps ) const;
std::vector<double>
createDeclineCurveValues( const std::vector<double>& values, const std::vector<time_t>& timeSteps, bool isAccumulatedResult ) const;
std::vector<double> createDeclineCurveValues( const std::vector<double>& values,
const std::vector<time_t>& timeSteps,
time_t minTimeStep,
time_t maxTimeStep,
bool isAccumulatedResult ) const;
static std::pair<std::vector<time_t>, std::vector<double>>
getInRangeValues( const std::vector<time_t>& timeSteps, const std::vector<double>& values, time_t minTimeStep, time_t maxTimeStep );
static std::vector<time_t> getTimeStepsInRange( const std::vector<time_t>& timeSteps, time_t minTimeStep, time_t maxTimeStep );
std::set<QDateTime> createFutureTimeSteps( const std::vector<time_t>& timeSteps ) const;
static void appendTimeSteps( std::vector<time_t>& timeSteps, const std::set<QDateTime>& moreTimeSteps );
@ -83,4 +96,9 @@ private:
caf::PdmField<caf::AppEnum<DeclineCurveType>> m_declineCurveType;
caf::PdmField<int> m_predictionYears;
caf::PdmField<double> m_hyperbolicDeclineConstant;
caf::PdmField<time_t> m_minTimeStep;
caf::PdmField<time_t> m_maxTimeStep;
caf::PdmField<bool> m_showTimeSelectionInPlot;
caf::PdmPointer<RimTimeAxisAnnotation> m_timeRangeAnnotation;
};