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

Avoid use of time_t when using sliders in GUI

Browse Source 
* Avoid use of time_t when using sliders in GUI
Sliders use int as internal representation of values, and time_t can cause overflow
This commit is contained in:
Magne Sjaastad
2023-10-12 10:02:58 +02:00
committed by GitHub
parent cdda7480f3
commit 4a3cdc4e94
7 changed files with 199 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -102,7 +102,6 @@ RimSummaryDeclineCurve* RicCreateDeclineCurvesFeature::createDeclineCurveAndAddT
RiaSummaryTools::copyCurveAxisData( *newCurve, *sourceCurve );
newCurve->updateDefaultValues();
newCurve->loadDataAndUpdate( true );
newCurve->updateConnectedEditors();

87
ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleCurveSet.cpp
View File

@@ -207,14 +207,14 @@ RimEnsembleCurveSet::RimEnsembleCurveSet()
CAF_PDM_InitFieldNoDefault( &m_minDateRange, "MinDateRange", "From" );
m_minDateRange.uiCapability()->setUiEditorTypeName( caf::PdmUiDateEditor::uiEditorTypeName() );
CAF_PDM_InitFieldNoDefault( &m_minTimeStep, "MinTimeStep", "" );
m_minTimeStep.uiCapability()->setUiEditorTypeName( caf::PdmUiSliderEditor::uiEditorTypeName() );
CAF_PDM_InitField( &m_minTimeSliderPosition, "MinTimeSliderPosition", 0, "" );
m_minTimeSliderPosition.uiCapability()->setUiEditorTypeName( caf::PdmUiSliderEditor::uiEditorTypeName() );
CAF_PDM_InitFieldNoDefault( &m_maxDateRange, "MaxDateRange", "To" );
m_maxDateRange.uiCapability()->setUiEditorTypeName( caf::PdmUiDateEditor::uiEditorTypeName() );
CAF_PDM_InitFieldNoDefault( &m_maxTimeStep, "MaxTimeStep", "" );
m_maxTimeStep.uiCapability()->setUiEditorTypeName( caf::PdmUiSliderEditor::uiEditorTypeName() );
CAF_PDM_InitField( &m_maxTimeSliderPosition, "MaxTimeSliderPosition", 100, "" );
m_maxTimeSliderPosition.uiCapability()->setUiEditorTypeName( caf::PdmUiSliderEditor::uiEditorTypeName() );
// Time Step Selection
CAF_PDM_InitFieldNoDefault( &m_timeStepFilter, "TimeStepFilter", "Available Time Steps" );
@@ -466,6 +466,37 @@ void RimEnsembleCurveSet::setSummaryAddressX( RifEclipseSummaryAddress address )
m_xAddressSelector->setAddress( address );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<time_t, time_t> RimEnsembleCurveSet::fullTimeStepRange() const
{
if ( !allAvailableTimeSteps().empty() )
{
auto min = *allAvailableTimeSteps().begin();
auto max = *allAvailableTimeSteps().rbegin();
return { min, max };
}
return {};
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<time_t, time_t> RimEnsembleCurveSet::selectedTimeStepRange() const
{
// Scale the slider values to the full time step range
auto [min, max] = fullTimeStepRange();
auto range = max - min;
auto selectedMin = min + static_cast<time_t>( range * ( m_minTimeSliderPosition / 100.0 ) );
auto selectedMax = min + static_cast<time_t>( range * ( m_maxTimeSliderPosition / 100.0 ) );
return { selectedMin, selectedMax };
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -867,8 +898,8 @@ void RimEnsembleCurveSet::fieldChangedByUi( const caf::PdmFieldHandle* changedFi
summaryAddress->setAddress( m_yValuesSummaryAddress->address() );
m_objectiveValuesSummaryAddresses.push_back( summaryAddress );
updateAddressesUiField();
m_minTimeStep = *allAvailableTimeSteps().begin();
m_maxTimeStep = *allAvailableTimeSteps().rbegin();
m_minTimeSliderPosition = 0;
m_maxTimeSliderPosition = 100;
updateMaxMinAndDefaultValues();
}
}
@@ -893,7 +924,7 @@ void RimEnsembleCurveSet::fieldChangedByUi( const caf::PdmFieldHandle* changedFi
updateObjectiveFunctionLegend();
updateMaxMinAndDefaultValues();
}
else if ( changedField == &m_minTimeStep || changedField == &m_maxTimeStep )
else if ( changedField == &m_minTimeSliderPosition || changedField == &m_maxTimeSliderPosition )
{
updateMaxMinAndDefaultValues();
updateCurveColors();
@@ -901,8 +932,18 @@ void RimEnsembleCurveSet::fieldChangedByUi( const caf::PdmFieldHandle* changedFi
}
else if ( changedField == &m_minDateRange || changedField == &m_maxDateRange )
{
m_minTimeStep = RiaTimeTTools::fromQDateTime( RiaQDateTimeTools::createDateTime( m_minDateRange() ) );
m_maxTimeStep = RiaTimeTTools::fromQDateTime( RiaQDateTimeTools::createDateTime( m_maxDateRange() ) );
auto [min, max] = fullTimeStepRange();
auto range = max - min;
auto minTime = RiaTimeTTools::fromQDateTime( RiaQDateTimeTools::createDateTime( m_minDateRange() ) );
minTime = std::clamp( minTime, min, max );
auto maxTime = RiaTimeTTools::fromQDateTime( RiaQDateTimeTools::createDateTime( m_maxDateRange() ) );
maxTime = std::clamp( maxTime, min, max );
// Convert from date to normalized value between 0 and 100
m_minTimeSliderPosition = static_cast<int>( ( double( minTime - min ) / double( range ) ) * 100 );
m_maxTimeSliderPosition = static_cast<int>( ( double( maxTime - min ) / double( range ) ) * 100 );
updateCurveColors();
updateTimeAnnotations();
}
@@ -1005,8 +1046,8 @@ void RimEnsembleCurveSet::fieldChangedByUi( const caf::PdmFieldHandle* changedFi
setTimeSteps( indices );
}
m_minTimeStep = *allAvailableTimeSteps().begin();
m_maxTimeStep = *allAvailableTimeSteps().rbegin();
m_minTimeSliderPosition = 0;
m_maxTimeSliderPosition = 100;
updateLegendMappingMode();
updateCurveColors();
@@ -1142,8 +1183,10 @@ void RimEnsembleCurveSet::defineUiOrdering( QString uiConfigName, caf::PdmUiOrde
//--------------------------------------------------------------------------------------------------
void RimEnsembleCurveSet::updateMaxMinAndDefaultValues()
{
m_minDateRange = QDateTime::fromSecsSinceEpoch( m_minTimeStep ).date();
m_maxDateRange = QDateTime::fromSecsSinceEpoch( m_maxTimeStep ).date();
auto [minTimeStep, maxTimeStep] = selectedTimeStepRange();
m_minDateRange = QDateTime::fromSecsSinceEpoch( minTimeStep ).date();
m_maxDateRange = QDateTime::fromSecsSinceEpoch( maxTimeStep ).date();
for ( auto filter : m_curveFilters->filters() )
{
@@ -1299,9 +1342,9 @@ void RimEnsembleCurveSet::appendColorGroup( caf::PdmUiOrdering& uiOrdering )
m_customObjectiveFunction()->weightContainsFunctionType( RimObjectiveFunction::FunctionType::F1 ) ) )
{
timeSelectionGroup->add( &m_minDateRange );
timeSelectionGroup->add( &m_minTimeStep );
timeSelectionGroup->add( &m_minTimeSliderPosition );
timeSelectionGroup->add( &m_maxDateRange );
timeSelectionGroup->add( &m_maxTimeStep );
timeSelectionGroup->add( &m_maxTimeSliderPosition );
}
if ( m_objectiveFunction()->functionType() == RimObjectiveFunction::FunctionType::F2 ||
( m_customObjectiveFunction() &&
@@ -1391,12 +1434,12 @@ void RimEnsembleCurveSet::defineEditorAttribute( const caf::PdmFieldHandle* fiel
attrib->m_buttonText = "...";
}
if ( field == &m_minTimeStep || field == &m_maxTimeStep )
if ( field == &m_minTimeSliderPosition || field == &m_maxTimeSliderPosition )
{
if ( auto* myAttr = dynamic_cast<caf::PdmUiSliderEditorAttribute*>( attribute ) )
{
myAttr->m_minimum = *allAvailableTimeSteps().begin();
myAttr->m_maximum = *allAvailableTimeSteps().rbegin();
myAttr->m_minimum = 0;
myAttr->m_maximum = 100;
myAttr->m_showSpinBox = false;
}
}
@@ -1544,7 +1587,7 @@ QList<caf::PdmOptionItemInfo> RimEnsembleCurveSet::calculateValueOptions( const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<time_t> RimEnsembleCurveSet::allAvailableTimeSteps()
std::set<time_t> RimEnsembleCurveSet::allAvailableTimeSteps() const
{
std::set<time_t> timeStepUnion;
@@ -1734,7 +1777,8 @@ void RimEnsembleCurveSet::updateObjectiveFunctionLegend()
//--------------------------------------------------------------------------------------------------
ObjectiveFunctionTimeConfig RimEnsembleCurveSet::objectiveFunctionTimeConfig() const
{
return { m_minTimeStep(), m_maxTimeStep(), selectedTimeSteps() };
auto [minTimeStep, maxTimeStep] = selectedTimeStepRange();
return { minTimeStep, maxTimeStep, selectedTimeSteps() };
}
//--------------------------------------------------------------------------------------------------
@@ -1934,7 +1978,8 @@ void RimEnsembleCurveSet::updateTimeAnnotations()
( m_colorMode() == ColorMode::BY_CUSTOM_OBJECTIVE_FUNCTION && m_customObjectiveFunction() &&
m_customObjectiveFunction()->weightContainsFunctionType( RimObjectiveFunction::FunctionType::F1 ) ) )
{
plot->addTimeRangeAnnotation( m_minTimeStep, m_maxTimeStep );
auto [minTimeStep, maxTimeStep] = selectedTimeStepRange();
plot->addTimeRangeAnnotation( minTimeStep, maxTimeStep );
}
if ( ( m_colorMode() == ColorMode::BY_OBJECTIVE_FUNCTION &&

9
ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleCurveSet.h
View File

@@ -209,7 +209,7 @@ private:
void defineEditorAttribute( const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute ) override;
QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions ) override;
std::set<time_t> allAvailableTimeSteps();
std::set<time_t> allAvailableTimeSteps() const;
std::set<RimSummaryCase*> timestepDefiningSourceCases();
RiaSummaryCurveDefinitionAnalyser* getOrCreateSelectedCurveDefAnalyser();
std::vector<RiaSummaryCurveDefinition> curveDefinitions() const;
@@ -241,6 +241,9 @@ private:
void setSummaryAddressX( RifEclipseSummaryAddress address );
std::pair<time_t, time_t> fullTimeStepRange() const;
std::pair<time_t, time_t> selectedTimeStepRange() const;
private:
caf::PdmField<bool> m_showCurves;
caf::PdmChildArrayField<RimSummaryCurve*> m_curves;
@@ -277,8 +280,8 @@ private:
caf::PdmField<QString> m_objectiveValuesSummaryAddressesUiField;
caf::PdmField<bool> m_objectiveValuesSelectSummaryAddressPushButton;
caf::PdmPtrField<RimCustomObjectiveFunction*> m_customObjectiveFunction;
caf::PdmField<time_t> m_minTimeStep;
caf::PdmField<time_t> m_maxTimeStep;
caf::PdmField<int> m_minTimeSliderPosition;
caf::PdmField<int> m_maxTimeSliderPosition;
caf::PdmField<QDate> m_minDateRange;
caf::PdmField<QDate> m_maxDateRange;
caf::PdmField<TimeStepFilterEnum> m_timeStepFilter;

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

@@ -61,11 +61,11 @@ RimSummaryDeclineCurve::RimSummaryDeclineCurve()
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_InitField( &m_minTimeSliderPosition, "MinTimeSliderPosition", 75, "From" );
m_minTimeSliderPosition.uiCapability()->setUiEditorTypeName( caf::PdmUiSliderEditor::uiEditorTypeName() );
CAF_PDM_InitFieldNoDefault( &m_maxTimeStep, "MaxTimeStep", "To" );
m_maxTimeStep.uiCapability()->setUiEditorTypeName( caf::PdmUiSliderEditor::uiEditorTypeName() );
CAF_PDM_InitField( &m_maxTimeSliderPosition, "MaxTimeSliderPosition", 100, "To" );
m_maxTimeSliderPosition.uiCapability()->setUiEditorTypeName( caf::PdmUiSliderEditor::uiEditorTypeName() );
CAF_PDM_InitField( &m_showTimeSelectionInPlot, "ShowTimeSelectionInPlot", true, "Show In Plot" );
}
@@ -84,10 +84,12 @@ RimSummaryDeclineCurve::~RimSummaryDeclineCurve()
//--------------------------------------------------------------------------------------------------
std::vector<double> RimSummaryDeclineCurve::valuesY() const
{
auto [minTimeStep, maxTimeStep] = selectedTimeStepRange();
return createDeclineCurveValues( RimSummaryCurve::valuesY(),
RimSummaryCurve::timeStepsY(),
m_minTimeStep,
m_maxTimeStep,
minTimeStep,
maxTimeStep,
RiaSummaryTools::hasAccumulatedData( summaryAddressY() ) );
}
@@ -96,10 +98,12 @@ std::vector<double> RimSummaryDeclineCurve::valuesY() const
//--------------------------------------------------------------------------------------------------
std::vector<double> RimSummaryDeclineCurve::valuesX() const
{
auto [minTimeStep, maxTimeStep] = selectedTimeStepRange();
return createDeclineCurveValues( RimSummaryCurve::valuesX(),
RimSummaryCurve::timeStepsX(),
m_minTimeStep,
m_maxTimeStep,
minTimeStep,
maxTimeStep,
RiaSummaryTools::hasAccumulatedData( summaryAddressX() ) );
}
@@ -108,7 +112,9 @@ std::vector<double> RimSummaryDeclineCurve::valuesX() const
//--------------------------------------------------------------------------------------------------
std::vector<time_t> RimSummaryDeclineCurve::timeStepsY() const
{
std::vector<time_t> timeSteps = getTimeStepsInRange( RimSummaryCurve::timeStepsY(), m_minTimeStep, m_maxTimeStep );
auto [minTimeStep, maxTimeStep] = selectedTimeStepRange();
std::vector<time_t> timeSteps = getTimeStepsInRange( RimSummaryCurve::timeStepsY(), minTimeStep, maxTimeStep );
appendFutureTimeSteps( timeSteps );
return timeSteps;
}
@@ -118,7 +124,9 @@ std::vector<time_t> RimSummaryDeclineCurve::timeStepsY() const
//--------------------------------------------------------------------------------------------------
std::vector<time_t> RimSummaryDeclineCurve::timeStepsX() const
{
std::vector<time_t> timeSteps = getTimeStepsInRange( RimSummaryCurve::timeStepsX(), m_minTimeStep, m_maxTimeStep );
auto [minTimeStep, maxTimeStep] = selectedTimeStepRange();
std::vector<time_t> timeSteps = getTimeStepsInRange( RimSummaryCurve::timeStepsX(), minTimeStep, maxTimeStep );
appendFutureTimeSteps( timeSteps );
return timeSteps;
}
@@ -135,7 +143,7 @@ std::vector<double> RimSummaryDeclineCurve::createDeclineCurveValues( const std:
if ( values.empty() || timeSteps.empty() ) return values;
// Use only the values inside the range specified
auto [timeStepsInRange, valuesInRange] = getInRangeValues( timeSteps, values, m_minTimeStep, m_maxTimeStep );
auto [timeStepsInRange, valuesInRange] = getInRangeValues( timeSteps, values, minTimeStep, maxTimeStep );
if ( timeStepsInRange.empty() || valuesInRange.empty() ) return values;
@@ -162,6 +170,9 @@ std::vector<double> RimSummaryDeclineCurve::createDeclineCurveValues( const std:
return outValues;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<double, double> RimSummaryDeclineCurve::computeInitialProductionAndDeclineRate( const std::vector<double>& values,
const std::vector<time_t>& timeSteps,
bool isAccumulatedResult )
@@ -265,6 +276,35 @@ double RimSummaryDeclineCurve::computePredictedValue( double initialProductionRa
return 0.0;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<time_t, time_t> RimSummaryDeclineCurve::fullTimeStepRange() const
{
auto timeSteps = RimSummaryCurve::timeStepsY();
if ( !timeSteps.empty() )
{
return std::make_pair( *timeSteps.begin(), *timeSteps.rbegin() );
}
return {};
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<time_t, time_t> RimSummaryDeclineCurve::selectedTimeStepRange() const
{
// Scale the slider values to the full time step range
auto [min, max] = fullTimeStepRange();
auto range = max - min;
auto selectedMin = min + static_cast<time_t>( range * ( m_minTimeSliderPosition / 100.0 ) );
auto selectedMax = min + static_cast<time_t>( range * ( m_maxTimeSliderPosition / 100.0 ) );
return { selectedMin, selectedMax };
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -315,8 +355,8 @@ void RimSummaryDeclineCurve::defineUiOrdering( QString uiConfigName, caf::PdmUiO
}
caf::PdmUiGroup* timeSelectionGroup = uiOrdering.addNewGroup( "Time Selection" );
timeSelectionGroup->add( &m_minTimeStep );
timeSelectionGroup->add( &m_maxTimeStep );
timeSelectionGroup->add( &m_minTimeSliderPosition );
timeSelectionGroup->add( &m_maxTimeSliderPosition );
timeSelectionGroup->add( &m_showTimeSelectionInPlot );
RimSummaryCurve::defineUiOrdering( uiConfigName, uiOrdering );
@@ -327,19 +367,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 )
if ( &m_minTimeSliderPosition == changedField && m_minTimeSliderPosition > m_maxTimeSliderPosition )
{
m_maxTimeStep = m_minTimeStep;
m_maxTimeSliderPosition = m_minTimeSliderPosition;
}
if ( &m_maxTimeStep == changedField && m_maxTimeStep < m_minTimeStep )
if ( &m_maxTimeSliderPosition == changedField && m_maxTimeSliderPosition < m_minTimeSliderPosition )
{
m_minTimeStep = m_maxTimeStep;
m_minTimeSliderPosition = m_maxTimeSliderPosition;
}
RimSummaryCurve::fieldChangedByUi( changedField, oldValue, newValue );
if ( changedField == &m_declineCurveType || changedField == &m_predictionYears || changedField == &m_hyperbolicDeclineConstant ||
changedField == &m_minTimeStep || changedField == &m_maxTimeStep || changedField == &m_showTimeSelectionInPlot )
changedField == &m_minTimeSliderPosition || changedField == &m_maxTimeSliderPosition || changedField == &m_showTimeSelectionInPlot )
{
loadAndUpdateDataAndPlot();
auto plot = firstAncestorOrThisOfTypeAsserted<RimSummaryPlot>();
@@ -373,16 +413,12 @@ void RimSummaryDeclineCurve::defineEditorAttribute( const caf::PdmFieldHandle* f
myAttr->m_decimals = 2;
}
}
else if ( field == &m_minTimeStep || field == &m_maxTimeStep )
else if ( field == &m_minTimeSliderPosition || field == &m_maxTimeSliderPosition )
{
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_minimum = 0;
myAttr->m_maximum = 100;
myAttr->m_showSpinBox = false;
}
}
@@ -422,28 +458,14 @@ void RimSummaryDeclineCurve::updateTimeAnnotations()
if ( m_showTimeSelectionInPlot && isChecked() )
{
m_timeRangeAnnotation = plot->addTimeRangeAnnotation( m_minTimeStep, m_maxTimeStep );
auto [minTimeStep, maxTimeStep] = selectedTimeStepRange();
m_timeRangeAnnotation = plot->addTimeRangeAnnotation( minTimeStep, maxTimeStep );
m_timeRangeAnnotation->setColor( color() );
m_timeRangeAnnotation->setName( "" );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
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();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

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

@@ -56,8 +56,6 @@ public:
// X Axis functions
std::vector<double> valuesX() const override;
void updateDefaultValues();
protected:
void updateTimeAnnotations() override;
@@ -93,12 +91,19 @@ private:
double computePredictedValue( double initialProductionRate, double initialDeclineRate, double timeSinceStart, bool isAccumulatedResult ) const;
std::pair<time_t, time_t> fullTimeStepRange() const;
std::pair<time_t, time_t> selectedTimeStepRange() const;
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;
// Time step range defined in the range [0..100] as time_t can hold values that do not fit into int used by QSpinBox
caf::PdmField<int> m_minTimeSliderPosition;
caf::PdmField<int> m_maxTimeSliderPosition;
caf::PdmField<bool> m_showTimeSelectionInPlot;
caf::PdmPointer<RimTimeAxisAnnotation> m_timeRangeAnnotation;
};

69
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryRegressionAnalysisCurve.cpp
View File

@@ -107,11 +107,11 @@ RimSummaryRegressionAnalysisCurve::RimSummaryRegressionAnalysisCurve()
CAF_PDM_InitField( &m_polynomialDegree, "PolynomialDegree", 3, "Degree" );
CAF_PDM_InitFieldNoDefault( &m_timeRangeSelection, "TimeRangeSelection", "Time Range" );
CAF_PDM_InitFieldNoDefault( &m_minTimeStep, "MinTimeStep", "From" );
m_minTimeStep.uiCapability()->setUiEditorTypeName( caf::PdmUiSliderEditor::uiEditorTypeName() );
CAF_PDM_InitFieldNoDefault( &m_minTimeSliderPosition, "MinTimeSliderPosition", "From" );
m_minTimeSliderPosition.uiCapability()->setUiEditorTypeName( caf::PdmUiSliderEditor::uiEditorTypeName() );
CAF_PDM_InitFieldNoDefault( &m_maxTimeStep, "MaxTimeStep", "To" );
m_maxTimeStep.uiCapability()->setUiEditorTypeName( caf::PdmUiSliderEditor::uiEditorTypeName() );
CAF_PDM_InitFieldNoDefault( &m_maxTimeSliderPosition, "MaxTimeSliderPosition", "To" );
m_maxTimeSliderPosition.uiCapability()->setUiEditorTypeName( caf::PdmUiSliderEditor::uiEditorTypeName() );
CAF_PDM_InitField( &m_showTimeSelectionInPlot, "ShowTimeSelectionInPlot", false, "Show In Plot" );
@@ -349,7 +349,8 @@ std::tuple<std::vector<time_t>, std::vector<double>, QString>
{
if ( values.empty() || timeSteps.empty() ) return { timeSteps, values, "" };
auto [timeStepsInRange, valuesInRange] = getInRangeValues( timeSteps, values, m_minTimeStep, m_maxTimeStep );
auto [minTimeStep, maxTimeStep] = selectedTimeStepRange();
auto [timeStepsInRange, valuesInRange] = getInRangeValues( timeSteps, values, minTimeStep, maxTimeStep );
if ( timeStepsInRange.empty() || valuesInRange.empty() ) return {};
@@ -473,8 +474,8 @@ void RimSummaryRegressionAnalysisCurve::defineUiOrdering( QString uiConfigName,
timeSelectionGroup->add( &m_timeRangeSelection );
if ( m_timeRangeSelection() == RangeType::USER_DEFINED_RANGE )
{
timeSelectionGroup->add( &m_minTimeStep );
timeSelectionGroup->add( &m_maxTimeStep );
timeSelectionGroup->add( &m_minTimeSliderPosition );
timeSelectionGroup->add( &m_maxTimeSliderPosition );
}
timeSelectionGroup->add( &m_showTimeSelectionInPlot );
}
@@ -511,14 +512,14 @@ void RimSummaryRegressionAnalysisCurve::fieldChangedByUi( const caf::PdmFieldHan
{
RimSummaryCurve::fieldChangedByUi( changedField, oldValue, newValue );
if ( &m_minTimeStep == changedField && m_minTimeStep > m_maxTimeStep )
if ( &m_minTimeSliderPosition == changedField && m_minTimeSliderPosition > m_maxTimeSliderPosition )
{
m_maxTimeStep = m_minTimeStep;
m_maxTimeSliderPosition = m_minTimeSliderPosition;
}
if ( &m_maxTimeStep == changedField && m_maxTimeStep < m_minTimeStep )
if ( &m_maxTimeSliderPosition == changedField && m_maxTimeSliderPosition < m_minTimeSliderPosition )
{
m_minTimeStep = m_maxTimeStep;
m_minTimeSliderPosition = m_maxTimeSliderPosition;
}
loadAndUpdateDataAndPlot();
@@ -552,16 +553,12 @@ void RimSummaryRegressionAnalysisCurve::defineEditorAttribute( const caf::PdmFie
lineEditorAttr->validator = new QIntValidator( 0, 50, nullptr );
}
}
else if ( field == &m_minTimeStep || field == &m_maxTimeStep )
else if ( field == &m_minTimeSliderPosition || field == &m_maxTimeSliderPosition )
{
if ( auto* myAttr = dynamic_cast<caf::PdmUiSliderEditorAttribute*>( attribute ) )
{
auto timeSteps = m_sourceTimeStepsY;
if ( !timeSteps.empty() )
{
myAttr->m_minimum = *timeSteps.begin();
myAttr->m_maximum = *timeSteps.rbegin();
}
myAttr->m_minimum = 0;
myAttr->m_maximum = 100;
myAttr->m_showSpinBox = false;
}
}
@@ -716,6 +713,35 @@ void RimSummaryRegressionAnalysisCurve::appendTimeSteps( std::vector<time_t>& de
destinationTimeSteps.push_back( RiaTimeTTools::fromQDateTime( t ) );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<time_t, time_t> RimSummaryRegressionAnalysisCurve::fullTimeStepRange() const
{
auto timeSteps = RimSummaryCurve::timeStepsY();
if ( !timeSteps.empty() )
{
return std::make_pair( *timeSteps.begin(), *timeSteps.rbegin() );
}
return {};
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<time_t, time_t> RimSummaryRegressionAnalysisCurve::selectedTimeStepRange() const
{
// Scale the slider values to the full time step range
auto [min, max] = fullTimeStepRange();
auto range = max - min;
auto selectedMin = min + static_cast<time_t>( range * ( m_minTimeSliderPosition / 100.0 ) );
auto selectedMax = min + static_cast<time_t>( range * ( m_maxTimeSliderPosition / 100.0 ) );
return { selectedMin, selectedMax };
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -843,7 +869,8 @@ void RimSummaryRegressionAnalysisCurve::updateTimeAnnotations()
if ( m_showTimeSelectionInPlot && isChecked() )
{
m_timeRangeAnnotation = plot->addTimeRangeAnnotation( m_minTimeStep, m_maxTimeStep );
auto [minTimeStep, maxTimeStep] = selectedTimeStepRange();
m_timeRangeAnnotation = plot->addTimeRangeAnnotation( minTimeStep, maxTimeStep );
m_timeRangeAnnotation->setColor( color() );
}
}
@@ -855,8 +882,8 @@ void RimSummaryRegressionAnalysisCurve::updateDefaultValues()
{
if ( !m_sourceTimeStepsY.empty() && m_timeRangeSelection() == RangeType::FULL_RANGE )
{
m_minTimeStep = m_sourceTimeStepsY.front();
m_maxTimeStep = m_sourceTimeStepsY.back();
m_minTimeSliderPosition = 0;
m_maxTimeSliderPosition = 100;
}
if ( !m_sourceValuesX.empty() && m_xRangeSelection() == RangeType::FULL_RANGE )

7
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryRegressionAnalysisCurve.h
View File

@@ -133,6 +133,9 @@ private:
static void appendTimeSteps( std::vector<time_t>& destinationTimeSteps, const std::set<QDateTime>& sourceTimeSteps );
std::pair<time_t, time_t> fullTimeStepRange() const;
std::pair<time_t, time_t> selectedTimeStepRange() const;
private:
caf::PdmField<caf::AppEnum<DataSource>> m_dataSourceForRegression;
caf::PdmPtrField<RimEnsembleCurveSet*> m_ensembleCurveSet;
@@ -141,8 +144,8 @@ private:
caf::PdmField<caf::AppEnum<RegressionType>> m_regressionType;
caf::PdmField<caf::AppEnum<RangeType>> m_timeRangeSelection;
caf::PdmField<time_t> m_minTimeStep;
caf::PdmField<time_t> m_maxTimeStep;
caf::PdmField<int> m_minTimeSliderPosition;
caf::PdmField<int> m_maxTimeSliderPosition;
caf::PdmField<bool> m_showTimeSelectionInPlot;
caf::PdmField<int> m_polynomialDegree;