#1596 Rename from RimDefines to RiaDefines

ApplicationCode/ProjectDataModel/CMakeLists_files.cmake

@@ -13,7 +13,7 @@ ${CEE_CURRENT_LIST_DIR}RimPropertyFilterCollection.h
 ${CEE_CURRENT_LIST_DIR}RimEclipsePropertyFilterCollection.h
 ${CEE_CURRENT_LIST_DIR}RimCellRangeFilter.h
 ${CEE_CURRENT_LIST_DIR}RimCellRangeFilterCollection.h
-${CEE_CURRENT_LIST_DIR}RimDefines.h
+${CEE_CURRENT_LIST_DIR}RiaDefines.h
 ${CEE_CURRENT_LIST_DIR}RimLegendConfig.h
 ${CEE_CURRENT_LIST_DIR}RimOilField.h
 ${CEE_CURRENT_LIST_DIR}RimProject.h
@@ -101,7 +101,7 @@ ${CEE_CURRENT_LIST_DIR}RimPropertyFilterCollection.cpp
 ${CEE_CURRENT_LIST_DIR}RimEclipsePropertyFilterCollection.cpp
 ${CEE_CURRENT_LIST_DIR}RimCellRangeFilter.cpp
 ${CEE_CURRENT_LIST_DIR}RimCellRangeFilterCollection.cpp
-${CEE_CURRENT_LIST_DIR}RimDefines.cpp
+${CEE_CURRENT_LIST_DIR}RiaDefines.cpp
 ${CEE_CURRENT_LIST_DIR}RimLegendConfig.cpp
 ${CEE_CURRENT_LIST_DIR}RimOilField.cpp
 ${CEE_CURRENT_LIST_DIR}RimProject.cpp

ApplicationCode/ProjectDataModel/Completions/RimCompletionCellIntersectionCalc.cpp

@@ -18,7 +18,7 @@
 
 #include "RimCompletionCellIntersectionCalc.h"
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 #include "RimProject.h"
 #include "RimOilField.h"
 #include "RimWellPathCollection.h"
@@ -58,7 +58,7 @@ void RimCompletionCellIntersectionCalc::calculateWellPathIntersections(const Rim
     
     for (auto& intersection : intersections)
     {
-        values[intersection.m_hexIndex] = RimDefines::WELL_PATH;
+        values[intersection.m_hexIndex] = RiaDefines::WELL_PATH;
     }
 
     for (const RimFishbonesMultipleSubs* fishbones : wellPath->fishbonesCollection()->fishbonesSubs)
@@ -87,7 +87,7 @@ void RimCompletionCellIntersectionCalc::calculateFishbonesIntersections(const Ri
             std::vector<HexIntersectionInfo> intersections = RigWellPathIntersectionTools::getIntersectedCells(grid, fishbonesSubs->coordsForLateral(sub.subIndex, lateralIndex));
             for (auto& intersection : intersections)
             {
-                values[intersection.m_hexIndex] = RimDefines::FISHBONES;
+                values[intersection.m_hexIndex] = RiaDefines::FISHBONES;
             }
         }
     }
@@ -101,6 +101,6 @@ void RimCompletionCellIntersectionCalc::calculatePerforationIntersections(const
     std::vector<HexIntersectionInfo> intersections = RigWellPathIntersectionTools::getIntersectedCells(grid, wellPath->wellPathGeometry()->clippedPointSubset(perforationInterval->startMD(), perforationInterval->endMD()));
     for (auto& intersection : intersections)
     {
-        values[intersection.m_hexIndex] = RimDefines::PERFORATION_INTERVAL;
+        values[intersection.m_hexIndex] = RiaDefines::PERFORATION_INTERVAL;
     }
 }

ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp

@@ -89,7 +89,7 @@ RimWellAllocationPlot::RimWellAllocationPlot()
     CAF_PDM_InitFieldNoDefault(&m_accumulatedWellFlowPlot, "AccumulatedWellFlowPlot",                      "Accumulated Well Flow",     "", "", "");
     m_accumulatedWellFlowPlot.uiCapability()->setUiHidden(true);
     m_accumulatedWellFlowPlot = new RimWellLogPlot;
-    m_accumulatedWellFlowPlot->setDepthUnit(RimDefines::UNIT_NONE);
+    m_accumulatedWellFlowPlot->setDepthUnit(RiaDefines::UNIT_NONE);
     m_accumulatedWellFlowPlot->setDepthType(RimWellLogPlot::CONNECTION_NUMBER);
     m_accumulatedWellFlowPlot->setTrackLegendsVisible(false);
     m_accumulatedWellFlowPlot->uiCapability()->setUiIcon(QIcon(":/WellFlowPlot16x16.png"));

ApplicationCode/ProjectDataModel/Flow/RimWellFlowRateCurve.cpp

@@ -175,7 +175,7 @@ void RimWellFlowRateCurve::updateStackedPlotData()
 
     bool isFirstTrack =  (wellLogTrack == wellLogPlot->trackByIndex(0));
 
-    RimDefines::DepthUnitType displayUnit = RimDefines::UNIT_NONE;
+    RiaDefines::DepthUnitType displayUnit = RiaDefines::UNIT_NONE;
 
     std::vector<double> depthValues = m_curveData->measuredDepthPlotValues(displayUnit);
     std::vector< std::pair<size_t, size_t> > polyLineStartStopIndices = m_curveData->polylineStartStopIndices();
@@ -276,7 +276,7 @@ void RimWellFlowRateCurve::setFlowValuesPrDepthValue(const QString& tracerName,
 {
     m_curveData = new RigWellLogCurveData;
 
-    m_curveData->setValuesAndMD(flowRates, depthValues, RimDefines::UNIT_NONE, false);
+    m_curveData->setValuesAndMD(flowRates, depthValues, RiaDefines::UNIT_NONE, false);
 
     m_tracerName = tracerName;
 }

ApplicationCode/ProjectDataModel/RiaDefines.cpp

@@ -0,0 +1,111 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2011-     Statoil ASA
+//  Copyright (C) 2013-     Ceetron Solutions AS
+//  Copyright (C) 2011-2012 Ceetron AS
+// 
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+// 
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+// 
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> 
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RiaDefines.h"
+#include "cafAppEnum.h"
+
+
+namespace caf
+{
+    template<>
+    void caf::AppEnum< RiaDefines::ResultCatType >::setUp()
+    {
+        addItem(RiaDefines::DYNAMIC_NATIVE, "DYNAMIC_NATIVE",   "Dynamic");
+        addItem(RiaDefines::STATIC_NATIVE,  "STATIC_NATIVE",    "Static");
+        addItem(RiaDefines::GENERATED,      "GENERATED",        "Generated");
+        addItem(RiaDefines::INPUT_PROPERTY, "INPUT_PROPERTY",   "Input Property");
+        addItem(RiaDefines::FORMATION_NAMES, "FORMATION_NAMES", "Formation Names");
+        addItem(RiaDefines::FLOW_DIAGNOSTICS, "FLOW_DIAGNOSTICS", "Flow Diagnostics");
+        setDefault(RiaDefines::DYNAMIC_NATIVE);
+    }
+
+    template<>
+    void caf::AppEnum< RiaDefines::PorosityModelType >::setUp()
+    {
+        addItem(RiaDefines::MATRIX_MODEL,   "MATRIX_MODEL",     "Matrix");
+        addItem(RiaDefines::FRACTURE_MODEL, "FRACTURE_MODEL",   "Fracture");
+
+        setDefault(RiaDefines::MATRIX_MODEL);
+    }
+
+    template<>
+    void caf::AppEnum< RiaDefines::DepthUnitType >::setUp()
+    {
+        addItem(RiaDefines::UNIT_METER,  "UNIT_METER",   "Meter");
+        addItem(RiaDefines::UNIT_FEET,   "UNIT_FEET",    "Feet");
+        addItem(RiaDefines::UNIT_NONE,   "UNIT_NONE",    "None");
+
+
+        setDefault(RiaDefines::UNIT_METER);
+    }
+
+    template<>
+    void caf::AppEnum< RiaDefines::PlotAxis >::setUp()
+    {
+        addItem(RiaDefines::PLOT_AXIS_LEFT,  "PLOT_AXIS_LEFT",  "Left");
+        addItem(RiaDefines::PLOT_AXIS_RIGHT, "PLOT_AXIS_RIGHT", "Right");
+
+        setDefault(RiaDefines::PLOT_AXIS_LEFT);
+    }
+
+    template<>
+    void caf::AppEnum< RiaDefines::CompletionType >::setUp()
+    {
+        addItem(RiaDefines::WELL_PATH, "WELL_PATH", "Well Path");
+        addItem(RiaDefines::PERFORATION_INTERVAL, "PERFORATION_INTERVAL", "Perforation Interval");
+        addItem(RiaDefines::FISHBONES, "FISHBONES", "Fishbones");
+
+        setDefault(RiaDefines::WELL_PATH);
+    }
+}
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+bool RiaDefines::isPerCellFaceResult(const QString& resultName)
+{
+    if (resultName.compare(RiaDefines::combinedTransmissibilityResultName(), Qt::CaseInsensitive) == 0)
+    {
+        return true;
+    }
+    else if (resultName.compare(RiaDefines::combinedMultResultName(), Qt::CaseInsensitive) == 0)
+    {
+        return true;
+    }
+    else if (resultName.compare(RiaDefines::ternarySaturationResultName(), Qt::CaseInsensitive) == 0)
+    {
+        return true;
+    }
+    else if (resultName.compare(RiaDefines::combinedRiTranResultName(), Qt::CaseInsensitive) == 0)
+    {
+        return true;
+    }
+    else if (resultName.compare(RiaDefines::combinedRiMultResultName(), Qt::CaseInsensitive) == 0)
+    {
+        return true;
+    }
+    else if (resultName.compare(RiaDefines::combinedRiAreaNormTranResultName(), Qt::CaseInsensitive) == 0)
+    {
+        return true;
+    }
+
+    return false;
+}

ApplicationCode/ProjectDataModel/RiaDefines.h

@@ -22,7 +22,7 @@
 
 #include <QString>
 
-class RimDefines
+class RiaDefines
 {
 
 public:

ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp

@@ -201,7 +201,7 @@ void Rim3dOverlayInfoConfig::defineUiOrdering(QString uiConfigName, caf::PdmUiOr
     caf::PdmUiGroup* statGroup = uiOrdering.addNewGroup("Statistics Options");
     RimEclipseView * eclipseView = dynamic_cast<RimEclipseView*>(m_viewDef.p());
 
-    if ( !eclipseView || eclipseView->cellResult()->resultType() != RimDefines::FLOW_DIAGNOSTICS ) // 
+    if ( !eclipseView || eclipseView->cellResult()->resultType() != RiaDefines::FLOW_DIAGNOSTICS ) // 
     {
         statGroup->add(&m_statisticsTimeRange);
     }
@@ -298,7 +298,7 @@ void Rim3dOverlayInfoConfig::updateEclipse3DInfo(RimEclipseView * eclipseView)
                 }
             }
             }
