OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

#1596 Merge dev into pre-proto

Browse Source
This commit is contained in:
Magne Sjaastad 2017-06-14 07:25:34 +02:00
commit a8b8e061d7
139 changed files with 1154 additions and 1068 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
ApplicationCode/Application/CMakeLists_files.cmake Normal file
View File

@ -0,0 +1,34 @@
# Use this workaround until we're on 2.8.3 on all platforms and can use CMAKE_CURRENT_LIST_DIR directly
if (${CMAKE_VERSION} VERSION_GREATER "2.8.2")
set(CEE_CURRENT_LIST_DIR ${CMAKE_CURRENT_LIST_DIR}/)
endif()
set (SOURCE_GROUP_HEADER_FILES
${CEE_CURRENT_LIST_DIR}RiaApplication.h
${CEE_CURRENT_LIST_DIR}RiaDefines.h
${CEE_CURRENT_LIST_DIR}RiaPreferences.h
)
set (SOURCE_GROUP_SOURCE_FILES
${CEE_CURRENT_LIST_DIR}RiaApplication.cpp
${CEE_CURRENT_LIST_DIR}RiaDefines.cpp
${CEE_CURRENT_LIST_DIR}RiaMain.cpp
${CEE_CURRENT_LIST_DIR}RiaPreferences.cpp
)
list(APPEND CODE_HEADER_FILES
${SOURCE_GROUP_HEADER_FILES}
)
list(APPEND CODE_SOURCE_FILES
${SOURCE_GROUP_SOURCE_FILES}
)
set (QT_MOC_HEADERS
${QT_MOC_HEADERS}
${CEE_CURRENT_LIST_DIR}RiaApplication.h
)
source_group( "Application" FILES ${SOURCE_GROUP_HEADER_FILES} ${SOURCE_GROUP_SOURCE_FILES} ${CEE_CURRENT_LIST_DIR}CMakeLists_files.cmake )

28
ApplicationCode/Application/RiaApplication.cpp
View File

