Refactor: extract EnsembleParameter into separate file.

ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlot.cpp

@@ -250,9 +250,9 @@ std::set<RifEclipseSummaryAddress> RimAnalysisPlot::unfilteredAddresses()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<EnsembleParameter> RimAnalysisPlot::ensembleParameters()
+std::set<RigEnsembleParameter> RimAnalysisPlot::ensembleParameters()
 {
-    std::set<EnsembleParameter> ensembleParms;
+    std::set<RigEnsembleParameter> ensembleParms;
 
     RiaSummaryCurveDefinitionAnalyser* analyserOfSelectedCurveDefs = getOrCreateSelectedCurveDefAnalyser();
 
@@ -268,7 +268,7 @@ std::set<EnsembleParameter> RimAnalysisPlot::ensembleParameters()
 
     for ( RimSummaryCaseCollection* ensemble : ensembles )
     {
-        std::vector<EnsembleParameter> parameters = ensemble->variationSortedEnsembleParameters();
+        std::vector<RigEnsembleParameter> parameters = ensemble->variationSortedEnsembleParameters();
         ensembleParms.insert( parameters.begin(), parameters.end() );
     }
 
@@ -278,15 +278,15 @@ std::set<EnsembleParameter> RimAnalysisPlot::ensembleParameters()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-EnsembleParameter RimAnalysisPlot::ensembleParameter( const QString& ensembleParameterName )
+RigEnsembleParameter RimAnalysisPlot::ensembleParameter( const QString& ensembleParameterName )
 {
-    std::set<EnsembleParameter> ensembleParms = ensembleParameters();
+    std::set<RigEnsembleParameter> ensembleParms = ensembleParameters();
-    for ( const EnsembleParameter& eParam : ensembleParms )
+    for ( const RigEnsembleParameter& eParam : ensembleParms )
     {
         if ( eParam.name == ensembleParameterName ) return eParam;
     }
 
-    return EnsembleParameter();
+    return RigEnsembleParameter();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1095,7 +1095,7 @@ void RimAnalysisPlot::applyFilter( const RimPlotDataFilterItem*        filter,
         {
             sumItemsToKeep = ( *filteredSummaryItems ); // Not filtering items
 
-            EnsembleParameter eParam = this->ensembleParameter( filter->ensembleParameterName() );
+            RigEnsembleParameter eParam = this->ensembleParameter( filter->ensembleParameterName() );
 
             for ( auto sumCase : ( *filteredSumCases ) )
             {

ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlot.h

@@ -23,6 +23,8 @@
 #include "RimSummaryCaseCollection.h"
 #include "RimTimeStepFilter.h"
 
+#include "RigEnsembleParameter.h"
+
 #include "cafPdmPtrField.h"
 
 #include <QDateTime>
@@ -81,8 +83,8 @@ public:
     void setTimeSteps( const std::vector<time_t>& timeSteps );
 
     std::set<RifEclipseSummaryAddress> unfilteredAddresses();
-    std::set<EnsembleParameter>        ensembleParameters();
+    std::set<RigEnsembleParameter>     ensembleParameters();
-    EnsembleParameter                  ensembleParameter( const QString& ensembleParameterName );
+    RigEnsembleParameter               ensembleParameter( const QString& ensembleParameterName );
 
     void maxMinValueFromAddress( const RifEclipseSummaryAddress&           address,
                                  RimPlotDataFilterItem::TimeStepSourceType timeStepSourceType,

ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimPlotDataFilterItem.cpp

@@ -298,8 +298,8 @@ QList<caf::PdmOptionItemInfo>
     {
         if ( m_filterTarget() == ENSEMBLE_CASE )
         {
-            std::set<EnsembleParameter> ensembleParams = parentPlot->ensembleParameters();
+            std::set<RigEnsembleParameter> ensembleParams = parentPlot->ensembleParameters();
-            for ( const EnsembleParameter& ensParam : ensembleParams )
+            for ( const RigEnsembleParameter& ensParam : ensembleParams )
             {
                 options.push_back( caf::PdmOptionItemInfo( ensParam.uiName(), ensParam.name ) );
             }
@@ -307,7 +307,7 @@ QList<caf::PdmOptionItemInfo>
     }
     else if ( fieldNeedingOptions == &m_ensembleParameterValueCategories )
     {
-        EnsembleParameter eParm = selectedEnsembleParameter();
+        RigEnsembleParameter eParm = selectedEnsembleParameter();
         if ( eParm.isText() )
         {
             for ( const auto& val : eParm.values )
@@ -359,7 +359,7 @@ void RimPlotDataFilterItem::defineUiOrdering( QString uiConfigName, caf::PdmUiOr
         }
     }
 
-    EnsembleParameter eParm;
+    RigEnsembleParameter eParm;
     if ( m_filterTarget() == ENSEMBLE_CASE )
     {
         eParm = selectedEnsembleParameter();
@@ -430,14 +430,14 @@ void RimPlotDataFilterItem::updateMaxMinAndDefaultValues( bool forceDefault )
     {
         if ( !selectedEnsembleParameter().isValid() )
         {
-            std::set<EnsembleParameter> ensembleParams = parentPlot->ensembleParameters();
+            std::set<RigEnsembleParameter> ensembleParams = parentPlot->ensembleParameters();
             if ( !ensembleParams.empty() )
             {
                 m_filterEnsembleParameter = ensembleParams.begin()->name;
             }
         }
 
-        EnsembleParameter eParam = selectedEnsembleParameter();
+        RigEnsembleParameter eParam = selectedEnsembleParameter();
         if ( eParam.isValid() && eParam.isNumeric() )
         {
             if ( RiaCurveDataTools::isValidValue( eParam.minValue, false ) )
@@ -475,7 +475,7 @@ void RimPlotDataFilterItem::updateMaxMinAndDefaultValues( bool forceDefault )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-EnsembleParameter RimPlotDataFilterItem::selectedEnsembleParameter() const
+RigEnsembleParameter RimPlotDataFilterItem::selectedEnsembleParameter() const
 {
     RimAnalysisPlot* parentPlot;
     this->firstAncestorOrThisOfTypeAsserted( parentPlot );

ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimPlotDataFilterItem.h

@@ -26,7 +26,7 @@
 #include "RifEclipseSummaryAddress.h"
 #include "RifEclipseSummaryAddressQMetaType.h"
 
-#include "RimSummaryCaseCollection.h"
+#include "RigEnsembleParameter.h"
 
 #include <QDateTime>
 
@@ -116,7 +116,7 @@ private:
     QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions,
                                                          bool*                      useOptionsOnly ) override;
 
-    EnsembleParameter selectedEnsembleParameter() const;
+    RigEnsembleParameter selectedEnsembleParameter() const;
 
     caf::PdmField<bool> m_isActive;
 

ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimAbstractCorrelationPlot.cpp

@@ -469,15 +469,15 @@ void RimAbstractCorrelationPlot::setCaseFilterDataSource( RimEnsembleCurveSet* e
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<EnsembleParameter> RimAbstractCorrelationPlot::ensembleParameters()
+std::set<RigEnsembleParameter> RimAbstractCorrelationPlot::ensembleParameters()
 {
-    std::set<EnsembleParameter> ensembleParms;
+    std::set<RigEnsembleParameter> ensembleParms;
 
     RiaSummaryCurveDefinitionAnalyser* analyserOfSelectedCurveDefs = getOrCreateSelectedCurveDefAnalyser();
 
     for ( RimSummaryCaseCollection* ensemble : analyserOfSelectedCurveDefs->m_ensembles )
     {
-        std::vector<EnsembleParameter> parameters = ensemble->alphabeticEnsembleParameters();
+        std::vector<RigEnsembleParameter> parameters = ensemble->alphabeticEnsembleParameters();
         ensembleParms.insert( parameters.begin(), parameters.end() );
     }
     return ensembleParms;
@@ -486,15 +486,15 @@ std::set<EnsembleParameter> RimAbstractCorrelationPlot::ensembleParameters()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<EnsembleParameter> RimAbstractCorrelationPlot::variationSortedEnsembleParameters()
+std::set<RigEnsembleParameter> RimAbstractCorrelationPlot::variationSortedEnsembleParameters()
 {
-    std::set<EnsembleParameter> ensembleParms;
+    std::set<RigEnsembleParameter> ensembleParms;
 
     RiaSummaryCurveDefinitionAnalyser* analyserOfSelectedCurveDefs = getOrCreateSelectedCurveDefAnalyser();
 
     for ( RimSummaryCaseCollection* ensemble : analyserOfSelectedCurveDefs->m_ensembles )
     {
-        std::vector<EnsembleParameter> parameters = ensemble->variationSortedEnsembleParameters();
+        std::vector<RigEnsembleParameter> parameters = ensemble->variationSortedEnsembleParameters();
         ensembleParms.insert( parameters.begin(), parameters.end() );
     }
     return ensembleParms;
@@ -503,15 +503,15 @@ std::set<EnsembleParameter> RimAbstractCorrelationPlot::variationSortedEnsembleP
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-EnsembleParameter RimAbstractCorrelationPlot::ensembleParameter( const QString& ensembleParameterName )
+RigEnsembleParameter RimAbstractCorrelationPlot::ensembleParameter( const QString& ensembleParameterName )
 {
-    std::set<EnsembleParameter> ensembleParms = ensembleParameters();
+    std::set<RigEnsembleParameter> ensembleParms = ensembleParameters();
-    for ( const EnsembleParameter& eParam : ensembleParms )
+    for ( const RigEnsembleParameter& eParam : ensembleParms )
     {
         if ( eParam.name == ensembleParameterName ) return eParam;
     }
 
-    return EnsembleParameter();
+    return RigEnsembleParameter();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimAbstractCorrelationPlot.h

@@ -34,7 +34,7 @@ class RimSummaryAddress;
 class RimEnsembleCurveSet;
 class RimSummaryCaseCollection;
 class RimSummaryCase;
-class EnsembleParameter;
+class RigEnsembleParameter;
 class RifEclipseSummaryAddress;
 
 class RimAbstractCorrelationPlot : public RimPlot
@@ -88,9 +88,9 @@ protected:
                                                          bool*                      useOptionsOnly ) override;
 
     std::set<RifEclipseSummaryAddress> addresses();
-    std::set<EnsembleParameter>        ensembleParameters();
+    std::set<RigEnsembleParameter>     ensembleParameters();
-    std::set<EnsembleParameter>        variationSortedEnsembleParameters();
+    std::set<RigEnsembleParameter>     variationSortedEnsembleParameters();
-    EnsembleParameter                  ensembleParameter( const QString& ensembleParameterName );
+    RigEnsembleParameter               ensembleParameter( const QString& ensembleParameterName );
 
     // RimViewWindow overrides
     QWidget* viewWidget() override;

ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimCorrelationMatrixPlot.cpp

@@ -30,6 +30,8 @@
 
 #include "RifSummaryReaderInterface.h"
 
+#include "RigEnsembleParameter.h"
+
 #include "RimDerivedSummaryCase.h"
 #include "RimEnsembleCurveSet.h"
 #include "RimPlotAxisProperties.h"
@@ -221,10 +223,10 @@ RimRegularLegendConfig* RimCorrelationMatrixPlot::legendConfig()
 void RimCorrelationMatrixPlot::selectAllParameters()
 {
     m_selectedParametersList.v().clear();
-    std::set<EnsembleParameter> params = variationSortedEnsembleParameters();
+    std::set<RigEnsembleParameter> params = variationSortedEnsembleParameters();
     for ( auto param : params )
     {
-        if ( !m_excludeParametersWithoutVariation() || param.variationBin > EnsembleParameter::NO_VARIATION )
+        if ( !m_excludeParametersWithoutVariation() || param.variationBin > RigEnsembleParameter::NO_VARIATION )
         {
             m_selectedParametersList.v().push_back( param.name );
         }
@@ -347,10 +349,10 @@ QList<caf::PdmOptionItemInfo>
 
     if ( fieldNeedingOptions == &m_selectedParametersList )
     {
-        std::set<EnsembleParameter> params = variationSortedEnsembleParameters();
+        std::set<RigEnsembleParameter> params = variationSortedEnsembleParameters();
         for ( auto param : params )
         {
-            if ( !m_excludeParametersWithoutVariation() || param.variationBin > EnsembleParameter::NO_VARIATION )
+            if ( !m_excludeParametersWithoutVariation() || param.variationBin > RigEnsembleParameter::NO_VARIATION )
             {
                 options.push_back( caf::PdmOptionItemInfo( param.uiName(), param.name ) );
             }
@@ -522,7 +524,7 @@ void RimCorrelationMatrixPlot::createMatrix()
                 std::vector<double> caseValuesAtTimestep;
                 std::vector<double> parameterValues;
 
-                EnsembleParameter parameter = ensemble->ensembleParameter( paramName );
+                RigEnsembleParameter parameter = ensemble->ensembleParameter( paramName );
 
                 if ( parameter.isValid() )
                 {

ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimCorrelationPlot.cpp

@@ -156,10 +156,10 @@ QList<caf::PdmOptionItemInfo> RimCorrelationPlot::calculateValueOptions( const c
 
     if ( fieldNeedingOptions == &m_selectedParametersList )
     {
-        std::set<EnsembleParameter> params = variationSortedEnsembleParameters();
+        std::set<RigEnsembleParameter> params = variationSortedEnsembleParameters();
         for ( auto param : params )
         {
-            if ( !m_excludeParametersWithoutVariation() || param.variationBin > EnsembleParameter::NO_VARIATION )
+            if ( !m_excludeParametersWithoutVariation() || param.variationBin > RigEnsembleParameter::NO_VARIATION )
             {
                 options.push_back( caf::PdmOptionItemInfo( param.uiName(), param.name ) );
             }
@@ -242,7 +242,7 @@ void RimCorrelationPlot::addDataToChartBuilder( RiuGroupedBarChartBuilder& chart
 
     std::set<RimSummaryCase*> activeCases = filterEnsembleCases( ensemble );
 
-    std::vector<std::pair<EnsembleParameter, double>> correlations =
+    std::vector<std::pair<RigEnsembleParameter, double>> correlations =
         ensemble->parameterCorrelations( address, selectedTimestep, m_selectedParametersList(), activeCases );
 
     for ( auto parameterCorrPair : correlations )
@@ -332,10 +332,10 @@ void RimCorrelationPlot::setSortByAbsoluteValues( bool sortByAbsoluteValues )
 void RimCorrelationPlot::selectAllParameters()
 {
     m_selectedParametersList.v().clear();
-    std::set<EnsembleParameter> params = variationSortedEnsembleParameters();
+    std::set<RigEnsembleParameter> params = variationSortedEnsembleParameters();
     for ( auto param : params )
     {
-        if ( !m_excludeParametersWithoutVariation() || param.variationBin > EnsembleParameter::NO_VARIATION )
+        if ( !m_excludeParametersWithoutVariation() || param.variationBin > RigEnsembleParameter::NO_VARIATION )
         {
             m_selectedParametersList.v().push_back( param.name );
         }

ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimParameterResultCrossPlot.cpp

@@ -26,6 +26,8 @@
 
 #include "RifSummaryReaderInterface.h"
 
+#include "RigEnsembleParameter.h"
+
 #include "RimDerivedSummaryCase.h"
 #include "RimEnsembleCurveSet.h"
 #include "RimMultiPlot.h"
@@ -244,7 +246,7 @@ void RimParameterResultCrossPlot::createPoints()
         int addressIdx = 0;
         for ( auto address : addresses() )
         {
-            EnsembleParameter parameter = ensembleParameter( m_ensembleParameter );
+            RigEnsembleParameter parameter = ensembleParameter( m_ensembleParameter );
             if ( !( parameter.isNumeric() && parameter.isValid() ) ) return;
 
             QStringList caseNames      = caseNamesOfValidEnsembleCases( ensemble );

ApplicationLibCode/ProjectDataModel/Flow/RimWellRftEnsembleCurveSet.cpp

@@ -159,7 +159,7 @@ RimRegularLegendConfig* RimWellRftEnsembleCurveSet::legendConfig()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-EnsembleParameter::Type RimWellRftEnsembleCurveSet::currentEnsembleParameterType() const
+RigEnsembleParameter::Type RimWellRftEnsembleCurveSet::currentEnsembleParameterType() const
 {
     if ( m_ensembleColorMode() == ColorMode::BY_ENSEMBLE_PARAM )
     {
@@ -172,7 +172,7 @@ EnsembleParameter::Type RimWellRftEnsembleCurveSet::currentEnsembleParameterType
             return eParam.type;
         }
     }
-    return EnsembleParameter::TYPE_NONE;
+    return RigEnsembleParameter::TYPE_NONE;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Flow/RimWellRftEnsembleCurveSet.h

@@ -21,6 +21,8 @@
 #include "RimEnsembleCurveSetColorManager.h"
 #include "RimSummaryCaseCollection.h"
 
+#include "RigEnsembleParameter.h"
+
 #include "cafPdmChildField.h"
 #include "cafPdmObject.h"
 #include "cafPdmProxyValueField.h"
@@ -51,9 +53,9 @@ public:
     cvf::Color3f              caseColor( const RimSummaryCase* summaryCase ) const;
     QString                   currentEnsembleParameter() const;
 
-    void                    setEnsembleParameter( const QString& parameterName );
+    void                       setEnsembleParameter( const QString& parameterName );
-    RimRegularLegendConfig* legendConfig();
+    RimRegularLegendConfig*    legendConfig();
-    EnsembleParameter::Type currentEnsembleParameterType() const;
+    RigEnsembleParameter::Type currentEnsembleParameterType() const;
 
 protected:
     void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;

ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleCurveFilter.cpp

@@ -279,7 +279,7 @@ QList<caf::PdmOptionItemInfo>
     {
         auto curveSet = parentCurveSet();
         auto ensemble = curveSet ? curveSet->summaryCaseCollection() : nullptr;
-        auto eParam   = ensemble ? ensemble->ensembleParameter( m_ensembleParameterName ) : EnsembleParameter();
+        auto eParam   = ensemble ? ensemble->ensembleParameter( m_ensembleParameterName ) : RigEnsembleParameter();
 
         if ( eParam.isText() )
         {
@@ -734,9 +734,9 @@ void RimEnsembleCurveFilter::updateMaxMinAndDefaultValues( bool forceDefault )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-EnsembleParameter RimEnsembleCurveFilter::selectedEnsembleParameter() const
+RigEnsembleParameter RimEnsembleCurveFilter::selectedEnsembleParameter() const
 {
     auto curveSet = parentCurveSet();
     auto ensemble = curveSet ? curveSet->summaryCaseCollection() : nullptr;
-    return ensemble ? ensemble->ensembleParameter( m_ensembleParameterName ) : EnsembleParameter();
+    return ensemble ? ensemble->ensembleParameter( m_ensembleParameterName ) : RigEnsembleParameter();
 }

ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleCurveFilter.h

@@ -30,7 +30,7 @@
 #include "cafPdmProxyValueField.h"
 #include "cafPdmPtrField.h"
 
-class EnsembleParameter;
+class RigEnsembleParameter;
 class RimEnsembleCurveSet;
 class RimSummaryCase;
 class RimSummaryAddress;
@@ -80,8 +80,8 @@ public:
 
     std::vector<RimSummaryCase*> applyFilter( const std::vector<RimSummaryCase*>& allSumCases );
 
-    void              loadDataAndUpdate();
+    void                 loadDataAndUpdate();
-    EnsembleParameter selectedEnsembleParameter() const;
+    RigEnsembleParameter selectedEnsembleParameter() const;
 
     RimEnsembleCurveSet* parentCurveSet() const;
 

ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleCurveSet.cpp

@@ -549,7 +549,7 @@ void RimEnsembleCurveSet::setEnsembleParameter( const QString& parameterName )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-EnsembleParameter::Type RimEnsembleCurveSet::currentEnsembleParameterType() const
+RigEnsembleParameter::Type RimEnsembleCurveSet::currentEnsembleParameterType() const
 {
     if ( m_colorMode() == ColorMode::BY_ENSEMBLE_PARAM )
     {
@@ -562,7 +562,7 @@ EnsembleParameter::Type RimEnsembleCurveSet::currentEnsembleParameterType() cons
             return eParam.type;
         }
     }
-    return EnsembleParameter::TYPE_NONE;
+    return RigEnsembleParameter::TYPE_NONE;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1838,7 +1838,7 @@ void RimEnsembleCurveSet::updateAllTextInPlot()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<EnsembleParameter> RimEnsembleCurveSet::variationSortedEnsembleParameters() const
+std::vector<RigEnsembleParameter> RimEnsembleCurveSet::variationSortedEnsembleParameters() const
 {
     RimSummaryCaseCollection* ensemble = m_yValuesSummaryCaseCollection;
     if ( ensemble )
@@ -1847,14 +1847,14 @@ std::vector<EnsembleParameter> RimEnsembleCurveSet::variationSortedEnsembleParam
     }
     else
     {
-        return std::vector<EnsembleParameter>();
+        return std::vector<RigEnsembleParameter>();
     }
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<std::pair<EnsembleParameter, double>> RimEnsembleCurveSet::correlationSortedEnsembleParameters() const
+std::vector<std::pair<RigEnsembleParameter, double>> RimEnsembleCurveSet::correlationSortedEnsembleParameters() const
 {
     RimSummaryCaseCollection* ensemble = m_yValuesSummaryCaseCollection;
     if ( ensemble )
@@ -1863,7 +1863,7 @@ std::vector<std::pair<EnsembleParameter, double>> RimEnsembleCurveSet::correlati
     }
     else
     {
-        return std::vector<std::pair<EnsembleParameter, double>>();
+        return std::vector<std::pair<RigEnsembleParameter, double>>();
     }
 }
 
@@ -2014,12 +2014,12 @@ void RimEnsembleCurveSet::updateLegendMappingMode()
 {
     switch ( currentEnsembleParameterType() )
     {
-        case EnsembleParameter::TYPE_TEXT:
+        case RigEnsembleParameter::TYPE_TEXT:
             if ( m_legendConfig->mappingMode() != RimRegularLegendConfig::MappingType::CATEGORY_INTEGER )
                 m_legendConfig->setMappingMode( RimRegularLegendConfig::MappingType::CATEGORY_INTEGER );
             break;
 
-        case EnsembleParameter::TYPE_NUMERIC:
+        case RigEnsembleParameter::TYPE_NUMERIC:
             if ( m_legendConfig->mappingMode() == RimRegularLegendConfig::MappingType::CATEGORY_INTEGER )
                 m_legendConfig->setMappingMode( RimRegularLegendConfig::MappingType::LINEAR_CONTINUOUS );
             break;

ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleCurveSet.h

@@ -32,6 +32,8 @@
 #include "RimSummaryCaseCollection.h"
 #include "RimTimeStepFilter.h"
 
+#include "RigEnsembleParameter.h"
+
 #include "cafAppEnum.h"
 #include "cafPdmChildArrayField.h"
 #include "cafPdmChildField.h"
@@ -114,10 +116,10 @@ public:
 
     RimEnsembleCurveFilterCollection* filterCollection() const;
 
-    ColorMode               colorMode() const;
+    ColorMode                  colorMode() const;
-    void                    setColorMode( ColorMode mode );
+    void                       setColorMode( ColorMode mode );
-    void                    setEnsembleParameter( const QString& parameterName );
+    void                       setEnsembleParameter( const QString& parameterName );
-    EnsembleParameter::Type currentEnsembleParameterType() const;
+    RigEnsembleParameter::Type currentEnsembleParameterType() const;
 
     RimRegularLegendConfig* legendConfig();
 
@@ -132,10 +134,10 @@ public:
     RimEnsembleCurveSet* clone() const;
     void                 showCurves( bool show );
 
-    void                           updateAllTextInPlot();
+    void                              updateAllTextInPlot();
-    std::vector<EnsembleParameter> variationSortedEnsembleParameters() const;
+    std::vector<RigEnsembleParameter> variationSortedEnsembleParameters() const;
 
-    std::vector<std::pair<EnsembleParameter, double>> correlationSortedEnsembleParameters() const;
+    std::vector<std::pair<RigEnsembleParameter, double>> correlationSortedEnsembleParameters() const;
 
     std::vector<RimSummaryCase*> filterEnsembleCases( const std::vector<RimSummaryCase*>& sumCases );
     void                         disableStatisticCurves();

ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleCurveSetColorManager.cpp

@@ -95,8 +95,8 @@ RimRegularLegendConfig::ColorRangesType RimEnsembleCurveSetColorManager::cycledE
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimEnsembleCurveSetColorManager::initializeLegendConfig( RimRegularLegendConfig*  legendConfig,
+void RimEnsembleCurveSetColorManager::initializeLegendConfig( RimRegularLegendConfig*     legendConfig,
-                                                              const EnsembleParameter& ensembleParam )
+                                                              const RigEnsembleParameter& ensembleParam )
 {
     if ( ensembleParam.isText() )
     {
@@ -170,7 +170,7 @@ void RimEnsembleCurveSetColorManager::initializeLegendConfig( RimRegularLegendCo
 //--------------------------------------------------------------------------------------------------
 cvf::Color3f RimEnsembleCurveSetColorManager::caseColor( const RimRegularLegendConfig* legendConfig,
                                                          const RimSummaryCase*         summaryCase,
-                                                         const EnsembleParameter&      ensembleParam )
+                                                         const RigEnsembleParameter&   ensembleParam )
 {
     if ( ensembleParam.isText() )
     {

ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleCurveSetColorManager.h

@@ -23,6 +23,8 @@
 #include "RimRegularLegendConfig.h"
 #include "RimSummaryCaseCollection.h"
 
+#include "RigEnsembleParameter.h"
+
 #include "cafPdmPointer.h"
 
 #include <map>
@@ -58,7 +60,7 @@ public:
         return m_ensembleColorRanges.find( colorRange ) != m_ensembleColorRanges.end();
     }
 
-    static void initializeLegendConfig( RimRegularLegendConfig* legendConfig, const EnsembleParameter& parameter );
+    static void initializeLegendConfig( RimRegularLegendConfig* legendConfig, const RigEnsembleParameter& parameter );
     static void initializeLegendConfig( RimRegularLegendConfig*                      legendConfig,
                                         RimObjectiveFunction*                        objectiveFunction,
                                         const std::vector<RimSummaryCase*>&          summaryCases,
@@ -70,7 +72,7 @@ public:
 
     static cvf::Color3f caseColor( const RimRegularLegendConfig* legendConfig,
                                    const RimSummaryCase*         summaryCase,
-                                   const EnsembleParameter&      parameter );
+                                   const RigEnsembleParameter&   parameter );
 
     static cvf::Color3f caseColor( const RimRegularLegendConfig*         legendConfig,
                                    RimSummaryCase*                       summaryCase,

ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCaseCollection.cpp

@@ -49,64 +49,7 @@ CAF_PDM_SOURCE_INIT( RimSummaryCaseCollection, "SummaryCaseSubCollection" );
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double EnsembleParameter::stdDeviation() const
+void RimSummaryCaseCollection::sortByBinnedVariation( std::vector<RigEnsembleParameter>& parameterVector )
-{
-    double N = static_cast<double>( values.size() );
-    if ( N > 1 && isNumeric() )
-    {
-        double sumValues        = 0.0;
-        double sumValuesSquared = 0.0;
-        for ( const QVariant& variant : values )
-        {
-            double value = variant.toDouble();
-            sumValues += value;
-            sumValuesSquared += value * value;
-        }
-
-        return std::sqrt( ( N * sumValuesSquared - sumValues * sumValues ) / ( N * ( N - 1.0 ) ) );
-    }
-    return 0.0;
-}
-
-//--------------------------------------------------------------------------------------------------
-/// Standard deviation normalized by max absolute value of min/max values.
-/// Produces values between 0.0 and sqrt(2.0).
-//--------------------------------------------------------------------------------------------------
-double EnsembleParameter::normalizedStdDeviation() const
-{
-    const double eps = 1.0e-4;
-
-    double maxAbs = std::max( std::fabs( maxValue ), std::fabs( minValue ) );
-    if ( maxAbs < eps )
-    {
-        return 0.0;
-    }
-
-    double normalisedStdDev = stdDeviation() / maxAbs;
-    if ( normalisedStdDev < eps )
-    {
-        return 0.0;
-    }
-    return normalisedStdDev;
-}
-
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-bool EnsembleParameter::operator<( const EnsembleParameter& other ) const
-{
-    if ( this->variationBin != other.variationBin )
-    {
-        return this->variationBin > other.variationBin; // Larger first
-    }
-
-    return this->name < other.name;
-}
-
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-void RimSummaryCaseCollection::sortByBinnedVariation( std::vector<EnsembleParameter>& parameterVector )
 {
     double minStdDev = std::numeric_limits<double>::infinity();
     double maxStdDev = 0.0;
@@ -124,16 +67,16 @@ void RimSummaryCaseCollection::sortByBinnedVariation( std::vector<EnsembleParame
         return;
     }
 
-    double delta = ( maxStdDev - minStdDev ) / EnsembleParameter::NR_OF_VARIATION_BINS;
+    double delta = ( maxStdDev - minStdDev ) / RigEnsembleParameter::NR_OF_VARIATION_BINS;
 
     std::vector<double> bins;
     bins.push_back( 0.0 );
-    for ( int i = 0; i < EnsembleParameter::NR_OF_VARIATION_BINS - 1; ++i )
+    for ( int i = 0; i < RigEnsembleParameter::NR_OF_VARIATION_BINS - 1; ++i )
     {
         bins.push_back( minStdDev + ( i + 1 ) * delta );
     }
 
-    for ( EnsembleParameter& nameParamPair : parameterVector )
+    for ( RigEnsembleParameter& nameParamPair : parameterVector )
     {
         int binNumber = -1;
         for ( double bin : bins )
@@ -150,40 +93,11 @@ void RimSummaryCaseCollection::sortByBinnedVariation( std::vector<EnsembleParame
     // index
     std::stable_sort( parameterVector.begin(),
                       parameterVector.end(),
-                      [&bins]( const EnsembleParameter& lhs, const EnsembleParameter& rhs ) {
+                      [&bins]( const RigEnsembleParameter& lhs, const RigEnsembleParameter& rhs ) {
                           return lhs.variationBin > rhs.variationBin;
                       } );
 }
 
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-QString EnsembleParameter::uiName() const
-{
-    QString stem = name;
-    QString variationString;
-    if ( isNumeric() )
-    {
-        switch ( variationBin )
-        {
-            case NO_VARIATION:
-                variationString = QString( " (No variation)" );
-                break;
-            case LOW_VARIATION:
-                variationString = QString( " (Low variation)" );
-                break;
-            case MEDIUM_VARIATION:
-                variationString = QString( " (Medium variation)" );
-                break;
-            case HIGH_VARIATION:
-                variationString = QString( " (High variation)" );
-                break;
-        }
-    }
-
-    return QString( "%1%2" ).arg( stem ).arg( variationString );
-}
-
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -448,7 +362,7 @@ RifReaderRftInterface* RimSummaryCaseCollection::rftStatisticsReader()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<EnsembleParameter> RimSummaryCaseCollection::variationSortedEnsembleParameters( bool excludeNoVariation ) const
+std::vector<RigEnsembleParameter> RimSummaryCaseCollection::variationSortedEnsembleParameters( bool excludeNoVariation ) const
 {
     if ( m_cachedSortedEnsembleParameters.empty() )
     {
@@ -480,8 +394,8 @@ std::vector<EnsembleParameter> RimSummaryCaseCollection::variationSortedEnsemble
     }
     else
     {
-        const double                   epsilon = 1e-9;
+        const double                      epsilon = 1e-9;
-        std::vector<EnsembleParameter> parametersWithVariation;
+        std::vector<RigEnsembleParameter> parametersWithVariation;
         for ( const auto& p : m_cachedSortedEnsembleParameters )
         {
             if ( std::abs( p.normalizedStdDeviation() ) > epsilon )
@@ -496,13 +410,13 @@ std::vector<EnsembleParameter> RimSummaryCaseCollection::variationSortedEnsemble
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<std::pair<EnsembleParameter, double>>
+std::vector<std::pair<RigEnsembleParameter, double>>
     RimSummaryCaseCollection::correlationSortedEnsembleParameters( const RifEclipseSummaryAddress& address ) const
 {
     auto parameters = parameterCorrelationsAllTimeSteps( address );
     std::sort( parameters.begin(),
                parameters.end(),
-               []( const std::pair<EnsembleParameter, double>& lhs, const std::pair<EnsembleParameter, double>& rhs ) {
+               []( const std::pair<RigEnsembleParameter, double>& lhs, const std::pair<RigEnsembleParameter, double>& rhs ) {
                    return std::abs( lhs.second ) > std::abs( rhs.second );
                } );
     return parameters;
@@ -511,14 +425,14 @@ std::vector<std::pair<EnsembleParameter, double>>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<std::pair<EnsembleParameter, double>>
+std::vector<std::pair<RigEnsembleParameter, double>>
     RimSummaryCaseCollection::correlationSortedEnsembleParameters( const RifEclipseSummaryAddress& address,
                                                                    time_t selectedTimeStep ) const
 {
     auto parameters = parameterCorrelations( address, selectedTimeStep );
     std::sort( parameters.begin(),
                parameters.end(),
-               []( const std::pair<EnsembleParameter, double>& lhs, const std::pair<EnsembleParameter, double>& rhs ) {
+               []( const std::pair<RigEnsembleParameter, double>& lhs, const std::pair<RigEnsembleParameter, double>& rhs ) {
                    return std::abs( lhs.second ) > std::abs( rhs.second );
                } );
     return parameters;
@@ -536,7 +450,7 @@ time_t timeDiff( time_t lhs, time_t rhs )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<std::pair<EnsembleParameter, double>>
+std::vector<std::pair<RigEnsembleParameter, double>>
     RimSummaryCaseCollection::parameterCorrelations( const RifEclipseSummaryAddress&  address,
                                                      time_t                           timeStep,
                                                      const std::vector<QString>&      selectedParameters,
@@ -548,7 +462,7 @@ std::vector<std::pair<EnsembleParameter, double>>
     {
         parameters.erase( std::remove_if( parameters.begin(),
                                           parameters.end(),
-                                          [&selectedParameters]( const EnsembleParameter& parameter ) {
+                                          [&selectedParameters]( const RigEnsembleParameter& parameter ) {
                                               return std::find( selectedParameters.begin(),
                                                                 selectedParameters.end(),
                                                                 parameter.name ) == selectedParameters.end();
@@ -556,8 +470,8 @@ std::vector<std::pair<EnsembleParameter, double>>
                           parameters.end() );
     }
 
-    std::vector<double>                              caseValuesAtTimestep;
+    std::vector<double>                                 caseValuesAtTimestep;
-    std::map<EnsembleParameter, std::vector<double>> parameterValues;
+    std::map<RigEnsembleParameter, std::vector<double>> parameterValues;
 
     for ( size_t caseIdx = 0u; caseIdx < m_cases.size(); ++caseIdx )
     {
@@ -600,7 +514,7 @@ std::vector<std::pair<EnsembleParameter, double>>
         }
     }
 
-    std::vector<std::pair<EnsembleParameter, double>> correlationResults;
+    std::vector<std::pair<RigEnsembleParameter, double>> correlationResults;
     for ( auto parameterValuesPair : parameterValues )
     {
         double correlation = 0.0;
@@ -614,7 +528,7 @@ std::vector<std::pair<EnsembleParameter, double>>
 //--------------------------------------------------------------------------------------------------
 /// Returns a vector of the parameters and the average absolute values of correlations per time step
 //--------------------------------------------------------------------------------------------------
-std::vector<std::pair<EnsembleParameter, double>>
+std::vector<std::pair<RigEnsembleParameter, double>>
     RimSummaryCaseCollection::parameterCorrelationsAllTimeSteps( const RifEclipseSummaryAddress& address,
                                                                  const std::vector<QString>& selectedParameters ) const
 {
@@ -625,11 +539,11 @@ std::vector<std::pair<EnsembleParameter, double>>
     std::vector<time_t> timeStepsVector( timeSteps.begin(), timeSteps.end() );
     size_t              stride = std::max( (size_t)1, timeStepsVector.size() / maxTimeStepCount );
 
-    std::vector<std::vector<std::pair<EnsembleParameter, double>>> correlationsForChosenTimeSteps;
+    std::vector<std::vector<std::pair<RigEnsembleParameter, double>>> correlationsForChosenTimeSteps;
 
     for ( size_t i = stride; i < timeStepsVector.size(); i += stride )
     {
-        std::vector<std::pair<EnsembleParameter, double>> correlationsForTimeStep =
+        std::vector<std::pair<RigEnsembleParameter, double>> correlationsForTimeStep =
             parameterCorrelations( address, timeStepsVector[i], selectedParameters );
         correlationsForChosenTimeSteps.push_back( correlationsForTimeStep );
     }
@@ -652,7 +566,7 @@ std::vector<std::pair<EnsembleParameter, double>>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<EnsembleParameter> RimSummaryCaseCollection::alphabeticEnsembleParameters() const
+std::vector<RigEnsembleParameter> RimSummaryCaseCollection::alphabeticEnsembleParameters() const
 {
     std::set<QString> paramSet;
     for ( RimSummaryCase* rimCase : this->allSummaryCases() )
@@ -667,7 +581,7 @@ std::vector<EnsembleParameter> RimSummaryCaseCollection::alphabeticEnsembleParam
         }
     }
 
-    std::vector<EnsembleParameter> sortedEnsembleParameters;
+    std::vector<RigEnsembleParameter> sortedEnsembleParameters;
     sortedEnsembleParameters.reserve( paramSet.size() );
     for ( const QString& parameterName : paramSet )
     {
@@ -679,23 +593,23 @@ std::vector<EnsembleParameter> RimSummaryCaseCollection::alphabeticEnsembleParam
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-EnsembleParameter RimSummaryCaseCollection::ensembleParameter( const QString& paramName ) const
+RigEnsembleParameter RimSummaryCaseCollection::ensembleParameter( const QString& paramName ) const
 {
-    if ( !isEnsemble() || paramName.isEmpty() ) return EnsembleParameter();
+    if ( !isEnsemble() || paramName.isEmpty() ) return RigEnsembleParameter();
 
-    const std::vector<EnsembleParameter>& ensembleParams = variationSortedEnsembleParameters();
+    const std::vector<RigEnsembleParameter>& ensembleParams = variationSortedEnsembleParameters();
 
-    for ( const EnsembleParameter& ensParam : ensembleParams )
+    for ( const RigEnsembleParameter& ensParam : ensembleParams )
     {
         if ( ensParam.name == paramName ) return ensParam;
     }
 
-    return EnsembleParameter();
+    return RigEnsembleParameter();
 }
 
-EnsembleParameter RimSummaryCaseCollection::createEnsembleParameter( const QString& paramName ) const
+RigEnsembleParameter RimSummaryCaseCollection::createEnsembleParameter( const QString& paramName ) const
 {
-    EnsembleParameter eParam;
+    RigEnsembleParameter eParam;
     eParam.name = paramName;
 
     size_t numericValuesCount = 0;
@@ -734,11 +648,11 @@ EnsembleParameter RimSummaryCaseCollection::createEnsembleParameter( const QStri
 
     if ( numericValuesCount && !textValuesCount )
     {
-        eParam.type = EnsembleParameter::TYPE_NUMERIC;
+        eParam.type = RigEnsembleParameter::TYPE_NUMERIC;
     }
     else if ( textValuesCount && !numericValuesCount )
     {
-        eParam.type = EnsembleParameter::TYPE_TEXT;
+        eParam.type = RigEnsembleParameter::TYPE_TEXT;
     }
     if ( numericValuesCount && textValuesCount )
     {
@@ -753,7 +667,7 @@ EnsembleParameter RimSummaryCaseCollection::createEnsembleParameter( const QStri
                     val.setValue( std::numeric_limits<double>::infinity() );
                 }
             }
-            eParam.type = EnsembleParameter::TYPE_NUMERIC;
+            eParam.type = RigEnsembleParameter::TYPE_NUMERIC;
         }
         else
         {
@@ -765,7 +679,7 @@ EnsembleParameter RimSummaryCaseCollection::createEnsembleParameter( const QStri
                     val.setValue( QString::number( val.value<double>() ) );
                 }
             }
-            eParam.type     = EnsembleParameter::TYPE_TEXT;
+            eParam.type     = RigEnsembleParameter::TYPE_TEXT;
             eParam.minValue = std::numeric_limits<double>::infinity();
             eParam.maxValue = -std::numeric_limits<double>::infinity();
         }

ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCaseCollection.h

@@ -23,6 +23,8 @@
 #include "RifEclipseSummaryAddress.h"
 #include "RifReaderEnsembleStatisticsRft.h"
 
+#include "RigEnsembleParameter.h"
+
 #include "RimObjectiveFunction.h"
 
 #include "cafPdmChildArrayField.h"
@@ -39,53 +41,6 @@ class RifReaderRftInterface;
 class RifReaderEnsembleStatisticsRft;
 class RimSummaryCase;
 
-//==================================================================================================
-///
-//==================================================================================================
-class EnsembleParameter
-{
-public:
-    enum Type
-    {
-        TYPE_NONE,
-        TYPE_NUMERIC,
-        TYPE_TEXT
-    };
-    enum Bins
-    {
-        NO_VARIATION  = -1,
-        LOW_VARIATION = 0,
-        MEDIUM_VARIATION,
-        HIGH_VARIATION,
-        NR_OF_VARIATION_BINS
-    };
-    QString               uiName() const;
-    QString               name;
-    Type                  type;
-    std::vector<QVariant> values;
-    double                minValue;
-    double                maxValue;
-    int                   variationBin;
-
-    EnsembleParameter()
-        : type( TYPE_NONE )
-        , minValue( std::numeric_limits<double>::infinity() )
-        , maxValue( -std::numeric_limits<double>::infinity() )
-        , variationBin( static_cast<int>( MEDIUM_VARIATION ) )
-    {
-    }
-
-    bool   isValid() const { return !name.isEmpty() && type != TYPE_NONE; }
-    bool   isNumeric() const { return type == TYPE_NUMERIC; }
-    bool   isText() const { return type == TYPE_TEXT; }
-    double normalizedStdDeviation() const;
-
-    bool operator<( const EnsembleParameter& other ) const;
-
-private:
-    double stdDeviation() const;
-};
-
 //==================================================================================================
 ///
 //==================================================================================================
@@ -117,26 +72,26 @@ public:
     int                                        ensembleId() const;
     bool                                       hasEnsembleParameters() const;
 
-    std::vector<EnsembleParameter> variationSortedEnsembleParameters( bool excludeNoVariation = false ) const;
+    std::vector<RigEnsembleParameter> variationSortedEnsembleParameters( bool excludeNoVariation = false ) const;
-    std::vector<std::pair<EnsembleParameter, double>>
+    std::vector<std::pair<RigEnsembleParameter, double>>
         correlationSortedEnsembleParameters( const RifEclipseSummaryAddress& address ) const;
-    std::vector<std::pair<EnsembleParameter, double>>
+    std::vector<std::pair<RigEnsembleParameter, double>>
         correlationSortedEnsembleParameters( const RifEclipseSummaryAddress& address, time_t selectedTimeStep ) const;
-    std::vector<std::pair<EnsembleParameter, double>>
+    std::vector<std::pair<RigEnsembleParameter, double>>
         parameterCorrelations( const RifEclipseSummaryAddress&  address,
                                time_t                           selectedTimeStep,
                                const std::vector<QString>&      selectedParameters = {},
                                const std::set<RimSummaryCase*>& selectedCases      = {} ) const;
 
-    std::vector<std::pair<EnsembleParameter, double>>
+    std::vector<std::pair<RigEnsembleParameter, double>>
         parameterCorrelationsAllTimeSteps( const RifEclipseSummaryAddress& address,
                                            const std::vector<QString>&     selectedParameters = {} ) const;
 
-    std::vector<EnsembleParameter> alphabeticEnsembleParameters() const;
+    std::vector<RigEnsembleParameter> alphabeticEnsembleParameters() const;
 
-    EnsembleParameter ensembleParameter( const QString& paramName ) const;
+    RigEnsembleParameter ensembleParameter( const QString& paramName ) const;
-    void              calculateEnsembleParametersIntersectionHash();
+    void                 calculateEnsembleParametersIntersectionHash();
-    void              clearEnsembleParametersHashes();
+    void                 clearEnsembleParametersHashes();
 
     void loadDataAndUpdate();
 
@@ -146,8 +101,8 @@ public:
     RiaDefines::EclipseUnitSystem unitSystem() const;
 
 private:
-    EnsembleParameter createEnsembleParameter( const QString& paramName ) const;
+    RigEnsembleParameter createEnsembleParameter( const QString& paramName ) const;
-    static void       sortByBinnedVariation( std::vector<EnsembleParameter>& parameterVector );
+    static void          sortByBinnedVariation( std::vector<RigEnsembleParameter>& parameterVector );
     friend class RimSummaryCaseCollection_TESTER;
 
     caf::PdmFieldHandle* userDescriptionField() override;
@@ -177,5 +132,5 @@ private:
 
     size_t m_commonAddressCount; // if different address count among cases, set to 0
 
-    mutable std::vector<EnsembleParameter> m_cachedSortedEnsembleParameters;
+    mutable std::vector<RigEnsembleParameter> m_cachedSortedEnsembleParameters;
 };

ApplicationLibCode/ReservoirDataModel/CMakeLists_files.cmake

@@ -88,6 +88,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RigTracerPoint.h
 ${CMAKE_CURRENT_LIST_DIR}/RigTracer.h
 ${CMAKE_CURRENT_LIST_DIR}/RigStimPlanModelTools.h
 ${CMAKE_CURRENT_LIST_DIR}/RigSlice2D.h
+${CMAKE_CURRENT_LIST_DIR}/RigEnsembleParameter.h
 )
 
 
@@ -173,6 +174,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RigTracerPoint.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigTracer.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigStimPlanModelTools.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigSlice2D.cpp
+${CMAKE_CURRENT_LIST_DIR}/RigEnsembleParameter.cpp
 )
 
 list(APPEND CODE_HEADER_FILES

ApplicationLibCode/ReservoirDataModel/RigEnsembleParameter.cpp

@@ -0,0 +1,108 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2017-     Statoil ASA
+//
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+//
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RigEnsembleParameter.h"
+
+#include <algorithm>
+#include <cmath>
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RigEnsembleParameter::stdDeviation() const
+{
+    double N = static_cast<double>( values.size() );
+    if ( N > 1 && isNumeric() )
+    {
+        double sumValues        = 0.0;
+        double sumValuesSquared = 0.0;
+        for ( const QVariant& variant : values )
+        {
+            double value = variant.toDouble();
+            sumValues += value;
+            sumValuesSquared += value * value;
+        }
+
+        return std::sqrt( ( N * sumValuesSquared - sumValues * sumValues ) / ( N * ( N - 1.0 ) ) );
+    }
+    return 0.0;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// Standard deviation normalized by max absolute value of min/max values.
+/// Produces values between 0.0 and sqrt(2.0).
+//--------------------------------------------------------------------------------------------------
+double RigEnsembleParameter::normalizedStdDeviation() const
+{
+    const double eps = 1.0e-4;
+
+    double maxAbs = std::max( std::fabs( maxValue ), std::fabs( minValue ) );
+    if ( maxAbs < eps )
+    {
+        return 0.0;
+    }
+
+    double normalisedStdDev = stdDeviation() / maxAbs;
+    if ( normalisedStdDev < eps )
+    {
+        return 0.0;
+    }
+    return normalisedStdDev;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RigEnsembleParameter::operator<( const RigEnsembleParameter& other ) const
+{
+    if ( this->variationBin != other.variationBin )
+    {
+        return this->variationBin > other.variationBin; // Larger first
+    }
+
+    return this->name < other.name;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+QString RigEnsembleParameter::uiName() const
+{
+    QString stem = name;
+    QString variationString;
+    if ( isNumeric() )
+    {
+        switch ( variationBin )
+        {
+            case NO_VARIATION:
+                variationString = QString( " (No variation)" );
+                break;
+            case LOW_VARIATION:
+                variationString = QString( " (Low variation)" );
+                break;
+            case MEDIUM_VARIATION:
+                variationString = QString( " (Medium variation)" );
+                break;
+            case HIGH_VARIATION:
+                variationString = QString( " (High variation)" );
+                break;
+        }
+    }
+
+    return QString( "%1%2" ).arg( stem ).arg( variationString );
+}

ApplicationLibCode/ReservoirDataModel/RigEnsembleParameter.h

@@ -0,0 +1,74 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016-     Statoil ASA
+//
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+//
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "RiaDefines.h"
+
+#include <QString>
+#include <QVariant>
+
+#include <utility>
+#include <vector>
+
+//==================================================================================================
+///
+//==================================================================================================
+class RigEnsembleParameter
+{
+public:
+    enum Type
+    {
+        TYPE_NONE,
+        TYPE_NUMERIC,
+        TYPE_TEXT
+    };
+    enum Bins
+    {
+        NO_VARIATION  = -1,
+        LOW_VARIATION = 0,
+        MEDIUM_VARIATION,
+        HIGH_VARIATION,
+        NR_OF_VARIATION_BINS
+    };
+    QString               uiName() const;
+    QString               name;
+    Type                  type;
+    std::vector<QVariant> values;
+    double                minValue;
+    double                maxValue;
+    int                   variationBin;
+
+    RigEnsembleParameter()
+        : type( TYPE_NONE )
+        , minValue( std::numeric_limits<double>::infinity() )
+        , maxValue( -std::numeric_limits<double>::infinity() )
+        , variationBin( static_cast<int>( MEDIUM_VARIATION ) )
+    {
+    }
+
+    bool   isValid() const { return !name.isEmpty() && type != TYPE_NONE; }
+    bool   isNumeric() const { return type == TYPE_NUMERIC; }
+    bool   isText() const { return type == TYPE_TEXT; }
+    double normalizedStdDeviation() const;
+
+    bool operator<( const RigEnsembleParameter& other ) const;
+
+private:
+    double stdDeviation() const;
+};

ApplicationLibCode/UnitTests/RimSummaryCaseCollection-Test.cpp

@@ -1,5 +1,6 @@
 #include "gtest/gtest.h"
 
+#include "RigEnsembleParameter.h"
 #include "RimSummaryCaseCollection.h"
 
 #include <random>
@@ -12,7 +13,7 @@ public:
     static void test1();
 };
 
-TEST( RimSummaryCaseCollection, EnsembleParameter )
+TEST( RimSummaryCaseCollection, RigEnsembleParameter )
 {
     RimSummaryCaseCollection_TESTER::test1();
 }
@@ -26,11 +27,11 @@ void RimSummaryCaseCollection_TESTER::test1()
     std::uniform_int_distribution<size_t>  countDistribution( 1u, 1000u );
     size_t                                 N = 1000;
 
-    std::vector<EnsembleParameter> parameters;
+    std::vector<RigEnsembleParameter> parameters;
     for ( size_t i = 0; i < N; ++i )
     {
-        EnsembleParameter param;
+        RigEnsembleParameter param;
-        param.type = EnsembleParameter::TYPE_NUMERIC;
+        param.type = RigEnsembleParameter::TYPE_NUMERIC;
 
         size_t valueCount = countDistribution( gen );
 
@@ -77,18 +78,18 @@ void RimSummaryCaseCollection_TESTER::test1()
     size_t currentSize = parameters.size();
     EXPECT_EQ( previousSize, currentSize );
 
-    int currentVariation = (int)EnsembleParameter::HIGH_VARIATION;
+    int currentVariation = (int)RigEnsembleParameter::HIGH_VARIATION;
-    for ( const EnsembleParameter& nameParamPair : parameters )
+    for ( const RigEnsembleParameter& nameParamPair : parameters )
     {
         if ( nameParamPair.normalizedStdDeviation() == 0.0 )
         {
-            EXPECT_EQ( nameParamPair.variationBin, (int)EnsembleParameter::NO_VARIATION );
+            EXPECT_EQ( nameParamPair.variationBin, (int)RigEnsembleParameter::NO_VARIATION );
         }
         else
         {
-            EXPECT_GE( nameParamPair.variationBin, (int)EnsembleParameter::LOW_VARIATION );
+            EXPECT_GE( nameParamPair.variationBin, (int)RigEnsembleParameter::LOW_VARIATION );
         }
-        EXPECT_LE( nameParamPair.variationBin, (int)EnsembleParameter::HIGH_VARIATION );
+        EXPECT_LE( nameParamPair.variationBin, (int)RigEnsembleParameter::HIGH_VARIATION );
         EXPECT_LE( nameParamPair.variationBin, currentVariation );
         currentVariation = nameParamPair.variationBin;
     }

ApplicationLibCode/UserInterface/RiuSummaryQwtPlot.cpp

@@ -318,12 +318,12 @@ void RiuSummaryQwtPlot::contextMenuEvent( QContextMenuEvent* event )
                             {
                                 menuBuilder.subMenuStart( "Cross Plots",
                                                           *caf::IconProvider( ":/CorrelationCrossPlot16x16.png" ).icon() );
-                                std::vector<std::pair<EnsembleParameter, double>> ensembleParameters =
+                                std::vector<std::pair<RigEnsembleParameter, double>> ensembleParameters =
                                     ensemble->parameterCorrelations( clickedEnsembleCurveSet->summaryAddress(), timeStep );
                                 std::sort( ensembleParameters.begin(),
                                            ensembleParameters.end(),
-                                           []( const std::pair<EnsembleParameter, double>& lhs,
+                                           []( const std::pair<RigEnsembleParameter, double>& lhs,
-                                               const std::pair<EnsembleParameter, double>& rhs ) {
+                                               const std::pair<RigEnsembleParameter, double>& rhs ) {
                                                return std::fabs( lhs.second ) > std::fabs( rhs.second );
                                            } );