-            else if (eclipseView->cellResult()->resultType() == RimDefines::FLOW_DIAGNOSTICS)
+            else if (eclipseView->cellResult()->resultType() == RiaDefines::FLOW_DIAGNOSTICS)
             {
                 if ( m_statisticsTimeRange == CURRENT_TIMESTEP ||  m_statisticsTimeRange == ALL_TIMESTEPS) // All timesteps is ignored
                 {
@@ -379,7 +379,7 @@ void Rim3dOverlayInfoConfig::updateEclipse3DInfo(RimEclipseView * eclipseView)
         {
             QString propName = eclipseView->cellResult()->resultVariableUiShortName();
             QString timeRangeText =  m_statisticsTimeRange().uiText();
-            if ( eclipseView->cellResult()->resultType() == RimDefines::FLOW_DIAGNOSTICS )
+            if ( eclipseView->cellResult()->resultType() == RiaDefines::FLOW_DIAGNOSTICS )
             {
                 timeRangeText = caf::AppEnum<StatisticsTimeRangeType>::uiText(CURRENT_TIMESTEP);
             }
@@ -624,7 +624,7 @@ void Rim3dOverlayInfoConfig::updateVisCellStatsIfNeeded()
         }
         else if (eclipseView)
         {
-            if ( eclipseView->cellResult()->resultType() == RimDefines::FLOW_DIAGNOSTICS )
+            if ( eclipseView->cellResult()->resultType() == RiaDefines::FLOW_DIAGNOSTICS )
             {
                 RigFlowDiagResultAddress resAddr = eclipseView->cellResult()->flowDiagResAddress();
                 RigFlowDiagResults* fldResults = eclipseView->cellResult()->flowDiagSolution()->flowDiagResults();

ApplicationCode/ProjectDataModel/RimCellEdgeColors.cpp

@@ -120,7 +120,7 @@ void RimCellEdgeColors::loadResult()
         int i;
         for (i = 0; i < vars.size(); ++i)
         {
-             size_t resultindex = m_reservoirView->currentGridCellResults()->findOrLoadScalarResult(RimDefines::STATIC_NATIVE, vars[i]);
+             size_t resultindex = m_reservoirView->currentGridCellResults()->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, vars[i]);
              int cubeFaceIdx;
              for (cubeFaceIdx = 0; cubeFaceIdx < 6; ++cubeFaceIdx)
              {
@@ -186,7 +186,7 @@ QList<caf::PdmOptionItemInfo> RimCellEdgeColors::calculateValueOptions(const caf
         if (m_reservoirView && m_reservoirView->currentGridCellResults())
         {
             QStringList varList;
-            varList = m_reservoirView->currentGridCellResults()->cellResults()->resultNames(RimDefines::STATIC_NATIVE);
+            varList = m_reservoirView->currentGridCellResults()->cellResults()->resultNames(RiaDefines::STATIC_NATIVE);
 
             //TODO: Must also handle input properties
             //varList += m_reservoirView->gridCellResults()->resultNames(RimDefines::INPUT_PROPERTY);
@@ -198,7 +198,7 @@ QList<caf::PdmOptionItemInfo> RimCellEdgeColors::calculateValueOptions(const caf
             int i;
             for (i = 0; i < varList.size(); ++i)
             {
-                if (RimDefines::isPerCellFaceResult(varList[i])) continue;
+                if (RiaDefines::isPerCellFaceResult(varList[i])) continue;
 
                 size_t cubeFaceIdx;
                 for (cubeFaceIdx = 0; cubeFaceIdx < EdgeFaceEnum::size(); ++cubeFaceIdx)
@@ -242,7 +242,7 @@ QList<caf::PdmOptionItemInfo> RimCellEdgeColors::calculateValueOptions(const caf
 
             }
 
-            options.push_front(caf::PdmOptionItemInfo(RimDefines::undefinedResultName(), ""));
+            options.push_front(caf::PdmOptionItemInfo(RiaDefines::undefinedResultName(), ""));
             
             if (useOptionsOnly) *useOptionsOnly = true;
 
@@ -295,13 +295,13 @@ QStringList RimCellEdgeColors::findResultVariableNames()
     if (m_reservoirView && m_reservoirView->currentGridCellResults() && !m_resultVariable().isEmpty())
     {
         QStringList varList;
-        varList = m_reservoirView->currentGridCellResults()->cellResults()->resultNames(RimDefines::STATIC_NATIVE);
+        varList = m_reservoirView->currentGridCellResults()->cellResults()->resultNames(RiaDefines::STATIC_NATIVE);
         //TODO: Must handle Input properties
 
         int i;
         for (i = 0; i < varList.size(); ++i)
         {
-            if (RimDefines::isPerCellFaceResult(varList[i])) continue;
+            if (RiaDefines::isPerCellFaceResult(varList[i])) continue;
 
             if (varList[i].startsWith(m_resultVariable))
             {               
@@ -365,7 +365,7 @@ void RimCellEdgeColors::cellEdgeMetaData(std::vector<RimCellEdgeMetaData>* metaD
     bool isStatic = true;
     if (isUsingSingleVariable())
     {
-        isStatic = m_singleVarEdgeResultColors->resultType() == RimDefines::STATIC_NATIVE;
+        isStatic = m_singleVarEdgeResultColors->resultType() == RiaDefines::STATIC_NATIVE;
     }
 
     for (size_t i = 0; i < 6; i++)
@@ -398,7 +398,7 @@ bool RimCellEdgeColors::hasResult() const
 {
     if (!enableCellEdgeColors()) return false;
 
-    if (isUsingSingleVariable() && m_singleVarEdgeResultColors->resultType() == RimDefines::FLOW_DIAGNOSTICS)
+    if (isUsingSingleVariable() && m_singleVarEdgeResultColors->resultType() == RiaDefines::FLOW_DIAGNOSTICS)
     {
         return true;
     }
@@ -437,7 +437,7 @@ void RimCellEdgeColors::minMaxCellEdgeValues(double& min, double& max)
     globalMin = HUGE_VAL;
     globalMax = -HUGE_VAL;
 
-    if (isUsingSingleVariable() && singleVarEdgeResultColors()->resultType() == RimDefines::FLOW_DIAGNOSTICS)
+    if (isUsingSingleVariable() && singleVarEdgeResultColors()->resultType() == RiaDefines::FLOW_DIAGNOSTICS)
     {
         int currentTimeStep = m_reservoirView->currentTimeStep();
 

ApplicationCode/ProjectDataModel/RimCellEdgeColors.h

@@ -20,7 +20,7 @@
 
 #pragma once
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 
 #include "cafAppEnum.h"
 #include "cafFixedArray.h"

ApplicationCode/ProjectDataModel/RimDefines.cpp

@@ -1,111 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) 2011-     Statoil ASA
-//  Copyright (C) 2013-     Ceetron Solutions AS
-//  Copyright (C) 2011-2012 Ceetron AS
-// 
-//  ResInsight is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-// 
-//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
-//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
-//  FITNESS FOR A PARTICULAR PURPOSE.
-// 
-//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> 
-//  for more details.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-#include "RimDefines.h"
-#include "cafAppEnum.h"
-
-
-namespace caf
-{
-    template<>
-    void caf::AppEnum< RimDefines::ResultCatType >::setUp()
-    {
-        addItem(RimDefines::DYNAMIC_NATIVE, "DYNAMIC_NATIVE",   "Dynamic");
-        addItem(RimDefines::STATIC_NATIVE,  "STATIC_NATIVE",    "Static");
-        addItem(RimDefines::GENERATED,      "GENERATED",        "Generated");
-        addItem(RimDefines::INPUT_PROPERTY, "INPUT_PROPERTY",   "Input Property");
-        addItem(RimDefines::FORMATION_NAMES, "FORMATION_NAMES", "Formation Names");
-        addItem(RimDefines::FLOW_DIAGNOSTICS, "FLOW_DIAGNOSTICS", "Flow Diagnostics");
-        setDefault(RimDefines::DYNAMIC_NATIVE);
-    }
-
-    template<>
-    void caf::AppEnum< RimDefines::PorosityModelType >::setUp()
-    {
-        addItem(RimDefines::MATRIX_MODEL,   "MATRIX_MODEL",     "Matrix");
-        addItem(RimDefines::FRACTURE_MODEL, "FRACTURE_MODEL",   "Fracture");
-
-        setDefault(RimDefines::MATRIX_MODEL);
-    }
-
-    template<>
-    void caf::AppEnum< RimDefines::DepthUnitType >::setUp()
-    {
-        addItem(RimDefines::UNIT_METER,  "UNIT_METER",   "Meter");
-        addItem(RimDefines::UNIT_FEET,   "UNIT_FEET",    "Feet");
-        addItem(RimDefines::UNIT_NONE,   "UNIT_NONE",    "None");
-
-
-        setDefault(RimDefines::UNIT_METER);
-    }
-
-    template<>
-    void caf::AppEnum< RimDefines::PlotAxis >::setUp()
-    {
-        addItem(RimDefines::PLOT_AXIS_LEFT,  "PLOT_AXIS_LEFT",  "Left");
-        addItem(RimDefines::PLOT_AXIS_RIGHT, "PLOT_AXIS_RIGHT", "Right");
-
-        setDefault(RimDefines::PLOT_AXIS_LEFT);
-    }
-
-    template<>
-    void caf::AppEnum< RimDefines::CompletionType >::setUp()
-    {
-        addItem(RimDefines::WELL_PATH, "WELL_PATH", "Well Path");
-        addItem(RimDefines::PERFORATION_INTERVAL, "PERFORATION_INTERVAL", "Perforation Interval");
-        addItem(RimDefines::FISHBONES, "FISHBONES", "Fishbones");
-
-        setDefault(RimDefines::WELL_PATH);
-    }
-}
-
-
-//--------------------------------------------------------------------------------------------------
-/// 
-//--------------------------------------------------------------------------------------------------
-bool RimDefines::isPerCellFaceResult(const QString& resultName)
-{
-    if (resultName.compare(RimDefines::combinedTransmissibilityResultName(), Qt::CaseInsensitive) == 0)
-    {
-        return true;
-    }
-    else if (resultName.compare(RimDefines::combinedMultResultName(), Qt::CaseInsensitive) == 0)
-    {
-        return true;
-    }
-    else if (resultName.compare(RimDefines::ternarySaturationResultName(), Qt::CaseInsensitive) == 0)
-    {
-        return true;
-    }
-    else if (resultName.compare(RimDefines::combinedRiTranResultName(), Qt::CaseInsensitive) == 0)
-    {
-        return true;
-    }
-    else if (resultName.compare(RimDefines::combinedRiMultResultName(), Qt::CaseInsensitive) == 0)
-    {
-        return true;
-    }
-    else if (resultName.compare(RimDefines::combinedRiAreaNormTranResultName(), Qt::CaseInsensitive) == 0)
-    {
-        return true;
-    }
-
-    return false;
-}

ApplicationCode/ProjectDataModel/RimEclipseCase.cpp

@@ -249,7 +249,7 @@ RimEclipseView* RimEclipseCase::createCopyAndAddView(const RimEclipseView* sourc
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimEclipseCase::removeEclipseResultAndScheduleRedrawAllViews(RimDefines::ResultCatType type, const QString& resultName)
+void RimEclipseCase::removeEclipseResultAndScheduleRedrawAllViews(RiaDefines::ResultCatType type, const QString& resultName)
 {
     m_matrixModelResults->clearScalarResult(type, resultName);
 
@@ -321,18 +321,18 @@ void RimEclipseCase::updateFormationNamesData()
             {
                 if (!activeFormationNames())
                 {
-                    if (eclView->cellResult()->resultType() == RimDefines::FORMATION_NAMES) 
+                    if (eclView->cellResult()->resultType() == RiaDefines::FORMATION_NAMES) 
                     {
-                        eclView->cellResult()->setResultVariable(RimDefines::undefinedResultName());
+                        eclView->cellResult()->setResultVariable(RiaDefines::undefinedResultName());
                         eclView->cellResult()->updateConnectedEditors();
                     }
 
                     RimEclipsePropertyFilterCollection* eclFilColl = eclView->eclipsePropertyFilterCollection();
                     for ( RimEclipsePropertyFilter* propFilter : eclFilColl->propertyFilters )
                     {
-                        if ( propFilter->resultDefinition->resultType() == RimDefines::FORMATION_NAMES ) 
+                        if ( propFilter->resultDefinition->resultType() == RiaDefines::FORMATION_NAMES ) 
                         {
-                            propFilter->resultDefinition()->setResultVariable(RimDefines::undefinedResultName());
+                            propFilter->resultDefinition()->setResultVariable(RiaDefines::undefinedResultName());
                         }
                     }
                 }
@@ -340,7 +340,7 @@ void RimEclipseCase::updateFormationNamesData()
                 RimEclipsePropertyFilterCollection* eclFilColl = eclView->eclipsePropertyFilterCollection();
                 for ( RimEclipsePropertyFilter* propFilter : eclFilColl->propertyFilters )
                 {
-                    if ( propFilter->resultDefinition->resultType() == RimDefines::FORMATION_NAMES )
+                    if ( propFilter->resultDefinition->resultType() == RiaDefines::FORMATION_NAMES )
                     {
                         propFilter->setToDefaultValues();
                         propFilter->updateConnectedEditors();
@@ -503,7 +503,7 @@ bool RimEclipseCase::openReserviorCase()
             results->cellResults()->createPlaceholderResultEntries();
             // After the placeholder result for combined transmissibility is created, 
             // make sure the nnc transmissibilities can be addressed by this scalarResultIndex as well
-            size_t combinedTransResIdx = results->cellResults()->findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::combinedTransmissibilityResultName());
+            size_t combinedTransResIdx = results->cellResults()->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedTransmissibilityResultName());
             if (combinedTransResIdx != cvf::UNDEFINED_SIZE_T)
             {
                 eclipseCaseData()->mainGrid()->nncData()->setCombTransmisibilityScalarResultIndex(combinedTransResIdx);

ApplicationCode/ProjectDataModel/RimEclipseCase.h

@@ -23,7 +23,7 @@
 #include "RifReaderInterface.h"
 
 #include "RimCase.h"
-#include "RimDefines.h"
+#include "RiaDefines.h"
 
 #include "cafPdmChildArrayField.h"
 #include "cafPdmChildField.h"
@@ -78,7 +78,7 @@ public:
     RimEclipseView*                             createAndAddReservoirView();
     RimEclipseView*                             createCopyAndAddView(const RimEclipseView* sourceView);
 
-    void                                        removeEclipseResultAndScheduleRedrawAllViews(RimDefines::ResultCatType type, const QString& resultName);
+    void                                        removeEclipseResultAndScheduleRedrawAllViews(RiaDefines::ResultCatType type, const QString& resultName);
 
     virtual QString                             locationOnDisc() const      { return QString(); }
     virtual QString                             gridFileName() const      { return QString(); }

ApplicationCode/ProjectDataModel/RimEclipseCellColors.cpp

@@ -90,7 +90,7 @@ void RimEclipseCellColors::fieldChangedByUi(const caf::PdmFieldHandle* changedFi
             changeLegendConfig(this->resultVariable());
         }
 
-        if (newValue != RimDefines::undefinedResultName())
+        if (newValue != RiaDefines::undefinedResultName())
         {
             if (m_reservoirView) m_reservoirView->hasUserRequestedAnimation = true;
         }
@@ -116,7 +116,7 @@ void RimEclipseCellColors::fieldChangedByUi(const caf::PdmFieldHandle* changedFi
 //--------------------------------------------------------------------------------------------------
 void RimEclipseCellColors::changeLegendConfig(QString resultVarNameOfNewLegend)
 {
-    if (resultVarNameOfNewLegend != RimDefines::ternarySaturationResultName())
+    if (resultVarNameOfNewLegend != RiaDefines::ternarySaturationResultName())
     {
         QString legendResultVariable;
 
@@ -185,7 +185,7 @@ void RimEclipseCellColors::initAfterRead()
 //--------------------------------------------------------------------------------------------------
 void RimEclipseCellColors::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/)
 {
-    if (this->resultVariable() == RimDefines::ternarySaturationResultName())
+    if (this->resultVariable() == RiaDefines::ternarySaturationResultName())
     {
         uiTreeOrdering.add(ternaryLegendConfig());
     }
@@ -273,7 +273,7 @@ public :
 //--------------------------------------------------------------------------------------------------
 void RimEclipseCellColors::updateLegendData(size_t currentTimeStep)
 {
-    if (this->resultType() == RimDefines::FLOW_DIAGNOSTICS)
+    if (this->resultType() == RiaDefines::FLOW_DIAGNOSTICS)
     {
         double globalMin, globalMax;
         double globalPosClosestToZero, globalNegClosestToZero;
@@ -377,18 +377,18 @@ void RimEclipseCellColors::updateLegendData(size_t currentTimeStep)
 
         if (this->hasCategoryResult())
         {
-            if (this->resultType() == RimDefines::FORMATION_NAMES)
+            if (this->resultType() == RiaDefines::FORMATION_NAMES)
             {
                 const std::vector<QString>& fnVector = eclipseCase->activeFormationNames()->formationNames();
                 this->legendConfig()->setNamedCategoriesInverse(fnVector);
             }
-            else if (this->resultType() == RimDefines::DYNAMIC_NATIVE && this->resultVariable() == RimDefines::completionTypeResultName())
+            else if (this->resultType() == RiaDefines::DYNAMIC_NATIVE && this->resultVariable() == RiaDefines::completionTypeResultName())
             {
                 std::vector< std::tuple<QString, int, cvf::Color3ub> > categories;
 
-                caf::AppEnum<RimDefines::CompletionType> wellPath(RimDefines::WELL_PATH);
-                caf::AppEnum<RimDefines::CompletionType> fishbone(RimDefines::FISHBONES);
-                caf::AppEnum<RimDefines::CompletionType> perforationInterval(RimDefines::PERFORATION_INTERVAL);
+                caf::AppEnum<RiaDefines::CompletionType> wellPath(RiaDefines::WELL_PATH);
+                caf::AppEnum<RiaDefines::CompletionType> fishbone(RiaDefines::FISHBONES);
+                caf::AppEnum<RiaDefines::CompletionType> perforationInterval(RiaDefines::PERFORATION_INTERVAL);
 
                 categories.push_back(std::make_tuple(wellPath.uiText(),             static_cast<int>(wellPath.index()),             cvf::Color3::RED));
                 categories.push_back(std::make_tuple(fishbone.uiText(),             static_cast<int>(fishbone.index()),             cvf::Color3::DARK_GREEN));

ApplicationCode/ProjectDataModel/RimEclipseCellColors.h

@@ -20,7 +20,7 @@
 
 #pragma once
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 #include "RimEclipseResultDefinition.h"
 
 #include "cafPdmChildArrayField.h"

ApplicationCode/ProjectDataModel/RimEclipseInputCase.cpp

@@ -33,7 +33,7 @@
 #include "RigEclipseCaseData.h"
 #include "RigMainGrid.h"
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 #include "RimEclipseInputProperty.h"
 #include "RimEclipseInputPropertyCollection.h"
 #include "RimReservoirCellResultsStorage.h"
@@ -76,7 +76,7 @@ RimEclipseInputCase::~RimEclipseInputCase()
 //--------------------------------------------------------------------------------------------------
 void RimEclipseInputCase::openDataFileSet(const QStringList& fileNames)
 {
-    if (fileNames.contains(RimDefines::mockModelBasicInputCase()))
+    if (fileNames.contains(RiaDefines::mockModelBasicInputCase()))
     {
         cvf::ref<RifReaderInterface> readerInterface = this->createMockModel(fileNames[0]);
         results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(readerInterface.p());
@@ -183,7 +183,7 @@ bool RimEclipseInputCase::openEclipseGridFile()
     {
         cvf::ref<RifReaderInterface> readerInterface;
 
-        if (m_gridFileName().contains(RimDefines::mockModelBasicInputCase()))
+        if (m_gridFileName().contains(RiaDefines::mockModelBasicInputCase()))
         {
             readerInterface = this->createMockModel(this->m_gridFileName());
         }
@@ -346,7 +346,7 @@ cvf::ref<RifReaderInterface> RimEclipseInputCase::createMockModel(QString modelN
     cvf::ref<RigEclipseCaseData> reservoir = new RigEclipseCaseData;
     cvf::ref<RifReaderMockModel> mockFileInterface = new RifReaderMockModel;
 
-    if (modelName == RimDefines::mockModelBasicInputCase())
+    if (modelName == RiaDefines::mockModelBasicInputCase())
     {
         m_gridFileName = modelName;
 

ApplicationCode/ProjectDataModel/RimEclipseInputProperty.cpp

@@ -94,7 +94,7 @@ void RimEclipseInputProperty::fieldChangedByUi(const caf::PdmFieldHandle* change
             RigCaseCellResultsData* matrixResults = rimCase->eclipseCaseData()->results(RifReaderInterface::MATRIX_RESULTS);
             if (matrixResults)
             {
-                if (matrixResults->updateResultName(RimDefines::INPUT_PROPERTY, oldName, newName))
+                if (matrixResults->updateResultName(RiaDefines::INPUT_PROPERTY, oldName, newName))
                 {
                     anyNameUpdated = true;
                 }
@@ -103,7 +103,7 @@ void RimEclipseInputProperty::fieldChangedByUi(const caf::PdmFieldHandle* change
             RigCaseCellResultsData* fracResults = rimCase->eclipseCaseData()->results(RifReaderInterface::FRACTURE_RESULTS);
             if (fracResults)
             {
-                if (fracResults->updateResultName(RimDefines::INPUT_PROPERTY, oldName, newName))
+                if (fracResults->updateResultName(RiaDefines::INPUT_PROPERTY, oldName, newName))
                 {
                     anyNameUpdated = true;
                 }

ApplicationCode/ProjectDataModel/RimEclipsePropertyFilter.cpp

@@ -252,7 +252,7 @@ void RimEclipsePropertyFilter::updateReadOnlyStateOfAllFields()
 //--------------------------------------------------------------------------------------------------
 void RimEclipsePropertyFilter::updateRangeLabel()
 {
-    if (resultDefinition->resultType() == RimDefines::FLOW_DIAGNOSTICS)
+    if (resultDefinition->resultType() == RiaDefines::FLOW_DIAGNOSTICS)
     {
         m_rangeLabelText = "Current Timestep";
     }
@@ -348,7 +348,7 @@ void RimEclipsePropertyFilter::computeResultValueRange()
 
     clearCategories();
 
-    if (resultDefinition->resultType() == RimDefines::FLOW_DIAGNOSTICS)
+    if (resultDefinition->resultType() == RiaDefines::FLOW_DIAGNOSTICS)
     {
         RimView* view;
         this->firstAncestorOrThisOfType(view);
@@ -379,7 +379,7 @@ void RimEclipsePropertyFilter::computeResultValueRange()
 
                 if ( resultDefinition->hasCategoryResult() )
                 {
-                    if ( resultDefinition->resultType() == RimDefines::FORMATION_NAMES )
+                    if ( resultDefinition->resultType() == RiaDefines::FORMATION_NAMES )
                     {
                         CVF_ASSERT(parentContainer()->reservoirView()->eclipseCase()->eclipseCaseData());
                         CVF_ASSERT(parentContainer()->reservoirView()->eclipseCase()->eclipseCaseData()->activeFormationNames());
@@ -387,10 +387,10 @@ void RimEclipsePropertyFilter::computeResultValueRange()
                         const std::vector<QString>& fnVector = parentContainer()->reservoirView()->eclipseCase()->eclipseCaseData()->activeFormationNames()->formationNames();
                         setCategoryNames(fnVector);
                     }
-                    else if (resultDefinition->resultVariable() == RimDefines::completionTypeResultName())
+                    else if (resultDefinition->resultVariable() == RiaDefines::completionTypeResultName())
                     {
                         std::vector<QString> ctNames;
-                        for (QString ctName : caf::AppEnum<RimDefines::CompletionType>::uiTexts())
+                        for (QString ctName : caf::AppEnum<RiaDefines::CompletionType>::uiTexts())
                         {
                             ctNames.push_back(ctName);
                         }
@@ -423,7 +423,7 @@ void RimEclipsePropertyFilter::updateFromCurrentTimeStep()
     //
     // If the user manually has set a filter value, this value is left untouched
 
-    if (resultDefinition->resultType() != RimDefines::FLOW_DIAGNOSTICS)
+    if (resultDefinition->resultType() != RiaDefines::FLOW_DIAGNOSTICS)
     {
         return;
     }

ApplicationCode/ProjectDataModel/RimEclipsePropertyFilterCollection.cpp

@@ -129,8 +129,8 @@ bool RimEclipsePropertyFilterCollection::isUsingFormationNames() const
     {
         RimEclipsePropertyFilter* propertyFilter = propertyFilters[i];
         if (   propertyFilter->isActive() 
-            && propertyFilter->resultDefinition->resultType() == RimDefines::FORMATION_NAMES 
-            && propertyFilter->resultDefinition->resultVariable() != RimDefines::undefinedResultName()) return true;
+            && propertyFilter->resultDefinition->resultType() == RiaDefines::FORMATION_NAMES 
+            && propertyFilter->resultDefinition->resultVariable() != RiaDefines::undefinedResultName()) return true;
     }
 
     return false;

ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp

@@ -225,7 +225,7 @@ cvf::ref<RifReaderInterface> RimEclipseResultCase::createMockModel(QString model
     cvf::ref<RifReaderMockModel> mockFileInterface = new RifReaderMockModel;
     cvf::ref<RigEclipseCaseData> reservoir = new RigEclipseCaseData;
 
-     if (modelName == RimDefines::mockModelBasic())
+     if (modelName == RiaDefines::mockModelBasic())
     {
         // Create the mock file interface and and RigSerervoir and set them up.
         mockFileInterface->setWorldCoordinates(cvf::Vec3d(10, 10, 10), cvf::Vec3d(20, 20, 20));
@@ -235,7 +235,7 @@ cvf::ref<RifReaderInterface> RimEclipseResultCase::createMockModel(QString model
 
         mockFileInterface->open("", reservoir.p());
     }
-    else if (modelName == RimDefines::mockModelBasicWithResults())
+    else if (modelName == RiaDefines::mockModelBasicWithResults())
     {
         mockFileInterface->setWorldCoordinates(cvf::Vec3d(10, 10, 10), cvf::Vec3d(-20, -20, -20));
         mockFileInterface->setGridPointDimensions(cvf::Vec3st(5, 10, 20));
@@ -248,7 +248,7 @@ cvf::ref<RifReaderInterface> RimEclipseResultCase::createMockModel(QString model
         cvf::Vec3d& tmp = reservoir->mainGrid()->nodes()[1];
         tmp += cvf::Vec3d(1, 0, 0);
     }
-    else if (modelName == RimDefines::mockModelLargeWithResults())
+    else if (modelName == RiaDefines::mockModelLargeWithResults())
     {
         double startX = 0;
         double startY = 0;
@@ -276,7 +276,7 @@ cvf::ref<RifReaderInterface> RimEclipseResultCase::createMockModel(QString model
         mockFileInterface->open("", reservoir.p());
 
     }
-    else if (modelName == RimDefines::mockModelCustomized())
+    else if (modelName == RiaDefines::mockModelCustomized())
     {
         QApplication::setOverrideCursor(QCursor(Qt::ArrowCursor));
 

ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp

@@ -72,7 +72,7 @@ RimEclipseResultDefinition::RimEclipseResultDefinition()
     CAF_PDM_InitFieldNoDefault(&m_porosityModel,  "PorosityModelType",    "Porosity", "", "", "");
     m_porosityModel.uiCapability()->setUiHidden(true);
 
-    CAF_PDM_InitField(&m_resultVariable, "ResultVariable", RimDefines::undefinedResultName(), "Variable", "", "", "" );
+    CAF_PDM_InitField(&m_resultVariable, "ResultVariable", RiaDefines::undefinedResultName(), "Variable", "", "", "" );
     m_resultVariable.uiCapability()->setUiHidden(true);
 
     CAF_PDM_InitFieldNoDefault(&m_flowSolution, "FlowDiagSolution", "Solution", "", "", "");
@@ -93,7 +93,7 @@ RimEclipseResultDefinition::RimEclipseResultDefinition()
     m_porosityModelUiField.xmlCapability()->setIOReadable(false);
     m_porosityModelUiField.xmlCapability()->setIOWritable(false);
 
-    CAF_PDM_InitField(&m_resultVariableUiField, "MResultVariable", RimDefines::undefinedResultName(), "Result property", "", "", "" );
+    CAF_PDM_InitField(&m_resultVariableUiField, "MResultVariable", RiaDefines::undefinedResultName(), "Result property", "", "", "" );
     m_resultVariableUiField.xmlCapability()->setIOReadable(false);
     m_resultVariableUiField.xmlCapability()->setIOWritable(false);
     m_resultVariableUiField.uiCapability()->setUiEditorTypeName(caf::PdmUiListEditor::uiEditorTypeName());
@@ -170,7 +170,7 @@ void RimEclipseResultDefinition::fieldChangedByUi(const caf::PdmFieldHandle* cha
 
         QStringList varList = getResultNamesForCurrentUiResultType();
 
-        bool isFlowDiagFieldsRelevant = (m_resultType() == RimDefines::FLOW_DIAGNOSTICS);
+        bool isFlowDiagFieldsRelevant = (m_resultType() == RiaDefines::FLOW_DIAGNOSTICS);
         
 
         if (   ( m_flowSolutionUiField() == m_flowSolution() || !isFlowDiagFieldsRelevant)
@@ -198,7 +198,7 @@ void RimEclipseResultDefinition::fieldChangedByUi(const caf::PdmFieldHandle* cha
         m_resultType     = m_resultTypeUiField;
         m_resultVariable = m_resultVariableUiField;
         
-        if (m_resultTypeUiField() == RimDefines::FLOW_DIAGNOSTICS)
+        if (m_resultTypeUiField() == RiaDefines::FLOW_DIAGNOSTICS)
         {
             m_flowSolution = m_flowSolutionUiField();
             m_selectedTracers = m_selectedTracersUiField();
@@ -308,7 +308,7 @@ void RimEclipseResultDefinition::updateAnyFieldHasChanged()
 //--------------------------------------------------------------------------------------------------
 void RimEclipseResultDefinition::setTofAndSelectTracer(const QString& tracerName)
 {
-    setResultType(RimDefines::FLOW_DIAGNOSTICS);
+    setResultType(RiaDefines::FLOW_DIAGNOSTICS);
     setResultVariable("TOF");
     setFlowDiagTracerSelectionType(FLOW_TR_BY_SELECTION);
 
@@ -434,11 +434,11 @@ QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calculateValueOptions(
         // Do not include flow diagnostics results if not available or is a time history curve
         if ( !hasFlowDiagFluxes || timeHistoryCurve != nullptr )
         {
-            using ResCatEnum = caf::AppEnum< RimDefines::ResultCatType >;
+            using ResCatEnum = caf::AppEnum< RiaDefines::ResultCatType >;
             for ( size_t i = 0; i < ResCatEnum::size(); ++i )
             {
-                RimDefines::ResultCatType resType = ResCatEnum::fromIndex(i);
-                if ( resType != RimDefines::FLOW_DIAGNOSTICS )
+                RiaDefines::ResultCatType resType = ResCatEnum::fromIndex(i);
+                if ( resType != RiaDefines::FLOW_DIAGNOSTICS )
                 {
                     QString uiString = ResCatEnum::uiTextFromIndex(i);
                     options.push_back(caf::PdmOptionItemInfo(uiString, resType));
@@ -451,7 +451,7 @@ QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calculateValueOptions(
         }
     }
 
-    if ( m_resultTypeUiField() != RimDefines::FLOW_DIAGNOSTICS )
+    if ( m_resultTypeUiField() != RiaDefines::FLOW_DIAGNOSTICS )
     {
         if ( fieldNeedingOptions == &m_resultVariableUiField )
         {
@@ -520,7 +520,7 @@ QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calculateValueOptions(
 //--------------------------------------------------------------------------------------------------
 QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calcOptionsForVariableUiFieldStandard()
 {
-    CVF_ASSERT(m_resultTypeUiField() != RimDefines::FLOW_DIAGNOSTICS);
+    CVF_ASSERT(m_resultTypeUiField() != RiaDefines::FLOW_DIAGNOSTICS);
 
     if (this->currentGridCellResults())
     {
@@ -531,7 +531,7 @@ QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calcOptionsForVariable
 
         foreach(QString s, getResultNamesForCurrentUiResultType())
         {
-            if (RimDefines::isPerCellFaceResult(s))
+            if (RiaDefines::isPerCellFaceResult(s))
             {
                 cellFaceResultNames.push_back(s);
             }
@@ -556,9 +556,9 @@ QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calcOptionsForVariable
         else if (cellCenterResultNames.contains("SGAS")) hasAtLeastOneTernaryComponent = true;
         else if (cellCenterResultNames.contains("SWAT")) hasAtLeastOneTernaryComponent = true;
 
-        if (m_resultTypeUiField == RimDefines::DYNAMIC_NATIVE && hasAtLeastOneTernaryComponent)
+        if (m_resultTypeUiField == RiaDefines::DYNAMIC_NATIVE && hasAtLeastOneTernaryComponent)
         {
-            optionList.push_front(caf::PdmOptionItemInfo(RimDefines::ternarySaturationResultName(), RimDefines::ternarySaturationResultName()));
+            optionList.push_front(caf::PdmOptionItemInfo(RiaDefines::ternarySaturationResultName(), RiaDefines::ternarySaturationResultName()));
         }
 
         // Cell Face result names
@@ -582,7 +582,7 @@ QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calcOptionsForVariable
             }
         }
 
-        optionList.push_front(caf::PdmOptionItemInfo(RimDefines::undefinedResultName(), RimDefines::undefinedResultName()));
+        optionList.push_front(caf::PdmOptionItemInfo(RiaDefines::undefinedResultName(), RiaDefines::undefinedResultName()));
 
         // Remove Per Cell Face options
         {
@@ -612,7 +612,7 @@ QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calcOptionsForVariable
 //--------------------------------------------------------------------------------------------------
 QStringList RimEclipseResultDefinition::getResultNamesForCurrentUiResultType()
 {
-    if ( m_resultTypeUiField() != RimDefines::FLOW_DIAGNOSTICS )
+    if ( m_resultTypeUiField() != RiaDefines::FLOW_DIAGNOSTICS )
     {
         RimReservoirCellResultsStorage* cellResultsStorage = currentGridCellResults();
 
@@ -640,7 +640,7 @@ size_t RimEclipseResultDefinition::scalarResultIndex() const
 {
     size_t gridScalarResultIndex = cvf::UNDEFINED_SIZE_T;
 
-    if (m_resultType() == RimDefines::FLOW_DIAGNOSTICS) return cvf::UNDEFINED_SIZE_T;
+    if (m_resultType() == RiaDefines::FLOW_DIAGNOSTICS) return cvf::UNDEFINED_SIZE_T;
 
     const RimReservoirCellResultsStorage* gridCellResults = this->currentGridCellResults();
     if (gridCellResults && gridCellResults->cellResults())
@@ -656,7 +656,7 @@ size_t RimEclipseResultDefinition::scalarResultIndex() const
 //--------------------------------------------------------------------------------------------------
 RigFlowDiagResultAddress RimEclipseResultDefinition::flowDiagResAddress() const
 {
-    CVF_ASSERT(m_resultType() == RimDefines::FLOW_DIAGNOSTICS);
+    CVF_ASSERT(m_resultType() == RiaDefines::FLOW_DIAGNOSTICS);
 
     size_t timeStep = 0;
 
@@ -736,7 +736,7 @@ void RimEclipseResultDefinition::setFlowDiagTracerSelectionType(FlowTracerSelect
 //--------------------------------------------------------------------------------------------------
 QString RimEclipseResultDefinition::resultVariableUiName() const
 {
-    if (resultType() == RimDefines::FLOW_DIAGNOSTICS)
+    if (resultType() == RiaDefines::FLOW_DIAGNOSTICS)
     {
         QString fullName;
 
@@ -761,7 +761,7 @@ QString RimEclipseResultDefinition::resultVariableUiName() const
 //--------------------------------------------------------------------------------------------------
 QString RimEclipseResultDefinition::resultVariableUiShortName() const
 {
-    if (resultType() == RimDefines::FLOW_DIAGNOSTICS)
+    if (resultType() == RiaDefines::FLOW_DIAGNOSTICS)
     {
         QString shortName;
 
@@ -795,7 +795,7 @@ QString RimEclipseResultDefinition::resultVariableUiShortName() const
 //--------------------------------------------------------------------------------------------------
 void RimEclipseResultDefinition::loadResult()
 {
-    if (m_resultType() == RimDefines::FLOW_DIAGNOSTICS) return; // Will load automatically on access
+    if (m_resultType() == RiaDefines::FLOW_DIAGNOSTICS) return; // Will load automatically on access
 
     RimReservoirCellResultsStorage* gridCellResults = this->currentGridCellResults();
     if (gridCellResults)
@@ -811,7 +811,7 @@ void RimEclipseResultDefinition::loadResult()
 //--------------------------------------------------------------------------------------------------
 bool RimEclipseResultDefinition::hasStaticResult() const
 {
-    if (this->resultType() == RimDefines::FLOW_DIAGNOSTICS) return false;
+    if (this->resultType() == RiaDefines::FLOW_DIAGNOSTICS) return false;
 
     const RimReservoirCellResultsStorage* gridCellResults = this->currentGridCellResults();
     size_t gridScalarResultIndex = this->scalarResultIndex();
@@ -831,7 +831,7 @@ bool RimEclipseResultDefinition::hasStaticResult() const
 //--------------------------------------------------------------------------------------------------
 bool RimEclipseResultDefinition::hasResult() const
 {
-    if (this->resultType() == RimDefines::FLOW_DIAGNOSTICS)
+    if (this->resultType() == RiaDefines::FLOW_DIAGNOSTICS)
     {
         if (m_flowSolution() && !m_resultVariable().isEmpty()) return true;
     }
@@ -853,11 +853,11 @@ bool RimEclipseResultDefinition::hasDynamicResult() const
 {
     if (hasResult())
     {
-        if (m_resultType() == RimDefines::DYNAMIC_NATIVE)
+        if (m_resultType() == RiaDefines::DYNAMIC_NATIVE)
         {
             return true;
         }
-        else if (m_resultType() == RimDefines::FLOW_DIAGNOSTICS)
+        else if (m_resultType() == RiaDefines::FLOW_DIAGNOSTICS)
         {
             return true;
         }
@@ -895,7 +895,7 @@ void RimEclipseResultDefinition::initAfterRead()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimEclipseResultDefinition::setResultType(RimDefines::ResultCatType val)
+void RimEclipseResultDefinition::setResultType(RiaDefines::ResultCatType val)
 {
     m_resultType = val;
     m_resultTypeUiField = val;
@@ -904,7 +904,7 @@ void RimEclipseResultDefinition::setResultType(RimDefines::ResultCatType val)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimEclipseResultDefinition::setPorosityModel(RimDefines::PorosityModelType val)
+void RimEclipseResultDefinition::setPorosityModel(RiaDefines::PorosityModelType val)
 {
     m_porosityModel = val;
     m_porosityModelUiField = val;
@@ -950,8 +950,8 @@ void RimEclipseResultDefinition::setSelectedTracers(const std::vector<QString>&
 //--------------------------------------------------------------------------------------------------
 bool RimEclipseResultDefinition::isTernarySaturationSelected() const
 {
-    bool isTernary =    (m_resultType() == RimDefines::DYNAMIC_NATIVE) && 
-                        (m_resultVariable().compare(RimDefines::ternarySaturationResultName(), Qt::CaseInsensitive) == 0);
+    bool isTernary =    (m_resultType() == RiaDefines::DYNAMIC_NATIVE) && 
+                        (m_resultVariable().compare(RiaDefines::ternarySaturationResultName(), Qt::CaseInsensitive) == 0);
 
     return isTernary;
 }
@@ -961,7 +961,7 @@ bool RimEclipseResultDefinition::isTernarySaturationSelected() const
 //--------------------------------------------------------------------------------------------------
 bool RimEclipseResultDefinition::isCompletionTypeSelected() const
 {
-    return (m_resultType() == RimDefines::DYNAMIC_NATIVE && m_resultVariable() == RimDefines::completionTypeResultName());
+    return (m_resultType() == RiaDefines::DYNAMIC_NATIVE && m_resultVariable() == RiaDefines::completionTypeResultName());
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -969,15 +969,15 @@ bool RimEclipseResultDefinition::isCompletionTypeSelected() const
 //--------------------------------------------------------------------------------------------------
 bool RimEclipseResultDefinition::hasCategoryResult() const
 {
-    if (this->m_resultType() == RimDefines::FORMATION_NAMES
+    if (this->m_resultType() == RiaDefines::FORMATION_NAMES
         && m_eclipseCase 
         && m_eclipseCase->eclipseCaseData() 
         && m_eclipseCase->eclipseCaseData()->activeFormationNames() ) return true;
 
-    if (this->m_resultType() == RimDefines::DYNAMIC_NATIVE
-        && this->resultVariable() == RimDefines::completionTypeResultName()) return true;
+    if (this->m_resultType() == RiaDefines::DYNAMIC_NATIVE
+        && this->resultVariable() == RiaDefines::completionTypeResultName()) return true;
 
-    if (this->m_resultType() == RimDefines::FLOW_DIAGNOSTICS
+    if (this->m_resultType() == RiaDefines::FLOW_DIAGNOSTICS
         && m_resultVariable() == RIG_FLD_MAX_FRACTION_TRACER_RESNAME) return true;
 
     if (!this->hasStaticResult()) return false;
@@ -1015,7 +1015,7 @@ void RimEclipseResultDefinition::defineUiOrdering(QString uiConfigName, caf::Pdm
         uiOrdering.add(&m_porosityModelUiField);
     }
 
-    if ( m_resultTypeUiField() == RimDefines::FLOW_DIAGNOSTICS )
+    if ( m_resultTypeUiField() == RiaDefines::FLOW_DIAGNOSTICS )
     { 
         uiOrdering.add(&m_flowSolutionUiField);
 
@@ -1042,7 +1042,7 @@ void RimEclipseResultDefinition::defineUiOrdering(QString uiConfigName, caf::Pdm
 //--------------------------------------------------------------------------------------------------
 void RimEclipseResultDefinition::defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute)
 {
-    if (m_resultTypeUiField() == RimDefines::FLOW_DIAGNOSTICS
+    if (m_resultTypeUiField() == RiaDefines::FLOW_DIAGNOSTICS
         && field == &m_resultVariableUiField)
     {
         caf::PdmUiListEditorAttribute* listEditAttr = dynamic_cast<caf::PdmUiListEditorAttribute*>(attribute);
@@ -1063,7 +1063,7 @@ void RimEclipseResultDefinition::removePerCellFaceOptionItems(QList<caf::PdmOpti
     {
         QString text = optionItems[i].optionUiText;
 
-        if (RimDefines::isPerCellFaceResult(text))
+        if (RiaDefines::isPerCellFaceResult(text))
         {
             indicesToRemove.push_back(i);
         }

ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.h

@@ -20,7 +20,7 @@
 
 #pragma once
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 
 #include "cafAppEnum.h"
 #include "cafPdmField.h"
@@ -62,10 +62,10 @@ public:
 
     void                            setEclipseCase(RimEclipseCase* eclipseCase);
 
-    RimDefines::ResultCatType       resultType() const { return m_resultType(); }
-    void                            setResultType(RimDefines::ResultCatType val);
-    RimDefines::PorosityModelType   porosityModel() const { return m_porosityModel(); }
-    void                            setPorosityModel(RimDefines::PorosityModelType val);
+    RiaDefines::ResultCatType       resultType() const { return m_resultType(); }
+    void                            setResultType(RiaDefines::ResultCatType val);
+    RiaDefines::PorosityModelType   porosityModel() const { return m_porosityModel(); }
+    void                            setPorosityModel(RiaDefines::PorosityModelType val);
     QString                         resultVariable() const { return m_resultVariable(); }
     virtual void                    setResultVariable(const QString& val);
     
@@ -105,8 +105,8 @@ protected:
     virtual void                          defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute) override;
 
 protected:
-    caf::PdmField< caf::AppEnum< RimDefines::ResultCatType > >      m_resultType;
-    caf::PdmField< caf::AppEnum< RimDefines::PorosityModelType > >  m_porosityModel;
+    caf::PdmField< caf::AppEnum< RiaDefines::ResultCatType > >      m_resultType;
+    caf::PdmField< caf::AppEnum< RiaDefines::PorosityModelType > >  m_porosityModel;
     caf::PdmField<QString>                                          m_resultVariable;
 
     caf::PdmPtrField<RimFlowDiagSolution*>                          m_flowSolution;
@@ -118,8 +118,8 @@ protected:
 
     // User interface only fields, to support "filtering"-like behaviour etc.
 
-    caf::PdmField< caf::AppEnum< RimDefines::ResultCatType > >      m_resultTypeUiField;
-    caf::PdmField< caf::AppEnum< RimDefines::PorosityModelType > >  m_porosityModelUiField;
+    caf::PdmField< caf::AppEnum< RiaDefines::ResultCatType > >      m_resultTypeUiField;
+    caf::PdmField< caf::AppEnum< RiaDefines::PorosityModelType > >  m_porosityModelUiField;
     caf::PdmField<QString>                                          m_resultVariableUiField;
 
     caf::PdmField< caf::AppEnum< FlowTracerSelectionType > >        m_flowTracerSelectionMode;

ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.cpp

@@ -109,7 +109,7 @@ RimEclipseStatisticsCase::RimEclipseStatisticsCase()
     CAF_PDM_InitField(&m_midPercentile, "MidPercentile", 50.0, "Mid", "", "", "");
     CAF_PDM_InitField(&m_highPercentile, "HighPercentile", 90.0, "High", "", "", "");
 
-    CAF_PDM_InitField(&m_wellDataSourceCase, "WellDataSourceCase", RimDefines::undefinedResultName(), "Well Data Source Case", "", "", "" );
+    CAF_PDM_InitField(&m_wellDataSourceCase, "WellDataSourceCase", RiaDefines::undefinedResultName(), "Well Data Source Case", "", "", "" );
 
     CAF_PDM_InitField(&m_useZeroAsInactiveCellValue, "UseZeroAsInactiveCellValue", false, "Use Zero as Inactive Cell Value", "", "", "");
 
@@ -248,42 +248,42 @@ void RimEclipseStatisticsCase::computeStatistics()
 
     for(size_t pIdx = 0; pIdx < m_selectedDynamicProperties().size(); ++pIdx)
     {
-        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::MATRIX_RESULTS, RimDefines::DYNAMIC_NATIVE, m_selectedDynamicProperties()[pIdx]));
+        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::MATRIX_RESULTS, RiaDefines::DYNAMIC_NATIVE, m_selectedDynamicProperties()[pIdx]));
     }
 
     for(size_t pIdx = 0; pIdx < m_selectedStaticProperties().size(); ++pIdx)
     {
-        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::MATRIX_RESULTS, RimDefines::STATIC_NATIVE, m_selectedStaticProperties()[pIdx]));
+        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::MATRIX_RESULTS, RiaDefines::STATIC_NATIVE, m_selectedStaticProperties()[pIdx]));
     }
 
     for(size_t pIdx = 0; pIdx < m_selectedGeneratedProperties().size(); ++pIdx)
     {
-        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::MATRIX_RESULTS, RimDefines::GENERATED, m_selectedGeneratedProperties()[pIdx]));
+        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::MATRIX_RESULTS, RiaDefines::GENERATED, m_selectedGeneratedProperties()[pIdx]));
     }
 
     for(size_t pIdx = 0; pIdx < m_selectedInputProperties().size(); ++pIdx)
     {
-        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::MATRIX_RESULTS, RimDefines::INPUT_PROPERTY, m_selectedInputProperties()[pIdx]));
+        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::MATRIX_RESULTS, RiaDefines::INPUT_PROPERTY, m_selectedInputProperties()[pIdx]));
     }
 
     for(size_t pIdx = 0; pIdx < m_selectedFractureDynamicProperties().size(); ++pIdx)
     {
-        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::FRACTURE_RESULTS, RimDefines::DYNAMIC_NATIVE, m_selectedFractureDynamicProperties()[pIdx]));
+        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::FRACTURE_RESULTS, RiaDefines::DYNAMIC_NATIVE, m_selectedFractureDynamicProperties()[pIdx]));
     }
 
     for(size_t pIdx = 0; pIdx < m_selectedFractureStaticProperties().size(); ++pIdx)
     {
-        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::FRACTURE_RESULTS, RimDefines::STATIC_NATIVE, m_selectedFractureStaticProperties()[pIdx]));
+        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::FRACTURE_RESULTS, RiaDefines::STATIC_NATIVE, m_selectedFractureStaticProperties()[pIdx]));
     }
 
     for(size_t pIdx = 0; pIdx < m_selectedFractureGeneratedProperties().size(); ++pIdx)
     {
-        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::FRACTURE_RESULTS, RimDefines::GENERATED, m_selectedFractureGeneratedProperties()[pIdx]));
+        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::FRACTURE_RESULTS, RiaDefines::GENERATED, m_selectedFractureGeneratedProperties()[pIdx]));
     }
 
     for(size_t pIdx = 0; pIdx < m_selectedFractureInputProperties().size(); ++pIdx)
     {
-        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::FRACTURE_RESULTS, RimDefines::INPUT_PROPERTY, m_selectedFractureInputProperties()[pIdx]));
+        resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RifReaderInterface::FRACTURE_RESULTS, RiaDefines::INPUT_PROPERTY, m_selectedFractureInputProperties()[pIdx]));
     }
 
     RimEclipseStatisticsCaseEvaluator stat(sourceCases, timeStepIndices, statisticsConfig, resultCase, gridCaseGroup);
@@ -420,49 +420,49 @@ QList<caf::PdmOptionItemInfo> RimEclipseStatisticsCase::calculateValueOptions(co
 
     if (&m_selectedDynamicProperties == fieldNeedingOptions)
     {
-        QStringList varList = caseData->results(RifReaderInterface::MATRIX_RESULTS)->resultNames(RimDefines::DYNAMIC_NATIVE);
+        QStringList varList = caseData->results(RifReaderInterface::MATRIX_RESULTS)->resultNames(RiaDefines::DYNAMIC_NATIVE);
         return toOptionList(varList);
     } 
     else if (&m_selectedStaticProperties == fieldNeedingOptions)
     {
-        QStringList varList = caseData->results(RifReaderInterface::MATRIX_RESULTS)->resultNames(RimDefines::STATIC_NATIVE);
+        QStringList varList = caseData->results(RifReaderInterface::MATRIX_RESULTS)->resultNames(RiaDefines::STATIC_NATIVE);
         return toOptionList(varList);
     } 
     else if (&m_selectedGeneratedProperties == fieldNeedingOptions)
     {
-        QStringList varList = caseData->results(RifReaderInterface::MATRIX_RESULTS)->resultNames(RimDefines::GENERATED);
+        QStringList varList = caseData->results(RifReaderInterface::MATRIX_RESULTS)->resultNames(RiaDefines::GENERATED);
         return toOptionList(varList);
     } 
     else if (&m_selectedInputProperties == fieldNeedingOptions)
     {
-        QStringList varList = caseData->results(RifReaderInterface::MATRIX_RESULTS)->resultNames(RimDefines::INPUT_PROPERTY);
+        QStringList varList = caseData->results(RifReaderInterface::MATRIX_RESULTS)->resultNames(RiaDefines::INPUT_PROPERTY);
         return toOptionList(varList);
     }
     else if (&m_selectedFractureDynamicProperties == fieldNeedingOptions)
     {
-        QStringList varList = caseData->results(RifReaderInterface::FRACTURE_RESULTS)->resultNames(RimDefines::DYNAMIC_NATIVE);
+        QStringList varList = caseData->results(RifReaderInterface::FRACTURE_RESULTS)->resultNames(RiaDefines::DYNAMIC_NATIVE);
         return toOptionList(varList);
     } 
     else if (&m_selectedFractureStaticProperties == fieldNeedingOptions)
     {
-        QStringList varList = caseData->results(RifReaderInterface::FRACTURE_RESULTS)->resultNames(RimDefines::STATIC_NATIVE);
+        QStringList varList = caseData->results(RifReaderInterface::FRACTURE_RESULTS)->resultNames(RiaDefines::STATIC_NATIVE);
         return toOptionList(varList);
     } 
     else if (&m_selectedFractureGeneratedProperties == fieldNeedingOptions)
     {
-        QStringList varList = caseData->results(RifReaderInterface::FRACTURE_RESULTS)->resultNames(RimDefines::GENERATED);
+        QStringList varList = caseData->results(RifReaderInterface::FRACTURE_RESULTS)->resultNames(RiaDefines::GENERATED);
         return toOptionList(varList);
     } 
     else if (&m_selectedFractureInputProperties == fieldNeedingOptions)
     {
-        QStringList varList = caseData->results(RifReaderInterface::FRACTURE_RESULTS)->resultNames(RimDefines::INPUT_PROPERTY);
+        QStringList varList = caseData->results(RifReaderInterface::FRACTURE_RESULTS)->resultNames(RiaDefines::INPUT_PROPERTY);
         return toOptionList(varList);
     }
 
     else if (&m_wellDataSourceCase == fieldNeedingOptions)
     {
         QStringList sourceCaseNames;
-        sourceCaseNames += RimDefines::undefinedResultName();
+        sourceCaseNames += RiaDefines::undefinedResultName();
 
         for (size_t i = 0; i < caseGroup()->caseCollection()->reservoirs().size(); i++)
         {
@@ -638,15 +638,15 @@ void RimEclipseStatisticsCase::updateSelectionListVisibilities()
     m_resultType.uiCapability()->setUiHidden(isLocked);
     m_porosityModel.uiCapability()->setUiHidden(isLocked ); // || !caseGroup()->mainCase()->reservoirData()->results(RifReaderInterface::FRACTURE_RESULTS)->resultCount()
 
-    m_selectedDynamicProperties.uiCapability()->setUiHidden(           isLocked || !(m_porosityModel() == RimDefines::MATRIX_MODEL && m_resultType() == RimDefines::DYNAMIC_NATIVE));
-    m_selectedStaticProperties.uiCapability()->setUiHidden(            isLocked || !(m_porosityModel() == RimDefines::MATRIX_MODEL && m_resultType() == RimDefines::STATIC_NATIVE));
-    m_selectedGeneratedProperties.uiCapability()->setUiHidden(         isLocked || !(m_porosityModel() == RimDefines::MATRIX_MODEL && m_resultType() == RimDefines::GENERATED));
-    m_selectedInputProperties.uiCapability()->setUiHidden(             isLocked || !(m_porosityModel() == RimDefines::MATRIX_MODEL && m_resultType() == RimDefines::INPUT_PROPERTY));
+    m_selectedDynamicProperties.uiCapability()->setUiHidden(           isLocked || !(m_porosityModel() == RiaDefines::MATRIX_MODEL && m_resultType() == RiaDefines::DYNAMIC_NATIVE));
+    m_selectedStaticProperties.uiCapability()->setUiHidden(            isLocked || !(m_porosityModel() == RiaDefines::MATRIX_MODEL && m_resultType() == RiaDefines::STATIC_NATIVE));
+    m_selectedGeneratedProperties.uiCapability()->setUiHidden(         isLocked || !(m_porosityModel() == RiaDefines::MATRIX_MODEL && m_resultType() == RiaDefines::GENERATED));
+    m_selectedInputProperties.uiCapability()->setUiHidden(             isLocked || !(m_porosityModel() == RiaDefines::MATRIX_MODEL && m_resultType() == RiaDefines::INPUT_PROPERTY));
 
-    m_selectedFractureDynamicProperties.uiCapability()->setUiHidden(   isLocked || !(m_porosityModel() == RimDefines::FRACTURE_MODEL && m_resultType() == RimDefines::DYNAMIC_NATIVE));
-    m_selectedFractureStaticProperties.uiCapability()->setUiHidden(    isLocked || !(m_porosityModel() == RimDefines::FRACTURE_MODEL && m_resultType() == RimDefines::STATIC_NATIVE));
-    m_selectedFractureGeneratedProperties.uiCapability()->setUiHidden( isLocked || !(m_porosityModel() == RimDefines::FRACTURE_MODEL && m_resultType() == RimDefines::GENERATED));
-    m_selectedFractureInputProperties.uiCapability()->setUiHidden(     isLocked || !(m_porosityModel() == RimDefines::FRACTURE_MODEL && m_resultType() == RimDefines::INPUT_PROPERTY));
+    m_selectedFractureDynamicProperties.uiCapability()->setUiHidden(   isLocked || !(m_porosityModel() == RiaDefines::FRACTURE_MODEL && m_resultType() == RiaDefines::DYNAMIC_NATIVE));
+    m_selectedFractureStaticProperties.uiCapability()->setUiHidden(    isLocked || !(m_porosityModel() == RiaDefines::FRACTURE_MODEL && m_resultType() == RiaDefines::STATIC_NATIVE));
+    m_selectedFractureGeneratedProperties.uiCapability()->setUiHidden( isLocked || !(m_porosityModel() == RiaDefines::FRACTURE_MODEL && m_resultType() == RiaDefines::GENERATED));
+    m_selectedFractureInputProperties.uiCapability()->setUiHidden(     isLocked || !(m_porosityModel() == RiaDefines::FRACTURE_MODEL && m_resultType() == RiaDefines::INPUT_PROPERTY));
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -750,28 +750,28 @@ void RimEclipseStatisticsCase::populateResultSelection()
 
     if (m_selectedDynamicProperties().size() == 0)
     {
-        QStringList varList = caseData->results(RifReaderInterface::MATRIX_RESULTS)->resultNames(RimDefines::DYNAMIC_NATIVE);
+        QStringList varList = caseData->results(RifReaderInterface::MATRIX_RESULTS)->resultNames(RiaDefines::DYNAMIC_NATIVE);
         if (varList.contains("SOIL"))     m_selectedDynamicProperties.v().push_back("SOIL");
         if (varList.contains("PRESSURE")) m_selectedDynamicProperties.v().push_back("PRESSURE");
     }
 
     if (m_selectedStaticProperties().size() == 0)
     {
-        QStringList varList = caseData->results(RifReaderInterface::MATRIX_RESULTS)->resultNames(RimDefines::STATIC_NATIVE);
+        QStringList varList = caseData->results(RifReaderInterface::MATRIX_RESULTS)->resultNames(RiaDefines::STATIC_NATIVE);
         if (varList.contains("PERMX")) m_selectedStaticProperties.v().push_back("PERMX");
         if (varList.contains("PORO"))  m_selectedStaticProperties.v().push_back("PORO");
     }
 
     if (m_selectedFractureDynamicProperties().size() == 0)
     {
-        QStringList varList = caseData->results(RifReaderInterface::FRACTURE_RESULTS)->resultNames(RimDefines::DYNAMIC_NATIVE);
+        QStringList varList = caseData->results(RifReaderInterface::FRACTURE_RESULTS)->resultNames(RiaDefines::DYNAMIC_NATIVE);
         if (varList.contains("SOIL"))     m_selectedFractureDynamicProperties.v().push_back("SOIL");
         if (varList.contains("PRESSURE")) m_selectedFractureDynamicProperties.v().push_back("PRESSURE");
     }
 
     if (m_selectedFractureStaticProperties().size() == 0)
     {
-        QStringList varList = caseData->results(RifReaderInterface::FRACTURE_RESULTS)->resultNames(RimDefines::STATIC_NATIVE);
+        QStringList varList = caseData->results(RifReaderInterface::FRACTURE_RESULTS)->resultNames(RiaDefines::STATIC_NATIVE);
         if (varList.contains("PERMX")) m_selectedFractureStaticProperties.v().push_back("PERMX");
         if (varList.contains("PORO"))  m_selectedFractureStaticProperties.v().push_back("PORO");
     }

ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.h

@@ -21,7 +21,7 @@
 #pragma once
 
 #include "RimEclipseCase.h"
-#include "RimDefines.h"
+#include "RiaDefines.h"
 
 #include "cvfBase.h"
 #include "cvfObject.h"
@@ -101,8 +101,8 @@ private:
     virtual void defineEditorAttribute( const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute * attribute );
     // Fields
 
-    caf::PdmField< caf::AppEnum< RimDefines::ResultCatType > >      m_resultType;
-    caf::PdmField< caf::AppEnum< RimDefines::PorosityModelType > >  m_porosityModel;
+    caf::PdmField< caf::AppEnum< RiaDefines::ResultCatType > >      m_resultType;
+    caf::PdmField< caf::AppEnum< RiaDefines::PorosityModelType > >  m_porosityModel;
 
     caf::PdmField<QString>                                          m_selectionSummary;
 

ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp

@@ -38,7 +38,7 @@
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimEclipseStatisticsCaseEvaluator::addNamedResult(RigCaseCellResultsData* destinationCellResults, RimDefines::ResultCatType resultType, const QString& resultName, size_t activeUnionCellCount)
+void RimEclipseStatisticsCaseEvaluator::addNamedResult(RigCaseCellResultsData* destinationCellResults, RiaDefines::ResultCatType resultType, const QString& resultName, size_t activeUnionCellCount)
 {
     // Use time step dates from first result in first source case
     CVF_ASSERT(m_sourceCases.size() > 0);
@@ -84,7 +84,7 @@ void RimEclipseStatisticsCaseEvaluator::evaluateForResults(const QList<ResSpec>&
     for (int i = 0; i < resultSpecification.size(); i++)
     {
         RifReaderInterface::PorosityModelResultType poroModel = resultSpecification[i].m_poroModel;
-        RimDefines::ResultCatType resultType = resultSpecification[i].m_resType;
+        RiaDefines::ResultCatType resultType = resultSpecification[i].m_resType;
         QString resultName = resultSpecification[i].m_resVarName;
 
         size_t activeCellCount = m_destinationCase->activeCellInfo(poroModel)->reservoirActiveCellCount();
@@ -135,7 +135,7 @@ void RimEclipseStatisticsCaseEvaluator::evaluateForResults(const QList<ResSpec>&
             for (int resSpecIdx = 0; resSpecIdx < resultSpecification.size(); resSpecIdx++)
             {
                 RifReaderInterface::PorosityModelResultType poroModel = resultSpecification[resSpecIdx].m_poroModel;
-                RimDefines::ResultCatType resultType = resultSpecification[resSpecIdx].m_resType;
+                RiaDefines::ResultCatType resultType = resultSpecification[resSpecIdx].m_resType;
                 QString resultName = resultSpecification[resSpecIdx].m_resVarName;
 
                 size_t activeCellCount = m_destinationCase->activeCellInfo(poroModel)->reservoirActiveCellCount();
@@ -147,7 +147,7 @@ void RimEclipseStatisticsCaseEvaluator::evaluateForResults(const QList<ResSpec>&
                 size_t dataAccessTimeStepIndex = timeStepIdx;
 
                 // Always evaluate statistics once, and always use time step index zero
-                if (resultType == RimDefines::STATIC_NATIVE)
+                if (resultType == RiaDefines::STATIC_NATIVE)
                 {
                     if (timeIndicesIdx > 0) continue;
 

ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.h

@@ -20,7 +20,7 @@
 
 #pragma once
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 #include "RimEclipseStatisticsCase.h"
 
 #include <vector>
@@ -64,13 +64,13 @@ public:
 
     struct ResSpec 
     {
-        ResSpec() : m_resType(RimDefines::DYNAMIC_NATIVE), m_poroModel(RifReaderInterface::MATRIX_RESULTS) {}
+        ResSpec() : m_resType(RiaDefines::DYNAMIC_NATIVE), m_poroModel(RifReaderInterface::MATRIX_RESULTS) {}
         ResSpec( RifReaderInterface::PorosityModelResultType poroModel,
-                 RimDefines::ResultCatType                   resType,
+                 RiaDefines::ResultCatType                   resType,
                  QString                                     resVarName) : m_poroModel(poroModel), m_resType(resType), m_resVarName(resVarName) {}
 
         RifReaderInterface::PorosityModelResultType m_poroModel;
-        RimDefines::ResultCatType                   m_resType;
+        RiaDefines::ResultCatType                   m_resType;
         QString                                     m_resVarName;
     };
 
@@ -79,8 +79,8 @@ public:
     void evaluateForResults(const QList<ResSpec >& resultSpecification);
 
 private:
-    void addNamedResult(RigCaseCellResultsData* cellResults, RimDefines::ResultCatType resultType, const QString& resultName, size_t activeCellCount);
-    void buildSourceMetaData(RifReaderInterface::PorosityModelResultType poroModel, RimDefines::ResultCatType resultType, const QString& resultName);
+    void addNamedResult(RigCaseCellResultsData* cellResults, RiaDefines::ResultCatType resultType, const QString& resultName, size_t activeCellCount);
+    void buildSourceMetaData(RifReaderInterface::PorosityModelResultType poroModel, RiaDefines::ResultCatType resultType, const QString& resultName);
 
     enum StatisticsParamType { MIN, MAX, SUM, RANGE, MEAN, STDEV, PMIN, PMID, PMAX, STAT_PARAM_COUNT };
 

ApplicationCode/ProjectDataModel/RimEclipseView.cpp

@@ -948,7 +948,7 @@ void RimEclipseView::updateLegends()
 
             if (this->cellEdgeResult()->hasCategoryResult())
             {
-                if(cellEdgeResult()->singleVarEdgeResultColors()->resultType() != RimDefines::FORMATION_NAMES)
+                if(cellEdgeResult()->singleVarEdgeResultColors()->resultType() != RiaDefines::FORMATION_NAMES)
                 {
                     cellEdgeResult()->legendConfig()->setIntegerCategories(results->uniqueCellScalarValues(cellEdgeResult()->singleVarEdgeResultColors()->scalarResultIndex()));
                 }
@@ -988,7 +988,7 @@ void RimEclipseView::updateMinMaxValuesAndAddLegendToView(QString legendLabel, R
     {
         RimReservoirCellResultsStorage* gridCellResults = resultColors->currentGridCellResults();
         {
-            size_t scalarSetIndex = gridCellResults->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SOIL");
+            size_t scalarSetIndex = gridCellResults->findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "SOIL");
             if (scalarSetIndex != cvf::UNDEFINED_SIZE_T)
             {
                 double globalMin = 0.0;
@@ -1004,7 +1004,7 @@ void RimEclipseView::updateMinMaxValuesAndAddLegendToView(QString legendLabel, R
         }
 
         {
-            size_t scalarSetIndex = gridCellResults->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SGAS");
+            size_t scalarSetIndex = gridCellResults->findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "SGAS");
             if (scalarSetIndex != cvf::UNDEFINED_SIZE_T)
             {
                 double globalMin = 0.0;
@@ -1020,7 +1020,7 @@ void RimEclipseView::updateMinMaxValuesAndAddLegendToView(QString legendLabel, R
         }
 
         {
-            size_t scalarSetIndex = gridCellResults->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SWAT");
+            size_t scalarSetIndex = gridCellResults->findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "SWAT");
             if (scalarSetIndex != cvf::UNDEFINED_SIZE_T)
             {
                 double globalMin = 0.0;
@@ -1589,7 +1589,7 @@ void RimEclipseView::axisLabels(cvf::String* xLabel, cvf::String* yLabel, cvf::S
 //--------------------------------------------------------------------------------------------------
 bool RimEclipseView::isUsingFormationNames() const
 {
-    if ((cellResult()->resultType() == RimDefines::FORMATION_NAMES)) return true;
+    if ((cellResult()->resultType() == RiaDefines::FORMATION_NAMES)) return true;
     
     return eclipsePropertyFilterCollection()->isUsingFormationNames();
 }

ApplicationCode/ProjectDataModel/RimFaultCollection.cpp

@@ -25,7 +25,7 @@
 
 #include "RigMainGrid.h"
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 #include "RimEclipseCase.h"
 #include "RimEclipseView.h"
 #include "RimFault.h"
@@ -203,12 +203,12 @@ void RimFaultCollection::syncronizeFaults()
         for (size_t i = 0; i < sortedFaults.size(); i++)
         {
             QString faultName = sortedFaults[i]->name();
-            if (faultName.compare(RimDefines::undefinedGridFaultName(), Qt::CaseInsensitive) == 0)
+            if (faultName.compare(RiaDefines::undefinedGridFaultName(), Qt::CaseInsensitive) == 0)
             {
                 undefinedFaults = sortedFaults[i];
             }
 
-            if(faultName.startsWith(RimDefines::undefinedGridFaultName(), Qt::CaseInsensitive) 
+            if(faultName.startsWith(RiaDefines::undefinedGridFaultName(), Qt::CaseInsensitive) 
                && faultName.contains("Inactive"))
             {
                 undefinedFaultsWInactive = sortedFaults[i];
@@ -249,7 +249,7 @@ void RimFaultCollection::syncronizeFaults()
             rimFault->faultColor = colorTable.cycledColor3f(fIdx);
             QString faultName = rigFaults[fIdx]->name();
 
-            if (faultName.startsWith(RimDefines::undefinedGridFaultName(), Qt::CaseInsensitive) 
+            if (faultName.startsWith(RiaDefines::undefinedGridFaultName(), Qt::CaseInsensitive) 
                 && faultName.contains("Inactive"))
             {
                 rimFault->showFault = false; // Turn fault against inactive cells off by default

ApplicationCode/ProjectDataModel/RimGeoMechResultDefinition.cpp

@@ -25,7 +25,7 @@
 #include "RigFemResultAddress.h"
 #include "RigGeoMechCaseData.h"
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 #include "RimGeoMechCase.h"
 #include "RimGeoMechCellColors.h"
 #include "RimGeoMechPropertyFilter.h"

ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.cpp

@@ -70,7 +70,7 @@ RimGridTimeHistoryCurve::RimGridTimeHistoryCurve()
     m_geometrySelectionItem.uiCapability()->setUiTreeHidden(true);
     m_geometrySelectionItem.uiCapability()->setUiTreeChildrenHidden(true);
 
-    CAF_PDM_InitField(&m_plotAxis, "PlotAxis", caf::AppEnum< RimDefines::PlotAxis >(RimDefines::PLOT_AXIS_LEFT), "Axis", "", "", "");
+    CAF_PDM_InitField(&m_plotAxis, "PlotAxis", caf::AppEnum< RiaDefines::PlotAxis >(RiaDefines::PLOT_AXIS_LEFT), "Axis", "", "", "");
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -137,7 +137,7 @@ void RimGridTimeHistoryCurve::setFromSelectionItem(const RiuSelectionItem* selec
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimDefines::PlotAxis RimGridTimeHistoryCurve::yAxis() const
+RiaDefines::PlotAxis RimGridTimeHistoryCurve::yAxis() const
 {
     return m_plotAxis();
 }
@@ -145,7 +145,7 @@ RimDefines::PlotAxis RimGridTimeHistoryCurve::yAxis() const
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimGridTimeHistoryCurve::setYAxis(RimDefines::PlotAxis plotAxis)
+void RimGridTimeHistoryCurve::setYAxis(RiaDefines::PlotAxis plotAxis)
 {
     m_plotAxis = plotAxis;
 
@@ -607,7 +607,7 @@ void RimGridTimeHistoryCurve::updateQwtPlotAxis()
 {
     if (m_qwtPlotCurve)
     {
-        if (this->yAxis() == RimDefines::PLOT_AXIS_LEFT)
+        if (this->yAxis() == RiaDefines::PLOT_AXIS_LEFT)
         {
             m_qwtPlotCurve->setYAxis(QwtPlot::yLeft);
         }

ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.h

@@ -19,7 +19,7 @@
 
 #include "RimPlotCurve.h"
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 
 #include "cafPdmChildField.h"
 #include "cafPdmProxyValueField.h"
@@ -51,8 +51,8 @@ public:
     virtual ~RimGridTimeHistoryCurve();
 
     void                    setFromSelectionItem(const RiuSelectionItem* selectionItem);
-    RimDefines::PlotAxis    yAxis() const;
-    void                    setYAxis(RimDefines::PlotAxis plotAxis);
+    RiaDefines::PlotAxis    yAxis() const;
+    void                    setYAxis(RiaDefines::PlotAxis plotAxis);
 
     std::vector<double>     yValues() const;
     std::vector<time_t>     timeStepValues() const;
@@ -88,6 +88,6 @@ private:
     caf::PdmChildField<RimGeoMechResultDefinition*> m_geoMechResultDefinition;
 
     caf::PdmChildField<RimGeometrySelectionItem*>     m_geometrySelectionItem;
-    caf::PdmField< caf::AppEnum< RimDefines::PlotAxis > > m_plotAxis;
+    caf::PdmField< caf::AppEnum< RiaDefines::PlotAxis > > m_plotAxis;
 };
 

ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp

@@ -253,7 +253,7 @@ void RimIdenticalGridCaseGroup::loadMainCaseAndActiveCellInfo()
 
             for (size_t resIdx = 0; resIdx < resultInfos.size(); resIdx++)
             {
-                RimDefines::ResultCatType resultType = resultInfos[resIdx].m_resultType;
+                RiaDefines::ResultCatType resultType = resultInfos[resIdx].m_resultType;
                 QString resultName = resultInfos[resIdx].m_resultName;
                 bool needsToBeStored = resultInfos[resIdx].m_needsToBeStored;
                 bool mustBeCalculated = resultInfos[resIdx].m_mustBeCalculated;
@@ -436,8 +436,8 @@ void RimIdenticalGridCaseGroup::clearStatisticsResults()
         for (size_t j = 0; j < rimStaticsCase->reservoirViews.size(); j++)
         {
             RimEclipseView* rimReservoirView = rimStaticsCase->reservoirViews[j];
-            rimReservoirView->cellResult()->setResultVariable(RimDefines::undefinedResultName());
-            rimReservoirView->cellEdgeResult()->setResultVariable(RimDefines::undefinedResultName());
+            rimReservoirView->cellResult()->setResultVariable(RiaDefines::undefinedResultName());
+            rimReservoirView->cellEdgeResult()->setResultVariable(RiaDefines::undefinedResultName());
             rimReservoirView->loadDataAndUpdate();
         }
     }

ApplicationCode/ProjectDataModel/RimMultiSnapshotDefinition.cpp

@@ -114,8 +114,8 @@ QList<caf::PdmOptionItemInfo> RimMultiSnapshotDefinition::calculateValueOptions(
     }
     else if (fieldNeedingOptions == &eclipseResultType)
     {
-        options.push_back(caf::PdmOptionItemInfo(caf::AppEnum<RimDefines::ResultCatType>(RimDefines::DYNAMIC_NATIVE).uiText(), RimDefines::DYNAMIC_NATIVE));
-        options.push_back(caf::PdmOptionItemInfo(caf::AppEnum<RimDefines::ResultCatType>(RimDefines::STATIC_NATIVE).uiText(), RimDefines::STATIC_NATIVE));
+        options.push_back(caf::PdmOptionItemInfo(caf::AppEnum<RiaDefines::ResultCatType>(RiaDefines::DYNAMIC_NATIVE).uiText(), RiaDefines::DYNAMIC_NATIVE));
+        options.push_back(caf::PdmOptionItemInfo(caf::AppEnum<RiaDefines::ResultCatType>(RiaDefines::STATIC_NATIVE).uiText(), RiaDefines::STATIC_NATIVE));
     }
     else if (fieldNeedingOptions == &selectedEclipseResults)
     {

ApplicationCode/ProjectDataModel/RimMultiSnapshotDefinition.h

@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 
 #include "cafAppEnum.h"
 #include "cafPdmField.h"
@@ -44,7 +44,7 @@ public:
 
     caf::PdmPtrField<RimView*>  view;
 
-    caf::PdmField< caf::AppEnum< RimDefines::ResultCatType > >  eclipseResultType;
+    caf::PdmField< caf::AppEnum< RiaDefines::ResultCatType > >  eclipseResultType;
     caf::PdmField< std::vector<QString> >                       selectedEclipseResults;
 
     caf::PdmField<int>       timeStepStart;

ApplicationCode/ProjectDataModel/RimProject.cpp

@@ -768,13 +768,13 @@ bool RimProject::showPlotWindow() const
 //--------------------------------------------------------------------------------------------------
 void RimProject::reloadCompletionTypeResultsInAllViews()
 {
-    removeEclipseResultAndRedrawAllViews(RimDefines::DYNAMIC_NATIVE, RimDefines::completionTypeResultName());
+    removeEclipseResultAndRedrawAllViews(RiaDefines::DYNAMIC_NATIVE, RiaDefines::completionTypeResultName());
 }
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimProject::removeEclipseResultAndRedrawAllViews(RimDefines::ResultCatType type, const QString & resultName)
+void RimProject::removeEclipseResultAndRedrawAllViews(RiaDefines::ResultCatType type, const QString & resultName)
 {
     for (RimEclipseCase* eclipseCase : activeOilField()->analysisModels->cases)
     {

ApplicationCode/ProjectDataModel/RimProject.h

@@ -20,7 +20,7 @@
 
 #pragma once
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 
 #include "cafPdmChildArrayField.h"
 #include "cafPdmChildField.h"
@@ -121,7 +121,7 @@ protected:
 
 private:
     void            appendScriptItems(QMenu* menu, RimScriptCollection* scriptCollection);
-    void            removeEclipseResultAndRedrawAllViews(RimDefines::ResultCatType type, const QString& resultName);
+    void            removeEclipseResultAndRedrawAllViews(RiaDefines::ResultCatType type, const QString& resultName);
 
 private:
     caf::PdmField<QString>  m_projectFileVersionString;

ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp

@@ -235,21 +235,21 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(const QString& res
 {
     if (!m_cellResults) return cvf::UNDEFINED_SIZE_T;
 
-    size_t scalarResultIndex = this->findOrLoadScalarResult(RimDefines::STATIC_NATIVE, resultName);
+    size_t scalarResultIndex = this->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, resultName);
 
     if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
     {
-        scalarResultIndex = this->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, resultName);
+        scalarResultIndex = this->findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, resultName);
     }
 
     if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
     {
-        scalarResultIndex = m_cellResults->findScalarResultIndex(RimDefines::GENERATED, resultName);
+        scalarResultIndex = m_cellResults->findScalarResultIndex(RiaDefines::GENERATED, resultName);
     }
 
     if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
     {
-        scalarResultIndex = m_cellResults->findScalarResultIndex(RimDefines::INPUT_PROPERTY, resultName);
+        scalarResultIndex = m_cellResults->findScalarResultIndex(RiaDefines::INPUT_PROPERTY, resultName);
     }
 
     return scalarResultIndex;
@@ -258,7 +258,7 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(const QString& res
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirCellResultsStorage::clearScalarResult(RimDefines::ResultCatType type, const QString & resultName)
+void RimReservoirCellResultsStorage::clearScalarResult(RiaDefines::ResultCatType type, const QString & resultName)
 {
     size_t scalarResultIndex = m_cellResults->findScalarResultIndex(type, resultName);
     m_cellResults->cellScalarResults(scalarResultIndex).clear();
@@ -267,7 +267,7 @@ void RimReservoirCellResultsStorage::clearScalarResult(RimDefines::ResultCatType
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(RimDefines::ResultCatType type, const QString& resultName)
+size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(RiaDefines::ResultCatType type, const QString& resultName)
 {
     if (!m_cellResults) return cvf::UNDEFINED_SIZE_T;
 
@@ -276,15 +276,15 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(RimDefines::Result
 
     // Load dependency data sets
 
-    if (type == RimDefines::STATIC_NATIVE)
+    if (type == RiaDefines::STATIC_NATIVE)
     {
-        if (resultName == RimDefines::combinedTransmissibilityResultName())
+        if (resultName == RiaDefines::combinedTransmissibilityResultName())
         {
             this->findOrLoadScalarResult(type, "TRANX");
             this->findOrLoadScalarResult(type, "TRANY");
             this->findOrLoadScalarResult(type, "TRANZ");
         }
-        else if (resultName == RimDefines::combinedMultResultName())
+        else if (resultName == RiaDefines::combinedMultResultName())
         {
             this->findOrLoadScalarResult(type, "MULTX");
             this->findOrLoadScalarResult(type, "MULTX-");
@@ -293,43 +293,43 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(RimDefines::Result
             this->findOrLoadScalarResult(type, "MULTZ");
             this->findOrLoadScalarResult(type, "MULTZ-");
         }
-        else if (resultName == RimDefines::combinedRiTranResultName())
+        else if (resultName == RiaDefines::combinedRiTranResultName())
         {
-            computeRiTransComponent(RimDefines::riTranXResultName());
-            computeRiTransComponent(RimDefines::riTranYResultName());
-            computeRiTransComponent(RimDefines::riTranZResultName());
+            computeRiTransComponent(RiaDefines::riTranXResultName());
+            computeRiTransComponent(RiaDefines::riTranYResultName());
+            computeRiTransComponent(RiaDefines::riTranZResultName());
             computeNncCombRiTrans();
         }
-        else if (resultName == RimDefines::riTranXResultName()
-            || resultName == RimDefines::riTranYResultName()
-            || resultName == RimDefines::riTranZResultName())
+        else if (resultName == RiaDefines::riTranXResultName()
+            || resultName == RiaDefines::riTranYResultName()
+            || resultName == RiaDefines::riTranZResultName())
         {
             computeRiTransComponent(resultName);
         }
-        else if (resultName == RimDefines::combinedRiMultResultName())
+        else if (resultName == RiaDefines::combinedRiMultResultName())
         {
-            computeRiMULTComponent(RimDefines::riMultXResultName());
-            computeRiMULTComponent(RimDefines::riMultYResultName());
-            computeRiMULTComponent(RimDefines::riMultZResultName());
+            computeRiMULTComponent(RiaDefines::riMultXResultName());
+            computeRiMULTComponent(RiaDefines::riMultYResultName());
+            computeRiMULTComponent(RiaDefines::riMultZResultName());
             computeNncCombRiTrans();
             computeNncCombRiMULT();
         }
-        else if (resultName == RimDefines::riMultXResultName()
-              || resultName == RimDefines::riMultYResultName()
-              || resultName == RimDefines::riMultZResultName())
+        else if (resultName == RiaDefines::riMultXResultName()
+              || resultName == RiaDefines::riMultYResultName()
+              || resultName == RiaDefines::riMultZResultName())
         {
             computeRiMULTComponent(resultName);
         }
-        else if (resultName == RimDefines::combinedRiAreaNormTranResultName())
+        else if (resultName == RiaDefines::combinedRiAreaNormTranResultName())
         {
-            computeRiTRANSbyAreaComponent(RimDefines::riAreaNormTranXResultName());
-            computeRiTRANSbyAreaComponent(RimDefines::riAreaNormTranYResultName());
-            computeRiTRANSbyAreaComponent(RimDefines::riAreaNormTranZResultName());
+            computeRiTRANSbyAreaComponent(RiaDefines::riAreaNormTranXResultName());
+            computeRiTRANSbyAreaComponent(RiaDefines::riAreaNormTranYResultName());
+            computeRiTRANSbyAreaComponent(RiaDefines::riAreaNormTranZResultName());
             computeNncCombRiTRANSbyArea();
         }
-        else if (resultName == RimDefines::riAreaNormTranXResultName()
-              || resultName == RimDefines::riAreaNormTranYResultName()
-              || resultName == RimDefines::riAreaNormTranZResultName())
+        else if (resultName == RiaDefines::riAreaNormTranXResultName()
+              || resultName == RiaDefines::riAreaNormTranYResultName()
+              || resultName == RiaDefines::riAreaNormTranZResultName())
         {
             computeRiTRANSbyAreaComponent(resultName);
         }
@@ -345,8 +345,8 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(RimDefines::Result
         if (m_cellResults->mustBeCalculated(scalarResultIndex))
         {
             // Trigger loading of SWAT, SGAS to establish time step count if no data has been loaded from file at this point
-            findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SWAT");
-            findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SGAS");
+            findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "SWAT");
+            findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "SGAS");
 
             m_cellResults->cellScalarResults(scalarResultIndex).resize(m_cellResults->maxTimeStepCount());
             for (size_t timeStepIdx = 0; timeStepIdx < m_cellResults->maxTimeStepCount(); timeStepIdx++)
@@ -361,7 +361,7 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(RimDefines::Result
             return scalarResultIndex;
         }
     }
-    else if (resultName == RimDefines::completionTypeResultName())
+    else if (resultName == RiaDefines::completionTypeResultName())
     {
         m_cellResults->cellScalarResults(scalarResultIndex).resize(m_cellResults->maxTimeStepCount());
         for (size_t timeStepIdx = 0; timeStepIdx < m_cellResults->maxTimeStepCount(); ++timeStepIdx)
@@ -370,7 +370,7 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(RimDefines::Result
         }
     }
 
-    if (type == RimDefines::GENERATED)
+    if (type == RiaDefines::GENERATED)
     {
         return cvf::UNDEFINED_SIZE_T;
     }
@@ -382,7 +382,7 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(RimDefines::Result
 
         bool resultLoadingSucess = true;
 
-        if (type == RimDefines::DYNAMIC_NATIVE && timeStepCount > 0)
+        if (type == RiaDefines::DYNAMIC_NATIVE && timeStepCount > 0)
         {
             m_cellResults->cellScalarResults(scalarResultIndex).resize(timeStepCount);
 
@@ -396,7 +396,7 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(RimDefines::Result
                 }
             }
         }
-        else if (type == RimDefines::STATIC_NATIVE)
+        else if (type == RiaDefines::STATIC_NATIVE)
         {
             m_cellResults->cellScalarResults(scalarResultIndex).resize(1);
 
@@ -421,12 +421,12 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(RimDefines::Result
 /// This method is intended to be used for multicase cross statistical calculations, when 
 /// we need process one timestep at a time, freeing memory as we go.
 //--------------------------------------------------------------------------------------------------
-size_t RimReservoirCellResultsStorage::findOrLoadScalarResultForTimeStep(RimDefines::ResultCatType type, const QString& resultName, size_t timeStepIndex)
+size_t RimReservoirCellResultsStorage::findOrLoadScalarResultForTimeStep(RiaDefines::ResultCatType type, const QString& resultName, size_t timeStepIndex)
 {
     if (!m_cellResults) return cvf::UNDEFINED_SIZE_T;
 
     // Special handling for SOIL
-    if (type == RimDefines::DYNAMIC_NATIVE && resultName.toUpper() == "SOIL")
+    if (type == RiaDefines::DYNAMIC_NATIVE && resultName.toUpper() == "SOIL")
     {
         size_t soilScalarResultIndex = m_cellResults->findScalarResultIndex(type, resultName);
 
@@ -443,7 +443,7 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResultForTimeStep(RimDefi
             return soilScalarResultIndex;
         }
     }
-    else if (type == RimDefines::DYNAMIC_NATIVE && resultName == RimDefines::completionTypeResultName())
+    else if (type == RiaDefines::DYNAMIC_NATIVE && resultName == RiaDefines::completionTypeResultName())
     {
         size_t completionTypeScalarResultIndex = m_cellResults->findScalarResultIndex(type, resultName);
         computeCompletionTypeForTimeStep(timeStepIndex);
@@ -453,7 +453,7 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResultForTimeStep(RimDefi
     size_t scalarResultIndex = m_cellResults->findScalarResultIndex(type, resultName);
     if (scalarResultIndex == cvf::UNDEFINED_SIZE_T) return cvf::UNDEFINED_SIZE_T;
 
-    if (type == RimDefines::GENERATED)
+    if (type == RiaDefines::GENERATED)
     {
         return cvf::UNDEFINED_SIZE_T;
     }
@@ -464,7 +464,7 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResultForTimeStep(RimDefi
 
         bool resultLoadingSucess = true;
 
-        if (type == RimDefines::DYNAMIC_NATIVE && timeStepCount > 0)
+        if (type == RiaDefines::DYNAMIC_NATIVE && timeStepCount > 0)
         {
             m_cellResults->cellScalarResults(scalarResultIndex).resize(timeStepCount);
 
@@ -477,7 +477,7 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResultForTimeStep(RimDefi
                 }
             }
         }
-        else if (type == RimDefines::STATIC_NATIVE)
+        else if (type == RiaDefines::STATIC_NATIVE)
         {
             m_cellResults->cellScalarResults(scalarResultIndex).resize(1);
 
@@ -504,8 +504,8 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResultForTimeStep(RimDefi
 //--------------------------------------------------------------------------------------------------
 void RimReservoirCellResultsStorage::computeSOILForTimeStep(size_t timeStepIndex)
 {
-    size_t scalarIndexSWAT = findOrLoadScalarResultForTimeStep(RimDefines::DYNAMIC_NATIVE, "SWAT", timeStepIndex);
-    size_t scalarIndexSGAS = findOrLoadScalarResultForTimeStep(RimDefines::DYNAMIC_NATIVE, "SGAS", timeStepIndex);
+    size_t scalarIndexSWAT = findOrLoadScalarResultForTimeStep(RiaDefines::DYNAMIC_NATIVE, "SWAT", timeStepIndex);
+    size_t scalarIndexSGAS = findOrLoadScalarResultForTimeStep(RiaDefines::DYNAMIC_NATIVE, "SGAS", timeStepIndex);
 
     // Early exit if none of SWAT or SGAS is present
     if (scalarIndexSWAT == cvf::UNDEFINED_SIZE_T && scalarIndexSGAS == cvf::UNDEFINED_SIZE_T)
@@ -542,7 +542,7 @@ void RimReservoirCellResultsStorage::computeSOILForTimeStep(size_t timeStepIndex
     
     // Make sure memory is allocated for the new SOIL results
 
-    size_t soilResultScalarIndex = m_cellResults->findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "SOIL");
+    size_t soilResultScalarIndex = m_cellResults->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "SOIL");
     m_cellResults->cellScalarResults(soilResultScalarIndex).resize(soilTimeStepCount);
 
     if (m_cellResults->cellScalarResults(soilResultScalarIndex, timeStepIndex).size() > 0)
@@ -602,12 +602,12 @@ void RimReservoirCellResultsStorage::computeDepthRelatedResults()
 {
     if (!m_cellResults) return;
 
-    size_t depthResultGridIndex  = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DEPTH");
-    size_t dxResultGridIndex     = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DX");
-    size_t dyResultGridIndex     = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DY");
-    size_t dzResultGridIndex     = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DZ");
-    size_t topsResultGridIndex   = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "TOPS");
-    size_t bottomResultGridIndex = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "BOTTOM");
+    size_t depthResultGridIndex  = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DEPTH");
+    size_t dxResultGridIndex     = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DX");
+    size_t dyResultGridIndex     = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DY");
+    size_t dzResultGridIndex     = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DZ");
+    size_t topsResultGridIndex   = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "TOPS");
+    size_t bottomResultGridIndex = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "BOTTOM");
 
     bool computeDepth = false;
     bool computeDx = false;
@@ -620,37 +620,37 @@ void RimReservoirCellResultsStorage::computeDepthRelatedResults()
 
     if (depthResultGridIndex == cvf::UNDEFINED_SIZE_T)
     {
-        depthResultGridIndex = m_cellResults->addStaticScalarResult(RimDefines::STATIC_NATIVE, "DEPTH", false, resultValueCount);
+        depthResultGridIndex = m_cellResults->addStaticScalarResult(RiaDefines::STATIC_NATIVE, "DEPTH", false, resultValueCount);
         computeDepth = true;
     }
 
     if (dxResultGridIndex == cvf::UNDEFINED_SIZE_T)
     {
-        dxResultGridIndex = m_cellResults->addStaticScalarResult(RimDefines::STATIC_NATIVE, "DX", false, resultValueCount);
+        dxResultGridIndex = m_cellResults->addStaticScalarResult(RiaDefines::STATIC_NATIVE, "DX", false, resultValueCount);
         computeDx = true;
     }
 
     if (dyResultGridIndex == cvf::UNDEFINED_SIZE_T)
     {
-        dyResultGridIndex = m_cellResults->addStaticScalarResult(RimDefines::STATIC_NATIVE, "DY", false, resultValueCount);
+        dyResultGridIndex = m_cellResults->addStaticScalarResult(RiaDefines::STATIC_NATIVE, "DY", false, resultValueCount);
         computeDy = true;
     }
 
     if (dzResultGridIndex == cvf::UNDEFINED_SIZE_T)
     {
-        dzResultGridIndex = m_cellResults->addStaticScalarResult(RimDefines::STATIC_NATIVE, "DZ", false, resultValueCount);
+        dzResultGridIndex = m_cellResults->addStaticScalarResult(RiaDefines::STATIC_NATIVE, "DZ", false, resultValueCount);
         computeDz = true;
     }
 
     if (topsResultGridIndex == cvf::UNDEFINED_SIZE_T)
     {
-        topsResultGridIndex = m_cellResults->addStaticScalarResult(RimDefines::STATIC_NATIVE, "TOPS", false, resultValueCount);
+        topsResultGridIndex = m_cellResults->addStaticScalarResult(RiaDefines::STATIC_NATIVE, "TOPS", false, resultValueCount);
         computeTops = true;
     }
 
     if (bottomResultGridIndex == cvf::UNDEFINED_SIZE_T)
     {
-        bottomResultGridIndex = m_cellResults->addStaticScalarResult(RimDefines::STATIC_NATIVE, "BOTTOM", false, resultValueCount);
+        bottomResultGridIndex = m_cellResults->addStaticScalarResult(RiaDefines::STATIC_NATIVE, "BOTTOM", false, resultValueCount);
         computeBottom = true;
     }
 
@@ -808,17 +808,17 @@ void RimReservoirCellResultsStorage::computeRiTransComponent(const QString& riTr
     cvf::StructGridInterface::FaceType faceId = cvf::StructGridInterface::NO_FACE;
     QString permCompName;
 
-    if (riTransComponentResultName == RimDefines::riTranXResultName())
+    if (riTransComponentResultName == RiaDefines::riTranXResultName())
     {
         permCompName = "PERMX";
         faceId = cvf::StructGridInterface::POS_I;
     }
-    else if (riTransComponentResultName == RimDefines::riTranYResultName())
+    else if (riTransComponentResultName == RiaDefines::riTranYResultName())
     {
         permCompName = "PERMY";
         faceId = cvf::StructGridInterface::POS_J;
     }
-    else if (riTransComponentResultName == RimDefines::riTranZResultName())
+    else if (riTransComponentResultName == RiaDefines::riTranZResultName())
     {
         permCompName = "PERMZ";
         faceId = cvf::StructGridInterface::POS_K;
@@ -832,14 +832,14 @@ void RimReservoirCellResultsStorage::computeRiTransComponent(const QString& riTr
 
     // Get the needed result indices we depend on
 
-    size_t permResultIdx = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, permCompName);
-    size_t ntgResultIdx = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "NTG");
+    size_t permResultIdx = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, permCompName);
+    size_t ntgResultIdx = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "NTG");
 
     bool hasNTGResults = ntgResultIdx != cvf::UNDEFINED_SIZE_T;
 
     // Get the result index of the output
 
-    size_t riTransResultIdx = m_cellResults->findScalarResultIndex(RimDefines::STATIC_NATIVE, riTransComponentResultName);
+    size_t riTransResultIdx = m_cellResults->findScalarResultIndex(RiaDefines::STATIC_NATIVE, riTransComponentResultName);
     CVF_ASSERT(riTransResultIdx != cvf::UNDEFINED_SIZE_T);
 
     // Get the result count, to handle that one of them might be globally defined
@@ -988,18 +988,18 @@ void RimReservoirCellResultsStorage::computeNncCombRiTrans()
 {
     if (!m_cellResults) return;
 
-    size_t riCombTransScalarResultIndex = m_cellResults->findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::combinedRiTranResultName());
+    size_t riCombTransScalarResultIndex = m_cellResults->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiTranResultName());
     if (m_ownerMainGrid->nncData()->connectionScalarResult(riCombTransScalarResultIndex)) return;
 
     double cdarchy = darchysValue();
 
     // Get the needed result indices we depend on
 
-    size_t permXResultIdx = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "PERMX");
-    size_t permYResultIdx = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "PERMY");
-    size_t permZResultIdx = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "PERMZ");
+    size_t permXResultIdx = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMX");
+    size_t permYResultIdx = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMY");
+    size_t permZResultIdx = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMZ");
 
-    size_t ntgResultIdx = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "NTG");
+    size_t ntgResultIdx = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "NTG");
 
     bool hasNTGResults = ntgResultIdx != cvf::UNDEFINED_SIZE_T;
 
@@ -1185,19 +1185,19 @@ void RimReservoirCellResultsStorage::computeRiMULTComponent(const QString& riMul
     QString riTransCompName;
     QString transCompName;
 
-    if (riMultCompName == RimDefines::riMultXResultName())
+    if (riMultCompName == RiaDefines::riMultXResultName())
     {
-        riTransCompName = RimDefines::riTranXResultName();
+        riTransCompName = RiaDefines::riTranXResultName();
         transCompName = "TRANX";
     }
-    else if (riMultCompName == RimDefines::riMultYResultName())
+    else if (riMultCompName == RiaDefines::riMultYResultName())
     {
-        riTransCompName = RimDefines::riTranYResultName();
+        riTransCompName = RiaDefines::riTranYResultName();
         transCompName = "TRANY";
     }
-    else if (riMultCompName == RimDefines::riMultZResultName())
+    else if (riMultCompName == RiaDefines::riMultZResultName())
     {
-        riTransCompName = RimDefines::riTranZResultName();
+        riTransCompName = RiaDefines::riTranZResultName();
         transCompName = "TRANZ";
     }
     else
@@ -1207,12 +1207,12 @@ void RimReservoirCellResultsStorage::computeRiMULTComponent(const QString& riMul
 
     // Get the needed result indices we depend on
 
-    size_t transResultIdx   = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, transCompName);
-    size_t riTransResultIdx = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, riTransCompName);
+    size_t transResultIdx   = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, transCompName);
+    size_t riTransResultIdx = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, riTransCompName);
 
     // Get the result index of the output
 
-    size_t riMultResultIdx = m_cellResults->findScalarResultIndex(RimDefines::STATIC_NATIVE, riMultCompName);
+    size_t riMultResultIdx = m_cellResults->findScalarResultIndex(RiaDefines::STATIC_NATIVE, riMultCompName);
     CVF_ASSERT(riMultResultIdx != cvf::UNDEFINED_SIZE_T);
 
     // Get the result count, to handle that one of them might be globally defined
@@ -1245,9 +1245,9 @@ void RimReservoirCellResultsStorage::computeNncCombRiMULT()
 {
     if (!m_cellResults) return;
 
-    size_t riCombMultScalarResultIndex = m_cellResults->findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::combinedRiMultResultName());
-    size_t riCombTransScalarResultIndex = m_cellResults->findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::combinedRiTranResultName());
-    size_t combTransScalarResultIndex = m_cellResults->findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::combinedTransmissibilityResultName());
+    size_t riCombMultScalarResultIndex = m_cellResults->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiMultResultName());
+    size_t riCombTransScalarResultIndex = m_cellResults->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiTranResultName());
+    size_t combTransScalarResultIndex = m_cellResults->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedTransmissibilityResultName());
 
     if (m_ownerMainGrid->nncData()->connectionScalarResult(riCombMultScalarResultIndex)) return;
 
@@ -1273,17 +1273,17 @@ void RimReservoirCellResultsStorage::computeRiTRANSbyAreaComponent(const QString
     cvf::StructGridInterface::FaceType faceId = cvf::StructGridInterface::NO_FACE;
     QString transCompName;
 
-    if (riTransByAreaCompResultName == RimDefines::riAreaNormTranXResultName())
+    if (riTransByAreaCompResultName == RiaDefines::riAreaNormTranXResultName())
     {
         transCompName = "TRANX";
         faceId = cvf::StructGridInterface::POS_I;
     }
-    else if (riTransByAreaCompResultName == RimDefines::riAreaNormTranYResultName())
+    else if (riTransByAreaCompResultName == RiaDefines::riAreaNormTranYResultName())
     {
         transCompName = "TRANY";
         faceId = cvf::StructGridInterface::POS_J;
     }
-    else if (riTransByAreaCompResultName == RimDefines::riAreaNormTranZResultName())
+    else if (riTransByAreaCompResultName == RiaDefines::riAreaNormTranZResultName())
     {
         transCompName = "TRANZ";
         faceId = cvf::StructGridInterface::POS_K;
@@ -1295,11 +1295,11 @@ void RimReservoirCellResultsStorage::computeRiTRANSbyAreaComponent(const QString
 
     // Get the needed result indices we depend on
 
-    size_t tranCompScResIdx = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, transCompName);
+    size_t tranCompScResIdx = findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, transCompName);
 
     // Get the result index of the output
 
-    size_t riTranByAreaScResIdx = m_cellResults->findScalarResultIndex(RimDefines::STATIC_NATIVE, riTransByAreaCompResultName);
+    size_t riTranByAreaScResIdx = m_cellResults->findScalarResultIndex(RiaDefines::STATIC_NATIVE, riTransByAreaCompResultName);
     CVF_ASSERT(riTranByAreaScResIdx != cvf::UNDEFINED_SIZE_T);
 
     // Get the result count, to handle that one of them might be globally defined
@@ -1379,8 +1379,8 @@ void RimReservoirCellResultsStorage::computeNncCombRiTRANSbyArea()
 {
     if (!m_cellResults) return;
 
-    size_t riCombTransByAreaScResIdx = m_cellResults->findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::combinedRiAreaNormTranResultName());
-    size_t combTransScalarResultIndex = m_cellResults->findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::combinedTransmissibilityResultName());
+    size_t riCombTransByAreaScResIdx = m_cellResults->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiAreaNormTranResultName());
+    size_t combTransScalarResultIndex = m_cellResults->findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::combinedTransmissibilityResultName());
 
     if (m_ownerMainGrid->nncData()->connectionScalarResult(riCombTransByAreaScResIdx)) return;
 
@@ -1404,7 +1404,7 @@ void RimReservoirCellResultsStorage::computeNncCombRiTRANSbyArea()
 //--------------------------------------------------------------------------------------------------
 void RimReservoirCellResultsStorage::computeCompletionTypeForTimeStep(size_t timeStep)
 {
-    size_t completionTypeResultIndex = m_cellResults->findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, RimDefines::completionTypeResultName());
+    size_t completionTypeResultIndex = m_cellResults->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, RiaDefines::completionTypeResultName());
 
     if (m_cellResults->cellScalarResults(completionTypeResultIndex).size() < cellResults()->maxTimeStepCount())
     {
@@ -1610,7 +1610,7 @@ RimReservoirCellResultsStorageEntryInfo::RimReservoirCellResultsStorageEntryInfo
 {
     CAF_PDM_InitObject("Cache Entry", "", "", "");
 
-    CAF_PDM_InitField(&m_resultType, "ResultType",  caf::AppEnum<RimDefines::ResultCatType>(RimDefines::REMOVED), "ResultType", "", "" ,"");
+    CAF_PDM_InitField(&m_resultType, "ResultType",  caf::AppEnum<RiaDefines::ResultCatType>(RiaDefines::REMOVED), "ResultType", "", "" ,"");
     CAF_PDM_InitField(&m_resultName, "ResultName",  QString(), "ResultName", "", "" ,"");
     CAF_PDM_InitFieldNoDefault(&m_timeStepDates, "TimeSteps", "TimeSteps", "", "" ,"");
     CAF_PDM_InitFieldNoDefault(&m_daysSinceSimulationStart, "DaysSinceSimulationStart", "DaysSinceSimulationStart", "", "", "");

ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.h

@@ -20,7 +20,7 @@
 #pragma once
 
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 
 #include "cafAppEnum.h"
 #include "cafPdmChildArrayField.h"
@@ -59,11 +59,11 @@ public:
     void                            computeDepthRelatedResults();
     bool                            isDataPresent(size_t scalarResultIndex) const;
 
-    size_t                          findOrLoadScalarResultForTimeStep(RimDefines::ResultCatType type, const QString& resultName, size_t timeStepIndex);
-    size_t                          findOrLoadScalarResult(RimDefines::ResultCatType type, const QString& resultName);
+    size_t                          findOrLoadScalarResultForTimeStep(RiaDefines::ResultCatType type, const QString& resultName, size_t timeStepIndex);
+    size_t                          findOrLoadScalarResult(RiaDefines::ResultCatType type, const QString& resultName);
     size_t                          findOrLoadScalarResult(const QString& resultName); ///< Simplified search. Assumes unique names across types.
 
-    void                            clearScalarResult(RimDefines::ResultCatType type, const QString& resultName);
+    void                            clearScalarResult(RiaDefines::ResultCatType type, const QString& resultName);
 
 protected:
     // Overridden methods from PdmObject
@@ -102,7 +102,7 @@ public:
     RimReservoirCellResultsStorageEntryInfo();
     virtual ~RimReservoirCellResultsStorageEntryInfo();
 
-    caf::PdmField<caf::AppEnum< RimDefines::ResultCatType> > m_resultType;
+    caf::PdmField<caf::AppEnum< RiaDefines::ResultCatType> > m_resultType;
     caf::PdmField<QString>                                   m_resultName;
     caf::PdmField< std::vector <QDateTime> >                 m_timeStepDates;
     caf::PdmField< std::vector <double> >                    m_daysSinceSimulationStart;

ApplicationCode/ProjectDataModel/RimViewLinker.h

@@ -19,7 +19,7 @@
 
 #pragma once
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 
 #include "RivCellSetEnum.h"
 

ApplicationCode/ProjectDataModel/RimViewLinkerCollection.h

@@ -19,7 +19,7 @@
 
 #pragma once
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 
 #include "cafPdmChildField.h"
 #include "cafPdmField.h"

ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp

@@ -330,7 +330,7 @@ void RimWellLogExtractionCurve::onLoadDataAndUpdate()
         std::vector<double> measuredDepthValues;
         std::vector<double> tvDepthValues;
 
-        RimDefines::DepthUnitType depthUnit = RimDefines::UNIT_METER;
+        RiaDefines::DepthUnitType depthUnit = RiaDefines::UNIT_METER;
 
         if (eclExtractor.notNull())
         {
@@ -354,7 +354,7 @@ void RimWellLogExtractionCurve::onLoadDataAndUpdate()
             {
                 // See https://github.com/OPM/ResInsight/issues/538
                 
-                depthUnit = RimDefines::UNIT_FEET;
+                depthUnit = RiaDefines::UNIT_FEET;
             }
         }
         else if (geomExtractor.notNull()) // geomExtractor
@@ -381,7 +381,7 @@ void RimWellLogExtractionCurve::onLoadDataAndUpdate()
             }
         }
 
-        RimDefines::DepthUnitType displayUnit = RimDefines::UNIT_METER;
+        RiaDefines::DepthUnitType displayUnit = RiaDefines::UNIT_METER;
 
         RimWellLogPlot* wellLogPlot;
         firstAncestorOrThisOfType(wellLogPlot);

ApplicationCode/ProjectDataModel/RimWellLogFileCurve.cpp

@@ -114,7 +114,7 @@ void RimWellLogFileCurve::onLoadDataAndUpdate()
             }
         }
 
-        RimDefines::DepthUnitType displayUnit = RimDefines::UNIT_METER;
+        RiaDefines::DepthUnitType displayUnit = RiaDefines::UNIT_METER;
         if (wellLogPlot)
         {
             displayUnit = wellLogPlot->depthUnit();

ApplicationCode/ProjectDataModel/RimWellLogPlot.cpp

@@ -70,7 +70,7 @@ RimWellLogPlot::RimWellLogPlot()
     caf::AppEnum< RimWellLogPlot::DepthTypeEnum > depthType = MEASURED_DEPTH;
     CAF_PDM_InitField(&m_depthType, "DepthType", depthType, "Depth type",   "", "", "");
 
-    caf::AppEnum< RimDefines::DepthUnitType > depthUnit = RimDefines::UNIT_METER;
+    caf::AppEnum< RiaDefines::DepthUnitType > depthUnit = RiaDefines::UNIT_METER;
     CAF_PDM_InitField(&m_depthUnit, "DepthUnit", depthUnit, "Depth unit", "", "", "");
 
     CAF_PDM_InitField(&m_minVisibleDepth, "MinimumDepth", 0.0, "Min", "", "", "");
@@ -160,9 +160,9 @@ QList<caf::PdmOptionItemInfo> RimWellLogPlot::calculateValueOptions(const caf::P
     }
     else if ( fieldNeedingOptions == &m_depthUnit)
     {
-        using UnitAppEnum = caf::AppEnum< RimDefines::DepthUnitType >;
-        options.push_back(caf::PdmOptionItemInfo(UnitAppEnum::uiText(RimDefines::UNIT_METER), RimDefines::UNIT_METER));
-        options.push_back(caf::PdmOptionItemInfo(UnitAppEnum::uiText(RimDefines::UNIT_FEET), RimDefines::UNIT_FEET));
+        using UnitAppEnum = caf::AppEnum< RiaDefines::DepthUnitType >;
+        options.push_back(caf::PdmOptionItemInfo(UnitAppEnum::uiText(RiaDefines::UNIT_METER), RiaDefines::UNIT_METER));
+        options.push_back(caf::PdmOptionItemInfo(UnitAppEnum::uiText(RiaDefines::UNIT_FEET), RiaDefines::UNIT_FEET));
     }
 
     (*useOptionsOnly) = true;
@@ -426,7 +426,7 @@ QString RimWellLogPlot::asciiDataForPlotExport() const
 
             if (curveNames.size() == 1)
             {
-                curveDepths = curveData->measuredDepthPlotValues(RimDefines::UNIT_NONE);
+                curveDepths = curveData->measuredDepthPlotValues(RiaDefines::UNIT_NONE);
             }
 
             std::vector<double> xPlotValues = curveData->xPlotValues();
@@ -671,7 +671,7 @@ void RimWellLogPlot::setDepthType(DepthTypeEnum depthType)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimDefines::DepthUnitType RimWellLogPlot::depthUnit() const
+RiaDefines::DepthUnitType RimWellLogPlot::depthUnit() const
 {
     return m_depthUnit.value();
 }
@@ -704,15 +704,15 @@ QString RimWellLogPlot::depthPlotTitle() const
 
     if (m_depthType() == CONNECTION_NUMBER) return depthTitle;
 
-    if (m_depthUnit == RimDefines::UNIT_METER)
+    if (m_depthUnit == RiaDefines::UNIT_METER)
     {
         depthTitle += " [m]";
     }
-    else if (m_depthUnit == RimDefines::UNIT_FEET)
+    else if (m_depthUnit == RiaDefines::UNIT_FEET)
     {
         depthTitle += " [ft]";
     }
-    else if (m_depthUnit == RimDefines::UNIT_NONE)
+    else if (m_depthUnit == RiaDefines::UNIT_NONE)
     {
         depthTitle += "";
     }
@@ -747,7 +747,7 @@ size_t RimWellLogPlot::trackIndex(RimWellLogTrack* track)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimWellLogPlot::setDepthUnit(RimDefines::DepthUnitType depthUnit)
+void RimWellLogPlot::setDepthUnit(RiaDefines::DepthUnitType depthUnit)
 {
     m_depthUnit = depthUnit;
 

ApplicationCode/ProjectDataModel/RimWellLogPlot.h

@@ -24,7 +24,7 @@
 #include "cafPdmChildArrayField.h"
 #include "cafAppEnum.h"
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 #include "RimViewWindow.h"
 
 #include <QPointer>
@@ -63,8 +63,8 @@ public:
     DepthTypeEnum                                   depthType() const;
     void                                            setDepthType(DepthTypeEnum depthType);
 
-    RimDefines::DepthUnitType                       depthUnit() const;
-    void                                            setDepthUnit(RimDefines::DepthUnitType depthUnit);
+    RiaDefines::DepthUnitType                       depthUnit() const;
+    void                                            setDepthUnit(RiaDefines::DepthUnitType depthUnit);
 
 
     QString                                         depthPlotTitle() const;
@@ -130,7 +130,7 @@ private:
     caf::PdmField<QString>                          m_userName;
     
     caf::PdmField< caf::AppEnum< DepthTypeEnum > >              m_depthType;
-    caf::PdmField< caf::AppEnum< RimDefines::DepthUnitType > >  m_depthUnit;
+    caf::PdmField< caf::AppEnum< RiaDefines::DepthUnitType > >  m_depthUnit;
     std::set<DepthTypeEnum>                         m_disabledDepthTypes;
 
     caf::PdmChildArrayField<RimWellLogTrack*>       m_tracks;

ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.cpp

@@ -24,7 +24,7 @@
 
 #include "RigSummaryCaseData.h"
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 #include "RimEclipseResultCase.h"
 #include "RimProject.h"
 #include "RimSummaryCase.h"
@@ -267,7 +267,7 @@ const std::vector<time_t>& RimSummaryCurve::timeSteps() const
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimSummaryCurve::setYAxis(RimDefines::PlotAxis plotAxis)
+void RimSummaryCurve::setYAxis(RiaDefines::PlotAxis plotAxis)
 {
     m_plotAxis = plotAxis;
 }
@@ -275,7 +275,7 @@ void RimSummaryCurve::setYAxis(RimDefines::PlotAxis plotAxis)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimDefines::PlotAxis RimSummaryCurve::yAxis() const
+RiaDefines::PlotAxis RimSummaryCurve::yAxis() const
 {
     return m_plotAxis();
 }
@@ -331,7 +331,7 @@ QList<caf::PdmOptionItemInfo> RimSummaryCurve::calculateValueOptions(const caf::
                 }
             }
 
-            options.push_front(caf::PdmOptionItemInfo(RimDefines::undefinedResultName(), addressCount));
+            options.push_front(caf::PdmOptionItemInfo(RiaDefines::undefinedResultName(), addressCount));
 
             if(useOptionsOnly) *useOptionsOnly = true;
         }
@@ -470,7 +470,7 @@ void RimSummaryCurve::updateQwtPlotAxis()
 {
     if (m_qwtPlotCurve)
     {
-        if (this->yAxis() == RimDefines::PLOT_AXIS_LEFT)
+        if (this->yAxis() == RiaDefines::PLOT_AXIS_LEFT)
         {
             m_qwtPlotCurve->setYAxis(QwtPlot::yLeft);
         }

ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.h

@@ -26,7 +26,7 @@
 #include "cafPdmChildField.h"
 
 #include "RifEclipseSummaryAddress.h"
-#include "RimDefines.h"
+#include "RiaDefines.h"
 #include "RimPlotCurve.h"
 
 #include "cafAppEnum.h"
@@ -87,8 +87,8 @@ public:
     std::vector<double>                     yValues() const;
     const std::vector<time_t>&              timeSteps() const;
 
-    void                                    setYAxis(RimDefines::PlotAxis plotAxis);
-    RimDefines::PlotAxis                    yAxis() const;
+    void                                    setYAxis(RiaDefines::PlotAxis plotAxis);
+    RiaDefines::PlotAxis                    yAxis() const;
     void                                    updateQwtPlotAxis();
 
     void                                    applyCurveAutoNameSettings(const RimSummaryCurveAutoName& autoNameSettings);
@@ -118,7 +118,7 @@ private:
 
     caf::PdmChildField<RimSummaryCurveAutoName*>   m_curveNameConfig;
 
-    caf::PdmField< caf::AppEnum< RimDefines::PlotAxis > > m_plotAxis;
+    caf::PdmField< caf::AppEnum< RiaDefines::PlotAxis > > m_plotAxis;
 
     // Filter fields
     caf::PdmChildField<RimSummaryFilter*>   m_summaryFilter;

ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveFilter.cpp

@@ -24,7 +24,7 @@
 
 #include "RigSummaryCaseData.h"
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 #include "RimEclipseResultCase.h"
 #include "RimProject.h"
 #include "RimSummaryCase.h"
@@ -586,7 +586,7 @@ void RimSummaryCurveFilter::updateCaseNameHasChanged()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimDefines::PlotAxis RimSummaryCurveFilter::associatedPlotAxis() const
+RiaDefines::PlotAxis RimSummaryCurveFilter::associatedPlotAxis() const
 {
     return m_plotAxis();
 }
@@ -594,7 +594,7 @@ RimDefines::PlotAxis RimSummaryCurveFilter::associatedPlotAxis() const
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimSummaryCurveFilter::setPlotAxis(RimDefines::PlotAxis plotAxis)
+void RimSummaryCurveFilter::setPlotAxis(RiaDefines::PlotAxis plotAxis)
 {
     m_plotAxis = plotAxis;
     updateConnectedEditors();

ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveFilter.h

@@ -30,7 +30,7 @@
 
 #include "RifEclipseSummaryAddress.h"
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 #include "RimSummaryCurveAppearanceCalculator.h"
 
 class QwtPlot;
@@ -70,8 +70,8 @@ public:
 
     void                                    updateCaseNameHasChanged();
 
-    RimDefines::PlotAxis                    associatedPlotAxis() const;
-    void                                    setPlotAxis(RimDefines::PlotAxis plotAxis);
+    RiaDefines::PlotAxis                    associatedPlotAxis() const;
+    void                                    setPlotAxis(RiaDefines::PlotAxis plotAxis);
 
     void                                    updateCompleteVariableStringFilterChanged();
     
@@ -109,7 +109,7 @@ private:
     caf::PdmPtrArrayField<RimSummaryCase*>    m_selectedSummaryCases;
     caf::PdmChildArrayField<RimSummaryCurve*> m_curves;
 
-    caf::PdmField< caf::AppEnum< RimDefines::PlotAxis > > m_plotAxis;
+    caf::PdmField< caf::AppEnum< RiaDefines::PlotAxis > > m_plotAxis;
     caf::PdmField<bool>                       m_showLegend;
 
 

ApplicationCode/ProjectDataModel/Summary/RimSummaryCurvesCalculator.cpp

@@ -20,7 +20,7 @@
 
 #include "RigStatisticsCalculator.h"
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 #include "RimSummaryCurve.h"
 #include "RimSummaryCurveFilter.h"
 #include "RimSummaryYAxisProperties.h"
@@ -276,8 +276,8 @@ void RimSummaryPlotYAxisRangeCalculator::computeYRange(double* min, double* max)
 
     if (minValue == HUGE_VAL)
     {
-        minValue = RimDefines::minimumDefaultValuePlot();
-        maxValue = RimDefines::maximumDefaultValuePlot();
+        minValue = RiaDefines::minimumDefaultValuePlot();
+        maxValue = RiaDefines::maximumDefaultValuePlot();
     }
 
     // For logarithmic auto scaling, compute positive curve value closest to zero and use

ApplicationCode/ProjectDataModel/Summary/RimSummaryPlot.cpp

@@ -113,8 +113,8 @@ RimSummaryPlot::~RimSummaryPlot()
 //--------------------------------------------------------------------------------------------------
 void RimSummaryPlot::updateAxes()
 {
-    updateAxis(RimDefines::PLOT_AXIS_LEFT);
-    updateAxis(RimDefines::PLOT_AXIS_RIGHT);
+    updateAxis(RiaDefines::PLOT_AXIS_LEFT);
+    updateAxis(RiaDefines::PLOT_AXIS_RIGHT);
 
     updateZoomInQwt();
 
@@ -124,7 +124,7 @@ void RimSummaryPlot::updateAxes()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimSummaryPlot::isLogarithmicScaleEnabled(RimDefines::PlotAxis plotAxis) const
+bool RimSummaryPlot::isLogarithmicScaleEnabled(RiaDefines::PlotAxis plotAxis) const
 {
     return yAxisPropertiesForAxis(plotAxis)->isLogarithmicScaleEnabled();
 }
@@ -365,12 +365,12 @@ QString RimSummaryPlot::asciiDataForPlotExport() const
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimSummaryPlot::updateAxis(RimDefines::PlotAxis plotAxis)
+void RimSummaryPlot::updateAxis(RiaDefines::PlotAxis plotAxis)
 {
     if (!m_qwtPlot) return;
 
     QwtPlot::Axis qwtAxis = QwtPlot::yLeft;
-    if (plotAxis == RimDefines::PLOT_AXIS_LEFT)
+    if (plotAxis == RiaDefines::PLOT_AXIS_LEFT)
     {
         qwtAxis = QwtPlot::yLeft;
     }
@@ -403,7 +403,7 @@ void RimSummaryPlot::updateAxis(RimDefines::PlotAxis plotAxis)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimSummaryPlot::updateZoomForAxis(RimDefines::PlotAxis plotAxis)
+void RimSummaryPlot::updateZoomForAxis(RiaDefines::PlotAxis plotAxis)
 {
     RimSummaryYAxisProperties* yAxisProps = yAxisPropertiesForAxis(plotAxis);
 
@@ -441,7 +441,7 @@ void RimSummaryPlot::updateZoomForAxis(RimDefines::PlotAxis plotAxis)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-std::vector<RimSummaryCurve*> RimSummaryPlot::visibleSummaryCurvesForAxis(RimDefines::PlotAxis plotAxis) const
+std::vector<RimSummaryCurve*> RimSummaryPlot::visibleSummaryCurvesForAxis(RiaDefines::PlotAxis plotAxis) const
 {
     std::vector<RimSummaryCurve*> curves;
 
@@ -473,7 +473,7 @@ std::vector<RimSummaryCurve*> RimSummaryPlot::visibleSummaryCurvesForAxis(RimDef
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimSummaryPlot::hasVisibleCurvesForAxis(RimDefines::PlotAxis plotAxis) const
+bool RimSummaryPlot::hasVisibleCurvesForAxis(RiaDefines::PlotAxis plotAxis) const
 {
     if (visibleSummaryCurvesForAxis(plotAxis).size() > 0)
     {
@@ -491,11 +491,11 @@ bool RimSummaryPlot::hasVisibleCurvesForAxis(RimDefines::PlotAxis plotAxis) cons
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimSummaryYAxisProperties* RimSummaryPlot::yAxisPropertiesForAxis(RimDefines::PlotAxis plotAxis) const
+RimSummaryYAxisProperties* RimSummaryPlot::yAxisPropertiesForAxis(RiaDefines::PlotAxis plotAxis) const
 {
     RimSummaryYAxisProperties* yAxisProps = nullptr;
 
-    if (plotAxis == RimDefines::PLOT_AXIS_LEFT)
+    if (plotAxis == RiaDefines::PLOT_AXIS_LEFT)
     {
         yAxisProps = m_leftYAxisProperties();
     }
@@ -512,7 +512,7 @@ RimSummaryYAxisProperties* RimSummaryPlot::yAxisPropertiesForAxis(RimDefines::Pl
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-std::vector<RimGridTimeHistoryCurve*> RimSummaryPlot::visibleTimeHistoryCurvesForAxis(RimDefines::PlotAxis plotAxis) const
+std::vector<RimGridTimeHistoryCurve*> RimSummaryPlot::visibleTimeHistoryCurvesForAxis(RiaDefines::PlotAxis plotAxis) const
 {
     std::vector<RimGridTimeHistoryCurve*> curves;
 
@@ -633,8 +633,8 @@ void RimSummaryPlot::zoomAll()
     {
         m_qwtPlot->setAxisAutoScale(QwtPlot::xBottom, true);
 
-        updateZoomForAxis(RimDefines::PLOT_AXIS_LEFT);
-        updateZoomForAxis(RimDefines::PLOT_AXIS_RIGHT);
+        updateZoomForAxis(RiaDefines::PLOT_AXIS_LEFT);
+        updateZoomForAxis(RiaDefines::PLOT_AXIS_RIGHT);
 
         m_qwtPlot->replot();
     }

ApplicationCode/ProjectDataModel/Summary/RimSummaryPlot.h

@@ -25,7 +25,7 @@
 #include "cafAppEnum.h"
 #include "cafPdmChildField.h"
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 #include "RimViewWindow.h"
 
 #include <QPointer>
@@ -79,7 +79,7 @@ public:
     void                                            updateZoomWindowFromQwt();
     void                                            disableAutoZoom();
     
-    bool                                            isLogarithmicScaleEnabled(RimDefines::PlotAxis plotAxis) const;
+    bool                                            isLogarithmicScaleEnabled(RiaDefines::PlotAxis plotAxis) const;
 
     RimSummaryTimeAxisProperties*                   timeAxisProperties();
     time_t                                          firstTimeStepOfFirstCurve();
@@ -100,13 +100,13 @@ protected:
     virtual QImage                                  snapshotWindowContent() override;
 
 private:
-    std::vector<RimSummaryCurve*>                   visibleSummaryCurvesForAxis(RimDefines::PlotAxis plotAxis) const;
-    std::vector<RimGridTimeHistoryCurve*>           visibleTimeHistoryCurvesForAxis(RimDefines::PlotAxis plotAxis) const;
-    bool                                            hasVisibleCurvesForAxis(RimDefines::PlotAxis plotAxis) const;
+    std::vector<RimSummaryCurve*>                   visibleSummaryCurvesForAxis(RiaDefines::PlotAxis plotAxis) const;
+    std::vector<RimGridTimeHistoryCurve*>           visibleTimeHistoryCurvesForAxis(RiaDefines::PlotAxis plotAxis) const;
+    bool                                            hasVisibleCurvesForAxis(RiaDefines::PlotAxis plotAxis) const;
 
-    RimSummaryYAxisProperties*                      yAxisPropertiesForAxis(RimDefines::PlotAxis plotAxis) const;
-    void                                            updateAxis(RimDefines::PlotAxis plotAxis);
-    void                                            updateZoomForAxis(RimDefines::PlotAxis plotAxis);
+    RimSummaryYAxisProperties*                      yAxisPropertiesForAxis(RiaDefines::PlotAxis plotAxis) const;
+    void                                            updateAxis(RiaDefines::PlotAxis plotAxis);
+    void                                            updateZoomForAxis(RiaDefines::PlotAxis plotAxis);
 
     void                                            updateTimeAxis();
     void                                            setZoomIntervalsInQwtPlot();

ApplicationCode/ProjectDataModel/Summary/RimSummaryYAxisProperties.cpp

@@ -19,7 +19,7 @@
 #include "RimSummaryYAxisProperties.h"
 
 #include "RimSummaryPlot.h"
-#include "RimDefines.h"
+#include "RiaDefines.h"
 
 
 namespace caf
@@ -68,8 +68,8 @@ RimSummaryYAxisProperties::RimSummaryYAxisProperties()
     CAF_PDM_InitFieldNoDefault(&titlePositionEnum, "TitlePosition", "Title Position", "", "", "");
     CAF_PDM_InitField(&fontSize, "FontSize", 11, "Font Size", "", "", "");
 
-    CAF_PDM_InitField(&visibleRangeMax, "VisibleRangeMax", RimDefines::maximumDefaultValuePlot(), "Max", "", "", "");
-    CAF_PDM_InitField(&visibleRangeMin, "VisibleRangeMin", RimDefines::minimumDefaultValuePlot(), "Min", "", "", "");
+    CAF_PDM_InitField(&visibleRangeMax, "VisibleRangeMax", RiaDefines::maximumDefaultValuePlot(), "Max", "", "", "");
+    CAF_PDM_InitField(&visibleRangeMin, "VisibleRangeMin", RiaDefines::minimumDefaultValuePlot(), "Min", "", "", "");
 
     CAF_PDM_InitFieldNoDefault(&numberFormat, "NumberFormat", "Number Format", "", "", "");
 
@@ -154,11 +154,11 @@ QwtPlot::Axis RimSummaryYAxisProperties::qwtPlotAxisType() const
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimDefines::PlotAxis RimSummaryYAxisProperties::plotAxisType() const
+RiaDefines::PlotAxis RimSummaryYAxisProperties::plotAxisType() const
 {
-    if (m_axis == QwtPlot::yRight) return RimDefines::PLOT_AXIS_RIGHT;
+    if (m_axis == QwtPlot::yRight) return RiaDefines::PLOT_AXIS_RIGHT;
 
-    return RimDefines::PLOT_AXIS_LEFT;
+    return RiaDefines::PLOT_AXIS_LEFT;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ProjectDataModel/Summary/RimSummaryYAxisProperties.h

@@ -19,7 +19,7 @@
 
 #pragma once
 
-#include "RimDefines.h"
+#include "RiaDefines.h"
 
 #include "cafPdmObject.h"
 #include "cafPdmField.h"
@@ -59,7 +59,7 @@ public:
 
     void                        setNameAndAxis(const QString& name, QwtPlot::Axis axis);
     QwtPlot::Axis               qwtPlotAxisType() const;
-    RimDefines::PlotAxis        plotAxisType() const;
+    RiaDefines::PlotAxis        plotAxisType() const;
 
     caf::PdmField<bool>         isAutoTitle;
     caf::PdmField<QString>      customTitle;