Convert to enum class

ApplicationCode/Application/RiaConsoleApplication.cpp

@@ -104,7 +104,7 @@ void RiaConsoleApplication::initialize()
     RiaApplication::initialize();
 
     RiaLogging::setLoggerInstance( new RiaStdOutLogger );
-    RiaLogging::loggerInstance()->setLevel( RI_LL_DEBUG );
+    RiaLogging::loggerInstance()->setLevel( int( RILogLevel::RI_LL_DEBUG ) );
 
     m_socketServer = new RiaSocketServer( this );
 }

ApplicationCode/Application/RiaEclipseFileNameTools.cpp

@@ -25,14 +25,14 @@ namespace caf
 template <>
 void caf::AppEnum<RiaEclipseFileNameTools::EclipseFileType>::setUp()
 {
-    addItem( RiaEclipseFileNameTools::ECLIPSE_DATA, "DATA", "Data Deck" );
+    addItem( RiaEclipseFileNameTools::EclipseFileType::ECLIPSE_DATA, "DATA", "Data Deck" );
-    addItem( RiaEclipseFileNameTools::ECLIPSE_GRID, "GRID", "Grid" );
+    addItem( RiaEclipseFileNameTools::EclipseFileType::ECLIPSE_GRID, "GRID", "Grid" );
-    addItem( RiaEclipseFileNameTools::ECLIPSE_EGRID, "EGRID", "Grid" );
+    addItem( RiaEclipseFileNameTools::EclipseFileType::ECLIPSE_EGRID, "EGRID", "Grid" );
-    addItem( RiaEclipseFileNameTools::ECLIPSE_UNRST, "UNRST", "Unified Restart" );
+    addItem( RiaEclipseFileNameTools::EclipseFileType::ECLIPSE_UNRST, "UNRST", "Unified Restart" );
-    addItem( RiaEclipseFileNameTools::ECLIPSE_SMSPEC, "SMSPEC", "Summary Specification" );
+    addItem( RiaEclipseFileNameTools::EclipseFileType::ECLIPSE_SMSPEC, "SMSPEC", "Summary Specification" );
-    addItem( RiaEclipseFileNameTools::ECLIPSE_UNSMRY, "UNSMR", "Summary Vectors" );
+    addItem( RiaEclipseFileNameTools::EclipseFileType::ECLIPSE_UNSMRY, "UNSMR", "Summary Vectors" );
 
-    addItem( RiaEclipseFileNameTools::RESINSIGHT_PROJECT, "rsp", "ResInsight Project" );
+    addItem( RiaEclipseFileNameTools::EclipseFileType::RESINSIGHT_PROJECT, "rsp", "ResInsight Project" );
 }
 
 } // End namespace caf
