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

Merged from maintenance branch

Browse Source
This commit is contained in:
Magne Sjaastad 2016-08-05 12:13:13 +02:00
commit e031f89dcc
27 changed files with 524 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
ApplicationCode/Commands/RicEclipsePropertyFilterFeatureImpl.cpp
View File

@ -123,4 +123,5 @@ void RicEclipsePropertyFilterFeatureImpl::setDefaults(RimEclipsePropertyFilter*
propertyFilter->resultDefinition->loadResult();
propertyFilter->setToDefaultValues();
propertyFilter->updateFilterName();
propertyFilter->m_valueSelection = true;
}

1
ApplicationCode/Commands/RicEclipsePropertyFilterInsertFeature.cpp
View File

@ -64,5 +64,6 @@ void RicEclipsePropertyFilterInsertFeature::onActionTriggered(bool isChecked)
//--------------------------------------------------------------------------------------------------
void RicEclipsePropertyFilterInsertFeature::setupActionLook(QAction* actionToSetup)
{
actionToSetup->setIcon(QIcon(":/CellFilter_Values.png"));
actionToSetup->setText("Insert Property Filter");
}

16
ApplicationCode/GeoMech/GeoMechDataModel/RigFemNativeStatCalc.cpp
View File

@ -137,6 +137,22 @@ void RigFemNativeStatCalc::addDataToHistogramCalculator(size_t timeStepIndex, Ri
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFemNativeStatCalc::uniqueValues(size_t timeStepIndex, std::set<int>& values)
{
for (int pIdx = 0; pIdx < m_resultsData->partCount(); ++pIdx)
{
const std::vector<float>& floatValues = m_resultsData->resultValues(m_resVarAddr, pIdx, (int)timeStepIndex);
for (size_t i = 0; i < floatValues.size(); i++)
{
values.insert(static_cast<int>(std::floor(floatValues[i])));
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/GeoMech/GeoMechDataModel/RigFemNativeStatCalc.h
View File

@ -42,6 +42,8 @@ public:
virtual void addDataToHistogramCalculator(size_t timeStepIndex, RigHistogramCalculator& histogramCalculator);
virtual void uniqueValues(size_t timeStepIndex, std::set<int>& values);
virtual size_t timeStepCount();
private:

10
ApplicationCode/GeoMech/GeoMechDataModel/RigFemNativeVisibleCellsStatCalc.cpp
View File

@ -82,6 +82,16 @@ void RigFemNativeVisibleCellsStatCalc::addDataToHistogramCalculator(size_t timeS
traverseElementNodes(histogramCalculator, timeStepIndex);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFemNativeVisibleCellsStatCalc::uniqueValues(size_t timeStepIndex, std::set<int>& values)
{
UniqueValueAccumulator acc;
traverseElementNodes(acc, timeStepIndex);
values = acc.uniqueValues;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

1
ApplicationCode/GeoMech/GeoMechDataModel/RigFemNativeVisibleCellsStatCalc.h
View File

@ -45,6 +45,7 @@ public:
virtual void posNegClosestToZero(size_t timeStepIndex, double& pos, double& neg);
virtual void valueSumAndSampleCount(size_t timeStepIndex, double& valueSum, size_t& sampleCount);
virtual void addDataToHistogramCalculator(size_t timeStepIndex, RigHistogramCalculator& histogramCalculator);
virtual void uniqueValues(size_t timeStepIndex, std::set<int>& values);
virtual size_t timeStepCount();
private:

20
ApplicationCode/GeoMech/GeoMechDataModel/RigFemPartResultsCollection.cpp
View File

@ -805,6 +805,26 @@ void RigFemPartResultsCollection::p10p90ScalarValues(const RigFemResultAddress&
this->statistics(resVarAddr)->p10p90CellScalarValues(frameIndex, *p10, *p90);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFemPartResultsCollection::sumScalarValue(const RigFemResultAddress& resVarAddr, double* sum)
{
CVF_ASSERT(sum);
this->statistics(resVarAddr)->sumCellScalarValues(*sum);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFemPartResultsCollection::sumScalarValue(const RigFemResultAddress& resVarAddr, int frameIndex, double* sum)
{
CVF_ASSERT(sum);
this->statistics(resVarAddr)->sumCellScalarValues(frameIndex, *sum);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/GeoMech/GeoMechDataModel/RigFemPartResultsCollection.h
View File

@ -55,6 +55,8 @@ public:
void meanScalarValue(const RigFemResultAddress& resVarAddr, int frameIndex, double* meanValue);
void p10p90ScalarValues(const RigFemResultAddress& resVarAddr, double* p10, double* p90);
void p10p90ScalarValues(const RigFemResultAddress& resVarAddr, int frameIndex, double* p10, double* p90);
void sumScalarValue(const RigFemResultAddress& resVarAddr, double* sum);
void sumScalarValue(const RigFemResultAddress& resVarAddr, int frameIndex, double* sum);
const std::vector<size_t>& scalarValuesHistogram(const RigFemResultAddress& resVarAddr);
const std::vector<size_t>& scalarValuesHistogram(const RigFemResultAddress& resVarAddr, int frameIndex);

68
ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.cpp
View File

@ -781,11 +781,8 @@ void RivReservoirViewPartMgr::computePropertyVisibility(cvf::UByteArray* cellVis
{
RimEclipsePropertyFilter* propertyFilter = propFilterColl->propertyFilters()[i];
if (propertyFilter->isActive()&& propertyFilter->resultDefinition->hasResult())
if (propertyFilter->isActive() && propertyFilter->resultDefinition->hasResult())
{
const double lowerBound = propertyFilter->lowerBound();
const double upperBound = propertyFilter->upperBound();
const RimCellFilter::FilterModeType filterType = propertyFilter->filterMode();
RigCaseData* eclipseCase = propFilterColl->reservoirView()->eclipseCase()->reservoirData();
@ -803,26 +800,65 @@ void RivReservoirViewPartMgr::computePropertyVisibility(cvf::UByteArray* cellVis
CVF_ASSERT(resultAccessor.notNull());
//#pragma omp parallel for schedule(dynamic)
for (int cellIndex = 0; cellIndex < static_cast<int>(grid->cellCount()); cellIndex++)
if (propertyFilter->isValueSelectionActive())
{
if ( (*cellVisibility)[cellIndex] )
std::vector<int> integerVector = propertyFilter->selectedValues();
std::set<int> integerSet;
for (auto val : integerVector)
{
size_t resultValueIndex = cellIndex;
double scalarValue = resultAccessor->cellScalar(resultValueIndex);
if (lowerBound <= scalarValue && scalarValue <= upperBound)
integerSet.insert(val);
}
for (int cellIndex = 0; cellIndex < static_cast<int>(grid->cellCount()); cellIndex++)
{
if ((*cellVisibility)[cellIndex])
{
if (filterType == RimCellFilter::EXCLUDE)
size_t resultValueIndex = cellIndex;
double scalarValue = resultAccessor->cellScalar(resultValueIndex);
if (integerSet.find(scalarValue) != integerSet.end())
{
(*cellVisibility)[cellIndex] = false;
if (filterType == RimCellFilter::EXCLUDE)
{
(*cellVisibility)[cellIndex] = false;
}
}
else
{
if (filterType == RimCellFilter::INCLUDE)
{
(*cellVisibility)[cellIndex] = false;
}
}
}
else
}
}
else
{
double lowerBound = 0.0;
double upperBound = 0.0;
propertyFilter->rangeValues(&lowerBound, &upperBound);
for (int cellIndex = 0; cellIndex < static_cast<int>(grid->cellCount()); cellIndex++)
{
if ((*cellVisibility)[cellIndex])
{
if (filterType == RimCellFilter::INCLUDE)
size_t resultValueIndex = cellIndex;
double scalarValue = resultAccessor->cellScalar(resultValueIndex);
if (lowerBound <= scalarValue && scalarValue <= upperBound)
{
(*cellVisibility)[cellIndex] = false;
if (filterType == RimCellFilter::EXCLUDE)
{
(*cellVisibility)[cellIndex] = false;
}
}
else
{
if (filterType == RimCellFilter::INCLUDE)
{
(*cellVisibility)[cellIndex] = false;
}
}
}
}

25
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

@ -197,6 +197,7 @@ void Rim3dOverlayInfoConfig::updateEclipse3DInfo(RimEclipseView * eclipseView)
double min = HUGE_VAL, max = HUGE_VAL;
double p10 = HUGE_VAL, p90 = HUGE_VAL;
double mean = HUGE_VAL;
double sum = 0.0;
const std::vector<size_t>* histogram = NULL;
bool isResultsInfoRelevant = eclipseView->hasUserRequestedAnimation() && eclipseView->cellResult()->hasResult();
@ -213,6 +214,7 @@ void Rim3dOverlayInfoConfig::updateEclipse3DInfo(RimEclipseView * eclipseView)
eclipseView->currentGridCellResults()->cellResults()->minMaxCellScalarValues(scalarIndex, min, max);
eclipseView->currentGridCellResults()->cellResults()->p10p90CellScalarValues(scalarIndex, p10, p90);
eclipseView->currentGridCellResults()->cellResults()->meanCellScalarValues(scalarIndex, mean);
eclipseView->currentGridCellResults()->cellResults()->sumCellScalarValues(scalarIndex, sum);
histogram = &(eclipseView->currentGridCellResults()->cellResults()->cellScalarValuesHistogram(scalarIndex));
}
else if (m_statisticsTimeRange == CURRENT_TIMESTEP )
@ -220,7 +222,8 @@ void Rim3dOverlayInfoConfig::updateEclipse3DInfo(RimEclipseView * eclipseView)
int timeStepIdx = eclipseView->currentTimeStep();
eclipseView->currentGridCellResults()->cellResults()->minMaxCellScalarValues(scalarIndex, timeStepIdx, min, max);
eclipseView->currentGridCellResults()->cellResults()->p10p90CellScalarValues(scalarIndex, timeStepIdx, p10, p90);
eclipseView->currentGridCellResults()->cellResults()->meanCellScalarValues(scalarIndex, timeStepIdx, mean);
eclipseView->currentGridCellResults()->cellResults()->meanCellScalarValues(scalarIndex, timeStepIdx, mean);
eclipseView->currentGridCellResults()->cellResults()->sumCellScalarValues(scalarIndex, timeStepIdx, sum);
histogram = &(eclipseView->currentGridCellResults()->cellResults()->cellScalarValuesHistogram(scalarIndex, timeStepIdx));
}
else
@ -237,6 +240,7 @@ void Rim3dOverlayInfoConfig::updateEclipse3DInfo(RimEclipseView * eclipseView)
m_visibleCellStatistics->meanCellScalarValues(mean);
m_visibleCellStatistics->minMaxCellScalarValues(min, max);
m_visibleCellStatistics->p10p90CellScalarValues(p10, p90);
m_visibleCellStatistics->sumCellScalarValues(sum);
histogram = &(m_visibleCellStatistics->cellScalarValuesHistogram());
}
@ -246,6 +250,7 @@ void Rim3dOverlayInfoConfig::updateEclipse3DInfo(RimEclipseView * eclipseView)
m_visibleCellStatistics->meanCellScalarValues(currentTimeStep, mean);
m_visibleCellStatistics->minMaxCellScalarValues(currentTimeStep, min, max);
m_visibleCellStatistics->p10p90CellScalarValues(currentTimeStep, p10, p90);
m_visibleCellStatistics->sumCellScalarValues(currentTimeStep, sum);
histogram = &(m_visibleCellStatistics->cellScalarValuesHistogram(currentTimeStep));
}
@ -303,9 +308,9 @@ void Rim3dOverlayInfoConfig::updateEclipse3DInfo(RimEclipseView * eclipseView)
infoText += QString("<b>Cell Property:</b> %1 ").arg(propName);
infoText += QString("<br><b>Statistics:</b> ") + m_statisticsTimeRange().uiText() + " and " + m_statisticsCellRange().uiText();
infoText += QString("<table border=0 cellspacing=5 >"
"<tr> <td>Min</td> <td>P10</td> <td>Mean</td> <td>P90</td> <td>Max</td> </tr>"
"<tr> <td>%1</td> <td> %2</td> <td> %3</td> <td> %4</td> <td> %5 </td></tr>"
"</table>").arg(min).arg(p10).arg(mean).arg(p90).arg(max);
"<tr> <td>Min</td> <td>P10</td> <td>Mean</td> <td>P90</td> <td>Max</td> <td>Sum</td> </tr>"
"<tr> <td>%1</td> <td> %2</td> <td> %3</td> <td> %4</td> <td> %5</td> <td> %6</td> </tr>"
"</table>").arg(min).arg(p10).arg(mean).arg(p90).arg(max).arg(sum);
if (eclipseView->faultResultSettings()->hasValidCustomResult())
{
@ -381,6 +386,7 @@ void Rim3dOverlayInfoConfig::updateGeoMech3DInfo(RimGeoMechView * geoMechView)
double min = HUGE_VAL, max = HUGE_VAL;
double p10 = HUGE_VAL, p90 = HUGE_VAL;
double mean = HUGE_VAL;
double sum = 0.0;
const std::vector<size_t>* histogram = NULL;
if (showResultInfo() || showHistogram())
@ -395,6 +401,7 @@ void Rim3dOverlayInfoConfig::updateGeoMech3DInfo(RimGeoMechView * geoMechView)
caseData->femPartResults()->meanScalarValue(resAddress, &mean);
caseData->femPartResults()->minMaxScalarValues(resAddress, &min, &max);
caseData->femPartResults()->p10p90ScalarValues(resAddress, &p10, &p90);
caseData->femPartResults()->sumScalarValue(resAddress, &sum);
histogram = &(caseData->femPartResults()->scalarValuesHistogram(resAddress));
}
@ -404,6 +411,7 @@ void Rim3dOverlayInfoConfig::updateGeoMech3DInfo(RimGeoMechView * geoMechView)
caseData->femPartResults()->meanScalarValue(resAddress, timeStepIdx, &mean);
caseData->femPartResults()->minMaxScalarValues(resAddress, timeStepIdx, &min, &max);
caseData->femPartResults()->p10p90ScalarValues(resAddress, timeStepIdx, &p10, &p90);
caseData->femPartResults()->sumScalarValue(resAddress, timeStepIdx, &sum);
histogram = &(caseData->femPartResults()->scalarValuesHistogram(resAddress, timeStepIdx));
}
@ -418,6 +426,7 @@ void Rim3dOverlayInfoConfig::updateGeoMech3DInfo(RimGeoMechView * geoMechView)
m_visibleCellStatistics->meanCellScalarValues(mean);
m_visibleCellStatistics->minMaxCellScalarValues(min, max);
m_visibleCellStatistics->p10p90CellScalarValues(p10, p90);
m_visibleCellStatistics->sumCellScalarValues(sum);
histogram = &(m_visibleCellStatistics->cellScalarValuesHistogram());
}
@ -427,6 +436,7 @@ void Rim3dOverlayInfoConfig::updateGeoMech3DInfo(RimGeoMechView * geoMechView)
m_visibleCellStatistics->meanCellScalarValues(timeStepIdx, mean);
m_visibleCellStatistics->minMaxCellScalarValues(timeStepIdx, min, max);
m_visibleCellStatistics->p10p90CellScalarValues(timeStepIdx, p10, p90);
m_visibleCellStatistics->sumCellScalarValues(timeStepIdx, sum);
histogram = &(m_visibleCellStatistics->cellScalarValuesHistogram(timeStepIdx));
}
@ -488,10 +498,9 @@ void Rim3dOverlayInfoConfig::updateGeoMech3DInfo(RimGeoMechView * geoMechView)
{
infoText += QString("<br><b>Statistics:</b> ") + m_statisticsTimeRange().uiText() + " and " + m_statisticsCellRange().uiText();
infoText += QString("<table border=0 cellspacing=5 >"
"<tr> <td>Min</td> <td>P10</td> <td>Mean</td> <td>P90</td> <td>Max</td> </tr>"
"<tr> <td>%1</td> <td> %2</td> <td> %3</td> <td> %4</td> <td> %5</td> </tr>"
"</table>").arg(min).arg(p10).arg(mean).arg(p90).arg(max);
"<tr> <td>Min</td> <td>P10</td> <td>Mean</td> <td>P90</td> <td>Max</td> <td>Sum</td> </tr>"
"<tr> <td>%1</td> <td> %2</td> <td> %3</td> <td> %4</td> <td> %5</td> <td> %6</td> </tr>"
"</table>").arg(min).arg(p10).arg(mean).arg(p90).arg(max).arg(sum);
}
}

184
ApplicationCode/ProjectDataModel/RimEclipsePropertyFilter.cpp
View File

@ -69,11 +69,16 @@ RimEclipsePropertyFilter::RimEclipsePropertyFilter()
resultDefinition.uiCapability()->setUiHidden(true);
resultDefinition.uiCapability()->setUiChildrenHidden(true);
CAF_PDM_InitField(&lowerBound, "LowerBound", 0.0, "Min", "", "", "");
lowerBound.uiCapability()->setUiEditorTypeName(caf::PdmUiDoubleSliderEditor::uiEditorTypeName());
CAF_PDM_InitField(&m_lowerBound, "LowerBound", 0.0, "Min", "", "", "");
m_lowerBound.uiCapability()->setUiEditorTypeName(caf::PdmUiDoubleSliderEditor::uiEditorTypeName());
CAF_PDM_InitField(&upperBound, "UpperBound", 0.0, "Max", "", "", "");
upperBound.uiCapability()->setUiEditorTypeName(caf::PdmUiDoubleSliderEditor::uiEditorTypeName());
CAF_PDM_InitField(&m_upperBound, "UpperBound", 0.0, "Max", "", "", "");
m_upperBound.uiCapability()->setUiEditorTypeName(caf::PdmUiDoubleSliderEditor::uiEditorTypeName());
CAF_PDM_InitFieldNoDefault(&m_selectedValues, "SelectedValues", "Values", "", "", "");
CAF_PDM_InitField(&m_valueSelection, "ValueSelection", false, "Value Selection", "", "", "");
m_upperBound.uiCapability()->setUiEditorTypeName(caf::PdmUiDoubleSliderEditor::uiEditorTypeName());
updateIconState();
@ -92,17 +97,50 @@ RimEclipsePropertyFilter::~RimEclipsePropertyFilter()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipsePropertyFilter::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
void RimEclipsePropertyFilter::rangeValues(double* lower, double* upper) const
{
if (&name == changedField)
*lower = this->m_lowerBound;
*upper = this->m_upperBound;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimEclipsePropertyFilter::isValueSelectionActive() const
{
if (resultDefinition->hasCategoryResult() && m_valueSelection)
{
return true;
}
if ( &lowerBound == changedField
|| &upperBound == changedField
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<int> RimEclipsePropertyFilter::selectedValues() const
{
return m_selectedValues;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipsePropertyFilter::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
if (&m_valueSelection == changedField)
{
updateFieldVisibility();
}
if ( &m_lowerBound == changedField
|| &m_upperBound == changedField
|| &obsoleteField_evaluationRegion == changedField
|| &isActive == changedField
|| &filterMode == changedField)
|| &filterMode == changedField
|| &m_selectedValues == changedField
|| &m_valueSelection == changedField)
{
updateFilterName();
this->updateIconState();
@ -129,8 +167,13 @@ void RimEclipsePropertyFilter::setToDefaultValues()
computeResultValueRange();
lowerBound = m_minimumResultValue;
upperBound = m_maximumResultValue;
m_lowerBound = m_minimumResultValue;
m_upperBound = m_maximumResultValue;
m_selectedValues = m_uniqueCellValues;
m_valueSelection = true;
updateFieldVisibility();
}
//--------------------------------------------------------------------------------------------------
@ -148,13 +191,16 @@ void RimEclipsePropertyFilter::defineUiOrdering(QString uiConfigName, caf::PdmUi
group1->add(&(resultDefinition->m_resultVariableUiField));
// Fields declared in RimCellFilter
uiOrdering.add(&isActive);
uiOrdering.add(&filterMode);
uiOrdering.add(&m_valueSelection);
// Fields declared in this class (RimCellPropertyFilter)
uiOrdering.add(&lowerBound);
uiOrdering.add(&upperBound);
uiOrdering.add(&filterMode);
uiOrdering.add(&m_lowerBound);
uiOrdering.add(&m_upperBound);
uiOrdering.add(&m_selectedValues);
uiOrdering.setForgetRemainingFields(true);
updateReadOnlyStateOfAllFields();
}
@ -169,6 +215,27 @@ void RimEclipsePropertyFilter::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTr
updateActiveState();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> RimEclipsePropertyFilter::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly)
{
QList<caf::PdmOptionItemInfo> optionList;
if (&m_selectedValues == fieldNeedingOptions)
{
if (useOptionsOnly) *useOptionsOnly = true;
for (auto it : m_uniqueCellValues)
{
QString str = QString::number(it);
optionList.push_back(caf::PdmOptionItemInfo(str, it));
}
}
return optionList;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -217,6 +284,38 @@ void RimEclipsePropertyFilter::updateActiveState()
isActive.uiCapability()->setUiReadOnly(isPropertyFilterControlled());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipsePropertyFilter::updateFieldVisibility()
{
if (resultDefinition->hasCategoryResult())
{
m_valueSelection.uiCapability()->setUiHidden(false);
if (!m_valueSelection)
{
m_selectedValues.uiCapability()->setUiHidden(true);
m_lowerBound.uiCapability()->setUiHidden(false);
m_upperBound.uiCapability()->setUiHidden(false);
}
else
{
m_selectedValues.uiCapability()->setUiHidden(false);
m_lowerBound.uiCapability()->setUiHidden(true);
m_upperBound.uiCapability()->setUiHidden(true);
}
}
else
{
m_lowerBound.uiCapability()->setUiHidden(false);
m_upperBound.uiCapability()->setUiHidden(false);
m_selectedValues.uiCapability()->setUiHidden(true);
m_valueSelection.uiCapability()->setUiHidden(true);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -227,7 +326,7 @@ void RimEclipsePropertyFilter::defineEditorAttribute(const caf::PdmFieldHandle*
return;
}
if (field == &lowerBound || field == &upperBound)
if (field == &m_lowerBound || field == &m_upperBound)
{
caf::PdmUiDoubleSliderEditorAttribute* myAttr = dynamic_cast<caf::PdmUiDoubleSliderEditorAttribute*>(attribute);
if (!myAttr)
@ -250,6 +349,8 @@ void RimEclipsePropertyFilter::computeResultValueRange()
double min = 0.0;
double max = 0.0;
m_uniqueCellValues.clear();
size_t scalarIndex = resultDefinition->scalarResultIndex();
if (scalarIndex != cvf::UNDEFINED_SIZE_T)
{
@ -257,14 +358,24 @@ void RimEclipsePropertyFilter::computeResultValueRange()
if (results)
{
results->cellResults()->minMaxCellScalarValues(scalarIndex, min, max);
if (resultDefinition->hasCategoryResult())
{
std::set<int> vals = results->cellResults()->uniqueCellScalarValues(scalarIndex);
for (auto val : vals)
{
m_uniqueCellValues.push_back(val);
}
}
}
}
m_maximumResultValue = max;
m_minimumResultValue = min;
lowerBound.uiCapability()->setUiName(QString("Min (%1)").arg(min));
upperBound.uiCapability()->setUiName(QString("Max (%1)").arg(max));
m_lowerBound.uiCapability()->setUiName(QString("Min (%1)").arg(min));
m_upperBound.uiCapability()->setUiName(QString("Max (%1)").arg(max));
}
//--------------------------------------------------------------------------------------------------
@ -272,12 +383,38 @@ void RimEclipsePropertyFilter::computeResultValueRange()
//--------------------------------------------------------------------------------------------------
void RimEclipsePropertyFilter::updateFilterName()
{
QString newFiltername;
newFiltername = resultDefinition->resultVariable() + " ("
+ QString::number(lowerBound()) + " .. " + QString::number(upperBound) + ")";
this->name = newFiltername;
QString newFiltername = resultDefinition->resultVariable() + " (";
uiCapability()->updateConnectedEditors();
if (isValueSelectionActive())
{
if (m_selectedValues().size() == m_uniqueCellValues.size())
{
newFiltername += QString::number(m_selectedValues()[0]);
newFiltername += "..";
newFiltername += QString::number(m_selectedValues()[m_selectedValues().size() - 1]);
}
else
{
for (size_t i = 0; i < m_selectedValues().size(); i++)
{
int val = m_selectedValues()[i];
newFiltername += QString::number(val);
if (i < m_selectedValues().size() - 1)
{
newFiltername += ", ";
}
}
}
newFiltername += ")";
}
else
{
newFiltername += QString::number(m_lowerBound) + " .. " + QString::number(m_upperBound) + ")";
}
this->name = newFiltername;
}
//--------------------------------------------------------------------------------------------------
@ -291,5 +428,6 @@ void RimEclipsePropertyFilter::initAfterRead()
resultDefinition->loadResult();
updateIconState();
computeResultValueRange();
updateFieldVisibility();
}

23
ApplicationCode/ProjectDataModel/RimEclipsePropertyFilter.h
View File

@ -44,10 +44,11 @@ public:
RimEclipsePropertyFilter();
virtual ~RimEclipsePropertyFilter();
caf::PdmChildField<RimEclipseResultDefinition*> resultDefinition;
caf::PdmChildField<RimEclipseResultDefinition*> resultDefinition;
caf::PdmField<double> lowerBound;
caf::PdmField<double> upperBound;
void rangeValues(double* lower, double* upper) const;
bool isValueSelectionActive() const;
std::vector<int> selectedValues() const;
RimEclipsePropertyFilterCollection* parentContainer();
void setToDefaultValues();
@ -57,20 +58,30 @@ public:
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue);
virtual void initAfterRead();
void updateActiveState();
protected:
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering);
virtual void defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName);
virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly);
virtual void defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute);
private:
friend class RimEclipsePropertyFilterCollection;
friend class RicEclipsePropertyFilterFeatureImpl;
void updateActiveState();
void updateFieldVisibility();
void updateReadOnlyStateOfAllFields();
bool isPropertyFilterControlled();
private:
double m_minimumResultValue;
caf::PdmField<double> m_lowerBound;
caf::PdmField<double> m_upperBound;
caf::PdmField< std::vector<int> > m_selectedValues;
caf::PdmField<bool> m_valueSelection;
double m_minimumResultValue;
double m_maximumResultValue;
public:
@ -82,6 +93,6 @@ public:
};
private:
caf::PdmField< caf::AppEnum< EvaluationRegionType > > obsoleteField_evaluationRegion;
std::vector<int> m_uniqueCellValues;
};

10
ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp
View File

@ -424,6 +424,16 @@ bool RimEclipseResultDefinition::isTernarySaturationSelected() const
return isTernary;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimEclipseResultDefinition::hasCategoryResult() const
{
if (!this->hasStaticResult()) return false;
return this->resultVariable().contains("NUM", Qt::CaseInsensitive);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

1
ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.h
View File

@ -58,6 +58,7 @@ public:
bool hasDynamicResult() const;
bool hasResult() const;
bool isTernarySaturationSelected() const;
bool hasCategoryResult() const;
RimReservoirCellResultsStorage* currentGridCellResults() const;

32
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@ -127,6 +127,38 @@ void RigCaseCellResultsData::meanCellScalarValues(size_t scalarResultIndex, size
m_statisticsDataCache[scalarResultIndex]->meanCellScalarValues(timeStepIndex, meanValue);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::set<int>& RigCaseCellResultsData::uniqueCellScalarValues(size_t scalarResultIndex)
{
return m_statisticsDataCache[scalarResultIndex]->uniqueCellScalarValues();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::set<int>& RigCaseCellResultsData::uniqueCellScalarValues(size_t scalarResultIndex, size_t timeStepIndex)
{
return m_statisticsDataCache[scalarResultIndex]->uniqueCellScalarValues(timeStepIndex);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseCellResultsData::sumCellScalarValues(size_t scalarResultIndex, double& sumValue)
{
m_statisticsDataCache[scalarResultIndex]->sumCellScalarValues(sumValue);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseCellResultsData::sumCellScalarValues(size_t scalarResultIndex, size_t timeStepIndex, double& sumValue)
{
m_statisticsDataCache[scalarResultIndex]->sumCellScalarValues(timeStepIndex, sumValue);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

4
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.h
View File

@ -59,6 +59,10 @@ public:
void p10p90CellScalarValues(size_t scalarResultIndex, size_t timeStepIndex, double& p10, double& p90);
void meanCellScalarValues(size_t scalarResultIndex, double& meanValue);
void meanCellScalarValues(size_t scalarResultIndex, size_t timeStepIndex, double& meanValue);
const std::set<int>& uniqueCellScalarValues(size_t scalarResultIndex);
const std::set<int>& uniqueCellScalarValues(size_t scalarResultIndex, size_t timeStepIndex);
void sumCellScalarValues(size_t scalarResultIndex, double& sumValue);
void sumCellScalarValues(size_t scalarResultIndex, size_t timeStepIndex, double& sumValue);
// Access meta-information about the results
size_t resultCount() const;

14
ApplicationCode/ReservoirDataModel/RigEclipseMultiPropertyStatCalc.cpp
View File

@ -97,6 +97,20 @@ void RigEclipseMultiPropertyStatCalc::addDataToHistogramCalculator(size_t timeSt
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseMultiPropertyStatCalc::uniqueValues(size_t timeStepIndex, std::set<int>& values)
{
for (size_t i = 0; i < m_nativeStatisticsCalculators.size(); i++)
{
if (m_nativeStatisticsCalculators.at(i))
{
m_nativeStatisticsCalculators.at(i)->uniqueValues(timeStepIndex, values);
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/ReservoirDataModel/RigEclipseMultiPropertyStatCalc.h
View File

@ -48,6 +48,8 @@ public:
virtual void addDataToHistogramCalculator(size_t timeStepIndex, RigHistogramCalculator& histogramCalculator);
virtual void uniqueValues(size_t timeStepIndex, std::set<int>& values);
virtual size_t timeStepCount();
private:

13
ApplicationCode/ReservoirDataModel/RigEclipseNativeStatCalc.cpp
View File

@ -83,6 +83,19 @@ void RigEclipseNativeStatCalc::addDataToHistogramCalculator(size_t timeStepIndex
histogramCalculator.addData(values);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseNativeStatCalc::uniqueValues(size_t timeStepIndex, std::set<int>& values)
{
std::vector<double>& doubleValues = m_resultsData->cellScalarResults(m_scalarResultIndex, timeStepIndex);
for (size_t cIdx = 0; cIdx < doubleValues.size(); ++cIdx)
{
values.insert(std::floor(doubleValues[cIdx]));
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/ReservoirDataModel/RigEclipseNativeStatCalc.h
View File

@ -43,6 +43,8 @@ public:
virtual void addDataToHistogramCalculator(size_t timeStepIndex, RigHistogramCalculator& histogramCalculator);
virtual void uniqueValues(size_t timeStepIndex, std::set<int>& values);
virtual size_t timeStepCount();
private:

10
ApplicationCode/ReservoirDataModel/RigEclipseNativeVisibleCellsStatCalc.cpp
View File

@ -80,6 +80,16 @@ void RigEclipseNativeVisibleCellsStatCalc::addDataToHistogramCalculator(size_t t
traverseCells(histogramCalculator, timeStepIndex);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseNativeVisibleCellsStatCalc::uniqueValues(size_t timeStepIndex, std::set<int>& values)
{
UniqueValueAccumulator acc;
traverseCells(acc, timeStepIndex);
values = acc.uniqueValues;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

1
ApplicationCode/ReservoirDataModel/RigEclipseNativeVisibleCellsStatCalc.h
View File

@ -43,6 +43,7 @@ public:
virtual void posNegClosestToZero(size_t timeStepIndex, double& pos, double& neg);
virtual void valueSumAndSampleCount(size_t timeStepIndex, double& valueSum, size_t& sampleCount);
virtual void addDataToHistogramCalculator(size_t timeStepIndex, RigHistogramCalculator& histogramCalculator);
virtual void uniqueValues(size_t timeStepIndex, std::set<int>& values);
virtual size_t timeStepCount();
private:

2
ApplicationCode/ResultStatisticsCache/RigStatisticsCalculator.h
View File

@ -45,6 +45,8 @@ public:
void addDataToHistogramCalculator(RigHistogramCalculator& histogramCalculator);
virtual void addDataToHistogramCalculator(size_t timeStepIndex, RigHistogramCalculator& histogramCalculator) = 0;
virtual void uniqueValues(size_t timeStepIndex, std::set<int>& values) = 0;
virtual size_t timeStepCount() = 0;
static void posNegClosestToZero(const std::vector<double>& values, double& pos, double& neg);

97
ApplicationCode/ResultStatisticsCache/RigStatisticsDataCache.cpp
View File

@ -190,6 +190,51 @@ void RigStatisticsDataCache::meanCellScalarValues(size_t timeStepIndex, double&
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigStatisticsDataCache::sumCellScalarValues(double& sumValue)
{
if (!m_statsAllTimesteps.m_isValueSumCalculated)
{
double aggregatedSum = 0.0;
for (size_t i = 0; i < m_statisticsCalculator->timeStepCount(); i++)
{
double valueSum = 0.0;
this->sumCellScalarValues(i, valueSum);
aggregatedSum += valueSum;
}
m_statsAllTimesteps.m_valueSum = aggregatedSum;
m_statsAllTimesteps.m_isValueSumCalculated = true;
}
sumValue = m_statsAllTimesteps.m_valueSum;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigStatisticsDataCache::sumCellScalarValues(size_t timeStepIndex, double& sumValue)
{
if (timeStepIndex >= m_statsPrTs.size())
{
m_statsPrTs.resize(timeStepIndex + 1);
}
if (!m_statsPrTs[timeStepIndex].m_isValueSumCalculated)
{
double valueSum = 0.0;
size_t sampleCount = 0;
m_statisticsCalculator->valueSumAndSampleCount(timeStepIndex, valueSum, sampleCount);
m_statsPrTs[timeStepIndex].m_valueSum = valueSum;
m_statsPrTs[timeStepIndex].m_isValueSumCalculated = true;
}
sumValue = m_statsPrTs[timeStepIndex].m_valueSum;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -210,6 +255,26 @@ const std::vector<size_t>& RigStatisticsDataCache::cellScalarValuesHistogram(siz
return m_statsPrTs[timeStepIndex].m_histogram;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::set<int>& RigStatisticsDataCache::uniqueCellScalarValues()
{
computeUniqueValuesIfNeeded();
return m_statsAllTimesteps.m_uniqueValues;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::set<int>& RigStatisticsDataCache::uniqueCellScalarValues(size_t timeStepIndex)
{
computeUniqueValuesIfNeeded(timeStepIndex);
return m_statsPrTs[timeStepIndex].m_uniqueValues;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -274,3 +339,35 @@ void RigStatisticsDataCache::computeHistogramStatisticsIfNeeded(size_t timeStepI
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigStatisticsDataCache::computeUniqueValuesIfNeeded(size_t timeStepIndex)
{
if (timeStepIndex >= m_statsPrTs.size())
{
m_statsPrTs.resize(timeStepIndex + 1);
}
if (m_statsPrTs[timeStepIndex].m_uniqueValues.size() == 0)
{
m_statisticsCalculator->uniqueValues(timeStepIndex, m_statsPrTs[timeStepIndex].m_uniqueValues);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigStatisticsDataCache::computeUniqueValuesIfNeeded()
{
if (m_statsAllTimesteps.m_uniqueValues.size() == 0)
{
for (size_t tIdx = 0; tIdx < m_statisticsCalculator->timeStepCount(); tIdx++)
{
computeUniqueValuesIfNeeded(tIdx);
m_statsAllTimesteps.m_uniqueValues.insert(m_statsPrTs[tIdx].m_uniqueValues.begin(), m_statsPrTs[tIdx].m_uniqueValues.end());
}
}
}

15
ApplicationCode/ResultStatisticsCache/RigStatisticsDataCache.h
View File

@ -49,13 +49,22 @@ public:
void meanCellScalarValues(double& meanValue);
void meanCellScalarValues(size_t timeStepIndex, double& meanValue);
void sumCellScalarValues(double& sumValue);
void sumCellScalarValues(size_t timeStepIndex, double& sumValue);
const std::vector<size_t>& cellScalarValuesHistogram();
const std::vector<size_t>& cellScalarValuesHistogram(size_t timeStepIndex);
const std::set<int>& uniqueCellScalarValues();
const std::set<int>& uniqueCellScalarValues(size_t timeStepIndex);
private:
void computeHistogramStatisticsIfNeeded();
void computeHistogramStatisticsIfNeeded(size_t timeStepIndex);
void computeUniqueValuesIfNeeded();
void computeUniqueValuesIfNeeded(size_t timeStepIndex);
private:
struct StatisticsValues
{
@ -71,6 +80,8 @@ private:
m_isClosestToZeroCalculated = false;
m_p10 = HUGE_VAL;
m_p90 = HUGE_VAL;
m_valueSum = 0.0;
m_isValueSumCalculated = false;
}
double m_minValue;
@ -87,7 +98,11 @@ private:
double m_p10;
double m_p90;
double m_valueSum;
bool m_isValueSumCalculated;
std::vector<size_t> m_histogram;
std::set<int> m_uniqueValues;
};
StatisticsValues m_statsAllTimesteps;

16
ApplicationCode/ResultStatisticsCache/RigStatisticsMath.h
View File

@ -18,6 +18,7 @@
#pragma once
#include <vector>
#include <set>
#include <cmath>
#include <cstddef>
@ -131,3 +132,18 @@ public:
double valueSum;
size_t sampleCount;
};
class UniqueValueAccumulator
{
public:
UniqueValueAccumulator()
{}
void addValue(double value)
{
uniqueValues.insert(static_cast<int>(value));
}
std::set<int> uniqueValues;
};

6
Fwk/AppFwk/cafProjectDataModel/cafPdmUiCore/cafPdmUiOrdering.cpp
View File

@ -94,7 +94,9 @@ bool PdmUiOrdering::contains(const PdmUiItem* item)
void PdmUiOrdering::add(const PdmFieldHandle* field)
{
PdmUiFieldHandle* uiItem = const_cast<PdmFieldHandle*>(field)->uiCapability();
assert(uiItem);
assert(uiItem);
assert(!this->contains(uiItem));
m_ordering.push_back(uiItem);
}
@ -105,6 +107,8 @@ void PdmUiOrdering::add(const PdmObjectHandle* obj)
{
PdmUiObjectHandle* uiItem = uiObj(const_cast<PdmObjectHandle*>(obj));
assert(uiItem);
assert(!this->contains(uiItem));
m_ordering.push_back(uiItem);
}