@ -37,7 +37,7 @@
#include "RimCellEdgeColors.h"
#include "RimCellRangeFilterCollection.h"
#include "RimCommandObject.h"
#include "RimDefines.h"
#include "RiaDefines.h"
#include "RimEclipseCaseCollection.h"
#include "RimEclipseCellColors.h"
#include "RimEclipseFaultColors.h"
@ -971,7 +971,7 @@ bool RiaApplication::openEclipseCase(const QString& caseName, const QString& cas
RimEclipseView* riv = rimResultReservoir->createAndAddReservoirView();
// Select SOIL as default result variable
riv->cellResult()->setResultType(RimDefines::DYNAMIC_NATIVE);
riv->cellResult()->setResultType(RiaDefines::DYNAMIC_NATIVE);
if (m_preferences->loadAndShowSoil)
{
@ -987,15 +987,15 @@ bool RiaApplication::openEclipseCase(const QString& caseName, const QString& cas
{
if (rimResultReservoir->eclipseCaseData()->unitsType() == RigEclipseCaseData::UNITS_METRIC)
{
project()->activeOilField()->fractureDefinitionCollection->defaultUnitsForFracTemplates = RimUnitSystem::UNITS_METRIC;
project()->activeOilField()->fractureDefinitionCollection->defaultUnitsForFracTemplates = RiaEclipseUnitTools::UNITS_METRIC;
}
else if (rimResultReservoir->eclipseCaseData()->unitsType() == RigEclipseCaseData::UNITS_FIELD)
{
project()->activeOilField()->fractureDefinitionCollection->defaultUnitsForFracTemplates = RimUnitSystem::UNITS_FIELD;
project()->activeOilField()->fractureDefinitionCollection->defaultUnitsForFracTemplates = RiaEclipseUnitTools::UNITS_FIELD;
}
else if (rimResultReservoir->eclipseCaseData()->unitsType() == RigEclipseCaseData::UNITS_LAB)
{
project()->activeOilField()->fractureDefinitionCollection->defaultUnitsForFracTemplates = RimUnitSystem::UNITS_METRIC;
project()->activeOilField()->fractureDefinitionCollection->defaultUnitsForFracTemplates = RiaEclipseUnitTools::UNITS_METRIC;
}
}
}
@ -1081,7 +1081,7 @@ bool RiaApplication::openEclipseCase(const QString& caseName, const QString& cas
if (!riv->cellResult()->hasResult())
{
riv->cellResult()->setResultVariable(RimDefines::undefinedResultName());
riv->cellResult()->setResultVariable(RiaDefines::undefinedResultName());
}
analysisModels->updateConnectedEditors();
@ -1110,14 +1110,14 @@ bool RiaApplication::openInputEclipseCaseFromFileNames(const QStringList& fileNa
RimEclipseView* riv = rimInputReservoir->createAndAddReservoirView();
riv->cellResult()->setResultType(RimDefines::INPUT_PROPERTY);
riv->cellResult()->setResultType(RiaDefines::INPUT_PROPERTY);
riv->hasUserRequestedAnimation = true;
riv->loadDataAndUpdate();
if (!riv->cellResult()->hasResult())
{
riv->cellResult()->setResultVariable(RimDefines::undefinedResultName());
riv->cellResult()->setResultVariable(RiaDefines::undefinedResultName());
}
analysisModels->updateConnectedEditors();
@ -1166,7 +1166,7 @@ bool RiaApplication::openOdbCaseFromFile(const QString& fileName)
//if (!riv->cellResult()->hasResult())
//{
// riv->cellResult()->setResultVariable(RimDefines::undefinedResultName());
// riv->cellResult()->setResultVariable(RiaEclipseUnitTools::undefinedResultName());
//}
progress.incrementProgress();
progress.setProgressDescription("Loading results information");
@ -1185,7 +1185,7 @@ bool RiaApplication::openOdbCaseFromFile(const QString& fileName)
//--------------------------------------------------------------------------------------------------
void RiaApplication::createMockModel()
{
openEclipseCase(RimDefines::mockModelBasic(), RimDefines::mockModelBasic());
openEclipseCase(RiaDefines::mockModelBasic(), RiaDefines::mockModelBasic());
}
//--------------------------------------------------------------------------------------------------
@ -1193,7 +1193,7 @@ void RiaApplication::createMockModel()
//--------------------------------------------------------------------------------------------------
void RiaApplication::createResultsMockModel()
{
openEclipseCase(RimDefines::mockModelBasicWithResults(), RimDefines::mockModelBasicWithResults());
openEclipseCase(RiaDefines::mockModelBasicWithResults(), RiaDefines::mockModelBasicWithResults());
}
@ -1202,7 +1202,7 @@ void RiaApplication::createResultsMockModel()
//--------------------------------------------------------------------------------------------------
void RiaApplication::createLargeResultsMockModel()
{
openEclipseCase(RimDefines::mockModelLargeWithResults(), RimDefines::mockModelLargeWithResults());
openEclipseCase(RiaDefines::mockModelLargeWithResults(), RiaDefines::mockModelLargeWithResults());
}
@ -1211,7 +1211,7 @@ void RiaApplication::createLargeResultsMockModel()
//--------------------------------------------------------------------------------------------------
void RiaApplication::createMockModelCustomized()
{
openEclipseCase(RimDefines::mockModelCustomized(), RimDefines::mockModelCustomized());
openEclipseCase(RiaDefines::mockModelCustomized(), RiaDefines::mockModelCustomized());
}
//--------------------------------------------------------------------------------------------------
@ -1219,7 +1219,7 @@ void RiaApplication::createMockModelCustomized()
//--------------------------------------------------------------------------------------------------
void RiaApplication::createInputMockModel()
{
openInputEclipseCaseFromFileNames(QStringList(RimDefines::mockModelBasicInputCase()));
openInputEclipseCaseFromFileNames(QStringList(RiaDefines::mockModelBasicInputCase()));
}
//--------------------------------------------------------------------------------------------------

111
ApplicationCode/Application/RiaDefines.cpp Normal file
View File

@ -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;
}

2
ApplicationCode/ProjectDataModel/RimDefines.h → ApplicationCode/Application/RiaDefines.h
View File

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

0
ApplicationCode/RiaMain.cpp → ApplicationCode/Application/RiaMain.cpp
View File

41
ApplicationCode/Application/Tools/CMakeLists_files.cmake Normal file
View File

@ -0,0 +1,41 @@
# Use this workaround until we're on 2.8.3 on all platforms and can use CMAKE_CURRENT_LIST_DIR directly
if (${CMAKE_VERSION} VERSION_GREATER "2.8.2")
set(CEE_CURRENT_LIST_DIR ${CMAKE_CURRENT_LIST_DIR}/)
endif()
set (SOURCE_GROUP_HEADER_FILES
${CEE_CURRENT_LIST_DIR}RiaColorTables.h
${CEE_CURRENT_LIST_DIR}RiaEclipseUnitTools.h
${CEE_CURRENT_LIST_DIR}RiaImageCompareReporter.h
${CEE_CURRENT_LIST_DIR}RiaImageFileCompare.h
${CEE_CURRENT_LIST_DIR}RiaLogging.h
${CEE_CURRENT_LIST_DIR}RiaProjectModifier.h
${CEE_CURRENT_LIST_DIR}RiaRegressionTest.h
)
set (SOURCE_GROUP_SOURCE_FILES
${CEE_CURRENT_LIST_DIR}RiaColorTables.cpp
${CEE_CURRENT_LIST_DIR}RiaEclipseUnitTools.cpp
${CEE_CURRENT_LIST_DIR}RiaImageCompareReporter.cpp
${CEE_CURRENT_LIST_DIR}RiaImageFileCompare.cpp
${CEE_CURRENT_LIST_DIR}RiaLogging.cpp
${CEE_CURRENT_LIST_DIR}RiaProjectModifier.cpp
${CEE_CURRENT_LIST_DIR}RiaRegressionTest.cpp
)
list(APPEND CODE_HEADER_FILES
${SOURCE_GROUP_HEADER_FILES}
)
list(APPEND CODE_SOURCE_FILES
${SOURCE_GROUP_SOURCE_FILES}
)
set (QT_MOC_HEADERS
${QT_MOC_HEADERS}
)
source_group( "Application\\Tools" FILES ${SOURCE_GROUP_HEADER_FILES} ${SOURCE_GROUP_SOURCE_FILES} ${CEE_CURRENT_LIST_DIR}CMakeLists_files.cmake )

0
ApplicationCode/Application/RiaColorTables.cpp → ApplicationCode/Application/Tools/RiaColorTables.cpp
View File

0
ApplicationCode/Application/RiaColorTables.h → ApplicationCode/Application/Tools/RiaColorTables.h
View File

14
ApplicationCode/ProjectDataModel/RimUnitSystem.cpp → ApplicationCode/Application/Tools/RiaEclipseUnitTools.cpp
View File

@ -16,7 +16,7 @@
//
/////////////////////////////////////////////////////////////////////////////////
#include "RimUnitSystem.h"
#include "RiaEclipseUnitTools.h"
#include "cafAppEnum.h"
@ -25,20 +25,20 @@
namespace caf
{
template<>
void RimUnitSystem::UnitSystemType::setUp()
void RiaEclipseUnitTools::UnitSystemType::setUp()
{
addItem(RimUnitSystem::UNITS_METRIC, "UNITS_METRIC", "Metric");
addItem(RimUnitSystem::UNITS_FIELD, "UNITS_FIELD", "Field");
addItem(RimUnitSystem::UNITS_UNKNOWN, "UNITS_UNKNOWN", "Unknown");
addItem(RiaEclipseUnitTools::UNITS_METRIC, "UNITS_METRIC", "Metric");
addItem(RiaEclipseUnitTools::UNITS_FIELD, "UNITS_FIELD", "Field");
addItem(RiaEclipseUnitTools::UNITS_UNKNOWN, "UNITS_UNKNOWN", "Unknown");
setDefault(RimUnitSystem::UNITS_METRIC);
setDefault(RiaEclipseUnitTools::UNITS_METRIC);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimUnitSystem::darcysConstant(UnitSystem unitSystem)
double RiaEclipseUnitTools::darcysConstant(UnitSystem unitSystem)
{
// See "Cartesian transmissibility calculations" in the "Eclipse Technical Description"
// CDARCY Darcys constant

4
ApplicationCode/ProjectDataModel/RimUnitSystem.h → ApplicationCode/Application/Tools/RiaEclipseUnitTools.h
View File

@ -20,7 +20,7 @@
#include "cafAppEnum.h"
class RimUnitSystem
class RiaEclipseUnitTools
{
public:
@ -32,7 +32,7 @@ public:
UNITS_UNKNOWN,
};
typedef caf::AppEnum< RimUnitSystem::UnitSystem > UnitSystemType;
typedef caf::AppEnum< RiaEclipseUnitTools::UnitSystem > UnitSystemType;
static double feetPerMeter() { return 3.2808399; }
static double meterPerFeet() { return 0.3048000; }

0
ApplicationCode/Application/RiaImageCompareReporter.cpp → ApplicationCode/Application/Tools/RiaImageCompareReporter.cpp
View File

0
ApplicationCode/Application/RiaImageCompareReporter.h → ApplicationCode/Application/Tools/RiaImageCompareReporter.h
View File

312
ApplicationCode/Application/RiaImageFileCompare.cpp → ApplicationCode/Application/Tools/RiaImageFileCompare.cpp
View File

@ -1,156 +1,156 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2011-2012 Statoil ASA, 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 "RiaImageFileCompare.h"
#include <QtCore/QProcess>
//==================================================================================================
//
//
//
//==================================================================================================
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaImageFileCompare::RiaImageFileCompare(QString compareExecutable)
: m_compareExecutable(compareExecutable)
{
reset();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaImageFileCompare::~RiaImageFileCompare()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiaImageFileCompare::reset()
{
m_imagesEqual = false;
m_lastError = IC_NO_ERROR;
m_errorMsg = "";
m_errorDetails = "";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiaImageFileCompare::runComparison(QString imgFileName, QString refFileName, QString diffFileName)
{
reset();
if (m_compareExecutable.isEmpty())
{
m_lastError = SEVERE_ERROR;
m_errorMsg = "Cannot compare images, no compare executable set";
return false;
}
//QString args = QString("-fuzz 2% -lowlight-color white -metric ae \"%1\" \"%2\" \"%3\"").arg(imgFileName).arg(refFileName).arg((diffFileName));
// The ImageMagick compare tool on RedHat 5 does not support the lowlight-color options
// Use GCC version as a crude mechanism for disabling use of this option on RedHat5
#if (__GNUC__ == 4 && __GNUC_MINOR__ <= 1)
QString args = QString("-fuzz 0.4% -metric ae \"%1\" \"%2\" \"%3\"").arg(imgFileName).arg(refFileName).arg((diffFileName));
#else
QString args = QString("-fuzz 0.4% -lowlight-color white -metric ae \"%1\" \"%2\" \"%3\"").arg(imgFileName).arg(refFileName).arg((diffFileName));
#endif
QString completeCommand = QString("\"%1\" %2").arg(m_compareExecutable).arg(args);
// Launch process and wait
QProcess proc;
proc.start(completeCommand);
proc.waitForFinished(30000);
QProcess::ProcessError procError = proc.error();
if (procError != QProcess::UnknownError)
{
m_lastError = SEVERE_ERROR;
m_errorMsg = "Error running compare tool process";
m_errorDetails = completeCommand;
return false;
}
QByteArray stdErr = proc.readAllStandardError();
int procExitCode = proc.exitCode();
if (procExitCode == 0)
{
// Strip out whitespace and look for 0 (as in zero pixel differences)
stdErr = stdErr.simplified();
if (!stdErr.isEmpty() && stdErr[0] == '0')
{
m_imagesEqual = true;
}
return true;
}
else
{
// Report non-severe error
m_lastError = IC_ERROR;
m_errorMsg = "Error running compare tool process";
m_errorDetails = stdErr;
return false;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiaImageFileCompare::imagesEqual() const
{
return m_imagesEqual;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaImageFileCompare::ErrorType RiaImageFileCompare::error() const
{
return m_lastError;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaImageFileCompare::errorMessage() const
{
return m_errorMsg;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaImageFileCompare::errorDetails() const
{
return m_errorDetails;
}
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2011-2012 Statoil ASA, 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 "RiaImageFileCompare.h"
#include <QtCore/QProcess>
//==================================================================================================
//
//
//
//==================================================================================================
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaImageFileCompare::RiaImageFileCompare(QString compareExecutable)
: m_compareExecutable(compareExecutable)
{
reset();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaImageFileCompare::~RiaImageFileCompare()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiaImageFileCompare::reset()
{
m_imagesEqual = false;
m_lastError = IC_NO_ERROR;
m_errorMsg = "";
m_errorDetails = "";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiaImageFileCompare::runComparison(QString imgFileName, QString refFileName, QString diffFileName)
{
reset();
if (m_compareExecutable.isEmpty())
{
m_lastError = SEVERE_ERROR;
m_errorMsg = "Cannot compare images, no compare executable set";
return false;
}
//QString args = QString("-fuzz 2% -lowlight-color white -metric ae \"%1\" \"%2\" \"%3\"").arg(imgFileName).arg(refFileName).arg((diffFileName));
// The ImageMagick compare tool on RedHat 5 does not support the lowlight-color options
// Use GCC version as a crude mechanism for disabling use of this option on RedHat5
#if (__GNUC__ == 4 && __GNUC_MINOR__ <= 1)
QString args = QString("-fuzz 0.4% -metric ae \"%1\" \"%2\" \"%3\"").arg(imgFileName).arg(refFileName).arg((diffFileName));
#else
QString args = QString("-fuzz 0.4% -lowlight-color white -metric ae \"%1\" \"%2\" \"%3\"").arg(imgFileName).arg(refFileName).arg((diffFileName));
#endif
QString completeCommand = QString("\"%1\" %2").arg(m_compareExecutable).arg(args);
// Launch process and wait
QProcess proc;
proc.start(completeCommand);
proc.waitForFinished(30000);
QProcess::ProcessError procError = proc.error();
if (procError != QProcess::UnknownError)
{
m_lastError = SEVERE_ERROR;
m_errorMsg = "Error running compare tool process";
m_errorDetails = completeCommand;
return false;
}
QByteArray stdErr = proc.readAllStandardError();
int procExitCode = proc.exitCode();
if (procExitCode == 0)
{
// Strip out whitespace and look for 0 (as in zero pixel differences)
stdErr = stdErr.simplified();
if (!stdErr.isEmpty() && stdErr[0] == '0')
{
m_imagesEqual = true;
}
return true;
}
else
{
// Report non-severe error
m_lastError = IC_ERROR;
m_errorMsg = "Error running compare tool process";
m_errorDetails = stdErr;
return false;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiaImageFileCompare::imagesEqual() const
{
return m_imagesEqual;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaImageFileCompare::ErrorType RiaImageFileCompare::error() const
{
return m_lastError;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaImageFileCompare::errorMessage() const
{
return m_errorMsg;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaImageFileCompare::errorDetails() const
{
return m_errorDetails;
}

0
ApplicationCode/Application/RiaImageFileCompare.h → ApplicationCode/Application/Tools/RiaImageFileCompare.h
View File

0
ApplicationCode/Application/RiaLogging.cpp → ApplicationCode/Application/Tools/RiaLogging.cpp
View File

0
ApplicationCode/Application/RiaLogging.h → ApplicationCode/Application/Tools/RiaLogging.h
View File

0
ApplicationCode/Application/RiaProjectModifier.cpp → ApplicationCode/Application/Tools/RiaProjectModifier.cpp
View File

0
ApplicationCode/Application/RiaProjectModifier.h → ApplicationCode/Application/Tools/RiaProjectModifier.h
View File

0
ApplicationCode/Application/RiaRegressionTest.cpp → ApplicationCode/Application/Tools/RiaRegressionTest.cpp
View File

0
ApplicationCode/Application/RiaRegressionTest.h → ApplicationCode/Application/Tools/RiaRegressionTest.h
View File

21
ApplicationCode/CMakeLists.txt
View File

@ -37,6 +37,7 @@ include_directories(
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/Adm
${CMAKE_CURRENT_SOURCE_DIR}/Application
${CMAKE_CURRENT_SOURCE_DIR}/Application/Tools
${CMAKE_CURRENT_SOURCE_DIR}/Commands
${CMAKE_CURRENT_SOURCE_DIR}/Commands/EclipseCommands
${CMAKE_CURRENT_SOURCE_DIR}/FileInterface
@ -69,20 +70,6 @@ include_directories(
# Use all h files in the subdirectories to make them available in the project
file( GLOB_RECURSE HEADER_FILES *.h )
set( APPLICATION_FILES
RiaMain.cpp
Application/RiaApplication.cpp
Application/RiaPreferences.cpp
Application/RiaImageFileCompare.cpp
Application/RiaImageCompareReporter.cpp
Application/RiaProjectModifier.cpp
Application/RiaRegressionTest.cpp
Application/RiaColorTables.cpp
Application/RiaLogging.h
Application/RiaLogging.cpp
)
set( SOCKET_INTERFACE_FILES
SocketInterface/RiaSocketServer.cpp
SocketInterface/RiaProjectInfoCommands.cpp
@ -95,12 +82,14 @@ set( SOCKET_INTERFACE_FILES
)
list( APPEND CPP_SOURCES
${APPLICATION_FILES}
${SOCKET_INTERFACE_FILES}
${UNIT_TEST_FILES}
)
list( APPEND REFERENCED_CMAKE_FILES
Application/CMakeLists_files.cmake
Application/Tools/CMakeLists_files.cmake
ReservoirDataModel/CMakeLists_files.cmake
ReservoirDataModel/CMakeLists_filesNotToUnitTest.cmake
FileInterface/CMakeLists_files.cmake
@ -185,7 +174,6 @@ add_subdirectory(GeoMech/GeoMechDataModel)
set ( QT_MOC_HEADERS
${QT_MOC_HEADERS}
Application/RiaApplication.h
ProjectDataModel/RimMimeData.h
ProjectDataModel/RimIntersectionBox.h
@ -221,7 +209,6 @@ endif()
################################################################################
# Create source groups - see also included CMakeLists_files.cmake
################################################################################
source_group( "Application" FILES ${APPLICATION_FILES} )
source_group( "ModelVisualization" FILES ${MODEL_VISUALIZATION_FILES} )
source_group( "SocketInterface" FILES ${SOCKET_INTERFACE_FILES} )
source_group( "UnitTests" FILES ${UNIT_TEST_FILES} )

32
ApplicationCode/Commands/CompletionCommands/RicExportFishbonesWellSegmentsFeature.cpp
View File

@ -244,6 +244,8 @@ void RicExportFishbonesWellSegmentsFeature::generateWelsegsTable(RifEclipseDataT
depth += location.trueVerticalDepth - previousTVD;
length += location.fishbonesSubs->measuredDepth(location.subIndex) - previousMD;
}
double diameter = computeEffectiveDiameter(wellPath->fishbonesCollection()->linerDiameter(), wellPath->fishbonesCollection()->mainBoreDiameter());
formatter.comment(QString("Segment for sub %1").arg(location.subIndex));
formatter.add(location.segmentNumber).add(location.segmentNumber);
@ -251,8 +253,8 @@ void RicExportFishbonesWellSegmentsFeature::generateWelsegsTable(RifEclipseDataT
formatter.add(location.segmentNumber - 1); // All main stem segments are connected to the segment below them
formatter.add(length);
formatter.add(depth);
formatter.add(-1.0); // FIXME : Diam of main stem?
formatter.add(-1.0); // FIXME : Rough of main stem?
formatter.add(diameter);
formatter.add(wellPath->fishbonesCollection()->roughnessFactor());
formatter.rowCompleted();
previousMD = location.measuredDepth;
@ -266,14 +268,15 @@ void RicExportFishbonesWellSegmentsFeature::generateWelsegsTable(RifEclipseDataT
formatter.comment("Rough: MSW - Open Hole Roughness Factor");
for (const WellSegmentLocation& location : locations)
{
double diameter = computeEffectiveDiameter(wellPath->fishbonesCollection()->linerDiameter(), wellPath->fishbonesCollection()->mainBoreDiameter());
formatter.comment("ICD");
formatter.add(location.icdSegmentNumber).add(location.icdSegmentNumber);
formatter.add(location.icdBranchNumber);
formatter.add(location.segmentNumber);
formatter.add(0.1); // ICDs have 0.1 length
formatter.add(0); // Depth change
formatter.add(-1.0); // Diam?
formatter.add(-1.0); // Rough?
formatter.add(diameter);
formatter.add(wellPath->fishbonesCollection()->roughnessFactor());
formatter.rowCompleted();
for (const WellSegmentLateral& lateral : location.laterals)
@ -295,13 +298,14 @@ void RicExportFishbonesWellSegmentsFeature::generateWelsegsTable(RifEclipseDataT
depth += intersection.depth;
length += intersection.length;
}
double diameter = computeEffectiveDiameter(location.fishbonesSubs->tubingDiameter(), location.fishbonesSubs->holeDiameter());
formatter.add(intersection.segmentNumber);
formatter.add(intersection.segmentNumber);
formatter.add(lateral.branchNumber);
formatter.add(intersection.attachedSegmentNumber);
formatter.add(length);
formatter.add(depth);
formatter.add(location.fishbonesSubs->tubingDiameter());
formatter.add(diameter);
formatter.add(location.fishbonesSubs->openHoleRoughnessFactor());
formatter.rowCompleted();
}
@ -401,3 +405,21 @@ void RicExportFishbonesWellSegmentsFeature::generateWsegvalvTable(RifEclipseData
}
formatter.tableCompleted();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RicExportFishbonesWellSegmentsFeature::computeEffectiveDiameter(double innerDiameter, double outerDiameter)
{
double innerRadius = innerDiameter / 2;
double innerArea = cvf::PI_D * innerRadius * innerRadius;
double outerRadius = outerDiameter / 2;
double outerArea = cvf::PI_D * outerRadius * outerRadius;
double effectiveArea = outerArea - innerArea;
double effectiveRadius = cvf::Math::sqrt(effectiveArea / cvf::PI_D);
return effectiveRadius * 2;
}

2
ApplicationCode/Commands/CompletionCommands/RicExportFishbonesWellSegmentsFeature.h
View File

@ -50,4 +50,6 @@ private:
static void generateWelsegsTable(RifEclipseDataTableFormatter& formatter, const RimWellPath* wellPath, const RicExportWellSegmentsSettingsUi& settings, const std::vector<WellSegmentLocation>& locations);
static void generateCompsegsTable(RifEclipseDataTableFormatter& formatter, const RimWellPath* wellPath, const RicExportWellSegmentsSettingsUi& settings, const std::vector<WellSegmentLocation>& locations);
static void generateWsegvalvTable(RifEclipseDataTableFormatter& formatter, const RimWellPath* wellPath, const RicExportWellSegmentsSettingsUi& settings, const std::vector<WellSegmentLocation>& locations);
static double computeEffectiveDiameter(double innerDiameter, double outerDiameter);
};

32
ApplicationCode/Commands/CompletionCommands/RicWellPathExportCompletionDataFeature.cpp
View File

@ -220,12 +220,12 @@ void RicWellPathExportCompletionDataFeature::exportCompletions(const std::vector
bool unitSystemMismatch = false;
for (const RimWellPath* wellPath : wellPaths)
{
if (wellPath->unitSystem() == RimUnitSystem::UNITS_FIELD && exportSettings.caseToApply->eclipseCaseData()->unitsType() != RigEclipseCaseData::UNITS_FIELD)
if (wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD && exportSettings.caseToApply->eclipseCaseData()->unitsType() != RigEclipseCaseData::UNITS_FIELD)
{
unitSystemMismatch = true;
break;
}
else if (wellPath->unitSystem() == RimUnitSystem::UNITS_METRIC && exportSettings.caseToApply->eclipseCaseData()->unitsType() != RigEclipseCaseData::UNITS_METRIC)
else if (wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC && exportSettings.caseToApply->eclipseCaseData()->unitsType() != RigEclipseCaseData::UNITS_METRIC)
{
unitSystemMismatch = true;
break;
@ -264,9 +264,9 @@ void RicWellPathExportCompletionDataFeature::exportCompletions(const std::vector
}
if (exportSettings.includeFishbones)
{
std::vector<RigCompletionData> fishbonesCompletionData = generateFishbonesCompdatValues(wellPath, exportSettings);
std::vector<RigCompletionData> fishbonesCompletionData = generateFishboneLateralsCompdatValues(wellPath, exportSettings);
appendCompletionData(&completionData, fishbonesCompletionData);
std::vector<RigCompletionData> fishbonesWellPathCompletionData = generateFishbonesWellPathCompdatValues(wellPath, exportSettings);
std::vector<RigCompletionData> fishbonesWellPathCompletionData = generateFishbonesImportedLateralsCompdatValues(wellPath, exportSettings);
appendCompletionData(&completionData, fishbonesWellPathCompletionData);
}
@ -412,7 +412,7 @@ void RicWellPathExportCompletionDataFeature::generateWpimultTable(RifEclipseData
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RigCompletionData> RicWellPathExportCompletionDataFeature::generateFishbonesCompdatValues(const RimWellPath* wellPath, const RicExportCompletionDataSettingsUi& settings)
std::vector<RigCompletionData> RicWellPathExportCompletionDataFeature::generateFishboneLateralsCompdatValues(const RimWellPath* wellPath, const RicExportCompletionDataSettingsUi& settings)
{
// Generate data
const RigEclipseCaseData* caseData = settings.caseToApply()->eclipseCaseData();
@ -467,7 +467,7 @@ std::vector<RigCompletionData> RicWellPathExportCompletionDataFeature::generateF
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RigCompletionData> RicWellPathExportCompletionDataFeature::generateFishbonesWellPathCompdatValues(const RimWellPath* wellPath, const RicExportCompletionDataSettingsUi& settings)
std::vector<RigCompletionData> RicWellPathExportCompletionDataFeature::generateFishbonesImportedLateralsCompdatValues(const RimWellPath* wellPath, const RicExportCompletionDataSettingsUi& settings)
{
std::vector<RigCompletionData> completionData;
@ -727,11 +727,11 @@ CellDirection RicWellPathExportCompletionDataFeature::calculateDirectionInCell(R
{
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DX");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DX");
cvf::ref<RigResultAccessor> dxAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RifReaderInterface::MATRIX_RESULTS, 0, "DX");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DY");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DY");
cvf::ref<RigResultAccessor> dyAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RifReaderInterface::MATRIX_RESULTS, 0, "DY");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DZ");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DZ");
cvf::ref<RigResultAccessor> dzAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RifReaderInterface::MATRIX_RESULTS, 0, "DZ");
double xLengthFraction = abs(lengthsInCell.x() / dxAccessObject->cellScalarGlobIdx(cellIndex));
@ -759,18 +759,18 @@ double RicWellPathExportCompletionDataFeature::calculateTransmissibility(RimEcli
{
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DX");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DX");
cvf::ref<RigResultAccessor> dxAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RifReaderInterface::MATRIX_RESULTS, 0, "DX");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DY");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DY");
cvf::ref<RigResultAccessor> dyAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RifReaderInterface::MATRIX_RESULTS, 0, "DY");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DZ");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DZ");
cvf::ref<RigResultAccessor> dzAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RifReaderInterface::MATRIX_RESULTS, 0, "DZ");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "PERMX");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMX");
cvf::ref<RigResultAccessor> permxAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RifReaderInterface::MATRIX_RESULTS, 0, "PERMX");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "PERMY");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMY");
cvf::ref<RigResultAccessor> permyAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RifReaderInterface::MATRIX_RESULTS, 0, "PERMY");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "PERMZ");
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMZ");
cvf::ref<RigResultAccessor> permzAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RifReaderInterface::MATRIX_RESULTS, 0, "PERMZ");
double dx = dxAccessObject->cellScalarGlobIdx(cellIndex);
@ -780,7 +780,7 @@ double RicWellPathExportCompletionDataFeature::calculateTransmissibility(RimEcli
double permy = permxAccessObject->cellScalarGlobIdx(cellIndex);
double permz = permxAccessObject->cellScalarGlobIdx(cellIndex);
double darcy = RimUnitSystem::darcysConstant(wellPath->unitSystem());
double darcy = RiaEclipseUnitTools::darcysConstant(wellPath->unitSystem());
double transx = RigTransmissibilityEquations::wellBoreTransmissibilityComponent(internalCellLengths.x(), permy, permz, dy, dz, wellRadius, skinFactor, darcy);
double transy = RigTransmissibilityEquations::wellBoreTransmissibilityComponent(internalCellLengths.y(), permx, permz, dx, dz, wellRadius, skinFactor, darcy);

5
ApplicationCode/Commands/CompletionCommands/RicWellPathExportCompletionDataFeature.h
View File

@ -139,8 +139,9 @@ private:
static void generateCompdatTable(RifEclipseDataTableFormatter& formatter, const std::vector<RigCompletionData>& completionData);
static void generateWpimultTable(RifEclipseDataTableFormatter& formatter, const std::vector<RigCompletionData>& completionData);
static std::vector<RigCompletionData> generateFishbonesCompdatValues(const RimWellPath* wellPath, const RicExportCompletionDataSettingsUi& settings);
static std::vector<RigCompletionData> generateFishbonesWellPathCompdatValues(const RimWellPath* wellPath, const RicExportCompletionDataSettingsUi& settings);
static std::vector<RigCompletionData> generateFishboneLateralsCompdatValues(const RimWellPath* wellPath, const RicExportCompletionDataSettingsUi& settings);
static std::vector<RigCompletionData> generateFishbonesImportedLateralsCompdatValues(const RimWellPath* wellPath, const RicExportCompletionDataSettingsUi& settings);
static std::vector<RigCompletionData> generatePerforationsCompdatValues(const RimWellPath* wellPath, const RicExportCompletionDataSettingsUi& settings);
static std::vector<size_t> findIntersectingCells(const RigEclipseCaseData* grid, const std::vector<cvf::Vec3d>& coords);

8
ApplicationCode/Commands/FlowCommands/RicPlotProductionRateFeature.cpp
View File

@ -113,7 +113,7 @@ void RicPlotProductionRateFeature::onActionTriggered(bool isChecked)
{
// Left Axis
RimDefines::PlotAxis plotAxis = RimDefines::PLOT_AXIS_LEFT;
RiaDefines::PlotAxis plotAxis = RiaDefines::PLOT_AXIS_LEFT;
{
// Note : The parameter "WOIR" is probably never-existing, but we check for existence before creating curve
@ -141,7 +141,7 @@ void RicPlotProductionRateFeature::onActionTriggered(bool isChecked)
{
// Left Axis
RimDefines::PlotAxis plotAxis = RimDefines::PLOT_AXIS_LEFT;
RiaDefines::PlotAxis plotAxis = RiaDefines::PLOT_AXIS_LEFT;
{
// Oil
@ -169,7 +169,7 @@ void RicPlotProductionRateFeature::onActionTriggered(bool isChecked)
// Right Axis
{
RimDefines::PlotAxis plotAxis = RimDefines::PLOT_AXIS_RIGHT;
RiaDefines::PlotAxis plotAxis = RiaDefines::PLOT_AXIS_RIGHT;
{
QString parameterName = "WTHP";
@ -271,7 +271,7 @@ bool RicPlotProductionRateFeature::isInjector(RimEclipseWell* well)
//--------------------------------------------------------------------------------------------------
RimSummaryCurve* RicPlotProductionRateFeature::addSummaryCurve( RimSummaryPlot* plot, const RimEclipseWell* well,
RimGridSummaryCase* gridSummaryCase, const QString& vectorName,
RimDefines::PlotAxis plotAxis, const cvf::Color3f& color)
RiaDefines::PlotAxis plotAxis, const cvf::Color3f& color)
{
CVF_ASSERT(plot);
CVF_ASSERT(gridSummaryCase);

4
ApplicationCode/Commands/FlowCommands/RicPlotProductionRateFeature.h
View File

@ -21,7 +21,7 @@
#include "cafCmdFeature.h"
#include "RimFlowDiagSolution.h"
#include "RimDefines.h"
#include "RiaDefines.h"
class RimGridSummaryCase;
class RimEclipseWell;
@ -46,7 +46,7 @@ private:
static bool isInjector(RimEclipseWell* well);
static RimSummaryCurve* addSummaryCurve(RimSummaryPlot* plot, const RimEclipseWell* well,
RimGridSummaryCase* gridSummaryCase, const QString& vectorName,
RimDefines::PlotAxis plotAxis, const cvf::Color3f& color);
RiaDefines::PlotAxis plotAxis, const cvf::Color3f& color);
};

2
ApplicationCode/Commands/FlowCommands/RicShowContributingWellsFeatureImpl.cpp
View File

@ -176,7 +176,7 @@ void RicShowContributingWellsFeatureImpl::modifyViewToShowContributingWells(RimE
}
viewToModify->setCurrentTimeStep(timeStep);
viewToModify->cellResult()->setResultType(RimDefines::FLOW_DIAGNOSTICS);
viewToModify->cellResult()->setResultType(RiaDefines::FLOW_DIAGNOSTICS);
viewToModify->cellResult()->setResultVariable("MaxFractionTracer");
viewToModify->cellResult()->setFlowSolution(flowDiagSolution);

5
ApplicationCode/Commands/RicConvertAllFractureTemplatesToFieldFeature.cpp
View File

@ -19,9 +19,8 @@
#include "RicConvertAllFractureTemplatesToFieldFeature.h"
#include "RiaApplication.h"
#include "RiaEclipseUnitTools.h"
#include "RimDefines.h"
#include "RimEclipseCase.h"
#include "RimEclipseView.h"
#include "RimEllipseFractureTemplate.h"
@ -65,7 +64,7 @@ void RicConvertAllFractureTemplatesToFieldFeature::onActionTriggered(bool isChec
for (auto ellipseFracTemplate : ellipseFracTemplates)
{
if (ellipseFracTemplate->fractureTemplateUnit == RimUnitSystem::UNITS_METRIC)
if (ellipseFracTemplate->fractureTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC)
{
ellipseFracTemplate->changeUnits();
}

4
ApplicationCode/Commands/RicConvertAllFractureTemplatesToMetricFeature.cpp
View File

@ -19,8 +19,8 @@
#include "RicConvertAllFractureTemplatesToMetricFeature.h"
#include "RiaApplication.h"
#include "RiaEclipseUnitTools.h"
#include "RimDefines.h"
#include "RimEclipseCase.h"
#include "RimEclipseView.h"
#include "RimEllipseFractureTemplate.h"
@ -64,7 +64,7 @@ void RicConvertAllFractureTemplatesToMetricFeature::onActionTriggered(bool isChe
for (auto ellipseFracTemplate : ellipseFracTemplates)
{
if (ellipseFracTemplate->fractureTemplateUnit == RimUnitSystem::UNITS_FIELD)
if (ellipseFracTemplate->fractureTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD)
{
ellipseFracTemplate->changeUnits();
}

6
ApplicationCode/Commands/RicConvertFractureTemplateUnitFeature.cpp
View File

@ -20,8 +20,8 @@
#include "RiaApplication.h"
#include "RiaEclipseUnitTools.h"
#include "RimDefines.h"
#include "RimEclipseCase.h"
#include "RimEclipseView.h"
#include "RimEllipseFractureTemplate.h"
@ -81,11 +81,11 @@ void RicConvertFractureTemplateUnitFeature::setupActionLook(QAction* actionToSet
objHandle->firstAncestorOrThisOfType(ellipseFractureTemplate);
QString text = "Convert Values to ";
if (ellipseFractureTemplate->fractureTemplateUnit == RimUnitSystem::UNITS_METRIC)
if (ellipseFractureTemplate->fractureTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC)
{
text += "Field";
}
else if (ellipseFractureTemplate->fractureTemplateUnit == RimUnitSystem::UNITS_FIELD)
else if (ellipseFractureTemplate->fractureTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD)
{
text += "Metric";
}

6
ApplicationCode/Commands/RicExportFaultsFeature.cpp
View File

@ -25,7 +25,7 @@
#include "RigFault.h"
#include "RigMainGrid.h"
#include "RimDefines.h"
#include "RiaDefines.h"
#include "RimEclipseCase.h"
#include "RimFault.h"
@ -87,8 +87,8 @@ void RicExportFaultsFeature::onActionTriggered(bool isChecked)
if (eclCase) caseName = eclCase->caseUserDescription();
QString faultName = rimFault->name();
if ( faultName == RimDefines::undefinedGridFaultName() ) faultName = "UNDEF";
if ( faultName == RimDefines::undefinedGridFaultWithInactiveName() ) faultName = "UNDEF_IA";
if ( faultName == RiaDefines::undefinedGridFaultName() ) faultName = "UNDEF";
if ( faultName == RiaDefines::undefinedGridFaultWithInactiveName() ) faultName = "UNDEF_IA";
QString baseFilename = "Fault_" + faultName + "_" + caseName;
baseFilename = caf::Utils::makeValidFileBasename(baseFilename);

4
ApplicationCode/Commands/RicNewSimWellFractureAtPosFeature.cpp
View File

@ -91,8 +91,8 @@ void RicNewSimWellFractureAtPosFeature::onActionTriggered(bool isChecked)
RimEclipseResultCase* eclipseCase = nullptr;
objHandle->firstAncestorOrThisOfType(eclipseCase);
RigEclipseCaseData::UnitsType caseUnit = eclipseCase->eclipseCaseData()->unitsType();
if (caseUnit == RigEclipseCaseData::UNITS_METRIC) fracture->fractureUnit = RimUnitSystem::UNITS_METRIC;
else if (caseUnit == RigEclipseCaseData::UNITS_FIELD) fracture->fractureUnit = RimUnitSystem::UNITS_FIELD;
if (caseUnit == RigEclipseCaseData::UNITS_METRIC) fracture->fractureUnit = RiaEclipseUnitTools::UNITS_METRIC;
else if (caseUnit == RigEclipseCaseData::UNITS_FIELD) fracture->fractureUnit = RiaEclipseUnitTools::UNITS_FIELD;
if (oilfield->fractureDefinitionCollection->fractureDefinitions.size() > 0)
{

4
ApplicationCode/Commands/RicNewSimWellFractureFeature.cpp
View File

@ -72,8 +72,8 @@ void RicNewSimWellFractureFeature::onActionTriggered(bool isChecked)
RimEclipseResultCase* eclipseCase = nullptr;
objHandle->firstAncestorOrThisOfType(eclipseCase);
RigEclipseCaseData::UnitsType caseUnit = eclipseCase->eclipseCaseData()->unitsType();
if (caseUnit == RigEclipseCaseData::UNITS_METRIC) fracture->fractureUnit = RimUnitSystem::UNITS_METRIC;
else if (caseUnit == RigEclipseCaseData::UNITS_FIELD) fracture->fractureUnit = RimUnitSystem::UNITS_FIELD;
if (caseUnit == RigEclipseCaseData::UNITS_METRIC) fracture->fractureUnit = RiaEclipseUnitTools::UNITS_METRIC;
else if (caseUnit == RigEclipseCaseData::UNITS_FIELD) fracture->fractureUnit = RiaEclipseUnitTools::UNITS_FIELD;
if (oilfield->fractureDefinitionCollection->fractureDefinitions.size() > 0)
{

2
ApplicationCode/Commands/SummaryPlotCommands/RicNewGridTimeHistoryCurveFeature.cpp
View File

@ -219,7 +219,7 @@ bool RicNewGridTimeHistoryCurveFeature::isCommandEnabled()
const RiuEclipseSelectionItem* eclSelectionItem = dynamic_cast<const RiuEclipseSelectionItem*>(items[0]);
if (eclSelectionItem)
{
if (eclSelectionItem->m_view->cellResult()->resultType() == RimDefines::FLOW_DIAGNOSTICS)
if (eclSelectionItem->m_view->cellResult()->resultType() == RiaDefines::FLOW_DIAGNOSTICS)
{
return false;
}

24
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryCurveSwitchAxisFeature.cpp
View File

@ -62,15 +62,15 @@ void RicSummaryCurveSwitchAxisFeature::onActionTriggered(bool isChecked)
for (RimSummaryCurveFilter* summaryCurveFilter: selectedCurveFilters)
{
RimDefines::PlotAxis plotAxis = summaryCurveFilter->associatedPlotAxis();
RiaDefines::PlotAxis plotAxis = summaryCurveFilter->associatedPlotAxis();
if ( plotAxis == RimDefines::PLOT_AXIS_LEFT )
if ( plotAxis == RiaDefines::PLOT_AXIS_LEFT )
{
summaryCurveFilter->setPlotAxis(RimDefines::PLOT_AXIS_RIGHT);
summaryCurveFilter->setPlotAxis(RiaDefines::PLOT_AXIS_RIGHT);
}
else
{
summaryCurveFilter->setPlotAxis(RimDefines::PLOT_AXIS_LEFT);
summaryCurveFilter->setPlotAxis(RiaDefines::PLOT_AXIS_LEFT);
}
summaryCurveFilter->updateConnectedEditors();
@ -78,15 +78,15 @@ void RicSummaryCurveSwitchAxisFeature::onActionTriggered(bool isChecked)
for (RimSummaryCurve* summaryCurve : selectedSoloCurves)
{
RimDefines::PlotAxis plotAxis = summaryCurve->yAxis();
RiaDefines::PlotAxis plotAxis = summaryCurve->yAxis();
if ( plotAxis == RimDefines::PLOT_AXIS_LEFT )
if ( plotAxis == RiaDefines::PLOT_AXIS_LEFT )
{
summaryCurve->setYAxis(RimDefines::PLOT_AXIS_RIGHT);
summaryCurve->setYAxis(RiaDefines::PLOT_AXIS_RIGHT);
}
else
{
summaryCurve->setYAxis(RimDefines::PLOT_AXIS_LEFT);
summaryCurve->setYAxis(RiaDefines::PLOT_AXIS_LEFT);
}
summaryCurve->updateQwtPlotAxis();
@ -99,15 +99,15 @@ void RicSummaryCurveSwitchAxisFeature::onActionTriggered(bool isChecked)
for (RimGridTimeHistoryCurve* timeHistoryCurve : gridTimeHistoryCurves)
{
RimDefines::PlotAxis plotAxis = timeHistoryCurve->yAxis();
RiaDefines::PlotAxis plotAxis = timeHistoryCurve->yAxis();
if (plotAxis == RimDefines::PLOT_AXIS_LEFT)
if (plotAxis == RiaDefines::PLOT_AXIS_LEFT)
{
timeHistoryCurve->setYAxis(RimDefines::PLOT_AXIS_RIGHT);
timeHistoryCurve->setYAxis(RiaDefines::PLOT_AXIS_RIGHT);
}
else
{
timeHistoryCurve->setYAxis(RimDefines::PLOT_AXIS_LEFT);
timeHistoryCurve->setYAxis(RiaDefines::PLOT_AXIS_LEFT);
}
timeHistoryCurve->updateConnectedEditors();

2
ApplicationCode/Commands/WellPathCommands/RicWellPathsUnitSystemSettingsImpl.cpp
View File

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

2
ApplicationCode/Commands/WellPathCommands/RicWellPathsUnitSystemSettingsImpl.h
View File

@ -18,7 +18,7 @@
#pragma once
#include "RimUnitSystem.h"
#include "RiaEclipseUnitTools.h"
#include "RimWellPath.h"
//==================================================================================================

4
ApplicationCode/Commands/WellPathCommands/RicWellPathsUnitSystemSettingsUi.cpp
View File

@ -38,8 +38,8 @@ QList<caf::PdmOptionItemInfo> RicWellPathsUnitSystemSettingsUi::calculateValueOp
QList<caf::PdmOptionItemInfo> options;
if (fieldNeedingOptions == &unitSystem)
{
options.push_back(caf::PdmOptionItemInfo(RimUnitSystem::UnitSystemType::uiText(RimUnitSystem::UNITS_METRIC), RimUnitSystem::UNITS_METRIC));
options.push_back(caf::PdmOptionItemInfo(RimUnitSystem::UnitSystemType::uiText(RimUnitSystem::UNITS_FIELD), RimUnitSystem::UNITS_FIELD));
options.push_back(caf::PdmOptionItemInfo(RiaEclipseUnitTools::UnitSystemType::uiText(RiaEclipseUnitTools::UNITS_METRIC), RiaEclipseUnitTools::UNITS_METRIC));
options.push_back(caf::PdmOptionItemInfo(RiaEclipseUnitTools::UnitSystemType::uiText(RiaEclipseUnitTools::UNITS_FIELD), RiaEclipseUnitTools::UNITS_FIELD));
}
return options;
}

4
ApplicationCode/Commands/WellPathCommands/RicWellPathsUnitSystemSettingsUi.h
View File

@ -18,7 +18,7 @@
#pragma once
#include "RimUnitSystem.h"
#include "RiaEclipseUnitTools.h"
#include "cafPdmObject.h"
#include "cafPdmField.h"
@ -34,7 +34,7 @@ public:
RicWellPathsUnitSystemSettingsUi();
caf::PdmField<RimUnitSystem::UnitSystemType> unitSystem;
caf::PdmField<RiaEclipseUnitTools::UnitSystemType> unitSystem;
protected:
virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly) override;

2
ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp
View File

@ -720,7 +720,7 @@ size_t RifEclipseInputFileTools::findOrCreateResult(const QString& newResultName
size_t resultIndex = reservoir->results(RifReaderInterface::MATRIX_RESULTS)->findScalarResultIndex(newResultName);
if (resultIndex == cvf::UNDEFINED_SIZE_T)
{
resultIndex = reservoir->results(RifReaderInterface::MATRIX_RESULTS)->addEmptyScalarResult(RimDefines::INPUT_PROPERTY, newResultName, false);
resultIndex = reservoir->results(RifReaderInterface::MATRIX_RESULTS)->addEmptyScalarResult(RiaDefines::INPUT_PROPERTY, newResultName, false);
}
return resultIndex;

8
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -672,7 +672,7 @@ void RifReaderEclipseOutput::buildMetaData()
for (int i = 0; i < matrixResultNames.size(); ++i)
{
size_t resIndex = matrixModelResults->addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, matrixResultNames[i], false);
size_t resIndex = matrixModelResults->addEmptyScalarResult(RiaDefines::DYNAMIC_NATIVE, matrixResultNames[i], false);
matrixModelResults->setTimeStepDates(resIndex, m_timeSteps, m_daysSinceSimulationStart, reportNumbers);
}
}
@ -685,7 +685,7 @@ void RifReaderEclipseOutput::buildMetaData()
for (int i = 0; i < fractureResultNames.size(); ++i)
{
size_t resIndex = fractureModelResults->addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, fractureResultNames[i], false);
size_t resIndex = fractureModelResults->addEmptyScalarResult(RiaDefines::DYNAMIC_NATIVE, fractureResultNames[i], false);
fractureModelResults->setTimeStepDates(resIndex, m_timeSteps, m_daysSinceSimulationStart, reportNumbers);
}
}
@ -758,7 +758,7 @@ void RifReaderEclipseOutput::buildMetaData()
for (int i = 0; i < matrixResultNames.size(); ++i)
{
size_t resIndex = matrixModelResults->addEmptyScalarResult(RimDefines::STATIC_NATIVE, matrixResultNames[i], false);
size_t resIndex = matrixModelResults->addEmptyScalarResult(RiaDefines::STATIC_NATIVE, matrixResultNames[i], false);
matrixModelResults->setTimeStepDates(resIndex, staticDate, staticDay, staticReportNumber);
}
}
@ -773,7 +773,7 @@ void RifReaderEclipseOutput::buildMetaData()
for (int i = 0; i < fractureResultNames.size(); ++i)
{
size_t resIndex = fractureModelResults->addEmptyScalarResult(RimDefines::STATIC_NATIVE, fractureResultNames[i], false);
size_t resIndex = fractureModelResults->addEmptyScalarResult(RiaDefines::STATIC_NATIVE, fractureResultNames[i], false);
fractureModelResults->setTimeStepDates(resIndex, staticDate, staticDay, staticReportNumber);
}
}

6
ApplicationCode/FileInterface/RifReaderMockModel.cpp
View File

@ -50,7 +50,7 @@ bool RifReaderMockModel::open(const QString& fileName, RigEclipseCaseData* eclip
for (size_t i = 0; i < m_reservoirBuilder.resultCount(); i++)
{
size_t resIdx = cellResults->addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, QString("Dynamic_Result_%1").arg(i), false);
size_t resIdx = cellResults->addEmptyScalarResult(RiaDefines::DYNAMIC_NATIVE, QString("Dynamic_Result_%1").arg(i), false);
cellResults->setTimeStepDates(resIdx, dates, days, repNumbers);
}
@ -71,7 +71,7 @@ bool RifReaderMockModel::open(const QString& fileName, RigEclipseCaseData* eclip
int resIndex = 0;
if (i > 1) resIndex = i;
size_t resIdx = cellResults->addEmptyScalarResult(RimDefines::STATIC_NATIVE, QString("Static_Result_%1%2").arg(resIndex).arg(varEnd), false);
size_t resIdx = cellResults->addEmptyScalarResult(RiaDefines::STATIC_NATIVE, QString("Static_Result_%1%2").arg(resIndex).arg(varEnd), false);
cellResults->setTimeStepDates(resIdx, staticDates, staticDays, staticRepNumbers);
}
@ -80,7 +80,7 @@ bool RifReaderMockModel::open(const QString& fileName, RigEclipseCaseData* eclip
{ \
size_t resIdx; \
QString resultName(Name); \
resIdx = cellResults->addEmptyScalarResult(RimDefines::INPUT_PROPERTY, resultName, false); \
resIdx = cellResults->addEmptyScalarResult(RiaDefines::INPUT_PROPERTY, resultName, false); \
cellResults->setTimeStepDates(resIdx, staticDates, staticDays, staticRepNumbers); \
cellResults->cellScalarResults(resIdx).resize(1); \
std::vector<double>& values = cellResults->cellScalarResults(resIdx)[0]; \

4
ApplicationCode/FileInterface/RifStimPlanXmlReader.cpp
View File

@ -96,12 +96,12 @@ cvf::ref<RigStimPlanFractureDefinition> RifStimPlanXmlReader::readStimPlanXMLFil
{
if (unit == "md-ft")
{
stimPlanFileData->unitSet = RimUnitSystem::UNITS_FIELD;
stimPlanFileData->unitSet = RiaEclipseUnitTools::UNITS_FIELD;
RiaLogging::info(QString("Setting unit system to Field for StimPlan fracture template %1").arg(stimPlanFileName));
}
if (unit == "md-m")
{
stimPlanFileData->unitSet = RimUnitSystem::UNITS_METRIC;
stimPlanFileData->unitSet = RiaEclipseUnitTools::UNITS_METRIC;
RiaLogging::info(QString("Setting unit system to Metric for StimPlan fracture template %1").arg(stimPlanFileName));
}
}

2
ApplicationCode/ModelVisualization/Intersections/RivIntersectionBoxPartMgr.cpp
View File

@ -121,7 +121,7 @@ void RivIntersectionBoxPartMgr::updateCellResultColor(size_t timeStepIndex)
const cvf::ScalarMapper* mapper = cellResultColors->legendConfig()->scalarMapper();
cvf::ref<RigResultAccessor> resultAccessor;
if (RimDefines::isPerCellFaceResult(cellResultColors->resultVariable()))
if (RiaDefines::isPerCellFaceResult(cellResultColors->resultVariable()))
{
resultAccessor = new RigHugeValResultAccessor;
}

2
ApplicationCode/ModelVisualization/Intersections/RivIntersectionPartMgr.cpp
View File

@ -129,7 +129,7 @@ void RivIntersectionPartMgr::updateCellResultColor(size_t timeStepIndex)
const cvf::ScalarMapper* mapper = cellResultColors->legendConfig()->scalarMapper();
cvf::ref<RigResultAccessor> resultAccessor;
if (RimDefines::isPerCellFaceResult(cellResultColors->resultVariable()))
if (RiaDefines::isPerCellFaceResult(cellResultColors->resultVariable()))
{
resultAccessor = new RigHugeValResultAccessor;
}

4
ApplicationCode/ProjectDataModel/CMakeLists_files.cmake
View File

@ -13,8 +13,6 @@ ${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}RimUnitSystem.h
${CEE_CURRENT_LIST_DIR}RimLegendConfig.h
${CEE_CURRENT_LIST_DIR}RimOilField.h
${CEE_CURRENT_LIST_DIR}RimProject.h
@ -104,8 +102,6 @@ ${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}RimUnitSystem.cpp
${CEE_CURRENT_LIST_DIR}RimLegendConfig.cpp
${CEE_CURRENT_LIST_DIR}RimOilField.cpp
${CEE_CURRENT_LIST_DIR}RimProject.cpp

8
ApplicationCode/ProjectDataModel/Completions/RimCompletionCellIntersectionCalc.cpp
View File

@ -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;
}
}

56
ApplicationCode/ProjectDataModel/Completions/RimEllipseFractureTemplate.cpp
View File

@ -18,6 +18,7 @@
#include "RimEllipseFractureTemplate.h"
#include "RiaEclipseUnitTools.h"
#include "RiaLogging.h"
#include "RigCellGeometryTools.h"
@ -25,7 +26,6 @@
#include "RigFractureGrid.h"
#include "RigTesselatorTools.h"
#include "RimUnitSystem.h"
#include "RimFracture.h"
#include "RimFractureContainment.h"
#include "RimFractureTemplate.h"
@ -107,7 +107,7 @@ void RimEllipseFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* cha
//--------------------------------------------------------------------------------------------------
void RimEllipseFractureTemplate::fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::uint>* triangleIndices,
RimUnitSystem::UnitSystem neededUnit)
RiaEclipseUnitTools::UnitSystem neededUnit)
{
RigEllipsisTesselator tesselator(20);
@ -120,17 +120,17 @@ void RimEllipseFractureTemplate::fractureTriangleGeometry(std::vector<cvf::Vec3f
b = height / 2.0f;
}
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_METRIC && neededUnit == RimUnitSystem::UNITS_FIELD)
else if (fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_METRIC && neededUnit == RiaEclipseUnitTools::UNITS_FIELD)
{
RiaLogging::info(QString("Converting fracture template geometry from metric to field"));
a = RimUnitSystem::meterToFeet(halfLength);
b = RimUnitSystem::meterToFeet(height / 2.0f);
a = RiaEclipseUnitTools::meterToFeet(halfLength);
b = RiaEclipseUnitTools::meterToFeet(height / 2.0f);
}
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_FIELD && neededUnit == RimUnitSystem::UNITS_METRIC)
else if (fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_FIELD && neededUnit == RiaEclipseUnitTools::UNITS_METRIC)
{
RiaLogging::info(QString("Converting fracture template geometry from field to metric"));
a = RimUnitSystem::feetToMeter(halfLength);
b = RimUnitSystem::feetToMeter(height / 2.0f);
a = RiaEclipseUnitTools::feetToMeter(halfLength);
b = RiaEclipseUnitTools::feetToMeter(height / 2.0f);
}
else
{
@ -146,7 +146,7 @@ void RimEllipseFractureTemplate::fractureTriangleGeometry(std::vector<cvf::Vec3f
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<cvf::Vec3f> RimEllipseFractureTemplate::fractureBorderPolygon(RimUnitSystem::UnitSystem neededUnit)
std::vector<cvf::Vec3f> RimEllipseFractureTemplate::fractureBorderPolygon(RiaEclipseUnitTools::UnitSystem neededUnit)
{
std::vector<cvf::Vec3f> polygon;
@ -168,23 +168,23 @@ std::vector<cvf::Vec3f> RimEllipseFractureTemplate::fractureBorderPolygon(RimUni
//--------------------------------------------------------------------------------------------------
void RimEllipseFractureTemplate::changeUnits()
{
if (fractureTemplateUnit == RimUnitSystem::UNITS_METRIC)
if (fractureTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC)
{
halfLength = RimUnitSystem::meterToFeet(halfLength);
height = RimUnitSystem::meterToFeet(height);
width = RimUnitSystem::meterToInch(width);
wellDiameter = RimUnitSystem::meterToInch(wellDiameter);
perforationLength = RimUnitSystem::meterToFeet(perforationLength);
fractureTemplateUnit = RimUnitSystem::UNITS_FIELD;
halfLength = RiaEclipseUnitTools::meterToFeet(halfLength);
height = RiaEclipseUnitTools::meterToFeet(height);
width = RiaEclipseUnitTools::meterToInch(width);
wellDiameter = RiaEclipseUnitTools::meterToInch(wellDiameter);
perforationLength = RiaEclipseUnitTools::meterToFeet(perforationLength);
fractureTemplateUnit = RiaEclipseUnitTools::UNITS_FIELD;
}
else if (fractureTemplateUnit == RimUnitSystem::UNITS_FIELD)
else if (fractureTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD)
{
halfLength = RimUnitSystem::feetToMeter(halfLength);
height = RimUnitSystem::feetToMeter(height);
width = RimUnitSystem::inchToMeter(width);
wellDiameter = RimUnitSystem::inchToMeter(wellDiameter);
perforationLength = RimUnitSystem::feetToMeter(perforationLength);
fractureTemplateUnit = RimUnitSystem::UNITS_METRIC;
halfLength = RiaEclipseUnitTools::feetToMeter(halfLength);
height = RiaEclipseUnitTools::feetToMeter(height);
width = RiaEclipseUnitTools::inchToMeter(width);
wellDiameter = RiaEclipseUnitTools::inchToMeter(wellDiameter);
perforationLength = RiaEclipseUnitTools::feetToMeter(perforationLength);
fractureTemplateUnit = RiaEclipseUnitTools::UNITS_METRIC;
}
this->updateConnectedEditors();
@ -227,15 +227,15 @@ void RimEllipseFractureTemplate::setupFractureGridCells()
cellPolygon.push_back(cvf::Vec3d(X1, Y2, 0.0));
double cond = cvf::UNDEFINED_DOUBLE;
if (fractureTemplateUnit == RimUnitSystem::UNITS_METRIC)
if (fractureTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC)
{
//Conductivity should be md-m, width is in m
cond = permeability * width;
}
else if(fractureTemplateUnit == RimUnitSystem::UNITS_FIELD)
else if(fractureTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD)
{
//Conductivity should be md-ft, but width is in inches
cond = permeability * RimUnitSystem::inchToFeet(width);
cond = permeability * RiaEclipseUnitTools::inchToFeet(width);
}
std::vector<cvf::Vec3f> ellipseFracPolygon = fractureBorderPolygon(fractureTemplateUnit());
@ -297,14 +297,14 @@ void RimEllipseFractureTemplate::defineUiOrdering(QString uiConfigName, caf::Pdm
{
RimFractureTemplate::defineUiOrdering(uiConfigName, uiOrdering);
if (fractureTemplateUnit == RimUnitSystem::UNITS_METRIC)
if (fractureTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC)
{
halfLength.uiCapability()->setUiName("Halflenght X<sub>f</sub> [m]");
height.uiCapability()->setUiName("Height [m]");
width.uiCapability()->setUiName("Width [m]");
wellDiameter.uiCapability()->setUiName("Well Diameter [m]");
}
else if (fractureTemplateUnit == RimUnitSystem::UNITS_FIELD)
else if (fractureTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD)
{
halfLength.uiCapability()->setUiName("Halflenght X<sub>f</sub> [Ft]");
height.uiCapability()->setUiName("Height [Ft]");

4
ApplicationCode/ProjectDataModel/Completions/RimEllipseFractureTemplate.h
View File

@ -56,8 +56,8 @@ public:
void fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::uint>* polygonIndices,
RimUnitSystem::UnitSystem neededUnit);
std::vector<cvf::Vec3f> fractureBorderPolygon(RimUnitSystem::UnitSystem neededUnit);
RiaEclipseUnitTools::UnitSystem neededUnit);
std::vector<cvf::Vec3f> fractureBorderPolygon(RiaEclipseUnitTools::UnitSystem neededUnit);
void changeUnits();
const RigFractureGrid* fractureGrid() const;

5
ApplicationCode/ProjectDataModel/Completions/RimFishbonesCollection.cpp
View File

@ -52,8 +52,9 @@ RimFishbonesCollection::RimFishbonesCollection()
m_wellPathCollection.uiCapability()->setUiHidden(true);
CAF_PDM_InitField(&m_startMD, "StartMD", HUGE_VAL, "Start MD", "", "", "");
CAF_PDM_InitField(&m_mainBoreDiameter, "MainBoreDiameter", 0.0, "Main Bore Diameter", "", "", "");
CAF_PDM_InitField(&m_linerDiameter, "LinerDiameter", 0.0, "Liner Diameter", "", "", "");
CAF_PDM_InitField(&m_mainBoreDiameter, "MainBoreDiameter", 0.216, "Main Bore Diameter", "", "", "");
CAF_PDM_InitField(&m_linerDiameter, "LinerDiameter", 0.152, "Liner Inner Diameter", "", "", "");
CAF_PDM_InitField(&m_roughnessFactor, "RoughnessFactor", 1e-05, "Roughness Factor", "", "", "");
}
//--------------------------------------------------------------------------------------------------

4
ApplicationCode/ProjectDataModel/Completions/RimFishbonesCollection.h
View File

@ -48,6 +48,9 @@ public:
void recalculateStartMD();
double startMD() const { return m_startMD(); }
double mainBoreDiameter() const { return m_mainBoreDiameter(); }
double linerDiameter() const { return m_linerDiameter(); }
double roughnessFactor() const { return m_roughnessFactor(); }
protected:
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
@ -61,4 +64,5 @@ private:
caf::PdmField<double> m_startMD;
caf::PdmField<double> m_mainBoreDiameter;
caf::PdmField<double> m_linerDiameter;
caf::PdmField<double> m_roughnessFactor;
};

2
ApplicationCode/ProjectDataModel/Completions/RimFishbonesMultipleSubs.cpp
View File

@ -77,7 +77,7 @@ RimFishbonesMultipleSubs::RimFishbonesMultipleSubs()
CAF_PDM_InitField(&m_icdCount, "IcdCount", size_t(2), "ICDs per Sub", "", "", "");
CAF_PDM_InitField(&m_icdOrificeDiameter, "IcdOrificeDiameter", 7.0, "ICD Orifice Diameter [mm]", "", "", "");
CAF_PDM_InitField(&m_icdFlowCoefficient, "IcdFlowCoeficcient", -1.0, "ICD Flow Coefficient", "", "", "");
CAF_PDM_InitField(&m_icdFlowCoefficient, "IcdFlowCoefficient", 1.5, "ICD Flow Coefficient", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_locationOfSubs, "LocationOfSubs", "Measured Depths [m]", "", "", "");
m_locationOfSubs.uiCapability()->setUiEditorTypeName(caf::PdmUiListEditor::uiEditorTypeName());

26
ApplicationCode/ProjectDataModel/Completions/RimFracture.cpp
View File

@ -19,6 +19,7 @@
#include "RimFracture.h"
#include "RiaApplication.h"
#include "RiaEclipseUnitTools.h"
#include "RiaLogging.h"
#include "RifReaderInterface.h"
@ -33,7 +34,6 @@
#include "RigResultAccessorFactory.h"
#include "RigTesselatorTools.h"
#include "RimDefines.h"
#include "RimEclipseCase.h"
#include "RimEclipseCellColors.h"
#include "RimEclipseView.h"
@ -89,7 +89,7 @@ RimFracture::RimFracture(void)
CAF_PDM_InitField(&dip, "Dip", 0.0, "Dip", "", "", "");
CAF_PDM_InitField(&tilt, "Tilt", 0.0, "Tilt", "", "", "");
CAF_PDM_InitField(&showPolygonFractureOutline, "showPolygonFractureOutline", true, "Show Polygon Outline", "", "", "");
CAF_PDM_InitField(&fractureUnit, "fractureUnit", caf::AppEnum<RimUnitSystem::UnitSystem>(RimUnitSystem::UNITS_METRIC), "Fracture Unit System", "", "", "");
CAF_PDM_InitField(&fractureUnit, "fractureUnit", caf::AppEnum<RiaEclipseUnitTools::UnitSystem>(RiaEclipseUnitTools::UNITS_METRIC), "Fracture Unit System", "", "", "");
CAF_PDM_InitField(&stimPlanTimeIndexToPlot, "timeIndexToPlot", 0, "StimPlan Time Step", "", "", "");
@ -139,15 +139,15 @@ void RimFracture::fieldChangedByUi(const caf::PdmFieldHandle* changedField, cons
if (changedField == &fractureUnit)
{
if (fractureUnit == RimUnitSystem::UNITS_METRIC)
if (fractureUnit == RiaEclipseUnitTools::UNITS_METRIC)
{
wellDiameter = RimUnitSystem::inchToMeter(wellDiameter);
perforationLength = RimUnitSystem::feetToMeter(perforationLength);
wellDiameter = RiaEclipseUnitTools::inchToMeter(wellDiameter);
perforationLength = RiaEclipseUnitTools::feetToMeter(perforationLength);
}
else if (fractureUnit == RimUnitSystem::UNITS_FIELD)
else if (fractureUnit == RiaEclipseUnitTools::UNITS_FIELD)
{
wellDiameter = RimUnitSystem::meterToInch(wellDiameter);
perforationLength = RimUnitSystem::meterToFeet(perforationLength);
wellDiameter = RiaEclipseUnitTools::meterToInch(wellDiameter);
perforationLength = RiaEclipseUnitTools::meterToFeet(perforationLength);
}
this->updateConnectedEditors();
}
@ -230,13 +230,13 @@ cvf::BoundingBox RimFracture::boundingBoxInDomainCoords()
//--------------------------------------------------------------------------------------------------
double RimFracture::wellRadius() const
{
if (fractureUnit == RimUnitSystem::UNITS_METRIC)
if (fractureUnit == RiaEclipseUnitTools::UNITS_METRIC)
{
return wellDiameter / 2;
}
else if (fractureUnit == RimUnitSystem::UNITS_FIELD)
else if (fractureUnit == RiaEclipseUnitTools::UNITS_FIELD)
{
return RimUnitSystem::inchToFeet(wellDiameter / 2);
return RiaEclipseUnitTools::inchToFeet(wellDiameter / 2);
}
return cvf::UNDEFINED_DOUBLE;
}
@ -374,12 +374,12 @@ QList<caf::PdmOptionItemInfo> RimFracture::calculateValueOptions(const caf::PdmF
//--------------------------------------------------------------------------------------------------
void RimFracture::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
if (fractureUnit == RimUnitSystem::UNITS_METRIC)
if (fractureUnit == RiaEclipseUnitTools::UNITS_METRIC)
{
wellDiameter.uiCapability()->setUiName("Well Diameter [m]");
perforationLength.uiCapability()->setUiName("Perforation Length [m]");
}
else if (fractureUnit == RimUnitSystem::UNITS_FIELD)
else if (fractureUnit == RiaEclipseUnitTools::UNITS_FIELD)
{
wellDiameter.uiCapability()->setUiName("Well Diameter [inches]");
perforationLength.uiCapability()->setUiName("Perforation Length [Ft]");

5
ApplicationCode/ProjectDataModel/Completions/RimFracture.h
View File

@ -18,9 +18,10 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "Rim3dPropertiesInterface.h"
#include "RimCheckableNamedObject.h"
#include "RimUnitSystem.h"
#include "cvfBase.h"
#include "cvfObject.h"
@ -65,7 +66,7 @@ public:
caf::PdmField<int> stimPlanTimeIndexToPlot;
caf::PdmField<bool> showPolygonFractureOutline;
caf::PdmField< RimUnitSystem::UnitSystemType > fractureUnit;
caf::PdmField< RiaEclipseUnitTools::UnitSystemType > fractureUnit;
double wellRadius() const;
cvf::Vec3d anchorPosition() const ;

10
ApplicationCode/ProjectDataModel/Completions/RimFractureTemplate.cpp
View File

@ -66,7 +66,7 @@ RimFractureTemplate::RimFractureTemplate(void)
CAF_PDM_InitObject("Fracture Template", ":/FractureTemplate16x16.png", "", "");
CAF_PDM_InitField(&name, "UserDescription", QString("Fracture Template"), "Name", "", "", "");
CAF_PDM_InitField(&fractureTemplateUnit, "fractureTemplateUnit", caf::AppEnum<RimUnitSystem::UnitSystem>(RimUnitSystem::UNITS_METRIC), "Units System", "", "", "");
CAF_PDM_InitField(&fractureTemplateUnit, "fractureTemplateUnit", caf::AppEnum<RiaEclipseUnitTools::UnitSystem>(RiaEclipseUnitTools::UNITS_METRIC), "Units System", "", "", "");
fractureTemplateUnit.uiCapability()->setUiReadOnly(true);
CAF_PDM_InitField(&orientationType, "Orientation", caf::AppEnum<FracOrientationEnum>(TRANSVERSE_WELL_PATH), "Fracture Orientation", "", "", "");
@ -175,12 +175,12 @@ void RimFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* changedFie
void RimFractureTemplate::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
if (fractureTemplateUnit == RimUnitSystem::UNITS_METRIC)
if (fractureTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC)
{
wellDiameter.uiCapability()->setUiName("Well Diameter [m]");
perforationLength.uiCapability()->setUiName("Perforation Length [m]");
}
else if (fractureTemplateUnit == RimUnitSystem::UNITS_FIELD)
else if (fractureTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD)
{
wellDiameter.uiCapability()->setUiName("Well Diameter [inches]");
perforationLength.uiCapability()->setUiName("Perforation Length [Ft]");
@ -231,11 +231,11 @@ void RimFractureTemplate::defineEditorAttribute(const caf::PdmFieldHandle* field
//--------------------------------------------------------------------------------------------------
void RimFractureTemplate::setDefaultWellDiameterFromUnit()
{
if (fractureTemplateUnit == RimUnitSystem::UNITS_FIELD)
if (fractureTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD)
{
wellDiameter = 8.5;
}
else if (fractureTemplateUnit == RimUnitSystem::UNITS_METRIC)
else if (fractureTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC)
{
wellDiameter = 0.216;
}

8
ApplicationCode/ProjectDataModel/Completions/RimFractureTemplate.h
View File

@ -18,7 +18,7 @@
#pragma once
#include "RimUnitSystem.h"
#include "RiaEclipseUnitTools.h"
#include "cafAppEnum.h"
#include "cafPdmField.h"
@ -71,14 +71,14 @@ public:
};
caf::PdmField< caf::AppEnum< FracConductivityEnum > > conductivityType;
caf::PdmField< RimUnitSystem::UnitSystemType > fractureTemplateUnit;
caf::PdmField< RiaEclipseUnitTools::UnitSystemType > fractureTemplateUnit;
void setDefaultWellDiameterFromUnit();
virtual void fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::uint>* triangleIndices,
RimUnitSystem::UnitSystem neededUnit) = 0;
virtual std::vector<cvf::Vec3f> fractureBorderPolygon(RimUnitSystem::UnitSystem neededUnit) = 0;
RiaEclipseUnitTools::UnitSystem neededUnit) = 0;
virtual std::vector<cvf::Vec3f> fractureBorderPolygon(RiaEclipseUnitTools::UnitSystem neededUnit) = 0;
virtual const RigFractureGrid* fractureGrid() const = 0;

2
ApplicationCode/ProjectDataModel/Completions/RimFractureTemplateCollection.cpp
View File

@ -34,7 +34,7 @@ RimFractureTemplateCollection::RimFractureTemplateCollection(void)
{
CAF_PDM_InitObject("Fracture Templates", ":/FractureTemplates16x16.png", "", "");
CAF_PDM_InitField(&defaultUnitsForFracTemplates, "defaultUnitForFracTemplates", caf::AppEnum<RimUnitSystem::UnitSystem>(RimUnitSystem::UNITS_METRIC), "Default unit system for fracture templates", "", "", "");
CAF_PDM_InitField(&defaultUnitsForFracTemplates, "defaultUnitForFracTemplates", caf::AppEnum<RiaEclipseUnitTools::UnitSystem>(RiaEclipseUnitTools::UNITS_METRIC), "Default unit system for fracture templates", "", "", "");
CAF_PDM_InitFieldNoDefault(&fractureDefinitions, "FractureDefinitions", "", "", "", "");
fractureDefinitions.uiCapability()->setUiHidden(true);
}

6
ApplicationCode/ProjectDataModel/Completions/RimFractureTemplateCollection.h
View File

@ -18,7 +18,7 @@
#pragma once
#include "RimUnitSystem.h"
#include "RiaEclipseUnitTools.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
@ -38,8 +38,8 @@ public:
RimFractureTemplateCollection(void);
virtual ~RimFractureTemplateCollection(void);
caf::PdmChildArrayField<RimFractureTemplate*> fractureDefinitions;
caf::PdmField< RimUnitSystem::UnitSystemType > defaultUnitsForFracTemplates;
caf::PdmChildArrayField<RimFractureTemplate*> fractureDefinitions;
caf::PdmField< RiaEclipseUnitTools::UnitSystemType > defaultUnitsForFracTemplates;
std::vector<std::pair<QString, QString> > stimPlanResultNamesAndUnits() const;
std::vector<QString> stimPlanResultNames() const;

6
ApplicationCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.cpp
View File

@ -233,7 +233,7 @@ void RimStimPlanFractureTemplate::loadDataAndUpdate()
}
else
{
fractureTemplateUnit = RimUnitSystem::UNITS_UNKNOWN;
fractureTemplateUnit = RiaEclipseUnitTools::UNITS_UNKNOWN;
}
updateFractureGrid();
@ -390,7 +390,7 @@ void RimStimPlanFractureTemplate::updateFractureGrid()
//--------------------------------------------------------------------------------------------------
void RimStimPlanFractureTemplate::fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::uint>* triangleIndices,
RimUnitSystem::UnitSystem neededUnit)
RiaEclipseUnitTools::UnitSystem neededUnit)
{
if (m_stimPlanFractureDefinitionData.isNull())
@ -409,7 +409,7 @@ void RimStimPlanFractureTemplate::fractureTriangleGeometry(std::vector<cvf::Vec3
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<cvf::Vec3f> RimStimPlanFractureTemplate::fractureBorderPolygon(RimUnitSystem::UnitSystem neededUnit)
std::vector<cvf::Vec3f> RimStimPlanFractureTemplate::fractureBorderPolygon(RiaEclipseUnitTools::UnitSystem neededUnit)
{
QString parameterName = m_borderPolygonResultName;

4
ApplicationCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.h
View File

@ -68,8 +68,8 @@ public:
void updateFractureGrid();
void fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::uint>* triangleIndices,
RimUnitSystem::UnitSystem neededUnit) override;
std::vector<cvf::Vec3f> fractureBorderPolygon(RimUnitSystem::UnitSystem neededUnit);
RiaEclipseUnitTools::UnitSystem neededUnit) override;
std::vector<cvf::Vec3f> fractureBorderPolygon(RiaEclipseUnitTools::UnitSystem neededUnit);
// Result Access

2
ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp
View File

@ -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"));

4
ApplicationCode/ProjectDataModel/Flow/RimWellFlowRateCurve.cpp
View File

@ -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;
}

8
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

@ -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();

20
ApplicationCode/ProjectDataModel/RimCellEdgeColors.cpp
View File

@ -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,10 +186,10 @@ 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);
//varList += m_reservoirView->gridCellResults()->resultNames(RiaEclipseUnitTools::INPUT_PROPERTY);
QList<caf::PdmOptionItemInfo> options;
@ -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();

2
ApplicationCode/ProjectDataModel/RimCellEdgeColors.h
View File

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

112
ApplicationCode/ProjectDataModel/RimDefines.cpp
View File

@ -1,112 +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;
}

14
ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
View File

@ -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()->setCombTransmissibilityScalarResultIndex(combinedTransResIdx);

4
ApplicationCode/ProjectDataModel/RimEclipseCase.h
View File

@ -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(); }

18
ApplicationCode/ProjectDataModel/RimEclipseCellColors.cpp
View File

@ -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));

2
ApplicationCode/ProjectDataModel/RimEclipseCellColors.h
View File

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

8
ApplicationCode/ProjectDataModel/RimEclipseInputCase.cpp
View File

@ -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;

4
ApplicationCode/ProjectDataModel/RimEclipseInputProperty.cpp
View File

@ -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;
}

12
ApplicationCode/ProjectDataModel/RimEclipsePropertyFilter.cpp
View File

@ -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;
}

4
ApplicationCode/ProjectDataModel/RimEclipsePropertyFilterCollection.cpp
View File

@ -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;

8
ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp
View File

@ -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));

72
ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp
View File

@ -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);
}

18
ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.h
View File

@ -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;

60
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.cpp
View File

@ -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");
}

6
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.h
View File

@ -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;

8
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp
View File

@ -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;

12
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.h
View File

@ -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 };

10
ApplicationCode/ProjectDataModel/RimEclipseView.cpp
View File

@ -991,7 +991,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()));
}
@ -1042,7 +1042,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;
@ -1058,7 +1058,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;
@ -1074,7 +1074,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;
@ -1658,7 +1658,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();
}

8
ApplicationCode/ProjectDataModel/RimFaultCollection.cpp
View File

@ -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

2
ApplicationCode/ProjectDataModel/RimGeoMechResultDefinition.cpp
View File

@ -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"

8
ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.cpp
View File

@ -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);
}

8
ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.h
View File

@ -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;
};

6
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

@ -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();
}
}

4
ApplicationCode/ProjectDataModel/RimMultiSnapshotDefinition.cpp
View File

@ -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)
{

4
ApplicationCode/ProjectDataModel/RimMultiSnapshotDefinition.h
View File

@ -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;

4
ApplicationCode/ProjectDataModel/RimProject.cpp
View File

@ -769,13 +769,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)
{

4
ApplicationCode/ProjectDataModel/RimProject.h
View File

@ -20,7 +20,7 @@
#pragma once
#include "RimDefines.h"
#include "RiaDefines.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmChildField.h"
@ -123,7 +123,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;

178
ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp
View File

@ -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())
{
@ -1585,7 +1585,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", "", "", "");

10
ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.h
View File

@ -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;

2
ApplicationCode/ProjectDataModel/RimViewLinker.h
View File

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

2
ApplicationCode/ProjectDataModel/RimViewLinkerCollection.h
View File

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

6
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp
View File

@ -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);

2
ApplicationCode/ProjectDataModel/RimWellLogFileCurve.cpp
View File

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

20
ApplicationCode/ProjectDataModel/RimWellLogPlot.cpp
View File

@ -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;

8
ApplicationCode/ProjectDataModel/RimWellLogPlot.h
View File

@ -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;

Some files were not shown because too many files have changed in this diff Show More