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

#5706 Refactored EnsembleParameter usage.

Browse Source 
Cache the list in SummaryCaseCollection
Removed the name, EnsembleParameter pair usage
Add operator< to be able to insert them in a set
This commit is contained in:
Jacob Støren
2020-03-20 11:22:14 +01:00
parent 1c57f7682f
commit 0accbfdd0d
10 changed files with 157 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveFilter.cpp
View File

@@ -139,11 +139,10 @@ QList<caf::PdmOptionItemInfo>
auto curveSet = parentCurveSet();
if ( curveSet )
{
auto nameParameterPairs = curveSet->ensembleParameters();
for ( auto& nameParamPair : nameParameterPairs )
auto ensParms = curveSet->variationSortedEnsembleParameters();
for ( auto& ensParm : ensParms )
{
options.push_back(
caf::PdmOptionItemInfo( EnsembleParameter::uiName( nameParamPair ), nameParamPair.first ) );
options.push_back( caf::PdmOptionItemInfo( ensParm.uiName(), ensParm.name ) );
}
}
}
@@ -357,10 +356,10 @@ void RimEnsembleCurveFilter::setInitialValues( bool forceDefault )
{
if ( !selectedEnsembleParameter().isValid() )
{
auto parameterNames = parentCurveSet()->ensembleParameters();
if ( !parameterNames.empty() )
auto ensParams = parentCurveSet()->variationSortedEnsembleParameters();
if ( !ensParams.empty() )
{
m_ensembleParameterName = parameterNames.front().first;
m_ensembleParameterName = ensParams.front().name;
updateConnectedEditors();
}
}

37
ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSet.cpp
View File

@@ -538,8 +538,8 @@ void RimEnsembleCurveSet::fieldChangedByUi( const caf::PdmFieldHandle* changedFi
{
if ( m_ensembleParameter().isEmpty() )
{
auto params = ensembleParameters();
m_ensembleParameter = !params.empty() ? params.front().first : "";
auto params = variationSortedEnsembleParameters();
m_ensembleParameter = !params.empty() ? params.front().name : "";
}
updateCurveColors();
@@ -766,16 +766,16 @@ QList<caf::PdmOptionItemInfo> RimEnsembleCurveSet::calculateValueOptions( const
auto byEnsParamOption = ColorModeEnum( ColorMode::BY_ENSEMBLE_PARAM );
options.push_back( caf::PdmOptionItemInfo( singleColorOption.uiText(), ColorMode::SINGLE_COLOR ) );
if ( !ensembleParameters().empty() )
if ( !variationSortedEnsembleParameters().empty() )
{
options.push_back( caf::PdmOptionItemInfo( byEnsParamOption.uiText(), ColorMode::BY_ENSEMBLE_PARAM ) );
}
}
else if ( fieldNeedingOptions == &m_ensembleParameter )
{
for ( const auto& paramPair : ensembleParameters() )
for ( const auto& param : variationSortedEnsembleParameters() )
{
options.push_back( caf::PdmOptionItemInfo( EnsembleParameter::uiName( paramPair ), paramPair.first ) );
options.push_back( caf::PdmOptionItemInfo( param.uiName(), param.name ) );
}
}
else if ( fieldNeedingOptions == &m_yValuesSummaryAddressUiField )
@@ -1114,32 +1114,17 @@ void RimEnsembleCurveSet::updateAllTextInPlot()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimEnsembleCurveSet::NameParameterPair> RimEnsembleCurveSet::ensembleParameters() const
std::vector<EnsembleParameter> RimEnsembleCurveSet::variationSortedEnsembleParameters() const
{
RimSummaryCaseCollection* group = m_yValuesSummaryCaseCollection;
std::set<QString> paramSet;
if ( group )
RimSummaryCaseCollection* ensemble = m_yValuesSummaryCaseCollection;
if ( ensemble )
{
for ( RimSummaryCase* rimCase : group->allSummaryCases() )
{
if ( rimCase->caseRealizationParameters() != nullptr )
{
auto ps = rimCase->caseRealizationParameters()->parameters();
for ( auto p : ps )
paramSet.insert( p.first );
}
}
return ensemble->variationSortedEnsembleParameters();
}
std::vector<NameParameterPair> parameterVector;
parameterVector.reserve( paramSet.size() );
for ( const QString& parameterName : paramSet )
else
{
parameterVector.push_back( std::make_pair( parameterName, group->ensembleParameter( parameterName ) ) );
return std::vector<EnsembleParameter>();
}
EnsembleParameter::sortByBinnedVariation( parameterVector );
return parameterVector;
}
//--------------------------------------------------------------------------------------------------

4
ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSet.h
View File

@@ -70,8 +70,6 @@ public:
using ColorMode = RimEnsembleCurveSetColorManager::ColorMode;
using ColorModeEnum = RimEnsembleCurveSetColorManager::ColorModeEnum;
using NameParameterPair = EnsembleParameter::NameParameterPair;
public:
RimEnsembleCurveSet();
~RimEnsembleCurveSet() override;
@@ -120,7 +118,7 @@ public:
void markCachedDataForPurge();
void updateAllTextInPlot();
std::vector<NameParameterPair> ensembleParameters() const;
std::vector<EnsembleParameter> variationSortedEnsembleParameters() const;
std::vector<RimSummaryCase*> filterEnsembleCases( const std::vector<RimSummaryCase*>& sumCases );
void disableStatisticCurves();

3
ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSetColorManager.h
View File

@@ -39,8 +39,7 @@ public:
SINGLE_COLOR,
BY_ENSEMBLE_PARAM
};
using ColorModeEnum = caf::AppEnum<ColorMode>;
using NameParameterPair = EnsembleParameter::NameParameterPair;
using ColorModeEnum = caf::AppEnum<ColorMode>;
public:
static const std::map<RimRegularLegendConfig::ColorRangesType, cvf::Color3ubArray>& EnsembleColorRanges();

88
ApplicationCode/ProjectDataModel/Summary/RimSummaryCaseCollection.cpp
View File

@@ -85,60 +85,73 @@ double EnsembleParameter::normalizedStdDeviation() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void EnsembleParameter::sortByBinnedVariation( std::vector<NameParameterPair>& parameterVector )
bool EnsembleParameter::operator<( const EnsembleParameter& other ) const
{
if ( this->variationBin != other.variationBin )
{
return this->variationBin < other.variationBin;
}
return this->name < other.name;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCaseCollection::sortByBinnedVariation( std::vector<EnsembleParameter>& parameterVector )
{
double minStdDev = std::numeric_limits<double>::infinity();
double maxStdDev = 0.0;
for ( const auto& paramPair : parameterVector )
{
minStdDev = std::min( minStdDev, paramPair.second.normalizedStdDeviation() );
maxStdDev = std::max( maxStdDev, paramPair.second.normalizedStdDeviation() );
minStdDev = std::min( minStdDev, paramPair.normalizedStdDeviation() );
maxStdDev = std::max( maxStdDev, paramPair.normalizedStdDeviation() );
}
if ( ( maxStdDev - minStdDev ) < 1.0e-8 )
{
return;
}
double delta = ( maxStdDev - minStdDev ) / NR_OF_VARIATION_BINS;
double delta = ( maxStdDev - minStdDev ) / EnsembleParameter::NR_OF_VARIATION_BINS;
std::vector<double> bins;
for ( int i = 0; i < NR_OF_VARIATION_BINS - 1; ++i )
for ( int i = 0; i < EnsembleParameter::NR_OF_VARIATION_BINS - 1; ++i )
{
bins.push_back( minStdDev + ( i + 1 ) * delta );
}
for ( NameParameterPair& nameParamPair : parameterVector )
for ( EnsembleParameter& nameParamPair : parameterVector )
{
int binNumber = 0;
for ( double bin : bins )
{
if ( nameParamPair.second.normalizedStdDeviation() >= bin )
if ( nameParamPair.normalizedStdDeviation() >= bin )
{
binNumber++;
}
}
nameParamPair.second.variationBin = binNumber;
nameParamPair.variationBin = binNumber;
}
// Sort by variation bin (highest first) but keep name as sorting parameter when parameters have the same variation
// index
std::stable_sort( parameterVector.begin(),
parameterVector.end(),
[&bins]( const NameParameterPair& lhs, const NameParameterPair& rhs ) {
return lhs.second.variationBin > rhs.second.variationBin;
[&bins]( const EnsembleParameter& lhs, const EnsembleParameter& rhs ) {
return lhs.variationBin > rhs.variationBin;
} );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString EnsembleParameter::uiName( const NameParameterPair& paramPair )
QString EnsembleParameter::uiName() const
{
QString stem = paramPair.first;
QString stem = name;
QString variationString;
if ( paramPair.second.isNumeric() )
if ( isNumeric() )
{
switch ( paramPair.second.variationBin )
switch ( variationBin )
{
case LOW_VARIATION:
variationString = QString( " (Low variation)" );
@@ -149,6 +162,7 @@ QString EnsembleParameter::uiName( const NameParameterPair& paramPair )
break;
}
}
return QString( "%1%2" ).arg( stem ).arg( variationString );
}
@@ -192,6 +206,9 @@ void RimSummaryCaseCollection::removeCase( RimSummaryCase* summaryCase )
{
size_t caseCountBeforeRemove = m_cases.size();
m_cases.removeChildObject( summaryCase );
m_cachedSortedEnsembleParameters.clear();
updateReferringCurveSets();
if ( m_isEnsemble && m_cases.size() != caseCountBeforeRemove )
@@ -207,6 +224,7 @@ void RimSummaryCaseCollection::removeCase( RimSummaryCase* summaryCase )
void RimSummaryCaseCollection::addCase( RimSummaryCase* summaryCase, bool updateCurveSets )
{
m_cases.push_back( summaryCase );
m_cachedSortedEnsembleParameters.clear();
// Update derived ensemble cases (if any)
std::vector<RimDerivedEnsembleCaseCollection*> referringObjects;
@@ -355,6 +373,36 @@ RifReaderRftInterface* RimSummaryCaseCollection::rftStatisticsReader()
return m_statisticsEclipseRftReader.p();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<EnsembleParameter>& RimSummaryCaseCollection::variationSortedEnsembleParameters() const
{
if ( m_cachedSortedEnsembleParameters.size() ) return m_cachedSortedEnsembleParameters;
std::set<QString> paramSet;
for ( RimSummaryCase* rimCase : this->allSummaryCases() )
{
if ( rimCase->caseRealizationParameters() != nullptr )
{
auto ps = rimCase->caseRealizationParameters()->parameters();
for ( auto p : ps )
{
paramSet.insert( p.first );
}
}
}
m_cachedSortedEnsembleParameters.reserve( paramSet.size() );
for ( const QString& parameterName : paramSet )
{
m_cachedSortedEnsembleParameters.push_back( this->createEnsembleParameter( parameterName ) );
}
RimSummaryCaseCollection::sortByBinnedVariation( m_cachedSortedEnsembleParameters );
return m_cachedSortedEnsembleParameters;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -362,6 +410,18 @@ EnsembleParameter RimSummaryCaseCollection::ensembleParameter( const QString& pa
{
if ( !isEnsemble() || paramName.isEmpty() ) return EnsembleParameter();
const std::vector<EnsembleParameter>& ensembleParams = variationSortedEnsembleParameters();
for ( const EnsembleParameter& ensParam : ensembleParams )
{
if ( ensParam.name == paramName ) return ensParam;
}
return EnsembleParameter();
}
EnsembleParameter RimSummaryCaseCollection::createEnsembleParameter( const QString& paramName ) const
{
EnsembleParameter eParam;
eParam.name = paramName;

22
ApplicationCode/ProjectDataModel/Summary/RimSummaryCaseCollection.h
View File

@@ -43,8 +43,6 @@ class RimSummaryCase;
class EnsembleParameter
{
public:
typedef std::pair<QString, EnsembleParameter> NameParameterPair;
enum Type
{
TYPE_NONE,
@@ -58,6 +56,7 @@ public:
HIGH_VARIATION,
NR_OF_VARIATION_BINS
};
QString uiName() const;
QString name;
Type type;
std::vector<QVariant> values;
@@ -78,9 +77,7 @@ public:
bool isText() const { return type == TYPE_TEXT; }
double normalizedStdDeviation() const;
static void sortByBinnedVariation( std::vector<NameParameterPair>& parameterVector );
static QString uiName( const NameParameterPair& paramPair );
bool operator<( const EnsembleParameter& other ) const;
private:
double stdDeviation() const;
@@ -109,6 +106,8 @@ public:
std::set<QDateTime> rftTimeStepsForWell( const QString& wellName ) const;
RifReaderRftInterface* rftStatisticsReader();
const std::vector<EnsembleParameter>& variationSortedEnsembleParameters() const;
EnsembleParameter ensembleParameter( const QString& paramName ) const;
void calculateEnsembleParametersIntersectionHash();
void clearEnsembleParametersHashes();
@@ -121,6 +120,10 @@ public:
RiaEclipseUnitTools::UnitSystem unitSystem() const;
private:
EnsembleParameter createEnsembleParameter( const QString& paramName ) const;
static void sortByBinnedVariation( std::vector<EnsembleParameter>& parameterVector );
friend class RimSummaryCaseCollection_TESTER;
caf::PdmFieldHandle* userDescriptionField() override;
QString nameAndItemCount() const;
void updateIcon();
@@ -137,10 +140,13 @@ protected:
caf::PdmChildArrayField<RimSummaryCase*> m_cases;
private:
caf::PdmField<QString> m_name;
caf::PdmProxyValueField<QString> m_nameAndItemCount;
caf::PdmField<bool> m_isEnsemble;
caf::PdmField<QString> m_name;
caf::PdmProxyValueField<QString> m_nameAndItemCount;
caf::PdmField<bool> m_isEnsemble;
cvf::ref<RifReaderEnsembleStatisticsRft> m_statisticsEclipseRftReader;
size_t m_commonAddressCount; // if different address count among cases, set to 0
mutable std::vector<EnsembleParameter> m_cachedSortedEnsembleParameters;
};