@@ -52,7 +52,7 @@ RiaEclipseFileNameTools::RiaEclipseFileNameTools( const QString& inputFilePath )
 //--------------------------------------------------------------------------------------------------
 QString RiaEclipseFileNameTools::findRelatedSummarySpecFile()
 {
-    return relatedFilePath( ECLIPSE_SMSPEC );
+    return relatedFilePath( EclipseFileType::ECLIPSE_SMSPEC );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -60,13 +60,13 @@ QString RiaEclipseFileNameTools::findRelatedSummarySpecFile()
 //--------------------------------------------------------------------------------------------------
 QString RiaEclipseFileNameTools::findRelatedGridFile()
 {
-    QString candidate = relatedFilePath( ECLIPSE_EGRID );
+    QString candidate = relatedFilePath( EclipseFileType::ECLIPSE_EGRID );
     if ( !candidate.isEmpty() )
     {
         return candidate;
     }
 
-    return relatedFilePath( ECLIPSE_GRID );
+    return relatedFilePath( EclipseFileType::ECLIPSE_GRID );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -74,7 +74,7 @@ QString RiaEclipseFileNameTools::findRelatedGridFile()
 //--------------------------------------------------------------------------------------------------
 QString RiaEclipseFileNameTools::findRelatedDataFile()
 {
-    return relatedFilePath( ECLIPSE_DATA );
+    return relatedFilePath( EclipseFileType::ECLIPSE_DATA );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -82,7 +82,7 @@ QString RiaEclipseFileNameTools::findRelatedDataFile()
 //--------------------------------------------------------------------------------------------------
 bool RiaEclipseFileNameTools::isProjectFile( const QString& fileName )
 {
-    return hasMatchingSuffix( fileName, RESINSIGHT_PROJECT );
+    return hasMatchingSuffix( fileName, EclipseFileType::RESINSIGHT_PROJECT );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -90,12 +90,12 @@ bool RiaEclipseFileNameTools::isProjectFile( const QString& fileName )
 //--------------------------------------------------------------------------------------------------
 bool RiaEclipseFileNameTools::isGridFile( const QString& fileName )
 {
-    if ( hasMatchingSuffix( fileName, ECLIPSE_EGRID ) )
+    if ( hasMatchingSuffix( fileName, EclipseFileType::ECLIPSE_EGRID ) )
     {
         return true;
     }
 
-    return hasMatchingSuffix( fileName, ECLIPSE_GRID );
+    return hasMatchingSuffix( fileName, EclipseFileType::ECLIPSE_GRID );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -103,7 +103,7 @@ bool RiaEclipseFileNameTools::isGridFile( const QString& fileName )
 //--------------------------------------------------------------------------------------------------
 bool RiaEclipseFileNameTools::isSummarySpecFile( const QString& fileName )
 {
-    return hasMatchingSuffix( fileName, ECLIPSE_SMSPEC );
+    return hasMatchingSuffix( fileName, EclipseFileType::ECLIPSE_SMSPEC );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/Application/RiaEclipseFileNameTools.h

@@ -30,7 +30,7 @@
 class RiaEclipseFileNameTools
 {
 public:
-    enum EclipseFileType
+    enum class EclipseFileType
     {
         ECLIPSE_DATA,
         ECLIPSE_GRID,

ApplicationCode/Application/RiaFractureDefines.cpp

@@ -33,9 +33,9 @@ QString RiaDefines::unitStringConductivity( RiaEclipseUnitTools::UnitSystem unit
 {
     switch ( unitSystem )
     {
-        case RiaEclipseUnitTools::UNITS_METRIC:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_METRIC:
             return "md-m";
-        case RiaEclipseUnitTools::UNITS_FIELD:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_FIELD:
             return "md-ft";
         default:
             return "";
@@ -49,11 +49,11 @@ double RiaDefines::nonDarcyFlowAlpha( RiaEclipseUnitTools::UnitSystem unitSystem
 {
     switch ( unitSystem )
     {
-        case RiaEclipseUnitTools::UNITS_METRIC:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_METRIC:
             return 2.24460e-10;
-        case RiaEclipseUnitTools::UNITS_FIELD:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_FIELD:
             return 6.83352e-8;
-        case RiaEclipseUnitTools::UNITS_LAB:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_LAB:
             return 5.41375E-11;
             // case RiaEclipseUnitTools::PVT_METRIC:  return 2.25533E-10;
 

ApplicationCode/Application/RiaGuiApplication.cpp

@@ -429,7 +429,7 @@ void RiaGuiApplication::initialize()
         logger->addMessagePanel( m_mainWindow->messagePanel() );
         logger->addMessagePanel( m_mainPlotWindow->messagePanel() );
         RiaLogging::setLoggerInstance( logger );
-        RiaLogging::loggerInstance()->setLevel( RI_LL_DEBUG );
+        RiaLogging::loggerInstance()->setLevel( int( RILogLevel::RI_LL_DEBUG ) );
     }
     m_socketServer = new RiaSocketServer( this );
 }
@@ -497,7 +497,7 @@ RiaApplication::ApplicationStatus RiaGuiApplication::handleArguments( cvf::Progr
         // This is useful when executing regression tests on a build server, and this is the reason for creating the
         // logger when parsing the command line options
         auto stdLogger = new RiaStdOutLogger;
-        stdLogger->setLevel( RI_LL_DEBUG );
+        stdLogger->setLevel( int( RILogLevel::RI_LL_DEBUG ) );
 
         RiaLogging::setLoggerInstance( stdLogger );
 

ApplicationCode/Application/RiaMain.cpp

@@ -53,7 +53,7 @@ int main( int argc, char* argv[] )
         return 1;
     }
 #endif
-    RiaLogging::loggerInstance()->setLevel( RI_LL_DEBUG );
+    RiaLogging::loggerInstance()->setLevel( int( RILogLevel::RI_LL_DEBUG ) );
 
     std::unique_ptr<RiaApplication> app( createApplication( argc, argv ) );
 

ApplicationCode/Application/RiaPreferences.cpp

@@ -45,19 +45,19 @@ namespace caf
 template <>
 void RiaPreferences::SummaryRestartFilesImportModeType::setUp()
 {
-    addItem( RiaPreferences::IMPORT, "IMPORT", "Unified" );
+    addItem( RiaPreferences::SummaryRestartFilesImportMode::IMPORT, "IMPORT", "Unified" );
-    addItem( RiaPreferences::SEPARATE_CASES, "SEPARATE_CASES", "Separate Cases" );
+    addItem( RiaPreferences::SummaryRestartFilesImportMode::SEPARATE_CASES, "SEPARATE_CASES", "Separate Cases" );
-    addItem( RiaPreferences::NOT_IMPORT, "NOT_IMPORT", "Skip" );
+    addItem( RiaPreferences::SummaryRestartFilesImportMode::NOT_IMPORT, "NOT_IMPORT", "Skip" );
-    setDefault( RiaPreferences::IMPORT );
+    setDefault( RiaPreferences::SummaryRestartFilesImportMode::IMPORT );
 }
 
 template <>
 void RiaPreferences::SummaryHistoryCurveStyleModeType::setUp()
 {
-    addItem( RiaPreferences::SYMBOLS, "SYMBOLS", "Symbols" );
+    addItem( RiaPreferences::SummaryHistoryCurveStyleMode::SYMBOLS, "SYMBOLS", "Symbols" );
-    addItem( RiaPreferences::LINES, "LINES", "Lines" );
+    addItem( RiaPreferences::SummaryHistoryCurveStyleMode::LINES, "LINES", "Lines" );
-    addItem( RiaPreferences::SYMBOLS_AND_LINES, "SYMBOLS_AND_LINES", "Symbols and Lines" );
+    addItem( RiaPreferences::SummaryHistoryCurveStyleMode::SYMBOLS_AND_LINES, "SYMBOLS_AND_LINES", "Symbols and Lines" );
-    setDefault( RiaPreferences::SYMBOLS );
+    setDefault( RiaPreferences::SummaryHistoryCurveStyleMode::SYMBOLS );
 }
 
 template <>
@@ -258,21 +258,21 @@ RiaPreferences::RiaPreferences( void )
                                 "" );
     CAF_PDM_InitField( &summaryImportMode,
                        "summaryImportMode",
-                       SummaryRestartFilesImportModeType( RiaPreferences::IMPORT ),
+                       SummaryRestartFilesImportModeType( RiaPreferences::SummaryRestartFilesImportMode::IMPORT ),
                        "Default Summary Import Option",
                        "",
                        "",
                        "" );
     CAF_PDM_InitField( &gridImportMode,
                        "gridImportMode",
-                       SummaryRestartFilesImportModeType( RiaPreferences::NOT_IMPORT ),
+                       SummaryRestartFilesImportModeType( RiaPreferences::SummaryRestartFilesImportMode::NOT_IMPORT ),
                        "Default Grid Import Option",
                        "",
                        "",
                        "" );
     CAF_PDM_InitField( &summaryEnsembleImportMode,
                        "summaryEnsembleImportMode",
-                       SummaryRestartFilesImportModeType( RiaPreferences::IMPORT ),
+                       SummaryRestartFilesImportModeType( RiaPreferences::SummaryRestartFilesImportMode::IMPORT ),
                        "Default Ensemble Summary Import Option",
                        "",
                        "",
@@ -280,7 +280,7 @@ RiaPreferences::RiaPreferences( void )
 
     CAF_PDM_InitField( &defaultSummaryHistoryCurveStyle,
                        "defaultSummaryHistoryCurveStyle",
-                       SummaryHistoryCurveStyleModeType( RiaPreferences::SYMBOLS ),
+                       SummaryHistoryCurveStyleModeType( RiaPreferences::SummaryHistoryCurveStyleMode::SYMBOLS ),
                        "Default Curve Style for History Vectors",
                        "",
                        "",
@@ -613,20 +613,24 @@ QList<caf::PdmOptionItemInfo> RiaPreferences::calculateValueOptions( const caf::
     if ( fieldNeedingOptions == &gridImportMode )
     {
         // Manual option handling in order to one only a subset of the enum values
-        SummaryRestartFilesImportModeType skip( RiaPreferences::NOT_IMPORT );
+        SummaryRestartFilesImportModeType skip( RiaPreferences::SummaryRestartFilesImportMode::NOT_IMPORT );
-        SummaryRestartFilesImportModeType separate( RiaPreferences::SEPARATE_CASES );
+        SummaryRestartFilesImportModeType separate( RiaPreferences::SummaryRestartFilesImportMode::SEPARATE_CASES );
 
-        options.push_back( caf::PdmOptionItemInfo( skip.uiText(), RiaPreferences::NOT_IMPORT ) );
+        options.push_back(
-        options.push_back( caf::PdmOptionItemInfo( separate.uiText(), RiaPreferences::SEPARATE_CASES ) );
+            caf::PdmOptionItemInfo( skip.uiText(), RiaPreferences::SummaryRestartFilesImportMode::NOT_IMPORT ) );
+        options.push_back( caf::PdmOptionItemInfo( separate.uiText(),
+                                                   RiaPreferences::SummaryRestartFilesImportMode::SEPARATE_CASES ) );
     }
     else if ( fieldNeedingOptions == &summaryEnsembleImportMode )
     {
         // Manual option handling in order to one only a subset of the enum values
-        SummaryRestartFilesImportModeType skip( RiaPreferences::NOT_IMPORT );
+        SummaryRestartFilesImportModeType skip( RiaPreferences::SummaryRestartFilesImportMode::NOT_IMPORT );
-        SummaryRestartFilesImportModeType allowImport( RiaPreferences::IMPORT );
+        SummaryRestartFilesImportModeType allowImport( RiaPreferences::SummaryRestartFilesImportMode::IMPORT );
 
-        options.push_back( caf::PdmOptionItemInfo( skip.uiText(), RiaPreferences::NOT_IMPORT ) );
+        options.push_back(
-        options.push_back( caf::PdmOptionItemInfo( allowImport.uiText(), RiaPreferences::IMPORT ) );
+            caf::PdmOptionItemInfo( skip.uiText(), RiaPreferences::SummaryRestartFilesImportMode::NOT_IMPORT ) );
+        options.push_back(
+            caf::PdmOptionItemInfo( allowImport.uiText(), RiaPreferences::SummaryRestartFilesImportMode::IMPORT ) );
     }
     else if ( fieldNeedingOptions == &m_dateFormat )
     {
@@ -646,7 +650,8 @@ QList<caf::PdmOptionItemInfo> RiaPreferences::calculateValueOptions( const caf::
         {
             QTime   exampleTime = QTime( 15, 48, 22 );
             QString timeFormatString =
-                RiaQDateTimeTools::timeFormatString( timeFormat, RiaQDateTimeTools::TIME_FORMAT_HOUR_MINUTE_SECOND );
+                RiaQDateTimeTools::timeFormatString( timeFormat,
+                                                     RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_HOUR_MINUTE_SECOND );
             QString uiText = QString( "%1 (%2)" ).arg( timeFormatString ).arg( exampleTime.toString( timeFormatString ) );
             uiText.replace( "AP", "AM/PM" );
             options.push_back( caf::PdmOptionItemInfo( uiText, QVariant::fromValue( timeFormat ) ) );

ApplicationCode/Application/RiaPreferences.h

@@ -50,7 +50,7 @@ class RiaPreferences : public caf::PdmObject
     CAF_PDM_HEADER_INIT;
 
 public:
-    enum SummaryRestartFilesImportMode
+    enum class SummaryRestartFilesImportMode
     {
         IMPORT,
         NOT_IMPORT,
@@ -59,7 +59,7 @@ public:
     typedef caf::AppEnum<SummaryRestartFilesImportMode> SummaryRestartFilesImportModeType;
     typedef RiaFontCache::FontSizeType                  FontSizeType;
 
-    enum SummaryHistoryCurveStyleMode
+    enum class SummaryHistoryCurveStyleMode
     {
         SYMBOLS,
         LINES,

ApplicationCode/Application/Tools/RiaCurveDataTools.h

@@ -36,7 +36,7 @@ class RiaCurveDataTools
 public:
     typedef std::vector<std::pair<size_t, size_t>> CurveIntervals;
 
-    enum ErrorAxis
+    enum class ErrorAxis
     {
         ERROR_ALONG_X_AXIS,
         ERROR_ALONG_Y_AXIS

ApplicationCode/Application/Tools/RiaEclipseUnitTools.cpp

@@ -28,11 +28,11 @@ namespace caf
 template <>
 void RiaEclipseUnitTools::UnitSystemType::setUp()
 {
-    addItem( RiaEclipseUnitTools::UNITS_METRIC, "UNITS_METRIC", "Metric" );
+    addItem( RiaEclipseUnitTools::UnitSystem::UNITS_METRIC, "UNITS_METRIC", "Metric" );
-    addItem( RiaEclipseUnitTools::UNITS_FIELD, "UNITS_FIELD", "Field" );
+    addItem( RiaEclipseUnitTools::UnitSystem::UNITS_FIELD, "UNITS_FIELD", "Field" );
-    addItem( RiaEclipseUnitTools::UNITS_UNKNOWN, "UNITS_UNKNOWN", "Unknown" );
+    addItem( RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN, "UNITS_UNKNOWN", "Unknown" );
 
-    setDefault( RiaEclipseUnitTools::UNITS_METRIC );
+    setDefault( RiaEclipseUnitTools::UnitSystem::UNITS_METRIC );
 }
 } // namespace caf
 
@@ -49,9 +49,9 @@ double RiaEclipseUnitTools::darcysConstant( UnitSystem unitSystem )
     //         = 0.00864 (PVT - M)
     switch ( unitSystem )
     {
-        case UNITS_FIELD:
+        case UnitSystem::UNITS_FIELD:
             return 0.001127;
-        case UNITS_METRIC:
+        case UnitSystem::UNITS_METRIC:
             return 0.008527;
         default:
             CVF_ASSERT( false );
@@ -66,16 +66,16 @@ RiaDefines::DepthUnitType RiaEclipseUnitTools::depthUnit( UnitSystem unit )
 {
     switch ( unit )
     {
-        case RiaEclipseUnitTools::UNITS_METRIC:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_METRIC:
             return RiaDefines::DepthUnitType::UNIT_METER;
             break;
-        case RiaEclipseUnitTools::UNITS_FIELD:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_FIELD:
             return RiaDefines::DepthUnitType::UNIT_FEET;
             break;
-        case RiaEclipseUnitTools::UNITS_LAB:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_LAB:
             return RiaDefines::DepthUnitType::UNIT_NONE;
             break;
-        case RiaEclipseUnitTools::UNITS_UNKNOWN:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN:
             return RiaDefines::DepthUnitType::UNIT_NONE;
             break;
         default:
@@ -102,9 +102,9 @@ double RiaEclipseUnitTools::convertSurfaceGasFlowRateToOilEquivalents( UnitSyste
 
     double oilEquivalentGasRate = HUGE_VAL;
 
-    if ( caseUnitSystem == RiaEclipseUnitTools::UNITS_FIELD )
+    if ( caseUnitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
         oilEquivalentGasRate = fieldGasToOilEquivalent * eclGasFlowRate;
-    if ( caseUnitSystem == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( caseUnitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
         oilEquivalentGasRate = metricGasToOilEquivalent * eclGasFlowRate;
 
     return oilEquivalentGasRate;
@@ -117,13 +117,13 @@ QString RiaEclipseUnitTools::unitStringPressure( UnitSystem unitSystem )
 {
     switch ( unitSystem )
     {
-        case RiaEclipseUnitTools::UNITS_METRIC:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_METRIC:
             return "barsa";
-        case RiaEclipseUnitTools::UNITS_FIELD:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_FIELD:
             return "psia";
-        case RiaEclipseUnitTools::UNITS_LAB:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_LAB:
             return "atma";
-        case RiaEclipseUnitTools::UNITS_UNKNOWN:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN:
             return "";
         default:
             return "";

ApplicationCode/Application/Tools/RiaEclipseUnitTools.h

@@ -24,7 +24,7 @@
 class RiaEclipseUnitTools
 {
 public:
-    enum UnitSystem
+    enum class UnitSystem
     {
         UNITS_METRIC,
         UNITS_FIELD,

ApplicationCode/Application/Tools/RiaGitDiff.cpp

@@ -44,7 +44,7 @@ RiaGitDiff::~RiaGitDiff()
 //--------------------------------------------------------------------------------------------------
 void RiaGitDiff::reset()
 {
-    m_lastError = IC_NO_ERROR;
+    m_lastError = ErrorType::IC_NO_ERROR;
     m_errorMsg.clear();
     m_errorDetails.clear();
     m_diffOutput.clear();
@@ -80,7 +80,7 @@ bool RiaGitDiff::executeDiff( const QString& baseFolder )
     QProcess::ProcessError procError = proc.error();
     if ( procError != QProcess::UnknownError )
     {
-        m_lastError    = SEVERE_ERROR;
+        m_lastError    = ErrorType::SEVERE_ERROR;
         m_errorMsg     = "Error running 'git' tool process";
         m_errorDetails = completeCommand;
         return false;

ApplicationCode/Application/Tools/RiaGitDiff.h

@@ -28,7 +28,7 @@
 class RiaGitDiff
 {
 public:
-    enum ErrorType
+    enum class ErrorType
     {
         IC_NO_ERROR, // No error occurred
         IC_ERROR, // An error occurred

ApplicationCode/Application/Tools/RiaImageFileCompare.cpp

@@ -47,7 +47,7 @@ RiaImageFileCompare::~RiaImageFileCompare()
 void RiaImageFileCompare::reset()
 {
     m_imagesEqual  = false;
-    m_lastError    = IC_NO_ERROR;
+    m_lastError    = ErrorType::IC_NO_ERROR;
     m_errorMsg     = "";
     m_errorDetails = "";
 }
@@ -61,7 +61,7 @@ bool RiaImageFileCompare::runComparison( const QString& imgFileName, const QStri
 
     if ( m_compareExecutable.isEmpty() )
     {
-        m_lastError = SEVERE_ERROR;
+        m_lastError = ErrorType::SEVERE_ERROR;
         m_errorMsg  = "Cannot compare images, no compare executable set";
         return false;
     }
@@ -89,7 +89,7 @@ bool RiaImageFileCompare::runComparison( const QString& imgFileName, const QStri
     QProcess::ProcessError procError = proc.error();
     if ( procError != QProcess::UnknownError )
     {
-        m_lastError    = SEVERE_ERROR;
+        m_lastError    = ErrorType::SEVERE_ERROR;
         m_errorMsg     = "Error running compare tool process";
         m_errorDetails = completeCommand;
         return false;
@@ -111,7 +111,7 @@ bool RiaImageFileCompare::runComparison( const QString& imgFileName, const QStri
     else
     {
         // Report non-severe error
-        m_lastError    = IC_ERROR;
+        m_lastError    = ErrorType::IC_ERROR;
         m_errorMsg     = "Error running compare tool process";
         m_errorDetails = stdErr;
 

ApplicationCode/Application/Tools/RiaImageFileCompare.h

@@ -28,7 +28,7 @@
 class RiaImageFileCompare
 {
 public:
-    enum ErrorType
+    enum class ErrorType
     {
         IC_NO_ERROR, // No error occurred
         IC_ERROR, // An error occurred

ApplicationCode/Application/Tools/RiaLogging.cpp

@@ -66,7 +66,7 @@ private:
 ///
 //--------------------------------------------------------------------------------------------------
 RiaDefaultConsoleLogger::RiaDefaultConsoleLogger()
-    : m_logLevel( RI_LL_WARNING )
+    : m_logLevel( int( RILogLevel::RI_LL_WARNING ) )
 {
 }
 
@@ -204,7 +204,7 @@ void RiaLogging::deleteLoggerInstance()
 //--------------------------------------------------------------------------------------------------
 void RiaLogging::error( const QString& message )
 {
-    if ( sm_logger && sm_logger->level() >= RI_LL_ERROR )
+    if ( sm_logger && sm_logger->level() >= int( RILogLevel::RI_LL_ERROR ) )
     {
 #pragma omp critical( critical_section_logging )
         sm_logger->error( message.toLatin1().constData() );
@@ -216,7 +216,7 @@ void RiaLogging::error( const QString& message )
 //--------------------------------------------------------------------------------------------------
 void RiaLogging::warning( const QString& message )
 {
-    if ( sm_logger && sm_logger->level() >= RI_LL_WARNING )
+    if ( sm_logger && sm_logger->level() >= int( RILogLevel::RI_LL_WARNING ) )
     {
 #pragma omp critical( critical_section_logging )
         sm_logger->warning( message.toLatin1().constData() );
@@ -228,7 +228,7 @@ void RiaLogging::warning( const QString& message )
 //--------------------------------------------------------------------------------------------------
 void RiaLogging::info( const QString& message )
 {
-    if ( sm_logger && sm_logger->level() >= RI_LL_INFO )
+    if ( sm_logger && sm_logger->level() >= int( RILogLevel::RI_LL_INFO ) )
     {
 #pragma omp critical( critical_section_logging )
         sm_logger->info( message.toLatin1().constData() );
@@ -240,7 +240,7 @@ void RiaLogging::info( const QString& message )
 //--------------------------------------------------------------------------------------------------
 void RiaLogging::debug( const QString& message )
 {
-    if ( sm_logger && sm_logger->level() >= RI_LL_DEBUG )
+    if ( sm_logger && sm_logger->level() >= int( RILogLevel::RI_LL_DEBUG ) )
     {
 #pragma omp critical( critical_section_logging )
         sm_logger->debug( message.toLatin1().constData() );
@@ -251,7 +251,7 @@ void RiaLogging::debug( const QString& message )
 ///
 //--------------------------------------------------------------------------------------------------
 RiuMessageLoggerBase::RiuMessageLoggerBase()
-    : m_logLevel( RI_LL_WARNING )
+    : m_logLevel( (int)RILogLevel::RI_LL_WARNING )
 {
 }
 

ApplicationCode/Application/Tools/RiaLogging.h

@@ -22,7 +22,7 @@
 
 class QString;
 
-enum RILogLevel
+enum class RILogLevel
 {
     RI_LL_ERROR   = 1,
     RI_LL_WARNING = 2,

ApplicationCode/Application/Tools/RiaQDateTimeTools.cpp

@@ -58,11 +58,11 @@ void caf::AppEnum<RiaQDateTimeTools::DateFormatComponents>::setUp()
 template <>
 void caf::AppEnum<RiaQDateTimeTools::TimeFormatComponents>::setUp()
 {
-    addItem( RiaQDateTimeTools::TIME_FORMAT_NONE,               "NO_TIME",              "No Time of Day" );
+    addItem( RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_NONE,               "NO_TIME",              "No Time of Day" );
-    addItem( RiaQDateTimeTools::TIME_FORMAT_HOUR,               "HOUR",                 "Hour Only" );
+    addItem( RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_HOUR,               "HOUR",                 "Hour Only" );
-    addItem( RiaQDateTimeTools::TIME_FORMAT_HOUR_MINUTE,        "HOUR_MINUTE",          "Hour and Minute" );
+    addItem( RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_HOUR_MINUTE,        "HOUR_MINUTE",          "Hour and Minute" );
-    addItem( RiaQDateTimeTools::TIME_FORMAT_HOUR_MINUTE_SECOND, "HOUR_MINUTE_SECONDS",  "Hour, Minutes and Seconds" );
+    addItem( RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_HOUR_MINUTE_SECOND, "HOUR_MINUTE_SECONDS",  "Hour, Minutes and Seconds" );
-    setDefault( RiaQDateTimeTools::TIME_FORMAT_NONE );
+    setDefault( RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_NONE );
 }
 
 template <>
@@ -489,12 +489,12 @@ QString RiaQDateTimeTools::dateFormatString( const QString& fullDateFormat, Date
 //--------------------------------------------------------------------------------------------------
 QString RiaQDateTimeTools::timeFormatString( const QString& fullTimeFormat, TimeFormatComponents timeComponents )
 {
-    if ( timeComponents == TIME_FORMAT_NONE ) return "";
+    if ( timeComponents == TimeFormatComponents::TIME_FORMAT_NONE ) return "";
 
     QStringList allVariants = fullTimeFormat.split( ";" );
     if ( static_cast<int>( timeComponents ) < allVariants.size() )
     {
-        return allVariants[timeComponents];
+        return allVariants[static_cast<int>( timeComponents )];
     }
     CVF_ASSERT( false && "Time format string is malformed" );
     return "";

ApplicationCode/Application/Tools/RiaQDateTimeTools.h

@@ -66,7 +66,7 @@ public:
         DATE_FORMAT_SIZE
     };
 
-    enum TimeFormatComponents
+    enum class TimeFormatComponents
     {
         TIME_FORMAT_UNSPECIFIED = -2,
         TIME_FORMAT_NONE        = -1,
@@ -117,7 +117,7 @@ public:
     static QDateTime          truncateTime( const QDateTime& dt, RiaQDateTimeTools::DateTimePeriod period );
 
     static std::vector<RiaQDateTimeTools::DateTimePeriod> dateTimePeriods();
-    static QString                     dateTimePeriodName( RiaQDateTimeTools::DateTimePeriod period );
+    static QString dateTimePeriodName( RiaQDateTimeTools::DateTimePeriod period );
 
     // This function uses C locale to make sure the text representation of a date is stable, independent of the locale
     // settings on local machine. Required for stable regression testing.

ApplicationCode/Commands/CompletionExportCommands/RicWellPathFractureTextReportFeatureImpl.cpp

@@ -314,7 +314,7 @@ QString RicWellPathFractureTextReportFeatureImpl::createStimPlanFractureText(
     QString tableText;
 
     RiaEclipseUnitTools::UnitSystem unitSystem   = stimPlanTemplates.front()->fractureTemplateUnit();
-    bool                            isFieldUnits = unitSystem == RiaEclipseUnitTools::UNITS_FIELD;
+    bool                            isFieldUnits = unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD;
 
     QTextStream               stream( &tableText );
     RifTextDataTableFormatter formatter( stream );
@@ -366,7 +366,7 @@ QString RicWellPathFractureTextReportFeatureImpl::createEllipseFractureText(
     QString tableText;
 
     RiaEclipseUnitTools::UnitSystem unitSystem   = ellipseTemplates.front()->fractureTemplateUnit();
-    bool                            isFieldUnits = unitSystem == RiaEclipseUnitTools::UNITS_FIELD;
+    bool                            isFieldUnits = unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD;
 
     QTextStream               stream( &tableText );
     RifTextDataTableFormatter formatter( stream );
@@ -513,7 +513,7 @@ QString RicWellPathFractureTextReportFeatureImpl::createFractureInstancesText(
     if ( fractures.empty() ) return "";
 
     RiaEclipseUnitTools::UnitSystem unitSystem   = fractures.front()->fractureUnit(); // Fix
-    bool                            isFieldUnits = unitSystem == RiaEclipseUnitTools::UNITS_FIELD;
+    bool                            isFieldUnits = unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD;
 
     QString tableText;
 
@@ -622,7 +622,7 @@ QString RicWellPathFractureTextReportFeatureImpl::createFractureCompletionSummar
     QString tableText;
 
     RiaEclipseUnitTools::UnitSystem unitSystem   = wellPathFractureReportItems.front().unitSystem();
-    bool                            isFieldUnits = unitSystem == RiaEclipseUnitTools::UNITS_FIELD;
+    bool                            isFieldUnits = unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD;
 
     QTextStream               stream( &tableText );
     RifTextDataTableFormatter formatter( stream );

ApplicationCode/Commands/FractureCommands/RicConvertAllFractureTemplatesToFieldFeature.cpp

@@ -60,7 +60,7 @@ void RicConvertAllFractureTemplatesToFieldFeature::onActionTriggered( bool isChe
 
     for ( auto ellipseFracTemplate : ellipseFracTemplates )
     {
-        if ( ellipseFracTemplate->fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_METRIC )
+        if ( ellipseFracTemplate->fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
         {
             ellipseFracTemplate->changeUnits();
 

ApplicationCode/Commands/FractureCommands/RicConvertAllFractureTemplatesToMetricFeature.cpp

@@ -61,7 +61,7 @@ void RicConvertAllFractureTemplatesToMetricFeature::onActionTriggered( bool isCh
 
     for ( auto ellipseFracTemplate : ellipseFracTemplates )
     {
-        if ( ellipseFracTemplate->fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_FIELD )
+        if ( ellipseFracTemplate->fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
         {
             ellipseFracTemplate->changeUnits();
 

ApplicationCode/Commands/FractureCommands/RicCreateDuplicateTemplateInOtherUnitSystemFeature.cpp

@@ -67,13 +67,13 @@ void RicCreateDuplicateTemplateInOtherUnitSystemFeature::onActionTriggered( bool
     fractureTemplateCollection->addFractureTemplate( copyOfTemplate );
 
     auto currentUnit = copyOfTemplate->fractureTemplateUnit();
-    if ( currentUnit == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( currentUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
-        copyOfTemplate->convertToUnitSystem( RiaEclipseUnitTools::UNITS_FIELD );
+        copyOfTemplate->convertToUnitSystem( RiaEclipseUnitTools::UnitSystem::UNITS_FIELD );
     }
     else
     {
-        copyOfTemplate->convertToUnitSystem( RiaEclipseUnitTools::UNITS_METRIC );
+        copyOfTemplate->convertToUnitSystem( RiaEclipseUnitTools::UnitSystem::UNITS_METRIC );
     }
 
     QString name = copyOfTemplate->name();
@@ -99,11 +99,11 @@ void RicCreateDuplicateTemplateInOtherUnitSystemFeature::setupActionLook( QActio
     if ( !fractureTemplate ) return;
 
     QString destinationUnit;
-    if ( fractureTemplate->fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( fractureTemplate->fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         destinationUnit += "Field";
     }
-    else if ( fractureTemplate->fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( fractureTemplate->fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         destinationUnit += "Metric";
     }

ApplicationCode/Commands/FractureCommands/RicNewSimWellFractureAtPosFeature.cpp

@@ -93,7 +93,7 @@ void RicNewSimWellFractureAtPosFeature::onActionTriggered( bool isChecked )
 
     fracture->setName( QString( "Fracture_" ) + fracNum );
 
-    auto unitSet = RiaEclipseUnitTools::UNITS_UNKNOWN;
+    auto unitSet = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
     {
         RimEclipseResultCase* eclipseCase = nullptr;
         simWell->firstAncestorOrThisOfType( eclipseCase );

ApplicationCode/Commands/FractureCommands/RicNewSimWellFractureFeature.cpp

@@ -78,7 +78,7 @@ void RicNewSimWellFractureFeature::onActionTriggered( bool isChecked )
 
     fracture->setName( RicFractureNameGenerator::nameForNewFracture() );
 
-    auto unitSet = RiaEclipseUnitTools::UNITS_UNKNOWN;
+    auto unitSet = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
     {
         RimEclipseResultCase* eclipseCase = nullptr;
         objHandle->firstAncestorOrThisOfType( eclipseCase );

ApplicationCode/Commands/WellPathCommands/RicWellPathsUnitSystemSettingsImpl.cpp

@@ -29,7 +29,7 @@
 //--------------------------------------------------------------------------------------------------
 bool RicWellPathsUnitSystemSettingsImpl::ensureHasUnitSystem( RimWellPath* wellPath )
 {
-    if ( wellPath->unitSystem() != RiaEclipseUnitTools::UNITS_UNKNOWN )
+    if ( wellPath->unitSystem() != RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
     {
         return true;
     }

ApplicationCode/Commands/WellPathCommands/RicWellPathsUnitSystemSettingsUi.cpp

@@ -40,12 +40,12 @@ QList<caf::PdmOptionItemInfo>
     QList<caf::PdmOptionItemInfo> options;
     if ( fieldNeedingOptions == &unitSystem )
     {
-        options.push_back(
+        options.push_back( caf::PdmOptionItemInfo( RiaEclipseUnitTools::UnitSystemType::uiText(
-            caf::PdmOptionItemInfo( RiaEclipseUnitTools::UnitSystemType::uiText( RiaEclipseUnitTools::UNITS_METRIC ),
+                                                       RiaEclipseUnitTools::UnitSystem::UNITS_METRIC ),
-                                    RiaEclipseUnitTools::UNITS_METRIC ) );
+                                                   RiaEclipseUnitTools::UnitSystem::UNITS_METRIC ) );
-        options.push_back(
+        options.push_back( caf::PdmOptionItemInfo( RiaEclipseUnitTools::UnitSystemType::uiText(
-            caf::PdmOptionItemInfo( RiaEclipseUnitTools::UnitSystemType::uiText( RiaEclipseUnitTools::UNITS_FIELD ),
+                                                       RiaEclipseUnitTools::UnitSystem::UNITS_FIELD ),
-                                    RiaEclipseUnitTools::UNITS_FIELD ) );
+                                                   RiaEclipseUnitTools::UnitSystem::UNITS_FIELD ) );
     }
     return options;
 }

ApplicationCode/FileInterface/RifColumnBasedUserData.cpp

@@ -137,7 +137,7 @@ std::string RifColumnBasedUserData::unitName( const RifEclipseSummaryAddress& re
 //--------------------------------------------------------------------------------------------------
 RiaEclipseUnitTools::UnitSystem RifColumnBasedUserData::unitSystem() const
 {
-    return RiaEclipseUnitTools::UNITS_UNKNOWN;
+    return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/FileInterface/RifCsvUserData.cpp

@@ -142,7 +142,7 @@ std::string RifCsvUserData::unitName( const RifEclipseSummaryAddress& resultAddr
 //--------------------------------------------------------------------------------------------------
 RiaEclipseUnitTools::UnitSystem RifCsvUserData::unitSystem() const
 {
-    return RiaEclipseUnitTools::UNITS_UNKNOWN;
+    return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/FileInterface/RifDerivedEnsembleReader.cpp

@@ -100,5 +100,5 @@ std::string RifDerivedEnsembleReader::unitName( const RifEclipseSummaryAddress&
 //--------------------------------------------------------------------------------------------------
 RiaEclipseUnitTools::UnitSystem RifDerivedEnsembleReader::unitSystem() const
 {
-    return RiaEclipseUnitTools::UNITS_UNKNOWN;
+    return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
 }

ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp

@@ -121,7 +121,7 @@ bool RifEclipseInputFileTools::openGridFile( const QString&      fileName,
         if ( gridFile.open( QFile::ReadOnly ) )
         {
             RiaEclipseUnitTools::UnitSystem units = readUnitSystem( gridFile, gridunitPos );
-            if ( units != RiaEclipseUnitTools::UNITS_UNKNOWN )
+            if ( units != RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
             {
                 eclipseCase->setUnitsType( units );
             }
@@ -417,9 +417,9 @@ bool RifEclipseInputFileTools::exportGrid( const QString&         fileName,
     }
 
     ert_ecl_unit_enum ecl_units = ECL_METRIC_UNITS;
-    if ( eclipseCase->unitsType() == RiaEclipseUnitTools::UNITS_FIELD )
+    if ( eclipseCase->unitsType() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
         ecl_units = ECL_FIELD_UNITS;
-    else if ( eclipseCase->unitsType() == RiaEclipseUnitTools::UNITS_LAB )
+    else if ( eclipseCase->unitsType() == RiaEclipseUnitTools::UnitSystem::UNITS_LAB )
         ecl_units = ECL_LAB_UNITS;
 
     ecl_grid_fprintf_grdecl2( mainEclGrid, filePtr, ecl_units );
@@ -1639,18 +1639,18 @@ RiaEclipseUnitTools::UnitSystem RifEclipseInputFileTools::readUnitSystem( QFile&
     {
         if ( unitString.contains( "FEET", Qt::CaseInsensitive ) )
         {
-            return RiaEclipseUnitTools::UNITS_FIELD;
+            return RiaEclipseUnitTools::UnitSystem::UNITS_FIELD;
         }
         else if ( unitString.contains( "CM", Qt::CaseInsensitive ) )
         {
-            return RiaEclipseUnitTools::UNITS_LAB;
+            return RiaEclipseUnitTools::UnitSystem::UNITS_LAB;
         }
         else if ( unitString.contains( "MET", Qt::CaseInsensitive ) )
         {
-            return RiaEclipseUnitTools::UNITS_METRIC;
+            return RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
         }
     }
-    return RiaEclipseUnitTools::UNITS_UNKNOWN;
+    return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/FileInterface/RifKeywordVectorUserData.cpp

@@ -232,7 +232,7 @@ std::string RifKeywordVectorUserData::unitName( const RifEclipseSummaryAddress&
 //--------------------------------------------------------------------------------------------------
 RiaEclipseUnitTools::UnitSystem RifKeywordVectorUserData::unitSystem() const
 {
-    return RiaEclipseUnitTools::UNITS_UNKNOWN;
+    return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp

@@ -998,7 +998,7 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
     // Unit system
     {
         // Default units type is METRIC
-        RiaEclipseUnitTools::UnitSystem unitsType = RiaEclipseUnitTools::UNITS_METRIC;
+        RiaEclipseUnitTools::UnitSystem unitsType = RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
         int                             unitsTypeValue;
 
         if ( m_dynamicResultsAccess.notNull() )
@@ -1019,11 +1019,11 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
 
         if ( unitsTypeValue == 2 )
         {
-            unitsType = RiaEclipseUnitTools::UNITS_FIELD;
+            unitsType = RiaEclipseUnitTools::UnitSystem::UNITS_FIELD;
         }
         else if ( unitsTypeValue == 3 )
         {
-            unitsType = RiaEclipseUnitTools::UNITS_LAB;
+            unitsType = RiaEclipseUnitTools::UnitSystem::UNITS_LAB;
         }
         m_eclipseCase->setUnitsType( unitsType );
     }

ApplicationCode/FileInterface/RifReaderEclipseSummary.cpp

@@ -66,13 +66,13 @@ RiaEclipseUnitTools::UnitSystem readUnitSystem( ecl_sum_type* ecl_sum )
     switch ( eclUnitEnum )
     {
         case ECL_METRIC_UNITS:
-            return RiaEclipseUnitTools::UNITS_METRIC;
+            return RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
         case ECL_FIELD_UNITS:
-            return RiaEclipseUnitTools::UNITS_FIELD;
+            return RiaEclipseUnitTools::UnitSystem::UNITS_FIELD;
         case ECL_LAB_UNITS:
-            return RiaEclipseUnitTools::UNITS_LAB;
+            return RiaEclipseUnitTools::UnitSystem::UNITS_LAB;
         default:
-            return RiaEclipseUnitTools::UNITS_UNKNOWN;
+            return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
     }
 }
 
@@ -124,7 +124,7 @@ void closeEclSum( ecl_sum_type* ecl_sum )
 RifReaderEclipseSummary::RifReaderEclipseSummary()
     : m_ecl_sum( nullptr )
     , m_ecl_SmSpec( nullptr )
-    , m_unitSystem( RiaEclipseUnitTools::UNITS_METRIC )
+    , m_unitSystem( RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
 {
     m_valuesCache.reset( new ValuesCache() );
 }

ApplicationCode/FileInterface/RifReaderObservedData.cpp

@@ -215,5 +215,5 @@ std::string RifReaderObservedData::unitName( const RifEclipseSummaryAddress& res
 //--------------------------------------------------------------------------------------------------
 RiaEclipseUnitTools::UnitSystem RifReaderObservedData::unitSystem() const
 {
-    return RiaEclipseUnitTools::UNITS_UNKNOWN;
+    return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
 }

ApplicationCode/FileInterface/RifStimPlanXmlReader.cpp

@@ -67,7 +67,7 @@ cvf::ref<RigStimPlanFractureDefinition>
 
         RiaEclipseUnitTools::UnitSystemType unitSystem = stimPlanFileData->unitSet();
 
-        if ( unitSystem != RiaEclipseUnitTools::UNITS_UNKNOWN )
+        if ( unitSystem != RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
             RiaLogging::info( QString( "Setting unit system for StimPlan fracture template %1 to %2" )
                                   .arg( stimPlanFileName )
                                   .arg( unitSystem.uiText() ) );
@@ -197,13 +197,13 @@ void RifStimPlanXmlReader::readStimplanGridAndTimesteps( QXmlStreamReader&
                 gridunit = getAttributeValueString( xmlStream, "uom" );
 
                 if ( gridunit == "m" )
-                    stimPlanFileData->m_unitSet = RiaEclipseUnitTools::UNITS_METRIC;
+                    stimPlanFileData->m_unitSet = RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
                 else if ( gridunit == "ft" )
-                    stimPlanFileData->m_unitSet = RiaEclipseUnitTools::UNITS_FIELD;
+                    stimPlanFileData->m_unitSet = RiaEclipseUnitTools::UnitSystem::UNITS_FIELD;
                 else
-                    stimPlanFileData->m_unitSet = RiaEclipseUnitTools::UNITS_UNKNOWN;
+                    stimPlanFileData->m_unitSet = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
 
-                if ( destinationUnit == RiaEclipseUnitTools::UNITS_UNKNOWN )
+                if ( destinationUnit == RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
                 {
                     // Use file unit set if requested unit is unknown
                     destinationUnit = stimPlanFileData->m_unitSet;
@@ -213,11 +213,11 @@ void RifStimPlanXmlReader::readStimplanGridAndTimesteps( QXmlStreamReader&
                 double tvdToBotPerfFt = getAttributeValueDouble( xmlStream, "TVDToBottomPerfFt" );
 
                 double tvdToTopPerfRequestedUnit =
-                    RifStimPlanXmlReader::valueInRequiredUnitSystem( RiaEclipseUnitTools::UNITS_FIELD,
+                    RifStimPlanXmlReader::valueInRequiredUnitSystem( RiaEclipseUnitTools::UnitSystem::UNITS_FIELD,
                                                                      destinationUnit,
                                                                      tvdToTopPerfFt );
                 double tvdToBotPerfRequestedUnit =
-                    RifStimPlanXmlReader::valueInRequiredUnitSystem( RiaEclipseUnitTools::UNITS_FIELD,
+                    RifStimPlanXmlReader::valueInRequiredUnitSystem( RiaEclipseUnitTools::UnitSystem::UNITS_FIELD,
                                                                      destinationUnit,
                                                                      tvdToBotPerfFt );
 
@@ -323,7 +323,8 @@ std::vector<double> RifStimPlanXmlReader::valuesInRequiredUnitSystem( RiaEclipse
                                                                       RiaEclipseUnitTools::UnitSystem requiredUnit,
                                                                       const std::vector<double>&      values )
 {
-    if ( sourceUnit == RiaEclipseUnitTools::UNITS_FIELD && requiredUnit == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( sourceUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD &&
+         requiredUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         std::vector<double> convertedValues;
         for ( const auto& valueInFeet : values )
@@ -333,7 +334,8 @@ std::vector<double> RifStimPlanXmlReader::valuesInRequiredUnitSystem( RiaEclipse
 
         return convertedValues;
     }
-    else if ( sourceUnit == RiaEclipseUnitTools::UNITS_METRIC && requiredUnit == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( sourceUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC &&
+              requiredUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         std::vector<double> convertedValues;
         for ( const auto& valueInMeter : values )
@@ -354,11 +356,13 @@ double RifStimPlanXmlReader::valueInRequiredUnitSystem( RiaEclipseUnitTools::Uni
                                                         RiaEclipseUnitTools::UnitSystem requiredUnit,
                                                         double                          value )
 {
-    if ( sourceUnit == RiaEclipseUnitTools::UNITS_FIELD && requiredUnit == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( sourceUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD &&
+         requiredUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         return RiaEclipseUnitTools::feetToMeter( value );
     }
-    else if ( sourceUnit == RiaEclipseUnitTools::UNITS_METRIC && requiredUnit == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( sourceUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC &&
+              requiredUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         return RiaEclipseUnitTools::meterToFeet( value );
     }

ApplicationCode/ProjectDataModel/Completions/RimEllipseFractureTemplate.cpp

@@ -141,13 +141,13 @@ std::vector<cvf::Vec3f> RimEllipseFractureTemplate::fractureBorderPolygon() cons
 //--------------------------------------------------------------------------------------------------
 void RimEllipseFractureTemplate::changeUnits()
 {
-    if ( fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
-        convertToUnitSystem( RiaEclipseUnitTools::UNITS_FIELD );
+        convertToUnitSystem( RiaEclipseUnitTools::UnitSystem::UNITS_FIELD );
     }
-    else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
-        convertToUnitSystem( RiaEclipseUnitTools::UNITS_METRIC );
+        convertToUnitSystem( RiaEclipseUnitTools::UnitSystem::UNITS_METRIC );
     }
 
     this->updateConnectedEditors();
@@ -284,7 +284,7 @@ const RigFractureGrid* RimEllipseFractureTemplate::fractureGrid() const
 //--------------------------------------------------------------------------------------------------
 void RimEllipseFractureTemplate::setDefaultValuesFromUnit()
 {
-    if ( fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_FIELD )
+    if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         m_width        = 0.5;
         m_permeability = 80000.0;
@@ -308,12 +308,12 @@ void RimEllipseFractureTemplate::setDefaultValuesFromUnit()
 double RimEllipseFractureTemplate::conductivity() const
 {
     double cond = cvf::UNDEFINED_DOUBLE;
-    if ( fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         // Conductivity should be md-m, width is in m
         cond = m_permeability * m_width;
     }
-    else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         // Conductivity should be md-ft, but width is in inches
         cond = m_permeability * RiaEclipseUnitTools::inchToFeet( m_width );
@@ -403,13 +403,13 @@ void RimEllipseFractureTemplate::convertToUnitSystem( RiaEclipseUnitTools::UnitS
     setUnitSystem( neededUnit );
     RimFractureTemplate::convertToUnitSystem( neededUnit );
 
-    if ( neededUnit == RiaEclipseUnitTools::UNITS_FIELD )
+    if ( neededUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         m_halfLength = RiaEclipseUnitTools::meterToFeet( m_halfLength );
         m_height     = RiaEclipseUnitTools::meterToFeet( m_height );
         m_width      = RiaEclipseUnitTools::meterToInch( m_width );
     }
-    else if ( neededUnit == RiaEclipseUnitTools::UNITS_METRIC )
+    else if ( neededUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         m_halfLength = RiaEclipseUnitTools::feetToMeter( m_halfLength );
         m_height     = RiaEclipseUnitTools::feetToMeter( m_height );
@@ -422,13 +422,13 @@ void RimEllipseFractureTemplate::convertToUnitSystem( RiaEclipseUnitTools::UnitS
 //--------------------------------------------------------------------------------------------------
 void RimEllipseFractureTemplate::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
 {
-    if ( fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         m_halfLength.uiCapability()->setUiName( "Halflenght X<sub>f</sub> [m]" );
         m_height.uiCapability()->setUiName( "Height [m]" );
         m_width.uiCapability()->setUiName( "Width [m]" );
     }
-    else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         m_halfLength.uiCapability()->setUiName( "Halflenght X<sub>f</sub> [ft]" );
         m_height.uiCapability()->setUiName( "Height [ft]" );

ApplicationCode/ProjectDataModel/Completions/RimFishbonesCollection.cpp

@@ -116,12 +116,12 @@ void RimFishbonesCollection::defineUiOrdering( QString uiConfigName, caf::PdmUiO
         firstAncestorOrThisOfType( wellPath );
         if ( wellPath )
         {
-            if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+            if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
             {
                 m_startMD.uiCapability()->setUiName( "Start MD [m]" );
                 m_mainBoreDiameter.uiCapability()->setUiName( "Main Bore Diameter [m]" );
             }
-            else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD )
+            else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
             {
                 m_startMD.uiCapability()->setUiName( "Start MD [ft]" );
                 m_mainBoreDiameter.uiCapability()->setUiName( "Main Bore Diameter [ft]" );
@@ -287,11 +287,13 @@ double RimFishbonesCollection::mainBoreDiameter( RiaEclipseUnitTools::UnitSystem
 {
     RimWellPath* wellPath;
     firstAncestorOrThisOfTypeAsserted( wellPath );
-    if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD && unitSystem == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD &&
+         unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         return RiaEclipseUnitTools::feetToMeter( m_mainBoreDiameter() );
     }
-    else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC && unitSystem == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC &&
+              unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         return RiaEclipseUnitTools::meterToFeet( m_mainBoreDiameter() );
     }
@@ -307,7 +309,7 @@ void RimFishbonesCollection::setUnitSystemSpecificDefaults()
     firstAncestorOrThisOfType( wellPath );
     if ( wellPath )
     {
-        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
         {
             m_mainBoreDiameter = 0.216;
         }

ApplicationCode/ProjectDataModel/Completions/RimFishbonesMultipleSubs.cpp

@@ -245,9 +245,9 @@ double RimFishbonesMultipleSubs::tubingDiameter( RiaEclipseUnitTools::UnitSystem
 {
     RimWellPath* wellPath;
     firstAncestorOrThisOfTypeAsserted( wellPath );
-    if ( unitSystem == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
-        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD )
+        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
         {
             return RiaEclipseUnitTools::inchToMeter( m_lateralTubingDiameter() );
         }
@@ -256,9 +256,9 @@ double RimFishbonesMultipleSubs::tubingDiameter( RiaEclipseUnitTools::UnitSystem
             return m_lateralTubingDiameter() / 1000;
         }
     }
-    else if ( unitSystem == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
-        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
         {
             return RiaEclipseUnitTools::meterToFeet( m_lateralTubingDiameter() / 1000 );
         }
@@ -295,11 +295,13 @@ double RimFishbonesMultipleSubs::openHoleRoughnessFactor( RiaEclipseUnitTools::U
 {
     RimWellPath* wellPath;
     firstAncestorOrThisOfTypeAsserted( wellPath );
-    if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD && unitSystem == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD &&
+         unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         return RiaEclipseUnitTools::feetToMeter( m_lateralOpenHoleRoghnessFactor() );
     }
-    else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC && unitSystem == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC &&
+              unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         return RiaEclipseUnitTools::meterToFeet( m_lateralOpenHoleRoghnessFactor() );
     }
@@ -420,7 +422,7 @@ void RimFishbonesMultipleSubs::setUnitSystemSpecificDefaults()
     firstAncestorOrThisOfType( wellPath );
     if ( wellPath )
     {
-        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
         {
             m_lateralLength                 = "11";
             m_lateralBuildAngle             = 6.0;
@@ -429,7 +431,7 @@ void RimFishbonesMultipleSubs::setUnitSystemSpecificDefaults()
             m_lateralTubingRoghnessFactor   = 1e-05;
             m_icdOrificeDiameter            = 7;
         }
-        else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD )
+        else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
         {
             m_lateralLength                 = "36";
             m_lateralBuildAngle             = 1.83;
@@ -557,7 +559,7 @@ void RimFishbonesMultipleSubs::defineUiOrdering( QString uiConfigName, caf::PdmU
         firstAncestorOrThisOfType( wellPath );
         if ( wellPath )
         {
-            if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+            if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
             {
                 m_lateralLength.uiCapability()->setUiName( "Length(s) [m]" );
                 m_lateralBuildAngle.uiCapability()->setUiName( "Build Angle [deg/m]" );
@@ -567,7 +569,7 @@ void RimFishbonesMultipleSubs::defineUiOrdering( QString uiConfigName, caf::PdmU
 
                 m_icdOrificeDiameter.uiCapability()->setUiName( "ICD Orifice Diameter [mm]" );
             }
-            else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD )
+            else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
             {
                 m_lateralLength.uiCapability()->setUiName( "Length(s) [ft]" );
                 m_lateralBuildAngle.uiCapability()->setUiName( "Build Angle [deg/ft]" );

ApplicationCode/ProjectDataModel/Completions/RimFishbonesPipeProperties.cpp

@@ -49,9 +49,9 @@ double RimFishbonesPipeProperties::holeDiameter( RiaEclipseUnitTools::UnitSystem
 {
     RimWellPath* wellPath;
     firstAncestorOrThisOfTypeAsserted( wellPath );
-    if ( unitSystem == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
-        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD )
+        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
         {
             return RiaEclipseUnitTools::inchToMeter( m_lateralHoleDiameter() );
         }
@@ -60,9 +60,9 @@ double RimFishbonesPipeProperties::holeDiameter( RiaEclipseUnitTools::UnitSystem
             return m_lateralHoleDiameter() / 1000;
         }
     }
-    else if ( unitSystem == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
-        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
         {
             return RiaEclipseUnitTools::meterToFeet( m_lateralHoleDiameter() / 1000 );
         }
@@ -84,11 +84,11 @@ void RimFishbonesPipeProperties::setUnitSystemSpecificDefaults()
     firstAncestorOrThisOfType( wellPath );
     if ( wellPath )
     {
-        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
         {
             m_lateralHoleDiameter = 12.5;
         }
-        else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD )
+        else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
         {
             m_lateralHoleDiameter = 0.5;
         }
@@ -105,11 +105,11 @@ void RimFishbonesPipeProperties::defineUiOrdering( QString uiConfigName, caf::Pd
         firstAncestorOrThisOfType( wellPath );
         if ( wellPath )
         {
-            if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+            if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
             {
                 m_lateralHoleDiameter.uiCapability()->setUiName( "Hole Diameter [mm]" );
             }
-            else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD )
+            else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
             {
                 m_lateralHoleDiameter.uiCapability()->setUiName( "Hole Diameter [in]" );
             }

ApplicationCode/ProjectDataModel/Completions/RimFracture.cpp

@@ -133,7 +133,7 @@ RimFracture::RimFracture()
     CAF_PDM_InitField(&m_dip, "Dip", 0.0, "Dip", "", "", "");
     CAF_PDM_InitField(&m_tilt, "Tilt", 0.0, "Tilt", "", "", "");
     
-    CAF_PDM_InitField(&m_fractureUnit, "FractureUnit", caf::AppEnum<RiaEclipseUnitTools::UnitSystem>(RiaEclipseUnitTools::UNITS_METRIC), "Fracture Unit System", "", "", "");
+    CAF_PDM_InitField(&m_fractureUnit, "FractureUnit", caf::AppEnum<RiaEclipseUnitTools::UnitSystem>(RiaEclipseUnitTools::UnitSystem::UNITS_METRIC), "Fracture Unit System", "", "", "");
     m_fractureUnit.uiCapability()->setUiReadOnly(true);
 
     CAF_PDM_InitField(&m_stimPlanTimeIndexToPlot, "TimeIndexToPlot", 0, "StimPlan Time Step", "", "", ""); 
@@ -427,11 +427,11 @@ cvf::BoundingBox RimFracture::boundingBoxInDomainCoords() const
 //--------------------------------------------------------------------------------------------------
 double RimFracture::wellRadius() const
 {
-    if ( m_fractureUnit == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( m_fractureUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         return m_wellDiameter / 2.0;
     }
-    else if ( m_fractureUnit == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( m_fractureUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         return RiaEclipseUnitTools::inchToFeet( m_wellDiameter / 2.0 );
     }
@@ -603,12 +603,12 @@ QList<caf::PdmOptionItemInfo> RimFracture::calculateValueOptions( const caf::Pdm
 //--------------------------------------------------------------------------------------------------
 void RimFracture::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
 {
-    if ( m_fractureUnit() == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( m_fractureUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         m_wellDiameter.uiCapability()->setUiName( "Well Diameter [m]" );
         m_perforationLength.uiCapability()->setUiName( "Perforation Length [m]" );
     }
-    else if ( m_fractureUnit() == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( m_fractureUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         m_wellDiameter.uiCapability()->setUiName( "Well Diameter [inches]" );
         m_perforationLength.uiCapability()->setUiName( "Perforation Length [ft]" );

ApplicationCode/ProjectDataModel/Completions/RimFractureTemplate.cpp

@@ -120,7 +120,7 @@ RimFractureTemplate::RimFractureTemplate()
     m_nameAndUnit.uiCapability()->setUiHidden(true);
     m_nameAndUnit.xmlCapability()->disableIO();
 
-    CAF_PDM_InitField(&m_fractureTemplateUnit, "UnitSystem", caf::AppEnum<RiaEclipseUnitTools::UnitSystem>(RiaEclipseUnitTools::UNITS_UNKNOWN), "Units System", "", "", "");
+    CAF_PDM_InitField(&m_fractureTemplateUnit, "UnitSystem", caf::AppEnum<RiaEclipseUnitTools::UnitSystem>(RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN), "Units System", "", "", "");
     m_fractureTemplateUnit.uiCapability()->setUiReadOnly(true);
 
     CAF_PDM_InitField(&m_orientationType,     "Orientation",  caf::AppEnum<FracOrientationEnum>(TRANSVERSE_WELL_PATH), "Fracture Orientation", "", "", "");
@@ -433,13 +433,13 @@ void RimFractureTemplate::defineEditorAttribute( const caf::PdmFieldHandle* fiel
 //--------------------------------------------------------------------------------------------------
 void RimFractureTemplate::prepareFieldsForUiDisplay()
 {
-    if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         m_wellDiameter.uiCapability()->setUiName( "Well Diameter [m]" );
         m_perforationLength.uiCapability()->setUiName( "Perforation Length [m]" );
         m_fractureWidth.uiCapability()->setUiName( "Fracture Width [m]" );
     }
-    else if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         m_wellDiameter.uiCapability()->setUiName( "Well Diameter [inches]" );
         m_perforationLength.uiCapability()->setUiName( "Perforation Length [ft]" );
@@ -712,13 +712,13 @@ double RimFractureTemplate::computeKh( const RimFracture* fractureInstance ) con
 //--------------------------------------------------------------------------------------------------
 void RimFractureTemplate::convertToUnitSystem( RiaEclipseUnitTools::UnitSystem neededUnit )
 {
-    if ( neededUnit == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( neededUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         m_perforationLength = RiaEclipseUnitTools::feetToMeter( m_perforationLength );
         m_wellDiameter      = RiaEclipseUnitTools::inchToMeter( m_wellDiameter );
         m_fractureWidth     = RiaEclipseUnitTools::feetToMeter( m_fractureWidth );
     }
-    else if ( neededUnit == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( neededUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         m_perforationLength = RiaEclipseUnitTools::meterToFeet( m_perforationLength );
         m_wellDiameter      = RiaEclipseUnitTools::meterToInch( m_wellDiameter );
@@ -870,11 +870,11 @@ QString RimFractureTemplate::nameAndUnit() const
 {
     QString decoratedName;
 
-    if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         decoratedName += "[M] - ";
     }
-    else if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         decoratedName += "[F] - ";
     }
@@ -937,11 +937,11 @@ float RimFractureTemplate::skinFactor() const
 //--------------------------------------------------------------------------------------------------
 void RimFractureTemplate::setDefaultWellDiameterFromUnit()
 {
-    if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD )
+    if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         m_wellDiameter = 8.5;
     }
-    else if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC )
+    else if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         m_wellDiameter = 0.216;
     }

ApplicationCode/ProjectDataModel/Completions/RimFractureTemplateCollection.cpp

@@ -55,7 +55,7 @@ RimFractureTemplateCollection::RimFractureTemplateCollection()
 
     CAF_PDM_InitField( &m_defaultUnitsForFracTemplates,
                        "DefaultUnitForTemplates",
-                       caf::AppEnum<RiaEclipseUnitTools::UnitSystem>( RiaEclipseUnitTools::UNITS_METRIC ),
+                       caf::AppEnum<RiaEclipseUnitTools::UnitSystem>( RiaEclipseUnitTools::UnitSystem::UNITS_METRIC ),
                        "Default unit system for fracture templates",
                        "",
                        "",
@@ -142,7 +142,7 @@ void RimFractureTemplateCollection::setDefaultUnitSystemBasedOnLoadedCases()
     RimProject* proj = RiaApplication::instance()->project();
 
     auto commonUnitSystem = proj->commonUnitSystemForAllCases();
-    if ( commonUnitSystem != RiaEclipseUnitTools::UNITS_UNKNOWN )
+    if ( commonUnitSystem != RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
     {
         m_defaultUnitsForFracTemplates = commonUnitSystem;
     }
@@ -242,14 +242,14 @@ void RimFractureTemplateCollection::createAndAssignTemplateCopyForNonMatchingUni
                                 caf::PdmDefaultObjectFactory::instance() ) );
 
                         auto currentUnit = fractureTemplate->fractureTemplateUnit();
-                        auto neededUnit  = RiaEclipseUnitTools::UNITS_UNKNOWN;
+                        auto neededUnit  = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
-                        if ( currentUnit == RiaEclipseUnitTools::UNITS_METRIC )
+                        if ( currentUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
                         {
-                            neededUnit = RiaEclipseUnitTools::UNITS_FIELD;
+                            neededUnit = RiaEclipseUnitTools::UnitSystem::UNITS_FIELD;
                         }
-                        else if ( currentUnit == RiaEclipseUnitTools::UNITS_FIELD )
+                        else if ( currentUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
                         {
-                            neededUnit = RiaEclipseUnitTools::UNITS_METRIC;
+                            neededUnit = RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
                         }
 
                         templateWithMatchingUnit->convertToUnitSystem( neededUnit );

ApplicationCode/ProjectDataModel/Completions/RimMswCompletionParameters.cpp

@@ -127,11 +127,13 @@ double RimMswCompletionParameters::linerDiameter( RiaEclipseUnitTools::UnitSyste
 {
     RimWellPath* wellPath;
     firstAncestorOrThisOfTypeAsserted( wellPath );
-    if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD && unitSystem == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD &&
+         unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         return RiaEclipseUnitTools::feetToMeter( m_linerDiameter() );
     }
-    else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC && unitSystem == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC &&
+              unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         return RiaEclipseUnitTools::meterToFeet( m_linerDiameter() );
     }
@@ -143,7 +145,7 @@ double RimMswCompletionParameters::linerDiameter( RiaEclipseUnitTools::UnitSyste
 //--------------------------------------------------------------------------------------------------
 double RimMswCompletionParameters::defaultLinerDiameter( RiaEclipseUnitTools::UnitSystem unitSystem )
 {
-    if ( unitSystem == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         return 0.152;
     }
@@ -160,11 +162,13 @@ double RimMswCompletionParameters::roughnessFactor( RiaEclipseUnitTools::UnitSys
 {
     RimWellPath* wellPath;
     firstAncestorOrThisOfTypeAsserted( wellPath );
-    if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD && unitSystem == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD &&
+         unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         return RiaEclipseUnitTools::feetToMeter( m_roughnessFactor() );
     }
-    else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC && unitSystem == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC &&
+              unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         return RiaEclipseUnitTools::meterToFeet( m_roughnessFactor() );
     }
@@ -176,7 +180,7 @@ double RimMswCompletionParameters::roughnessFactor( RiaEclipseUnitTools::UnitSys
 //--------------------------------------------------------------------------------------------------
 double RimMswCompletionParameters::defaultRoughnessFactor( RiaEclipseUnitTools::UnitSystem unitSystem )
 {
-    if ( unitSystem == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         return 1.0e-5;
     }
@@ -288,12 +292,12 @@ void RimMswCompletionParameters::defineUiOrdering( QString uiConfigName, caf::Pd
         firstAncestorOrThisOfType( wellPath );
         if ( wellPath )
         {
-            if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+            if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
             {
                 m_linerDiameter.uiCapability()->setUiName( "Liner Inner Diameter [m]" );
                 m_roughnessFactor.uiCapability()->setUiName( "Roughness Factor [m]" );
             }
-            else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD )
+            else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
             {
                 m_linerDiameter.uiCapability()->setUiName( "Liner Inner Diameter [ft]" );
                 m_roughnessFactor.uiCapability()->setUiName( "Roughness Factor [ft]" );

ApplicationCode/ProjectDataModel/Completions/RimMultipleValveLocations.cpp

@@ -230,14 +230,14 @@ void RimMultipleValveLocations::defineUiOrdering( QString uiConfigName, caf::Pdm
         firstAncestorOrThisOfType( wellPath );
         if ( wellPath )
         {
-            if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+            if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
             {
                 m_locationOfValves.uiCapability()->setUiName( "Measured Depths [m]" );
                 m_rangeStart.uiCapability()->setUiName( "Start MD [m]" );
                 m_rangeEnd.uiCapability()->setUiName( "End MD [m]" );
                 m_rangeValveSpacing.uiCapability()->setUiName( "Spacing [m]" );
             }
-            else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD )
+            else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
             {
                 m_locationOfValves.uiCapability()->setUiName( "Measured Depths [ft]" );
                 m_rangeStart.uiCapability()->setUiName( "Start MD [ft]" );
@@ -331,7 +331,7 @@ void RimMultipleValveLocations::fieldChangedByUi( const caf::PdmFieldHandle* cha
 
         RimWellPath* wellPath = nullptr;
         this->firstAncestorOrThisOfTypeAsserted( wellPath );
-        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD )
+        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
         {
             double minimumDistanceFeet = RiaEclipseUnitTools::meterToFeet( minimumDistanceMeter );
             m_rangeValveSpacing        = cvf::Math::clamp( m_rangeValveSpacing(),

ApplicationCode/ProjectDataModel/Completions/RimPerforationInterval.cpp

@@ -135,11 +135,13 @@ double RimPerforationInterval::diameter( RiaEclipseUnitTools::UnitSystem unitSys
 {
     RimWellPath* wellPath;
     firstAncestorOrThisOfTypeAsserted( wellPath );
-    if ( unitSystem == RiaEclipseUnitTools::UNITS_METRIC && wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD )
+    if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC &&
+         wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         return RiaEclipseUnitTools::feetToMeter( m_diameter() );
     }
-    else if ( unitSystem == RiaEclipseUnitTools::UNITS_FIELD && wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+    else if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD &&
+              wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         return RiaEclipseUnitTools::meterToFeet( m_diameter() );
     }
@@ -196,11 +198,11 @@ void RimPerforationInterval::setUnitSystemSpecificDefaults()
     firstAncestorOrThisOfType( wellPath );
     if ( wellPath )
     {
-        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
         {
             m_diameter = 0.216;
         }
-        else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD )
+        else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
         {
             m_diameter = 0.709;
         }
@@ -341,13 +343,13 @@ void RimPerforationInterval::defineUiOrdering( QString uiConfigName, caf::PdmUiO
         firstAncestorOrThisOfType( wellPath );
         if ( wellPath )
         {
-            if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+            if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
             {
                 m_startMD.uiCapability()->setUiName( "Start MD [m]" );
                 m_endMD.uiCapability()->setUiName( "End MD [m]" );
                 m_diameter.uiCapability()->setUiName( "Diameter [m]" );
             }
-            else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD )
+            else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
             {
                 m_startMD.uiCapability()->setUiName( "Start MD [ft]" );
                 m_endMD.uiCapability()->setUiName( "End MD [ft]" );

ApplicationCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.cpp

@@ -270,7 +270,7 @@ void RimStimPlanFractureTemplate::loadDataAndUpdate()
     {
         setDefaultConductivityResultIfEmpty();
 
-        if ( fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_UNKNOWN )
+        if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
         {
             setUnitSystem( m_stimPlanFractureDefinitionData->unitSet() );
         }
@@ -279,7 +279,7 @@ void RimStimPlanFractureTemplate::loadDataAndUpdate()
     }
     else
     {
-        setUnitSystem( RiaEclipseUnitTools::UNITS_UNKNOWN );
+        setUnitSystem( RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN );
         m_readError = true;
     }
 
@@ -405,11 +405,11 @@ void RimStimPlanFractureTemplate::computePerforationLength()
         }
     }
 
-    if ( fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_METRIC && m_perforationLength < 10 )
+    if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC && m_perforationLength < 10 )
     {
         m_perforationLength = 10;
     }
-    else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_FIELD &&
+    else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD &&
               m_perforationLength < RiaEclipseUnitTools::meterToFeet( 10 ) )
     {
         m_perforationLength = std::round( RiaEclipseUnitTools::meterToFeet( 10 ) );
@@ -428,14 +428,14 @@ std::vector<double>
     auto resultValues =
         m_stimPlanFractureDefinitionData->fractureGridResults( resultName, unitName, m_activeTimeStepIndex );
 
-    if ( fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         for ( auto& v : resultValues )
         {
             v = RiaEclipseUnitTools::convertToMeter( v, unitName );
         }
     }
-    else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         for ( auto& v : resultValues )
         {
@@ -782,11 +782,11 @@ void RimStimPlanFractureTemplate::convertToUnitSystem( RiaEclipseUnitTools::Unit
 
     if ( m_stimPlanFractureDefinitionData.isNull() ) return;
 
-    if ( neededUnit == RiaEclipseUnitTools::UNITS_FIELD )
+    if ( neededUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         m_wellPathDepthAtFracture = RiaEclipseUnitTools::meterToFeet( m_wellPathDepthAtFracture );
     }
-    else if ( neededUnit == RiaEclipseUnitTools::UNITS_METRIC )
+    else if ( neededUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         m_wellPathDepthAtFracture = RiaEclipseUnitTools::feetToMeter( m_wellPathDepthAtFracture );
     }

ApplicationCode/ProjectDataModel/Completions/RimValveTemplate.cpp

@@ -34,7 +34,7 @@ RimValveTemplate::RimValveTemplate()
 
     CAF_PDM_InitField( &m_valveTemplateUnit,
                        "UnitSystem",
-                       caf::AppEnum<RiaEclipseUnitTools::UnitSystem>( RiaEclipseUnitTools::UNITS_UNKNOWN ),
+                       caf::AppEnum<RiaEclipseUnitTools::UnitSystem>( RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN ),
                        "Units System",
                        "",
                        "",
@@ -83,11 +83,11 @@ void RimValveTemplate::setUnitSystem( RiaEclipseUnitTools::UnitSystemType unitSy
 //--------------------------------------------------------------------------------------------------
 void RimValveTemplate::setDefaultValuesFromUnits()
 {
-    if ( m_valveTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( m_valveTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
         m_orificeDiameter = 8;
     }
-    else if ( m_valveTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( m_valveTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
         m_orificeDiameter = 0.315;
     }
@@ -200,11 +200,11 @@ void RimValveTemplate::defineUiOrdering( QString uiConfigName, caf::PdmUiOrderin
     uiOrdering.add( &m_valveTemplateUnit );
     if ( m_type() == RiaDefines::WellPathComponentType::ICV || m_type() == RiaDefines::WellPathComponentType::ICD )
     {
-        if ( m_valveTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC )
+        if ( m_valveTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
         {
             m_orificeDiameter.uiCapability()->setUiName( "Orifice Diameter [mm]" );
         }
-        else if ( m_valveTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD )
+        else if ( m_valveTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
         {
             m_orificeDiameter.uiCapability()->setUiName( "Orifice Diameter [in]" );
         }

ApplicationCode/ProjectDataModel/Completions/RimValveTemplateCollection.cpp

@@ -38,7 +38,7 @@ RimValveTemplateCollection::RimValveTemplateCollection()
                                 "",
                                 "",
                                 "" );
-    m_defaultUnitsForValveTemplates = RiaEclipseUnitTools::UNITS_METRIC;
+    m_defaultUnitsForValveTemplates = RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
     m_valveDefinitions.uiCapability()->setUiHidden( true );
     addDefaultValveTemplates();
 }
@@ -96,7 +96,7 @@ void RimValveTemplateCollection::setDefaultUnitSystemBasedOnLoadedCases()
     RimProject* proj = RiaApplication::instance()->project();
 
     auto commonUnitSystem = proj->commonUnitSystemForAllCases();
-    if ( commonUnitSystem != RiaEclipseUnitTools::UNITS_UNKNOWN )
+    if ( commonUnitSystem != RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
     {
         m_defaultUnitsForValveTemplates = commonUnitSystem;
     }

ApplicationCode/ProjectDataModel/Completions/RimWellPathAicdParameters.cpp

@@ -215,7 +215,7 @@ bool RimWellPathAicdParameters::isMetric() const
     firstAncestorOrThisOfType( wellPath );
     if ( wellPath )
     {
-        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+        if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
         {
             metric = true;
         }

ApplicationCode/ProjectDataModel/Completions/RimWellPathValve.cpp

@@ -232,9 +232,9 @@ double RimWellPathValve::convertOrificeDiameter( double
                                                  RiaEclipseUnitTools::UnitSystem wellPathUnits,
                                                  RiaEclipseUnitTools::UnitSystem unitSystem )
 {
-    if ( unitSystem == RiaEclipseUnitTools::UNITS_METRIC )
+    if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
     {
-        if ( wellPathUnits == RiaEclipseUnitTools::UNITS_FIELD )
+        if ( wellPathUnits == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
         {
             return RiaEclipseUnitTools::inchToMeter( orificeDiameterWellPathUnits );
         }
@@ -243,9 +243,9 @@ double RimWellPathValve::convertOrificeDiameter( double
             return RiaEclipseUnitTools::mmToMeter( orificeDiameterWellPathUnits );
         }
     }
-    else if ( unitSystem == RiaEclipseUnitTools::UNITS_FIELD )
+    else if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
     {
-        if ( wellPathUnits == RiaEclipseUnitTools::UNITS_METRIC )
+        if ( wellPathUnits == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
         {
             return RiaEclipseUnitTools::meterToFeet( RiaEclipseUnitTools::mmToMeter( orificeDiameterWellPathUnits ) );
         }
@@ -504,11 +504,11 @@ void RimWellPathValve::defineUiOrdering( QString uiConfigName, caf::PdmUiOrderin
             firstAncestorOrThisOfType( wellPath );
             if ( wellPath )
             {
-                if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC )
+                if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
                 {
                     m_measuredDepth.uiCapability()->setUiName( "Measured Depth [m]" );
                 }
-                else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD )
+                else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
                 {
                     m_measuredDepth.uiCapability()->setUiName( "Measured Depth [ft]" );
                 }

ApplicationCode/ProjectDataModel/Flow/RimWellPlotTools.cpp

@@ -835,13 +835,13 @@ QString flowConditionReservoirUnitText( RiaEclipseUnitTools::UnitSystem unitSyst
 
     switch ( unitSystem )
     {
-        case RiaEclipseUnitTools::UNITS_METRIC:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_METRIC:
             unitText = "[m<sup>3</sup>/day]";
             break;
-        case RiaEclipseUnitTools::UNITS_FIELD:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_FIELD:
             unitText = "[Brl/day]";
             break;
-        case RiaEclipseUnitTools::UNITS_LAB:
+        case RiaEclipseUnitTools::UnitSystem::UNITS_LAB:
             unitText = "[cm<sup>3</sup>/hr]";
             break;
         default:
@@ -867,13 +867,13 @@ QString RimWellPlotTools::flowUnitText( RimWellLogFile::WellFlowCondition condit
     {
         switch ( unitSystem )
         {
-            case RiaEclipseUnitTools::UNITS_METRIC:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_METRIC:
                 unitText = "[Liquid Sm<sup>3</sup>/day], [Gas kSm<sup>3</sup>/day]";
                 break;
-            case RiaEclipseUnitTools::UNITS_FIELD:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_FIELD:
                 unitText = "[Liquid BBL/day], [Gas BOE/day]";
                 break;
-            case RiaEclipseUnitTools::UNITS_LAB:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_LAB:
                 unitText = "[cm<sup>3</sup>/hr]";
                 break;
             default:
@@ -901,7 +901,7 @@ QString RimWellPlotTools::curveUnitText( RimWellLogFile::WellFlowCondition condi
     {
         switch ( unitSystem )
         {
-            case RiaEclipseUnitTools::UNITS_METRIC:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_METRIC:
                 switch ( flowPhase )
                 {
                     case FLOW_PHASE_GAS:
@@ -917,7 +917,7 @@ QString RimWellPlotTools::curveUnitText( RimWellLogFile::WellFlowCondition condi
                 }
                 break;
 
-            case RiaEclipseUnitTools::UNITS_FIELD:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_FIELD:
                 switch ( flowPhase )
                 {
                     case FLOW_PHASE_GAS:
@@ -932,7 +932,7 @@ QString RimWellPlotTools::curveUnitText( RimWellLogFile::WellFlowCondition condi
                         break;
                 }
                 break;
-            case RiaEclipseUnitTools::UNITS_LAB:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_LAB:
                 unitText = "[cm<sup>3</sup>/hr]";
                 break;
             default:

ApplicationCode/ProjectDataModel/Flow/RimWellPltPlot.cpp

@@ -170,13 +170,13 @@ void RimWellPltPlot::setPlotXAxisTitles( RimWellLogTrack* plotTrack )
                 switch ( source.wellLogFile()->wellLogFileData()->depthUnit() )
                 {
                     case RiaDefines::DepthUnitType::UNIT_METER:
-                        presentUnitSystems.insert( RiaEclipseUnitTools::UNITS_METRIC );
+                        presentUnitSystems.insert( RiaEclipseUnitTools::UnitSystem::UNITS_METRIC );
                         break;
                     case RiaDefines::DepthUnitType::UNIT_FEET:
-                        presentUnitSystems.insert( RiaEclipseUnitTools::UNITS_FIELD );
+                        presentUnitSystems.insert( RiaEclipseUnitTools::UnitSystem::UNITS_FIELD );
                         break;
                     case RiaDefines::DepthUnitType::UNIT_NONE:
-                        presentUnitSystems.insert( RiaEclipseUnitTools::UNITS_UNKNOWN );
+                        presentUnitSystems.insert( RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN );
                         break;
                 }
             }
@@ -541,7 +541,7 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
             resultPointCalc.reset( new RigSimWellResultPointCalculator( m_wellPathName, rimEclipseResultCase, timeStep ) );
         }
 
-        RiaEclipseUnitTools::UnitSystem unitSet = RiaEclipseUnitTools::UNITS_UNKNOWN;
+        RiaEclipseUnitTools::UnitSystem unitSet = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
         if ( rimEclipseResultCase )
         {
             unitSet = rimEclipseResultCase->eclipseCaseData()->unitsType();
@@ -654,13 +654,13 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
 
                     std::vector<double> depthValues = wellLogFileData->depthValues();
 
-                    RiaEclipseUnitTools::UnitSystem unitSystem = RiaEclipseUnitTools::UNITS_UNKNOWN;
+                    RiaEclipseUnitTools::UnitSystem unitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
                     {
                         RiaDefines::DepthUnitType depthUnit = wellLogFileData->depthUnit();
                         if ( depthUnit == RiaDefines::DepthUnitType::UNIT_FEET )
-                            unitSystem = RiaEclipseUnitTools::UNITS_FIELD;
+                            unitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_FIELD;
                         if ( depthUnit == RiaDefines::DepthUnitType::UNIT_METER )
-                            unitSystem = RiaEclipseUnitTools::UNITS_METRIC;
+                            unitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
                     }
 
                     for ( const ChannelValNameIdxTuple& channelInfo : sortedChannels )

ApplicationCode/ProjectDataModel/RimPlotCurve.cpp

@@ -515,7 +515,7 @@ void RimPlotCurve::setSamplesFromXYErrorValues(
     {
         if ( filteredYValues[i] != DOUBLE_INF && filteredErrorValues[i] != DOUBLE_INF )
         {
-            if ( errorAxis == RiaCurveDataTools::ERROR_ALONG_Y_AXIS )
+            if ( errorAxis == RiaCurveDataTools::ErrorAxis::ERROR_ALONG_Y_AXIS )
             {
                 errorIntervals << QwtIntervalSample( filteredXValues[i],
                                                      filteredYValues[i] - filteredErrorValues[i],
@@ -542,7 +542,7 @@ void RimPlotCurve::setSamplesFromXYErrorValues(
     if ( m_qwtCurveErrorBars )
     {
         m_qwtCurveErrorBars->setSamples( errorIntervals );
-        if ( errorAxis == RiaCurveDataTools::ERROR_ALONG_Y_AXIS )
+        if ( errorAxis == RiaCurveDataTools::ErrorAxis::ERROR_ALONG_Y_AXIS )
         {
             m_qwtCurveErrorBars->setOrientation( Qt::Vertical );
         }

ApplicationCode/ProjectDataModel/RimPlotCurve.h

@@ -117,11 +117,11 @@ protected:
     void         updatePlotTitle();
     virtual void updateLegendsInPlot();
 
-    void setSamplesFromXYErrorValues( const std::vector<double>&   xValues,
+    void setSamplesFromXYErrorValues( const std::vector<double>& xValues,
-                                      const std::vector<double>&   yValues,
+                                      const std::vector<double>& yValues,
-                                      const std::vector<double>&   errorValues,
+                                      const std::vector<double>& errorValues,
-                                      bool                         keepOnlyPositiveValues,
+                                      bool                       keepOnlyPositiveValues,
-                                      RiaCurveDataTools::ErrorAxis errorAxis = RiaCurveDataTools::ERROR_ALONG_Y_AXIS );
+                                      RiaCurveDataTools::ErrorAxis errorAxis = RiaCurveDataTools::ErrorAxis::ERROR_ALONG_Y_AXIS );
     void setSamplesFromXYValues( const std::vector<double>& xValues,
                                  const std::vector<double>& yValues,
                                  bool                       keepOnlyPositiveValues );

ApplicationCode/ProjectDataModel/RimProject.cpp

@@ -1284,20 +1284,20 @@ RiaEclipseUnitTools::UnitSystemType RimProject::commonUnitSystemForAllCases() co
     std::vector<RimCase*> rimCases;
     allCases( rimCases );
 
-    RiaEclipseUnitTools::UnitSystem commonUnitSystem = RiaEclipseUnitTools::UNITS_UNKNOWN;
+    RiaEclipseUnitTools::UnitSystem commonUnitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
 
     for ( const auto& c : rimCases )
     {
         auto eclipseCase = dynamic_cast<RimEclipseCase*>( c );
         if ( eclipseCase && eclipseCase->eclipseCaseData() )
         {
-            if ( commonUnitSystem == RiaEclipseUnitTools::UNITS_UNKNOWN )
+            if ( commonUnitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
             {
                 commonUnitSystem = eclipseCase->eclipseCaseData()->unitsType();
             }
             else if ( commonUnitSystem != eclipseCase->eclipseCaseData()->unitsType() )
             {
-                commonUnitSystem = RiaEclipseUnitTools::UNITS_UNKNOWN;
+                commonUnitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
                 break;
             }
         }

ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp

@@ -474,7 +474,7 @@ void RimWellLogExtractionCurve::extractData( bool*  isUsingPseudoLength,
         }
 
         RiaEclipseUnitTools::UnitSystem eclipseUnitsType = eclipseCase->eclipseCaseData()->unitsType();
-        if ( eclipseUnitsType == RiaEclipseUnitTools::UNITS_FIELD )
+        if ( eclipseUnitsType == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
         {
             // See https://github.com/OPM/ResInsight/issues/538
 

ApplicationCode/ProjectDataModel/RimWellLogRftCurve.cpp

@@ -403,7 +403,7 @@ void RimWellLogRftCurve::onLoadDataAndUpdate( bool updateParentPlot )
             return;
         }
 
-        RiaEclipseUnitTools::UnitSystem unitSystem = RiaEclipseUnitTools::UNITS_METRIC;
+        RiaEclipseUnitTools::UnitSystem unitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
         if ( m_eclipseResultCase )
         {
             unitSystem = m_eclipseResultCase->eclipseCaseData()->unitsType();
@@ -419,7 +419,7 @@ void RimWellLogRftCurve::onLoadDataAndUpdate( bool updateParentPlot )
         else if ( m_observedFmuRftData )
         {
             // TODO: Read unit system somewhere for FMU RFT Data
-            unitSystem     = RiaEclipseUnitTools::UNITS_METRIC;
+            unitSystem     = RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
             perPointLabels = this->perPointLabels();
         }
         else
@@ -481,7 +481,7 @@ void RimWellLogRftCurve::onLoadDataAndUpdate( bool updateParentPlot )
                                                    yValues,
                                                    errors,
                                                    keepOnlyPositiveValues,
-                                                   RiaCurveDataTools::ERROR_ALONG_X_AXIS );
+                                                   RiaCurveDataTools::ErrorAxis::ERROR_ALONG_X_AXIS );
             }
             else
             {
@@ -523,7 +523,11 @@ void RimWellLogRftCurve::onLoadDataAndUpdate( bool updateParentPlot )
 
             if ( !errors.empty() )
             {
-                this->setSamplesFromXYErrorValues( xValues, yValues, errors, isLogCurve, RiaCurveDataTools::ERROR_ALONG_X_AXIS );
+                this->setSamplesFromXYErrorValues( xValues,
+                                                   yValues,
+                                                   errors,
+                                                   isLogCurve,
+                                                   RiaCurveDataTools::ErrorAxis::ERROR_ALONG_X_AXIS );
             }
             else
             {

ApplicationCode/ProjectDataModel/RimWellPathCollection.cpp

@@ -644,7 +644,7 @@ RiaEclipseUnitTools::UnitSystemType RimWellPathCollection::findUnitSystemForWell
     firstAncestorOrThisOfTypeAsserted( project );
     if ( project->activeOilField()->analysisModels->cases.empty() )
     {
-        return RiaEclipseUnitTools::UNITS_UNKNOWN;
+        return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
     }
 
     const RigEclipseCaseData* eclipseCaseData = project->activeOilField()->analysisModels->cases()[0]->eclipseCaseData();
@@ -659,7 +659,7 @@ RiaEclipseUnitTools::UnitSystemType RimWellPathCollection::findUnitSystemForWell
     {
         return eclipseCaseData->unitsType();
     }
-    return RiaEclipseUnitTools::UNITS_UNKNOWN;
+    return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ProjectDataModel/Summary/RimCalculatedSummaryCurveReader.cpp

@@ -108,5 +108,5 @@ RimSummaryCalculation*
 //--------------------------------------------------------------------------------------------------
 RiaEclipseUnitTools::UnitSystem RifCalculatedSummaryCurveReader::unitSystem() const
 {
-    return RiaEclipseUnitTools::UNITS_UNKNOWN;
+    return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
 }

ApplicationCode/ProjectDataModel/Summary/RimEnsembleStatisticsCase.cpp

@@ -205,7 +205,7 @@ RiaEclipseUnitTools::UnitSystem RimEnsembleStatisticsCase::unitSystem() const
     {
         return m_curveSet->summaryCaseCollection()->unitSystem();
     }
-    return RiaEclipseUnitTools::UNITS_UNKNOWN;
+    return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ProjectDataModel/Summary/RimSummaryCase.cpp

@@ -250,7 +250,7 @@ RiaEclipseUnitTools::UnitSystemType RimSummaryCase::unitsSystem()
     {
         return reader->unitSystem();
     }
-    return RiaEclipseUnitTools::UNITS_UNKNOWN;
+    return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ProjectDataModel/Summary/RimSummaryCaseCollection.cpp

@@ -249,7 +249,7 @@ void RimSummaryCaseCollection::addCase( RimSummaryCase* summaryCase, bool update
 
     if ( m_isEnsemble )
     {
-        validateEnsembleCases( { summaryCase } );
+        validateEnsembleCases( {summaryCase} );
         calculateEnsembleParametersIntersectionHash();
     }
 
@@ -744,7 +744,7 @@ RiaEclipseUnitTools::UnitSystem RimSummaryCaseCollection::unitSystem() const
 {
     if ( m_cases.empty() )
     {
-        return RiaEclipseUnitTools::UNITS_UNKNOWN;
+        return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
     }
     return m_cases[0]->unitsSystem();
 }

ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.cpp

@@ -825,21 +825,21 @@ void RimSummaryCurve::setCurveAppearanceFromCaseType()
     {
         RiaPreferences* prefs = RiaApplication::instance()->preferences();
 
-        if ( prefs->defaultSummaryHistoryCurveStyle() == RiaPreferences::SYMBOLS )
+        if ( prefs->defaultSummaryHistoryCurveStyle() == RiaPreferences::SummaryHistoryCurveStyleMode::SYMBOLS )
         {
             m_symbolEdgeColor = m_curveColor;
 
             setSymbol( RiuQwtSymbol::SYMBOL_XCROSS );
             setLineStyle( RiuQwtPlotCurve::STYLE_NONE );
         }
-        else if ( prefs->defaultSummaryHistoryCurveStyle() == RiaPreferences::SYMBOLS_AND_LINES )
+        else if ( prefs->defaultSummaryHistoryCurveStyle() == RiaPreferences::SummaryHistoryCurveStyleMode::SYMBOLS_AND_LINES )
         {
             m_symbolEdgeColor = m_curveColor;
 
             setSymbol( RiuQwtSymbol::SYMBOL_XCROSS );
             setLineStyle( RiuQwtPlotCurve::STYLE_SOLID );
         }
-        else if ( prefs->defaultSummaryHistoryCurveStyle() == RiaPreferences::LINES )
+        else if ( prefs->defaultSummaryHistoryCurveStyle() == RiaPreferences::SummaryHistoryCurveStyleMode::LINES )
         {
             setSymbol( RiuQwtSymbol::SYMBOL_NONE );
             setLineStyle( RiuQwtPlotCurve::STYLE_SOLID );

ApplicationCode/ProjectDataModel/Summary/RimSummaryTimeAxisProperties.cpp

@@ -399,7 +399,8 @@ QList<caf::PdmOptionItemInfo>
             QTime   exampleTime = QTime( 15, 48, 22 );
             QString timeFormatString =
                 RiaQDateTimeTools::timeFormatString( timeFormat,
-                                                     timeComponents( RiaQDateTimeTools::TIME_FORMAT_HOUR_MINUTE_SECOND ) );
+                                                     timeComponents(
+                                                         RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_HOUR_MINUTE_SECOND ) );
             QString uiText = QString( "%1 (%2)" ).arg( timeFormatString ).arg( exampleTime.toString( timeFormatString ) );
             uiText.replace( "AP", "AM/PM" );
             options.push_back( caf::PdmOptionItemInfo( uiText, QVariant::fromValue( timeFormat ) ) );
@@ -579,7 +580,7 @@ void RimSummaryTimeAxisProperties::defineUiOrdering( QString uiConfigName, caf::
         {
             advancedGroup->add( &m_dateFormat );
         }
-        if ( m_automaticDateComponents() || m_timeComponents() != RiaQDateTimeTools::TIME_FORMAT_NONE )
+        if ( m_automaticDateComponents() || m_timeComponents() != RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_NONE )
         {
             advancedGroup->add( &m_timeFormat );
         }
@@ -709,7 +710,8 @@ void RimSummaryTimeAxisProperties::defineEditorAttribute( const caf::PdmFieldHan
         if ( timeAttrib )
         {
             timeAttrib->timeFormat =
-                RiaQDateTimeTools::timeFormatString( m_timeFormat(), RiaQDateTimeTools::TIME_FORMAT_HOUR_MINUTE_SECOND );
+                RiaQDateTimeTools::timeFormatString( m_timeFormat(),
+                                                     RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_HOUR_MINUTE_SECOND );
         }
     }
 }

ApplicationCode/ProjectDataModel/Summary/RimSummaryTimeAxisProperties.h

@@ -76,7 +76,8 @@ public:
     RiaQDateTimeTools::DateFormatComponents
         dateComponents( RiaQDateTimeTools::DateFormatComponents fallback = RiaQDateTimeTools::DATE_FORMAT_UNSPECIFIED ) const;
     RiaQDateTimeTools::TimeFormatComponents
-        timeComponents( RiaQDateTimeTools::TimeFormatComponents fallback = RiaQDateTimeTools::TIME_FORMAT_UNSPECIFIED ) const;
+        timeComponents( RiaQDateTimeTools::TimeFormatComponents fallback =
+                            RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_UNSPECIFIED ) const;
 
     const QString& dateFormat() const;
     const QString& timeFormat() const;

ApplicationCode/ReservoirDataModel/RigEclipseCaseData.cpp

@@ -56,7 +56,7 @@ RigEclipseCaseData::RigEclipseCaseData( RimEclipseCase* ownerCase )
     m_matrixModelResults->setActiveCellInfo( m_activeCellInfo.p() );
     m_fractureModelResults->setActiveCellInfo( m_fractureActiveCellInfo.p() );
 
-    m_unitsType = RiaEclipseUnitTools::UNITS_METRIC;
+    m_unitsType = RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.cpp

@@ -148,11 +148,11 @@ public:
 
         // Try and set output unit system to the same system as the eclipse case system
         std::unique_ptr<const Opm::ECLUnits::UnitSystem> eclUnitSystem;
-        if ( caseUnitSystem == RiaEclipseUnitTools::UNITS_METRIC )
+        if ( caseUnitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
             eclUnitSystem = Opm::ECLUnits::metricUnitConventions();
-        else if ( caseUnitSystem == RiaEclipseUnitTools::UNITS_FIELD )
+        else if ( caseUnitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
             eclUnitSystem = Opm::ECLUnits::fieldUnitConventions();
-        else if ( caseUnitSystem == RiaEclipseUnitTools::UNITS_LAB )
+        else if ( caseUnitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_LAB )
             eclUnitSystem = Opm::ECLUnits::labUnitConventions();
 
         if ( eclUnitSystem )

ApplicationCode/ReservoirDataModel/RigStimPlanFractureDefinition.cpp

@@ -45,7 +45,7 @@ const double RigStimPlanFractureDefinition::THRESHOLD_VALUE = 1e-5;
 ///
 //--------------------------------------------------------------------------------------------------
 RigStimPlanFractureDefinition::RigStimPlanFractureDefinition()
-    : m_unitSet( RiaEclipseUnitTools::UNITS_UNKNOWN )
+    : m_unitSet( RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
     , m_topPerfTvd( HUGE_VAL )
     , m_bottomPerfTvd( HUGE_VAL )
     , m_xMirrorMode( false )
@@ -316,11 +316,11 @@ std::vector<std::vector<double>>
     {
         for ( auto& xVal : yValues )
         {
-            if ( requiredUnitSet == RiaEclipseUnitTools::UNITS_FIELD )
+            if ( requiredUnitSet == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
             {
                 xVal = RiaEclipseUnitTools::convertToFeet( xVal, conductivityUnitTextOnFile );
             }
-            else if ( requiredUnitSet == RiaEclipseUnitTools::UNITS_METRIC )
+            else if ( requiredUnitSet == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
             {
                 xVal = RiaEclipseUnitTools::convertToMeter( xVal, conductivityUnitTextOnFile );
             }

ApplicationCode/UserInterface/RiuMessagePanel.cpp

@@ -56,17 +56,17 @@ RiuMessagePanel::RiuMessagePanel( QDockWidget* parent )
 void RiuMessagePanel::addMessage( RILogLevel messageLevel, const QString& msg )
 {
     QColor clr( Qt::black );
-    if ( messageLevel == RI_LL_ERROR )
+    if ( messageLevel == RILogLevel::RI_LL_ERROR )
         clr = Qt::red;
-    else if ( messageLevel == RI_LL_WARNING )
+    else if ( messageLevel == RILogLevel::RI_LL_WARNING )
         clr = QColor( 220, 100, 10 );
-    else if ( messageLevel == RI_LL_DEBUG )
+    else if ( messageLevel == RILogLevel::RI_LL_DEBUG )
         clr = QColor( 100, 100, 200 );
 
     QTextCharFormat form = m_textEdit->currentCharFormat();
     form.setForeground( clr );
-    form.setFontWeight( messageLevel == RI_LL_ERROR ? QFont::DemiBold : QFont::Normal );
+    form.setFontWeight( messageLevel == RILogLevel::RI_LL_ERROR ? QFont::DemiBold : QFont::Normal );
-    form.setFontItalic( messageLevel == RI_LL_DEBUG ? true : false );
+    form.setFontItalic( messageLevel == RILogLevel::RI_LL_DEBUG ? true : false );
     m_textEdit->setCurrentCharFormat( form );
     m_textEdit->appendPlainText( msg );
 
@@ -75,7 +75,7 @@ void RiuMessagePanel::addMessage( RILogLevel messageLevel, const QString& msg )
 
     if ( !RiaRegressionTestRunner::instance()->isRunningRegressionTests() )
     {
-        if ( messageLevel == RI_LL_ERROR || messageLevel == RI_LL_WARNING )
+        if ( messageLevel == RILogLevel::RI_LL_ERROR || messageLevel == RILogLevel::RI_LL_WARNING )
         {
             QDockWidget* parentDockWidget = dynamic_cast<QDockWidget*>( this->parent() );
             if ( parentDockWidget && !parentDockWidget->isVisible() )
@@ -138,7 +138,7 @@ void RiuMessagePanel::slotClearMessages()
 ///
 //--------------------------------------------------------------------------------------------------
 RiuMessagePanelLogger::RiuMessagePanelLogger()
-    : m_logLevel( RI_LL_WARNING )
+    : m_logLevel( int( RILogLevel::RI_LL_WARNING ) )
 {
 }
 
@@ -171,7 +171,7 @@ void RiuMessagePanelLogger::setLevel( int logLevel )
 //--------------------------------------------------------------------------------------------------
 void RiuMessagePanelLogger::error( const char* message )
 {
-    writeToMessagePanel( RI_LL_ERROR, message );
+    writeToMessagePanel( RILogLevel::RI_LL_ERROR, message );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -179,7 +179,7 @@ void RiuMessagePanelLogger::error( const char* message )
 //--------------------------------------------------------------------------------------------------
 void RiuMessagePanelLogger::warning( const char* message )
 {
-    writeToMessagePanel( RI_LL_WARNING, message );
+    writeToMessagePanel( RILogLevel::RI_LL_WARNING, message );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -187,7 +187,7 @@ void RiuMessagePanelLogger::warning( const char* message )
 //--------------------------------------------------------------------------------------------------
 void RiuMessagePanelLogger::info( const char* message )
 {
-    writeToMessagePanel( RI_LL_INFO, message );
+    writeToMessagePanel( RILogLevel::RI_LL_INFO, message );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -195,7 +195,7 @@ void RiuMessagePanelLogger::info( const char* message )
 //--------------------------------------------------------------------------------------------------
 void RiuMessagePanelLogger::debug( const char* message )
 {
-    writeToMessagePanel( RI_LL_DEBUG, message );
+    writeToMessagePanel( RILogLevel::RI_LL_DEBUG, message );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -203,7 +203,7 @@ void RiuMessagePanelLogger::debug( const char* message )
 //--------------------------------------------------------------------------------------------------
 void RiuMessagePanelLogger::writeToMessagePanel( RILogLevel messageLevel, const char* message )
 {
-    if ( messageLevel > m_logLevel )
+    if ( int( messageLevel ) > m_logLevel )
     {
         return;
     }

ApplicationCode/UserInterface/RiuProcessMonitor.cpp

@@ -156,7 +156,7 @@ void RiuProcessMonitor::addStringToLog( const QString& sTxt )
     RiuPlotMainWindow* mainPlotWindow = RiaGuiApplication::instance()->mainPlotWindow();
     if ( mainPlotWindow && mainPlotWindow->messagePanel() )
     {
-        mainPlotWindow->messagePanel()->addMessage( RI_LL_INFO, sTxt );
+        mainPlotWindow->messagePanel()->addMessage( RILogLevel::RI_LL_INFO, sTxt );
     }
 }
 

ApplicationCode/UserInterface/RiuPvtPlotPanel.cpp

@@ -506,7 +506,7 @@ void RiuPvtPlotWidget::slotPickerActivated( bool on )
 //--------------------------------------------------------------------------------------------------
 RiuPvtPlotPanel::RiuPvtPlotPanel( QDockWidget* parent )
     : QWidget( parent )
-    , m_unitSystem( RiaEclipseUnitTools::UNITS_UNKNOWN )
+    , m_unitSystem( RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
     , m_plotUpdater( new RiuPvtPlotUpdater( this ) )
 {
     m_phaseComboBox = new QComboBox( this );
@@ -591,7 +591,7 @@ void RiuPvtPlotPanel::clearPlot()
         return;
     }
 
-    m_unitSystem = RiaEclipseUnitTools::UNITS_UNKNOWN;
+    m_unitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
     m_allFvfCurvesArr.clear();
     m_allViscosityCurvesArr.clear();
     m_fvfDynProps       = FvfDynProps();
@@ -756,11 +756,11 @@ QString RiuPvtPlotPanel::unitLabelFromCurveIdent( RiaEclipseUnitTools::UnitSyste
     {
         switch ( unitSystem )
         {
-            case RiaEclipseUnitTools::UNITS_METRIC:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_METRIC:
                 return "rm3/sm3";
-            case RiaEclipseUnitTools::UNITS_FIELD:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_FIELD:
                 return "rb/stb";
-            case RiaEclipseUnitTools::UNITS_LAB:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_LAB:
                 return "rcc/scc";
             default:
                 return "";
@@ -770,11 +770,11 @@ QString RiuPvtPlotPanel::unitLabelFromCurveIdent( RiaEclipseUnitTools::UnitSyste
     {
         switch ( unitSystem )
         {
-            case RiaEclipseUnitTools::UNITS_METRIC:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_METRIC:
                 return "rm3/sm3";
-            case RiaEclipseUnitTools::UNITS_FIELD:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_FIELD:
                 return "rb/Mscf";
-            case RiaEclipseUnitTools::UNITS_LAB:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_LAB:
                 return "rcc/scc";
             default:
                 return "";
@@ -785,11 +785,11 @@ QString RiuPvtPlotPanel::unitLabelFromCurveIdent( RiaEclipseUnitTools::UnitSyste
     {
         switch ( unitSystem )
         {
-            case RiaEclipseUnitTools::UNITS_METRIC:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_METRIC:
                 return "cP";
-            case RiaEclipseUnitTools::UNITS_FIELD:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_FIELD:
                 return "cP";
-            case RiaEclipseUnitTools::UNITS_LAB:
+            case RiaEclipseUnitTools::UnitSystem::UNITS_LAB:
                 return "cP";
             default:
                 return "";

ApplicationCode/UserInterface/RiuQwtPlotTools.cpp

@@ -67,7 +67,7 @@ void RiuQwtPlotTools::setCommonPlotBehaviour( QwtPlot* plot )
     plot->setAxisFont( QwtPlot::yRight, axisFont );
 
     // Axis title font
-    std::vector<QwtPlot::Axis> axes = { QwtPlot::xBottom, QwtPlot::xTop, QwtPlot::yLeft, QwtPlot::yRight };
+    std::vector<QwtPlot::Axis> axes = {QwtPlot::xBottom, QwtPlot::xTop, QwtPlot::yLeft, QwtPlot::yRight};
 
     for ( QwtPlot::Axis axis : axes )
     {
@@ -131,14 +131,14 @@ void RiuQwtPlotTools::enableDateBasedBottomXAxis( QwtPlot*
 {
     QwtDateScaleDraw* scaleDraw = new QwtDateScaleDraw( Qt::UTC );
 
-    std::set<QwtDate::IntervalType> intervals = { QwtDate::Year,
+    std::set<QwtDate::IntervalType> intervals = {QwtDate::Year,
-                                                  QwtDate::Month,
+                                                 QwtDate::Month,
-                                                  QwtDate::Week,
+                                                 QwtDate::Week,
-                                                  QwtDate::Day,
+                                                 QwtDate::Day,
-                                                  QwtDate::Hour,
+                                                 QwtDate::Hour,
-                                                  QwtDate::Minute,
+                                                 QwtDate::Minute,
-                                                  QwtDate::Second,
+                                                 QwtDate::Second,
-                                                  QwtDate::Millisecond };
+                                                 QwtDate::Millisecond};
 
     for ( QwtDate::IntervalType interval : intervals )
     {
@@ -161,7 +161,7 @@ QString RiuQwtPlotTools::dateTimeFormatForInterval( QwtDate::IntervalType
                                                     RiaQDateTimeTools::TimeFormatComponents timeComponents )
 {
     if ( dateComponents != RiaQDateTimeTools::DATE_FORMAT_UNSPECIFIED &&
-         timeComponents != RiaQDateTimeTools::TIME_FORMAT_UNSPECIFIED )
+         timeComponents != RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_UNSPECIFIED )
     {
         return RiaQDateTimeTools::timeFormatString( timeFormat, timeComponents ) + "\n" +
                RiaQDateTimeTools::dateFormatString( dateFormat, dateComponents );
@@ -172,13 +172,15 @@ QString RiuQwtPlotTools::dateTimeFormatForInterval( QwtDate::IntervalType
         {
             case QwtDate::Millisecond:
                 return RiaQDateTimeTools::timeFormatString( timeFormat,
-                                                            RiaQDateTimeTools::TIME_FORMAT_HOUR_MINUTE_SECOND_MILLISECOND );
+                                                            RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_HOUR_MINUTE_SECOND_MILLISECOND );
             case QwtDate::Second:
-                return RiaQDateTimeTools::timeFormatString( timeFormat, RiaQDateTimeTools::TIME_FORMAT_HOUR_MINUTE_SECOND );
+                return RiaQDateTimeTools::timeFormatString( timeFormat,
+                                                            RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_HOUR_MINUTE_SECOND );
             case QwtDate::Minute:
             {
                 QString fullFormat =
-                    RiaQDateTimeTools::timeFormatString( timeFormat, RiaQDateTimeTools::TIME_FORMAT_HOUR_MINUTE );
+                    RiaQDateTimeTools::timeFormatString( timeFormat,
+                                                         RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_HOUR_MINUTE );
                 fullFormat += "\n";
                 fullFormat +=
                     RiaQDateTimeTools::dateFormatString( dateFormat, RiaQDateTimeTools::DATE_FORMAT_YEAR_MONTH_DAY );
@@ -186,7 +188,9 @@ QString RiuQwtPlotTools::dateTimeFormatForInterval( QwtDate::IntervalType
             }
             case QwtDate::Hour:
             {
-                QString fullFormat = RiaQDateTimeTools::timeFormatString( timeFormat, RiaQDateTimeTools::TIME_FORMAT_HOUR );
+                QString fullFormat =
+                    RiaQDateTimeTools::timeFormatString( timeFormat,
+                                                         RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_HOUR );
                 if ( !fullFormat.endsWith( "AP" ) )
                 {
                     fullFormat += ":00";

ApplicationCode/UserInterface/RiuQwtPlotTools.h

@@ -33,7 +33,7 @@ public:
         const QString&                          dateFormat,
         const QString&                          timeFormat,
         RiaQDateTimeTools::DateFormatComponents dateComponents = RiaQDateTimeTools::DATE_FORMAT_UNSPECIFIED,
-        RiaQDateTimeTools::TimeFormatComponents timeComponents = RiaQDateTimeTools::TIME_FORMAT_UNSPECIFIED );
+        RiaQDateTimeTools::TimeFormatComponents timeComponents = RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_UNSPECIFIED );
 
     static QString dateTimeFormatForInterval( QwtDate::IntervalType                   interval,
                                               const QString&                          dateFormat,

ApplicationCode/UserInterface/RiuRelativePermeabilityPlotPanel.cpp

@@ -78,7 +78,7 @@ public:
 //--------------------------------------------------------------------------------------------------
 RiuRelativePermeabilityPlotPanel::RiuRelativePermeabilityPlotPanel( QDockWidget* parent )
     : QWidget( parent )
-    , m_unitSystem( RiaEclipseUnitTools::UNITS_UNKNOWN )
+    , m_unitSystem( RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
     , m_swat( HUGE_VAL )
     , m_sgas( HUGE_VAL )
     , m_plotUpdater( new RiuRelativePermeabilityPlotUpdater( this ) )
@@ -207,7 +207,7 @@ void RiuRelativePermeabilityPlotPanel::clearPlot()
         return;
     }
 
-    m_unitSystem = RiaEclipseUnitTools::UNITS_UNKNOWN;
+    m_unitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
     m_allCurvesArr.clear();
     m_swat = HUGE_VAL;
     m_sgas = HUGE_VAL;

ApplicationCode/UserInterface/RiuSummaryQwtPlot.h

@@ -45,11 +45,11 @@ public:
     RiuSummaryQwtPlot( RimSummaryPlot* plot, QWidget* parent = nullptr );
     ~RiuSummaryQwtPlot() override;
 
-    void useDateBasedTimeAxis(
+    void useDateBasedTimeAxis( const QString&                          dateFormat,
-        const QString&                          dateFormat,
+                               const QString&                          timeFormat,
-        const QString&                          timeFormat,
+                               RiaQDateTimeTools::DateFormatComponents dateComponents = RiaQDateTimeTools::DATE_FORMAT_UNSPECIFIED,
-        RiaQDateTimeTools::DateFormatComponents dateComponents = RiaQDateTimeTools::DATE_FORMAT_UNSPECIFIED,
+                               RiaQDateTimeTools::TimeFormatComponents timeComponents =
-        RiaQDateTimeTools::TimeFormatComponents timeComponents = RiaQDateTimeTools::TIME_FORMAT_UNSPECIFIED );
+                                   RiaQDateTimeTools::TimeFormatComponents::TIME_FORMAT_UNSPECIFIED );
 
     void useTimeBasedTimeAxis();
     void setAxisIsLogarithmic( QwtPlot::Axis axis, bool logarithmic );