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 Rename from RimDefines to RiaDefines

Browse Source
This commit is contained in:
Magne Sjaastad 2017-06-13 15:41:52 +02:00
parent 3ca22692b9
commit cf859e7c16
82 changed files with 684 additions and 684 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
ApplicationCode/Application/RiaApplication.cpp
View File

@ -36,7 +36,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"
@ -967,7 +967,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)
{
@ -1056,7 +1056,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();
@ -1085,14 +1085,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();
@ -1160,7 +1160,7 @@ bool RiaApplication::openOdbCaseFromFile(const QString& fileName)
//--------------------------------------------------------------------------------------------------
void RiaApplication::createMockModel()
{
openEclipseCase(RimDefines::mockModelBasic(), RimDefines::mockModelBasic());
openEclipseCase(RiaDefines::mockModelBasic(), RiaDefines::mockModelBasic());
}
//--------------------------------------------------------------------------------------------------
@ -1168,7 +1168,7 @@ void RiaApplication::createMockModel()
//--------------------------------------------------------------------------------------------------
void RiaApplication::createResultsMockModel()
{
openEclipseCase(RimDefines::mockModelBasicWithResults(), RimDefines::mockModelBasicWithResults());
openEclipseCase(RiaDefines::mockModelBasicWithResults(), RiaDefines::mockModelBasicWithResults());
}
@ -1177,7 +1177,7 @@ void RiaApplication::createResultsMockModel()
//--------------------------------------------------------------------------------------------------
void RiaApplication::createLargeResultsMockModel()
{
openEclipseCase(RimDefines::mockModelLargeWithResults(), RimDefines::mockModelLargeWithResults());
openEclipseCase(RiaDefines::mockModelLargeWithResults(), RiaDefines::mockModelLargeWithResults());
}
@ -1186,7 +1186,7 @@ void RiaApplication::createLargeResultsMockModel()
//--------------------------------------------------------------------------------------------------
void RiaApplication::createMockModelCustomized()
{
openEclipseCase(RimDefines::mockModelCustomized(), RimDefines::mockModelCustomized());
openEclipseCase(RiaDefines::mockModelCustomized(), RiaDefines::mockModelCustomized());
}
//--------------------------------------------------------------------------------------------------
@ -1194,7 +1194,7 @@ void RiaApplication::createMockModelCustomized()
//--------------------------------------------------------------------------------------------------
void RiaApplication::createInputMockModel()
{
openInputEclipseCaseFromFileNames(QStringList(RimDefines::mockModelBasicInputCase()));
openInputEclipseCaseFromFileNames(QStringList(RiaDefines::mockModelBasicInputCase()));
}
//--------------------------------------------------------------------------------------------------

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

@ -640,11 +640,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));
@ -672,18 +672,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);

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

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

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/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]; \

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,7 +13,7 @@ ${CEE_CURRENT_LIST_DIR}RimPropertyFilterCollection.h
${CEE_CURRENT_LIST_DIR}RimEclipsePropertyFilterCollection.h
${CEE_CURRENT_LIST_DIR}RimCellRangeFilter.h
${CEE_CURRENT_LIST_DIR}RimCellRangeFilterCollection.h
${CEE_CURRENT_LIST_DIR}RimDefines.h
${CEE_CURRENT_LIST_DIR}RiaDefines.h
${CEE_CURRENT_LIST_DIR}RimLegendConfig.h
${CEE_CURRENT_LIST_DIR}RimOilField.h
${CEE_CURRENT_LIST_DIR}RimProject.h
@ -101,7 +101,7 @@ ${CEE_CURRENT_LIST_DIR}RimPropertyFilterCollection.cpp
${CEE_CURRENT_LIST_DIR}RimEclipsePropertyFilterCollection.cpp
${CEE_CURRENT_LIST_DIR}RimCellRangeFilter.cpp
${CEE_CURRENT_LIST_DIR}RimCellRangeFilterCollection.cpp
${CEE_CURRENT_LIST_DIR}RimDefines.cpp
${CEE_CURRENT_LIST_DIR}RiaDefines.cpp
${CEE_CURRENT_LIST_DIR}RimLegendConfig.cpp
${CEE_CURRENT_LIST_DIR}RimOilField.cpp
${CEE_CURRENT_LIST_DIR}RimProject.cpp

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

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

111
ApplicationCode/ProjectDataModel/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/ProjectDataModel/RiaDefines.h
View File

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

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

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

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"

111
ApplicationCode/ProjectDataModel/RimDefines.cpp
View File

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

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()->setCombTransmisibilityScalarResultIndex(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

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

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

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

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"
@ -121,7 +121,7 @@ protected:
private:
void appendScriptItems(QMenu* menu, RimScriptCollection* scriptCollection);
void removeEclipseResultAndRedrawAllViews(RimDefines::ResultCatType type, const QString& resultName);
void removeEclipseResultAndRedrawAllViews(RiaDefines::ResultCatType type, const QString& resultName);
private:
caf::PdmField<QString> m_projectFileVersionString;

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())
{
@ -1610,7 +1610,7 @@ RimReservoirCellResultsStorageEntryInfo::RimReservoirCellResultsStorageEntryInfo
{
CAF_PDM_InitObject("Cache Entry", "", "", "");
CAF_PDM_InitField(&m_resultType, "ResultType", caf::AppEnum<RimDefines::ResultCatType>(RimDefines::REMOVED), "ResultType", "", "" ,"");
CAF_PDM_InitField(&m_resultType, "ResultType", caf::AppEnum<RiaDefines::ResultCatType>(RiaDefines::REMOVED), "ResultType", "", "" ,"");
CAF_PDM_InitField(&m_resultName, "ResultName", QString(), "ResultName", "", "" ,"");
CAF_PDM_InitFieldNoDefault(&m_timeStepDates, "TimeSteps", "TimeSteps", "", "" ,"");
CAF_PDM_InitFieldNoDefault(&m_daysSinceSimulationStart, "DaysSinceSimulationStart", "DaysSinceSimulationStart", "", "", "");

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;

10
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.cpp
View File

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

8
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.h
View File

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

6
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveFilter.cpp
View File

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

8
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveFilter.h
View File

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

6
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurvesCalculator.cpp
View File

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

26
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlot.cpp
View File

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

16
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlot.h
View File

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

12
ApplicationCode/ProjectDataModel/Summary/RimSummaryYAxisProperties.cpp
View File

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

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

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

138
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@ -203,7 +203,7 @@ std::vector<double>& RigCaseCellResultsData::cellScalarResults(size_t scalarResu
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigCaseCellResultsData::findScalarResultIndex(RimDefines::ResultCatType type, const QString& resultName) const
size_t RigCaseCellResultsData::findScalarResultIndex(RiaDefines::ResultCatType type, const QString& resultName) const
{
std::vector<ResultInfo>::const_iterator it;
for (it = m_resultInfos.begin(); it != m_resultInfos.end(); ++it)
@ -222,26 +222,26 @@ size_t RigCaseCellResultsData::findScalarResultIndex(RimDefines::ResultCatType t
//--------------------------------------------------------------------------------------------------
size_t RigCaseCellResultsData::findScalarResultIndex(const QString& resultName) const
{
size_t scalarResultIndex = this->findScalarResultIndex(RimDefines::STATIC_NATIVE, resultName);
size_t scalarResultIndex = this->findScalarResultIndex(RiaDefines::STATIC_NATIVE, resultName);
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{
scalarResultIndex = this->findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, resultName);
scalarResultIndex = this->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, resultName);
}
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{
scalarResultIndex = this->findScalarResultIndex(RimDefines::GENERATED, resultName);
scalarResultIndex = this->findScalarResultIndex(RiaDefines::GENERATED, resultName);
}
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{
scalarResultIndex = this->findScalarResultIndex(RimDefines::INPUT_PROPERTY, resultName);
scalarResultIndex = this->findScalarResultIndex(RiaDefines::INPUT_PROPERTY, resultName);
}
if(scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{
scalarResultIndex = this->findScalarResultIndex(RimDefines::FORMATION_NAMES, resultName);
scalarResultIndex = this->findScalarResultIndex(RiaDefines::FORMATION_NAMES, resultName);
}
return scalarResultIndex;
@ -251,7 +251,7 @@ size_t RigCaseCellResultsData::findScalarResultIndex(const QString& resultName)
/// Adds an empty scalar set, and returns the scalarResultIndex to it.
/// if resultName already exists, it just returns the scalarResultIndex to the existing result.
//--------------------------------------------------------------------------------------------------
size_t RigCaseCellResultsData::addEmptyScalarResult(RimDefines::ResultCatType type, const QString& resultName, bool needsToBeStored)
size_t RigCaseCellResultsData::addEmptyScalarResult(RiaDefines::ResultCatType type, const QString& resultName, bool needsToBeStored)
{
size_t scalarResultIndex = this->findScalarResultIndex(type, resultName);
@ -274,51 +274,51 @@ size_t RigCaseCellResultsData::addEmptyScalarResult(RimDefines::ResultCatType ty
cvf::ref<RigStatisticsCalculator> statisticsCalculator;
if (resultName == RimDefines::combinedTransmissibilityResultName())
if (resultName == RiaDefines::combinedTransmissibilityResultName())
{
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, "TRANX"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, "TRANY"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, "TRANZ"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, "TRANX"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, "TRANY"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, "TRANZ"));
statisticsCalculator = calc;
}
else if (resultName == RimDefines::combinedMultResultName())
else if (resultName == RiaDefines::combinedMultResultName())
{
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, "MULTX"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, "MULTX-"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, "MULTY"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, "MULTY-"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, "MULTZ"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, "MULTZ-"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, "MULTX"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, "MULTX-"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, "MULTY"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, "MULTY-"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, "MULTZ"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, "MULTZ-"));
statisticsCalculator = calc;
}
else if (resultName == RimDefines::combinedRiTranResultName())
else if (resultName == RiaDefines::combinedRiTranResultName())
{
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::riTranXResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::riTranYResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::riTranZResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::riTranXResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::riTranYResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::riTranZResultName()));
statisticsCalculator = calc;
}
else if (resultName == RimDefines::combinedRiMultResultName())
else if (resultName == RiaDefines::combinedRiMultResultName())
{
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::riMultXResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::riMultYResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::riMultZResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::riMultXResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::riMultYResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::riMultZResultName()));
statisticsCalculator = calc;
}
else if (resultName == RimDefines::combinedRiAreaNormTranResultName())
else if (resultName == RiaDefines::combinedRiAreaNormTranResultName())
{
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::riAreaNormTranXResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::riAreaNormTranYResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::riAreaNormTranZResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::riAreaNormTranXResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::riAreaNormTranYResultName()));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::riAreaNormTranZResultName()));
statisticsCalculator = calc;
}
else
@ -336,7 +336,7 @@ size_t RigCaseCellResultsData::addEmptyScalarResult(RimDefines::ResultCatType ty
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QStringList RigCaseCellResultsData::resultNames(RimDefines::ResultCatType resType) const
QStringList RigCaseCellResultsData::resultNames(RiaDefines::ResultCatType resType) const
{
QStringList varList;
std::vector<ResultInfo>::const_iterator it;
@ -378,7 +378,7 @@ bool RigCaseCellResultsData::isUsingGlobalActiveIndex(size_t scalarResultIndex)
//--------------------------------------------------------------------------------------------------
bool RigCaseCellResultsData::hasFlowDiagUsableFluxes() const
{
QStringList dynResVarNames = resultNames(RimDefines::DYNAMIC_NATIVE);
QStringList dynResVarNames = resultNames(RiaDefines::DYNAMIC_NATIVE);
bool hasFlowFluxes = true;
hasFlowFluxes = dynResVarNames.contains("FLRWATI+");
@ -541,7 +541,7 @@ void RigCaseCellResultsData::removeResult(const QString& resultName)
m_cellScalarResults[resultIdx].clear();
m_resultInfos[resultIdx].m_resultType = RimDefines::REMOVED;
m_resultInfos[resultIdx].m_resultType = RiaDefines::REMOVED;
}
//--------------------------------------------------------------------------------------------------
@ -575,7 +575,7 @@ void RigCaseCellResultsData::freeAllocatedResultsData()
/// Make sure we have a result with given type and name, and make sure one "timestep" result vector
// for the static result values are allocated
//--------------------------------------------------------------------------------------------------
size_t RigCaseCellResultsData::addStaticScalarResult(RimDefines::ResultCatType type, const QString& resultName, bool needsToBeStored, size_t resultValueCount)
size_t RigCaseCellResultsData::addStaticScalarResult(RiaDefines::ResultCatType type, const QString& resultName, bool needsToBeStored, size_t resultValueCount)
{
size_t resultIdx = addEmptyScalarResult(type, resultName, needsToBeStored);
@ -588,9 +588,9 @@ size_t RigCaseCellResultsData::addStaticScalarResult(RimDefines::ResultCatType t
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifReaderInterface::PorosityModelResultType RigCaseCellResultsData::convertFromProjectModelPorosityModel(RimDefines::PorosityModelType porosityModel)
RifReaderInterface::PorosityModelResultType RigCaseCellResultsData::convertFromProjectModelPorosityModel(RiaDefines::PorosityModelType porosityModel)
{
if (porosityModel == RimDefines::MATRIX_MODEL) return RifReaderInterface::MATRIX_RESULTS;
if (porosityModel == RiaDefines::MATRIX_MODEL) return RifReaderInterface::MATRIX_RESULTS;
return RifReaderInterface::FRACTURE_RESULTS;
}
@ -598,7 +598,7 @@ RifReaderInterface::PorosityModelResultType RigCaseCellResultsData::convertFromP
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigCaseCellResultsData::updateResultName(RimDefines::ResultCatType resultType, QString& oldName, const QString& newName)
bool RigCaseCellResultsData::updateResultName(RiaDefines::ResultCatType resultType, QString& oldName, const QString& newName)
{
bool anyNameUpdated = false;
@ -653,15 +653,15 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
{
// SOIL
{
size_t soilIndex = findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "SOIL");
size_t soilIndex = findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "SOIL");
if (soilIndex == cvf::UNDEFINED_SIZE_T)
{
size_t swatIndex = findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "SWAT");
size_t sgasIndex = findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "SGAS");
size_t swatIndex = findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "SWAT");
size_t sgasIndex = findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "SGAS");
if (swatIndex != cvf::UNDEFINED_SIZE_T || sgasIndex != cvf::UNDEFINED_SIZE_T)
{
soilIndex = addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, "SOIL", false);
soilIndex = addEmptyScalarResult(RiaDefines::DYNAMIC_NATIVE, "SOIL", false);
this->setMustBeCalculated(soilIndex);
}
}
@ -669,10 +669,10 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
// Completion type
{
size_t completionTypeIndex = findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, RimDefines::completionTypeResultName());
size_t completionTypeIndex = findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, RiaDefines::completionTypeResultName());
if (completionTypeIndex == cvf::UNDEFINED_SIZE_T)
{
addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, RimDefines::completionTypeResultName(), false);
addEmptyScalarResult(RiaDefines::DYNAMIC_NATIVE, RiaDefines::completionTypeResultName(), false);
}
}
@ -681,24 +681,24 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
size_t tranX, tranY, tranZ;
if (findTransmissibilityResults(tranX, tranY, tranZ))
{
addStaticScalarResult(RimDefines::STATIC_NATIVE, RimDefines::combinedTransmissibilityResultName(), false, 0);
addStaticScalarResult(RiaDefines::STATIC_NATIVE, RiaDefines::combinedTransmissibilityResultName(), false, 0);
}
}
// MULTXYZ
{
addStaticScalarResult(RimDefines::STATIC_NATIVE, RimDefines::combinedMultResultName(), false, 0);
addStaticScalarResult(RiaDefines::STATIC_NATIVE, RiaDefines::combinedMultResultName(), false, 0);
}
// riTRANSXYZ and X,Y,Z
{
if ( findScalarResultIndex(RimDefines::STATIC_NATIVE, "PERMX") != cvf::UNDEFINED_SIZE_T
&& findScalarResultIndex(RimDefines::STATIC_NATIVE, "PERMY") != cvf::UNDEFINED_SIZE_T
&& findScalarResultIndex(RimDefines::STATIC_NATIVE, "PERMZ") != cvf::UNDEFINED_SIZE_T)
if ( findScalarResultIndex(RiaDefines::STATIC_NATIVE, "PERMX") != cvf::UNDEFINED_SIZE_T
&& findScalarResultIndex(RiaDefines::STATIC_NATIVE, "PERMY") != cvf::UNDEFINED_SIZE_T
&& findScalarResultIndex(RiaDefines::STATIC_NATIVE, "PERMZ") != cvf::UNDEFINED_SIZE_T)
{
addStaticScalarResult(RimDefines::STATIC_NATIVE, RimDefines::riTranXResultName(), false, 0);
addStaticScalarResult(RimDefines::STATIC_NATIVE, RimDefines::riTranYResultName(), false, 0);
addStaticScalarResult(RimDefines::STATIC_NATIVE, RimDefines::riTranZResultName(), false, 0);
addStaticScalarResult(RimDefines::STATIC_NATIVE, RimDefines::combinedRiTranResultName(), false, 0);
addStaticScalarResult(RiaDefines::STATIC_NATIVE, RiaDefines::riTranXResultName(), false, 0);
addStaticScalarResult(RiaDefines::STATIC_NATIVE, RiaDefines::riTranYResultName(), false, 0);
addStaticScalarResult(RiaDefines::STATIC_NATIVE, RiaDefines::riTranZResultName(), false, 0);
addStaticScalarResult(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiTranResultName(), false, 0);
}
}
@ -706,38 +706,38 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
{
size_t tranX, tranY, tranZ;
if (findTransmissibilityResults(tranX, tranY, tranZ)
&& findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::riTranXResultName()) != cvf::UNDEFINED_SIZE_T
&& findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::riTranYResultName()) != cvf::UNDEFINED_SIZE_T
&& findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::riTranZResultName()) != cvf::UNDEFINED_SIZE_T)
&& findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::riTranXResultName()) != cvf::UNDEFINED_SIZE_T
&& findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::riTranYResultName()) != cvf::UNDEFINED_SIZE_T
&& findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::riTranZResultName()) != cvf::UNDEFINED_SIZE_T)
{
addStaticScalarResult(RimDefines::STATIC_NATIVE, RimDefines::riMultXResultName(), false, 0);
addStaticScalarResult(RimDefines::STATIC_NATIVE, RimDefines::riMultYResultName(), false, 0);
addStaticScalarResult(RimDefines::STATIC_NATIVE, RimDefines::riMultZResultName(), false, 0);
addStaticScalarResult(RimDefines::STATIC_NATIVE, RimDefines::combinedRiMultResultName(), false, 0);
addStaticScalarResult(RiaDefines::STATIC_NATIVE, RiaDefines::riMultXResultName(), false, 0);
addStaticScalarResult(RiaDefines::STATIC_NATIVE, RiaDefines::riMultYResultName(), false, 0);
addStaticScalarResult(RiaDefines::STATIC_NATIVE, RiaDefines::riMultZResultName(), false, 0);
addStaticScalarResult(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiMultResultName(), false, 0);
}
}
// riTRANSXYZbyArea and X, Y, Z
{
if (findScalarResultIndex(RimDefines::STATIC_NATIVE, "TRANX") != cvf::UNDEFINED_SIZE_T)
if (findScalarResultIndex(RiaDefines::STATIC_NATIVE, "TRANX") != cvf::UNDEFINED_SIZE_T)
{
addStaticScalarResult(RimDefines::STATIC_NATIVE, RimDefines::riAreaNormTranXResultName(), false, 0);
addStaticScalarResult(RiaDefines::STATIC_NATIVE, RiaDefines::riAreaNormTranXResultName(), false, 0);
}
if (findScalarResultIndex(RimDefines::STATIC_NATIVE, "TRANY") != cvf::UNDEFINED_SIZE_T)
if (findScalarResultIndex(RiaDefines::STATIC_NATIVE, "TRANY") != cvf::UNDEFINED_SIZE_T)
{
addStaticScalarResult(RimDefines::STATIC_NATIVE, RimDefines::riAreaNormTranYResultName(), false, 0);
addStaticScalarResult(RiaDefines::STATIC_NATIVE, RiaDefines::riAreaNormTranYResultName(), false, 0);
}
if (findScalarResultIndex(RimDefines::STATIC_NATIVE, "TRANZ") != cvf::UNDEFINED_SIZE_T)
if (findScalarResultIndex(RiaDefines::STATIC_NATIVE, "TRANZ") != cvf::UNDEFINED_SIZE_T)
{
addStaticScalarResult(RimDefines::STATIC_NATIVE, RimDefines::riAreaNormTranZResultName(), false, 0);
addStaticScalarResult(RiaDefines::STATIC_NATIVE, RiaDefines::riAreaNormTranZResultName(), false, 0);
}
size_t tranX, tranY, tranZ;
if (findTransmissibilityResults(tranX, tranY, tranZ))
{
addStaticScalarResult(RimDefines::STATIC_NATIVE, RimDefines::combinedRiAreaNormTranResultName(), false, 0);
addStaticScalarResult(RiaDefines::STATIC_NATIVE, RiaDefines::combinedRiAreaNormTranResultName(), false, 0);
}
}
}
@ -747,9 +747,9 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
//--------------------------------------------------------------------------------------------------
bool RigCaseCellResultsData::findTransmissibilityResults(size_t& tranX, size_t& tranY, size_t& tranZ) const
{
tranX = findScalarResultIndex(RimDefines::STATIC_NATIVE, "TRANX");
tranY = findScalarResultIndex(RimDefines::STATIC_NATIVE, "TRANY");
tranZ = findScalarResultIndex(RimDefines::STATIC_NATIVE, "TRANZ");
tranX = findScalarResultIndex(RiaDefines::STATIC_NATIVE, "TRANX");
tranY = findScalarResultIndex(RiaDefines::STATIC_NATIVE, "TRANY");
tranZ = findScalarResultIndex(RiaDefines::STATIC_NATIVE, "TRANZ");
if (tranX == cvf::UNDEFINED_SIZE_T ||
tranY == cvf::UNDEFINED_SIZE_T ||

18
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.h
View File

@ -22,7 +22,7 @@
#include "RifReaderInterface.h"
#include "RimDefines.h"
#include "RiaDefines.h"
#include "cvfCollection.h"
@ -69,7 +69,7 @@ public:
size_t resultCount() const;
size_t timeStepCount(size_t scalarResultIndex) const;
size_t maxTimeStepCount(size_t* scalarResultIndex = NULL) const;
QStringList resultNames(RimDefines::ResultCatType type) const;
QStringList resultNames(RiaDefines::ResultCatType type) const;
bool isUsingGlobalActiveIndex(size_t scalarResultIndex) const;
bool hasFlowDiagUsableFluxes() const;
@ -84,10 +84,10 @@ public:
// Find or create a slot for the results
size_t findScalarResultIndex(RimDefines::ResultCatType type, const QString& resultName) const;
size_t findScalarResultIndex(RiaDefines::ResultCatType type, const QString& resultName) const;
size_t findScalarResultIndex(const QString& resultName) const;
size_t addEmptyScalarResult(RimDefines::ResultCatType type, const QString& resultName, bool needsToBeStored);
size_t addEmptyScalarResult(RiaDefines::ResultCatType type, const QString& resultName, bool needsToBeStored);
QString makeResultNameUnique(const QString& resultNameProposal) const;
void createPlaceholderResultEntries();
@ -102,19 +102,19 @@ public:
std::vector< std::vector<double> > & cellScalarResults(size_t scalarResultIndex);
std::vector<double>& cellScalarResults(size_t scalarResultIndex, size_t timeStepIndex);
static RifReaderInterface::PorosityModelResultType convertFromProjectModelPorosityModel(RimDefines::PorosityModelType porosityModel);
static RifReaderInterface::PorosityModelResultType convertFromProjectModelPorosityModel(RiaDefines::PorosityModelType porosityModel);
bool updateResultName(RimDefines::ResultCatType resultType, QString& oldName, const QString& newName);
bool updateResultName(RiaDefines::ResultCatType resultType, QString& oldName, const QString& newName);
public:
class ResultInfo
{
public:
ResultInfo(RimDefines::ResultCatType resultType, bool needsToBeStored, bool mustBeCalculated, QString resultName, size_t gridScalarResultIndex)
ResultInfo(RiaDefines::ResultCatType resultType, bool needsToBeStored, bool mustBeCalculated, QString resultName, size_t gridScalarResultIndex)
: m_resultType(resultType), m_needsToBeStored(needsToBeStored), m_resultName(resultName), m_gridScalarResultIndex(gridScalarResultIndex), m_mustBeCalculated(mustBeCalculated) { }
public:
RimDefines::ResultCatType m_resultType;
RiaDefines::ResultCatType m_resultType;
bool m_needsToBeStored;
bool m_mustBeCalculated;
QString m_resultName;
@ -131,7 +131,7 @@ public:
public:
size_t addStaticScalarResult(RimDefines::ResultCatType type,
size_t addStaticScalarResult(RiaDefines::ResultCatType type,
const QString& resultName,
bool needsToBeStored,
size_t resultValueCount);

2
ApplicationCode/ReservoirDataModel/RigEclipseCaseData.cpp
View File

@ -537,7 +537,7 @@ void RigEclipseCaseData::setActiveFormationNames(RigFormationNames* activeFormat
m_activeFormationNamesData = activeFormationNames;
size_t totalGlobCellCount = m_mainGrid->globalCellArray().size();
size_t resIndex = m_matrixModelResults->addStaticScalarResult(RimDefines::FORMATION_NAMES,
size_t resIndex = m_matrixModelResults->addStaticScalarResult(RiaDefines::FORMATION_NAMES,
"Active Formation Names",
false,
totalGlobCellCount);

22
ApplicationCode/ReservoirDataModel/RigLasFileExporter.cpp
View File

@ -20,7 +20,7 @@
#include "RigWellLogCurveData.h"
#include "RimCase.h"
#include "RimDefines.h"
#include "RiaDefines.h"
#include "RimWellLogCurve.h"
#include "RimWellLogExtractionCurve.h"
@ -196,15 +196,15 @@ public:
const RigWellLogCurveData* firstCurveData = curveDataForFirstCurve();
if (firstCurveData->depthUnit() == RimDefines::UNIT_METER)
if (firstCurveData->depthUnit() == RiaDefines::UNIT_METER)
{
lasFile->AddLog("DEPTH", "M", "Depth in meters", firstCurveData->measuredDepths());
}
else if (firstCurveData->depthUnit() == RimDefines::UNIT_FEET)
else if (firstCurveData->depthUnit() == RiaDefines::UNIT_FEET)
{
lasFile->AddLog("DEPTH", "FT", "Depth in feet", firstCurveData->measuredDepths());
}
else if ( firstCurveData->depthUnit() == RimDefines::UNIT_NONE )
else if ( firstCurveData->depthUnit() == RiaDefines::UNIT_NONE )
{
CVF_ASSERT(false);
lasFile->AddLog("DEPTH", "", "Depth in Connection number", firstCurveData->measuredDepths());
@ -223,15 +223,15 @@ public:
value += m_rkbDiff;
}
if (firstCurveData->depthUnit() == RimDefines::UNIT_METER)
if (firstCurveData->depthUnit() == RiaDefines::UNIT_METER)
{
lasFile->AddLog("TVDRKB", "M", "True vertical depth (Rotary Kelly Bushing)", tvdrkbValues);
}
else if (firstCurveData->depthUnit() == RimDefines::UNIT_FEET)
else if (firstCurveData->depthUnit() == RiaDefines::UNIT_FEET)
{
lasFile->AddLog("TVDRKB", "FT", "True vertical depth (Rotary Kelly Bushing)", tvdrkbValues);
}
else if ( firstCurveData->depthUnit() == RimDefines::UNIT_NONE )
else if ( firstCurveData->depthUnit() == RiaDefines::UNIT_NONE )
{
CVF_ASSERT(false);
lasFile->AddLog("TVDRKB", "", "", tvdrkbValues);
@ -247,15 +247,15 @@ public:
lasFile->setStartDepth(minDepth);
lasFile->setStopDepth(maxDepth);
if (firstCurveData->depthUnit() == RimDefines::UNIT_METER)
if (firstCurveData->depthUnit() == RiaDefines::UNIT_METER)
{
lasFile->setDepthUnit("M");
}
else if (firstCurveData->depthUnit() == RimDefines::UNIT_FEET)
else if (firstCurveData->depthUnit() == RiaDefines::UNIT_FEET)
{
lasFile->setDepthUnit("FT");
}
else if ( firstCurveData->depthUnit() == RimDefines::UNIT_NONE )
else if ( firstCurveData->depthUnit() == RiaDefines::UNIT_NONE )
{
CVF_ASSERT(false);
}
@ -299,7 +299,7 @@ private:
double m_rkbDiff;
bool m_exportTvdrkb;
RimDefines::DepthUnitType m_depthUnit;
RiaDefines::DepthUnitType m_depthUnit;
std::vector<double> m_depthValues;
std::vector<SingleChannelData> m_logCurveData;

10
ApplicationCode/ReservoirDataModel/RigMainGrid.cpp
View File

@ -21,7 +21,7 @@
#include "RigMainGrid.h"
#include "RiaLogging.h"
#include "RimDefines.h"
#include "RiaDefines.h"
#include "RigFault.h"
#include "RigActiveCellInfo.h"
@ -237,8 +237,8 @@ bool RigMainGrid::hasFaultWithName(const QString& name) const
//--------------------------------------------------------------------------------------------------
void RigMainGrid::calculateFaults(const RigActiveCellInfo* activeCellInfo)
{
if (hasFaultWithName(RimDefines::undefinedGridFaultName())
&& hasFaultWithName(RimDefines::undefinedGridFaultWithInactiveName()))
if (hasFaultWithName(RiaDefines::undefinedGridFaultName())
&& hasFaultWithName(RiaDefines::undefinedGridFaultWithInactiveName()))
{
//RiaLogging::debug(QString("Calculate faults already run for grid."));
return;
@ -255,12 +255,12 @@ void RigMainGrid::calculateFaults(const RigActiveCellInfo* activeCellInfo)
// Separate the grid faults that has an inactive cell as member
RigFault* unNamedFault = new RigFault;
unNamedFault->setName(RimDefines::undefinedGridFaultName());
unNamedFault->setName(RiaDefines::undefinedGridFaultName());
int unNamedFaultIdx = static_cast<int>(m_faults.size());
m_faults.push_back(unNamedFault);
RigFault* unNamedFaultWithInactive = new RigFault;
unNamedFaultWithInactive->setName(RimDefines::undefinedGridFaultWithInactiveName());
unNamedFaultWithInactive->setName(RiaDefines::undefinedGridFaultWithInactiveName());
int unNamedFaultWithInactiveIdx = static_cast<int>(m_faults.size());
m_faults.push_back(unNamedFaultWithInactive);

34
ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.cpp
View File

@ -52,7 +52,7 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromUiResultName(Rig
RigGridBase* grid = eclipseCase->grid(gridIndex);
if (uiResultName == RimDefines::combinedTransmissibilityResultName())
if (uiResultName == RiaDefines::combinedTransmissibilityResultName())
{
CVF_ASSERT(timeStepIndex == 0); // Static result, only data for first time step
@ -66,7 +66,7 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromUiResultName(Rig
return cellFaceAccessObject;
}
else if (uiResultName == RimDefines::combinedMultResultName())
else if (uiResultName == RiaDefines::combinedMultResultName())
{
CVF_ASSERT(timeStepIndex == 0); // Static result, only data for first time step
@ -83,43 +83,43 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromUiResultName(Rig
return cellFaceAccessObject;
}
else if (uiResultName == RimDefines::combinedRiTranResultName())
else if (uiResultName == RiaDefines::combinedRiTranResultName())
{
CVF_ASSERT(timeStepIndex == 0); // Static result, only data for first time step
cvf::ref<RigCombTransResultAccessor> cellFaceAccessObject = new RigCombTransResultAccessor(grid);
cvf::ref<RigResultAccessor> xTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riTranXResultName());
cvf::ref<RigResultAccessor> yTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riTranYResultName());
cvf::ref<RigResultAccessor> zTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riTranZResultName());
cvf::ref<RigResultAccessor> xTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RiaDefines::riTranXResultName());
cvf::ref<RigResultAccessor> yTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RiaDefines::riTranYResultName());
cvf::ref<RigResultAccessor> zTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RiaDefines::riTranZResultName());
cellFaceAccessObject->setTransResultAccessors(xTransAccessor.p(), yTransAccessor.p(), zTransAccessor.p());
return cellFaceAccessObject;
}
else if (uiResultName == RimDefines::combinedRiMultResultName())
else if (uiResultName == RiaDefines::combinedRiMultResultName())
{
CVF_ASSERT(timeStepIndex == 0); // Static result, only data for first time step
cvf::ref<RigCombTransResultAccessor> cellFaceAccessObject = new RigCombTransResultAccessor(grid);
cvf::ref<RigResultAccessor> xRiMultAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riMultXResultName());
cvf::ref<RigResultAccessor> yRiMultAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riMultYResultName());
cvf::ref<RigResultAccessor> zRiMultAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riMultZResultName());
cvf::ref<RigResultAccessor> xRiMultAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RiaDefines::riMultXResultName());
cvf::ref<RigResultAccessor> yRiMultAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RiaDefines::riMultYResultName());
cvf::ref<RigResultAccessor> zRiMultAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RiaDefines::riMultZResultName());
cellFaceAccessObject->setTransResultAccessors(xRiMultAccessor.p(), yRiMultAccessor.p(), zRiMultAccessor.p());
return cellFaceAccessObject;
}
else if (uiResultName == RimDefines::combinedRiAreaNormTranResultName())
else if (uiResultName == RiaDefines::combinedRiAreaNormTranResultName())
{
CVF_ASSERT(timeStepIndex == 0); // Static result, only data for first time step
cvf::ref<RigCombTransResultAccessor> cellFaceAccessObject = new RigCombTransResultAccessor(grid);
cvf::ref<RigResultAccessor> xRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riAreaNormTranXResultName());
cvf::ref<RigResultAccessor> yRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riAreaNormTranYResultName());
cvf::ref<RigResultAccessor> zRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riAreaNormTranZResultName());
cvf::ref<RigResultAccessor> xRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RiaDefines::riAreaNormTranXResultName());
cvf::ref<RigResultAccessor> yRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RiaDefines::riAreaNormTranYResultName());
cvf::ref<RigResultAccessor> zRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RiaDefines::riAreaNormTranZResultName());
cellFaceAccessObject->setTransResultAccessors(xRiAreaNormTransAccessor.p(), yRiAreaNormTransAccessor.p(), zRiAreaNormTransAccessor.p());
@ -137,7 +137,7 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromNameAndType(RigE
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,
const QString& uiResultName,
RimDefines::ResultCatType resultType)
RiaDefines::ResultCatType resultType)
{
CVF_ASSERT(gridIndex < eclipseCase->gridCount());
CVF_ASSERT(eclipseCase);
@ -156,7 +156,7 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromNameAndType(RigE
}
size_t adjustedTimeStepIndex = timeStepIndex;
if (resultType == RimDefines::STATIC_NATIVE)
if (resultType == RiaDefines::STATIC_NATIVE)
{
adjustedTimeStepIndex = 0;
}
@ -174,7 +174,7 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromResultDefinition
{
RifReaderInterface::PorosityModelResultType porosityModel = RigCaseCellResultsData::convertFromProjectModelPorosityModel(resultDefinition->porosityModel());
if (resultDefinition->resultType() != RimDefines::FLOW_DIAGNOSTICS)
if (resultDefinition->resultType() != RiaDefines::FLOW_DIAGNOSTICS)
{
size_t adjustedTimeStepIndex = timeStepIndex;

4
ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.h
View File

@ -22,7 +22,7 @@
#include "RifReaderInterface.h"
#include "RigResultAccessor.h"
#include "RimDefines.h"
#include "RiaDefines.h"
class RigActiveCellInfo;
class RigGridBase;
@ -51,7 +51,7 @@ public:
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,
const QString& uiResultName,
RimDefines::ResultCatType resultType);
RiaDefines::ResultCatType resultType);
static cvf::ref<RigResultAccessor>
createFromResultIdx(RigEclipseCaseData* eclipseCase,

2
ApplicationCode/ReservoirDataModel/RigSingleWellResultsData.h
View File

@ -22,7 +22,7 @@
#include "cvfObject.h"
#include "cvfMath.h"
#include "RimDefines.h"
#include "RiaDefines.h"
#include <QDateTime>
#include <vector>
#include "cvfVector3.h"

16
ApplicationCode/ReservoirDataModel/RigWellLogCurveData.cpp
View File

@ -34,7 +34,7 @@
RigWellLogCurveData::RigWellLogCurveData()
{
m_isExtractionCurve = false;
m_depthUnit = RimDefines::UNIT_METER;
m_depthUnit = RiaDefines::UNIT_METER;
}
//--------------------------------------------------------------------------------------------------
@ -49,7 +49,7 @@ RigWellLogCurveData::~RigWellLogCurveData()
//--------------------------------------------------------------------------------------------------
void RigWellLogCurveData::setValuesAndMD(const std::vector<double>& xValues,
const std::vector<double>& measuredDepths,
RimDefines::DepthUnitType depthUnit,
RiaDefines::DepthUnitType depthUnit,
bool isExtractionCurve)
{
CVF_ASSERT(xValues.size() == measuredDepths.size());
@ -72,7 +72,7 @@ void RigWellLogCurveData::setValuesAndMD(const std::vector<double>& xValues,
void RigWellLogCurveData::setValuesWithTVD(const std::vector<double>& xValues,
const std::vector<double>& measuredDepths,
const std::vector<double>& tvDepths,
RimDefines::DepthUnitType depthUnit)
RiaDefines::DepthUnitType depthUnit)
{
CVF_ASSERT(xValues.size() == measuredDepths.size());
@ -126,7 +126,7 @@ std::vector<double> RigWellLogCurveData::xPlotValues() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> RigWellLogCurveData::trueDepthPlotValues(RimDefines::DepthUnitType destinationDepthUnit) const
std::vector<double> RigWellLogCurveData::trueDepthPlotValues(RiaDefines::DepthUnitType destinationDepthUnit) const
{
std::vector<double> filteredValues;
if(m_tvDepths.size())
@ -148,7 +148,7 @@ std::vector<double> RigWellLogCurveData::trueDepthPlotValues(RimDefines::DepthUn
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> RigWellLogCurveData::measuredDepthPlotValues(RimDefines::DepthUnitType destinationDepthUnit) const
std::vector<double> RigWellLogCurveData::measuredDepthPlotValues(RiaDefines::DepthUnitType destinationDepthUnit) const
{
std::vector<double> filteredValues;
@ -354,7 +354,7 @@ bool RigWellLogCurveData::calculateMDRange(double* minimumDepth, double* maximum
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimDefines::DepthUnitType RigWellLogCurveData::depthUnit() const
RiaDefines::DepthUnitType RigWellLogCurveData::depthUnit() const
{
return m_depthUnit;
}
@ -392,11 +392,11 @@ std::vector<double> RigWellLogCurveData::convertFromFeetToMeter(const std::vecto
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> RigWellLogCurveData::convertDepthValues(RimDefines::DepthUnitType destinationDepthUnit, const std::vector<double>& values) const
std::vector<double> RigWellLogCurveData::convertDepthValues(RiaDefines::DepthUnitType destinationDepthUnit, const std::vector<double>& values) const
{
CVF_ASSERT(destinationDepthUnit != m_depthUnit);
if (destinationDepthUnit == RimDefines::UNIT_METER)
if (destinationDepthUnit == RiaDefines::UNIT_METER)
{
return convertFromFeetToMeter(values);
}

16
ApplicationCode/ReservoirDataModel/RigWellLogCurveData.h
View File

@ -19,7 +19,7 @@
#pragma once
#include "RimDefines.h"
#include "RiaDefines.h"
#include "cvfBase.h"
#include "cvfObject.h"
@ -39,24 +39,24 @@ public:
void setValuesAndMD(const std::vector<double>& xValues,
const std::vector<double>& measuredDepths,
RimDefines::DepthUnitType depthUnit,
RiaDefines::DepthUnitType depthUnit,
bool isExtractionCurve);
void setValuesWithTVD(const std::vector<double>& xValues,
const std::vector<double>& measuredDepths,
const std::vector<double>& tvDepths,
RimDefines::DepthUnitType depthUnit);
RiaDefines::DepthUnitType depthUnit);
const std::vector<double>& xValues() const;
const std::vector<double>& measuredDepths() const;
const std::vector<double>& tvDepths() const;
bool calculateMDRange(double* minMD, double* maxMD) const;
RimDefines::DepthUnitType depthUnit() const;
RiaDefines::DepthUnitType depthUnit() const;
std::vector<double> xPlotValues() const;
std::vector<double> trueDepthPlotValues(RimDefines::DepthUnitType destinationDepthUnit) const;
std::vector<double> measuredDepthPlotValues(RimDefines::DepthUnitType destinationDepthUnit) const;
std::vector<double> trueDepthPlotValues(RiaDefines::DepthUnitType destinationDepthUnit) const;
std::vector<double> measuredDepthPlotValues(RiaDefines::DepthUnitType destinationDepthUnit) const;
std::vector< std::pair<size_t, size_t> > polylineStartStopIndices() const;
cvf::ref<RigWellLogCurveData> calculateResampledCurveData(double newMeasuredDepthStepSize) const;
@ -68,7 +68,7 @@ private:
size_t startIdx, size_t stopIdx,
std::vector< std::pair<size_t, size_t> >* intervals);
std::vector<double> convertDepthValues(RimDefines::DepthUnitType destinationDepthUnit, const std::vector<double>& originalValues) const;
std::vector<double> convertDepthValues(RiaDefines::DepthUnitType destinationDepthUnit, const std::vector<double>& originalValues) const;
static std::vector<double> convertFromMeterToFeet(const std::vector<double>& valuesInMeter);
static std::vector<double> convertFromFeetToMeter(const std::vector<double>& valuesInFeet);
@ -81,6 +81,6 @@ private:
std::vector< std::pair<size_t, size_t> > m_intervalsOfContinousValidValues;
RimDefines::DepthUnitType m_depthUnit;
RiaDefines::DepthUnitType m_depthUnit;
};

26
ApplicationCode/ReservoirDataModel/RigWellLogFile.cpp
View File

@ -208,7 +208,7 @@ QString RigWellLogFile::depthUnitString() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RigWellLogFile::wellLogChannelUnitString(const QString& wellLogChannelName, RimDefines::DepthUnitType displayDepthUnit) const
QString RigWellLogFile::wellLogChannelUnitString(const QString& wellLogChannelName, RiaDefines::DepthUnitType displayDepthUnit) const
{
QString unit;
@ -222,15 +222,15 @@ QString RigWellLogFile::wellLogChannelUnitString(const QString& wellLogChannelNa
{
if (displayDepthUnit != depthUnit())
{
if (displayDepthUnit == RimDefines::UNIT_METER)
if (displayDepthUnit == RiaDefines::UNIT_METER)
{
return "M";
}
else if (displayDepthUnit == RimDefines::UNIT_FEET)
else if (displayDepthUnit == RiaDefines::UNIT_FEET)
{
return "FT";
}
else if (displayDepthUnit == RimDefines::UNIT_NONE)
else if (displayDepthUnit == RiaDefines::UNIT_NONE)
{
CVF_ASSERT(false);
return "";
@ -279,15 +279,15 @@ bool RigWellLogFile::exportToLasFile(const RimWellLogCurve* curve, const QString
lasFile.addWellInfo("WELL", curve->wellName().trimmed().toStdString());
lasFile.addWellInfo("DATE", wellLogDate.toStdString());
if (curveData->depthUnit() == RimDefines::UNIT_METER)
if (curveData->depthUnit() == RiaDefines::UNIT_METER)
{
lasFile.AddLog("DEPTH", "M", "Depth in meters", curveData->measuredDepths());
}
else if (curveData->depthUnit() == RimDefines::UNIT_FEET)
else if (curveData->depthUnit() == RiaDefines::UNIT_FEET)
{
lasFile.AddLog("DEPTH", "FT", "Depth in feet", curveData->measuredDepths());
}
else if (curveData->depthUnit() == RimDefines::UNIT_NONE)
else if (curveData->depthUnit() == RiaDefines::UNIT_NONE)
{
CVF_ASSERT(false);
lasFile.AddLog("DEPTH", "", "Depth in connection number", curveData->measuredDepths());
@ -308,15 +308,15 @@ bool RigWellLogFile::exportToLasFile(const RimWellLogCurve* curve, const QString
lasFile.setStartDepth(minDepth);
lasFile.setStopDepth(maxDepth);
if (curveData->depthUnit() == RimDefines::UNIT_METER)
if (curveData->depthUnit() == RiaDefines::UNIT_METER)
{
lasFile.setDepthUnit("M");
}
else if (curveData->depthUnit() == RimDefines::UNIT_FEET)
else if (curveData->depthUnit() == RiaDefines::UNIT_FEET)
{
lasFile.setDepthUnit("FT");
}
else if ( curveData->depthUnit() == RimDefines::UNIT_NONE )
else if ( curveData->depthUnit() == RiaDefines::UNIT_NONE )
{
CVF_ASSERT(false);
lasFile.setDepthUnit("");
@ -333,13 +333,13 @@ bool RigWellLogFile::exportToLasFile(const RimWellLogCurve* curve, const QString
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimDefines::DepthUnitType RigWellLogFile::depthUnit() const
RiaDefines::DepthUnitType RigWellLogFile::depthUnit() const
{
RimDefines::DepthUnitType unitType = RimDefines::UNIT_METER;
RiaDefines::DepthUnitType unitType = RiaDefines::UNIT_METER;
if (depthUnitString().toUpper() == "F" || depthUnitString().toUpper() == "FT")
{
unitType = RimDefines::UNIT_FEET;
unitType = RiaDefines::UNIT_FEET;
}
return unitType;

6
ApplicationCode/ReservoirDataModel/RigWellLogFile.h
View File

@ -19,7 +19,7 @@
#pragma once
#include "RimDefines.h"
#include "RiaDefines.h"
#include "cvfBase.h"
#include "cvfObject.h"
@ -51,8 +51,8 @@ public:
std::vector<double> depthValues() const;
std::vector<double> values(const QString& name) const;
QString wellLogChannelUnitString(const QString& wellLogChannelName, RimDefines::DepthUnitType displayDepthUnit) const;
RimDefines::DepthUnitType depthUnit() const;
QString wellLogChannelUnitString(const QString& wellLogChannelName, RiaDefines::DepthUnitType displayDepthUnit) const;
RiaDefines::DepthUnitType depthUnit() const;
static bool exportToLasFile(const RimWellLogCurve* curve, const QString& fileName);

20
ApplicationCode/SocketInterface/RiaPropertyDataCommands.cpp
View File

@ -407,11 +407,11 @@ public:
if (rimCase && rimCase->results(m_porosityModelEnum))
{
scalarResultIndex = rimCase->results(m_porosityModelEnum)->findOrLoadScalarResult(RimDefines::GENERATED, propertyName);
scalarResultIndex = rimCase->results(m_porosityModelEnum)->findOrLoadScalarResult(RiaDefines::GENERATED, propertyName);
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{
scalarResultIndex = rimCase->results(m_porosityModelEnum)->cellResults()->addEmptyScalarResult(RimDefines::GENERATED, propertyName, true);
scalarResultIndex = rimCase->results(m_porosityModelEnum)->cellResults()->addEmptyScalarResult(RiaDefines::GENERATED, propertyName, true);
}
if (scalarResultIndex != cvf::UNDEFINED_SIZE_T)
@ -795,11 +795,11 @@ public:
if (rimCase && rimCase->results(m_porosityModelEnum))
{
scalarResultIndex = rimCase->results(m_porosityModelEnum)->findOrLoadScalarResult(RimDefines::GENERATED, propertyName);
scalarResultIndex = rimCase->results(m_porosityModelEnum)->findOrLoadScalarResult(RiaDefines::GENERATED, propertyName);
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{
scalarResultIndex = rimCase->results(m_porosityModelEnum)->cellResults()->addEmptyScalarResult(RimDefines::GENERATED, propertyName, true);
scalarResultIndex = rimCase->results(m_porosityModelEnum)->cellResults()->addEmptyScalarResult(RiaDefines::GENERATED, propertyName, true);
}
if (scalarResultIndex != cvf::UNDEFINED_SIZE_T)
@ -1104,20 +1104,20 @@ public:
RigCaseCellResultsData* results = rimCase->eclipseCaseData()->results(porosityModelEnum);
std::vector<RimDefines::ResultCatType> resTypes;
std::vector<RiaDefines::ResultCatType> resTypes;
std::vector<QString> resTypeNames;
resTypes.push_back(RimDefines::DYNAMIC_NATIVE);
resTypes.push_back(RiaDefines::DYNAMIC_NATIVE);
resTypeNames.push_back("DynamicNative");
resTypes.push_back(RimDefines::STATIC_NATIVE );
resTypes.push_back(RiaDefines::STATIC_NATIVE );
resTypeNames.push_back("StaticNative");
resTypes.push_back(RimDefines::GENERATED );
resTypes.push_back(RiaDefines::GENERATED );
resTypeNames.push_back("Generated");
resTypes.push_back(RimDefines::INPUT_PROPERTY);
resTypes.push_back(RiaDefines::INPUT_PROPERTY);
resTypeNames.push_back("Input");
for (size_t rtIdx = 0; rtIdx < resTypes.size(); ++rtIdx)
{
RimDefines::ResultCatType resType = resTypes[rtIdx];
RiaDefines::ResultCatType resType = resTypes[rtIdx];
QStringList names = results->resultNames(resType);
for (int pnIdx = 0; pnIdx < names.size(); ++pnIdx){

10
ApplicationCode/UnitTests/RifReaderEclipseOutput-Test.cpp
View File

@ -260,7 +260,7 @@ TEST(RigReservoirTest, UnifiedTestFile)
void buildResultInfoString(RigReservoir* reservoir, RifReaderInterface::PorosityModelResultType porosityModel, RimDefines::ResultCatType resultType)
void buildResultInfoString(RigReservoir* reservoir, RifReaderInterface::PorosityModelResultType porosityModel, RiaDefines::ResultCatType resultType)
{
RigCaseCellResultsData* matrixResults = reservoir->results(porosityModel);
{
@ -302,22 +302,22 @@ TEST(RigReservoirTest, DualPorosityTest)
qDebug() << "\n\n" <<
"Matrix porosities, DYNAMIC results" <<
"----------------------------------";
buildResultInfoString(reservoir.p(), RifReaderInterface::MATRIX_RESULTS, RimDefines::DYNAMIC_NATIVE);
buildResultInfoString(reservoir.p(), RifReaderInterface::MATRIX_RESULTS, RiaDefines::DYNAMIC_NATIVE);
qDebug() << "\n\n" <<
"Matrix porosities, STATIC results" <<
"----------------------------------";
buildResultInfoString(reservoir.p(), RifReaderInterface::MATRIX_RESULTS, RimDefines::STATIC_NATIVE);
buildResultInfoString(reservoir.p(), RifReaderInterface::MATRIX_RESULTS, RiaDefines::STATIC_NATIVE);
qDebug() << "\n\n" <<
"Fracture porosities, DYNAMIC results" <<
"----------------------------------";
buildResultInfoString(reservoir.p(), RifReaderInterface::FRACTURE_RESULTS, RimDefines::DYNAMIC_NATIVE);
buildResultInfoString(reservoir.p(), RifReaderInterface::FRACTURE_RESULTS, RiaDefines::DYNAMIC_NATIVE);
qDebug() << "\n\n" <<
"Fracture porosities, STATIC results" <<
"----------------------------------";
buildResultInfoString(reservoir.p(), RifReaderInterface::FRACTURE_RESULTS, RimDefines::STATIC_NATIVE);
buildResultInfoString(reservoir.p(), RifReaderInterface::FRACTURE_RESULTS, RiaDefines::STATIC_NATIVE);
}

32
ApplicationCode/UserInterface/RiuResultTextBuilder.cpp
View File

@ -380,9 +380,9 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigEclipseCaseData* eclips
RimReservoirCellResultsStorage* gridCellResults = resultColors->currentGridCellResults();
if (gridCellResults)
{
size_t soilScalarSetIndex = gridCellResults->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SOIL");
size_t sgasScalarSetIndex = gridCellResults->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SGAS");
size_t swatScalarSetIndex = gridCellResults->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SWAT");
size_t soilScalarSetIndex = gridCellResults->findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "SOIL");
size_t sgasScalarSetIndex = gridCellResults->findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "SGAS");
size_t swatScalarSetIndex = gridCellResults->findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "SWAT");
cvf::ref<RigResultAccessor> dataAccessObjectX = RigResultAccessorFactory::createFromResultIdx(eclipseCase, gridIndex, porosityModel, timeStepIndex, soilScalarSetIndex);
cvf::ref<RigResultAccessor> dataAccessObjectY = RigResultAccessorFactory::createFromResultIdx(eclipseCase, gridIndex, porosityModel, timeStepIndex, sgasScalarSetIndex);
@ -411,9 +411,9 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigEclipseCaseData* eclips
if (resultColors->hasStaticResult())
{
if (resultColors->resultVariable().compare(RimDefines::combinedTransmissibilityResultName(), Qt::CaseInsensitive) == 0)
if (resultColors->resultVariable().compare(RiaDefines::combinedTransmissibilityResultName(), Qt::CaseInsensitive) == 0)
{
cvf::ref<RigResultAccessor> transResultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedTransmissibilityResultName());
cvf::ref<RigResultAccessor> transResultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RiaDefines::combinedTransmissibilityResultName());
{
double scalarValue = transResultAccessor->cellFaceScalar(cellIndex, cvf::StructGridInterface::POS_I);
resultInfoText->append(QString("Tran X : %1\n").arg(scalarValue));
@ -427,9 +427,9 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigEclipseCaseData* eclips
return;
}
else if (resultColors->resultVariable().compare(RimDefines::combinedMultResultName(), Qt::CaseInsensitive) == 0)
else if (resultColors->resultVariable().compare(RiaDefines::combinedMultResultName(), Qt::CaseInsensitive) == 0)
{
cvf::ref<RigResultAccessor> multResultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedMultResultName());
cvf::ref<RigResultAccessor> multResultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RiaDefines::combinedMultResultName());
{
double scalarValue = multResultAccessor->cellFaceScalar(cellIndex, cvf::StructGridInterface::POS_I);
resultInfoText->append(QString("MULTX : %1\n").arg(scalarValue));
@ -449,9 +449,9 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigEclipseCaseData* eclips
return;
}
else if (resultColors->resultVariable().compare(RimDefines::combinedRiTranResultName(), Qt::CaseInsensitive) == 0)
else if (resultColors->resultVariable().compare(RiaDefines::combinedRiTranResultName(), Qt::CaseInsensitive) == 0)
{
cvf::ref<RigResultAccessor> transResultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedRiTranResultName());
cvf::ref<RigResultAccessor> transResultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RiaDefines::combinedRiTranResultName());
{
double scalarValue = transResultAccessor->cellFaceScalar(cellIndex, cvf::StructGridInterface::POS_I);
resultInfoText->append(QString("riTran X : %1\n").arg(scalarValue));
@ -465,9 +465,9 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigEclipseCaseData* eclips
return;
}
else if (resultColors->resultVariable().compare(RimDefines::combinedRiMultResultName(), Qt::CaseInsensitive) == 0)
else if (resultColors->resultVariable().compare(RiaDefines::combinedRiMultResultName(), Qt::CaseInsensitive) == 0)
{
cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedRiMultResultName());
cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RiaDefines::combinedRiMultResultName());
{
double scalarValue = resultAccessor->cellFaceScalar(cellIndex, cvf::StructGridInterface::POS_I);
resultInfoText->append(QString("riMult X : %1\n").arg(scalarValue));
@ -481,9 +481,9 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigEclipseCaseData* eclips
return;
}
else if (resultColors->resultVariable().compare(RimDefines::combinedRiAreaNormTranResultName(), Qt::CaseInsensitive) == 0)
else if (resultColors->resultVariable().compare(RiaDefines::combinedRiAreaNormTranResultName(), Qt::CaseInsensitive) == 0)
{
cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedRiAreaNormTranResultName());
cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RiaDefines::combinedRiAreaNormTranResultName());
{
double scalarValue = resultAccessor->cellFaceScalar(cellIndex, cvf::StructGridInterface::POS_I);
resultInfoText->append(QString("riTransByArea X : %1\n").arg(scalarValue));
@ -662,9 +662,9 @@ QString RiuResultTextBuilder::cellResultText(RimEclipseCellColors* resultColors)
RimReservoirCellResultsStorage* gridCellResults = m_reservoirView->cellResult()->currentGridCellResults();
if (gridCellResults)
{
size_t soilScalarSetIndex = gridCellResults->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SOIL");
size_t sgasScalarSetIndex = gridCellResults->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SGAS");
size_t swatScalarSetIndex = gridCellResults->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SWAT");
size_t soilScalarSetIndex = gridCellResults->findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "SOIL");
size_t sgasScalarSetIndex = gridCellResults->findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "SGAS");
size_t swatScalarSetIndex = gridCellResults->findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "SWAT");
RifReaderInterface::PorosityModelResultType porosityModel = RigCaseCellResultsData::convertFromProjectModelPorosityModel(resultColors->porosityModel());

2
ApplicationCode/UserInterface/RiuSelectionChangedHandler.cpp
View File

@ -103,7 +103,7 @@ void RiuSelectionChangedHandler::addCurveFromSelectionItem(const RiuEclipseSelec
{
RimEclipseView* eclipseView = eclipseSelectionItem->m_view.p();
if (eclipseView->cellResult()->resultType() == RimDefines::FLOW_DIAGNOSTICS)
if (eclipseView->cellResult()->resultType() == RiaDefines::FLOW_DIAGNOSTICS)
{
// NB! Do not read out data for flow results, as this can be a time consuming operation

4
ApplicationCode/UserInterface/RiuViewerCommands.cpp
View File

@ -38,7 +38,7 @@
#include "RimCellEdgeColors.h"
#include "RimContextCommandBuilder.h"
#include "RimIntersection.h"
#include "RimDefines.h"
#include "RiaDefines.h"
#include "RimEclipseCase.h"
#include "RimEclipseCellColors.h"
#include "RimEclipseFaultColors.h"
@ -239,7 +239,7 @@ void RiuViewerCommands::displayContextMenu(QMouseEvent* event)
QAction* propertyAction = new QAction(QIcon(":/CellFilter_Values.png"), QString("Add property filter"), this);
connect(propertyAction, SIGNAL(triggered()), SLOT(slotAddEclipsePropertyFilter()));
bool isPerCellFaceResult = RimDefines::isPerCellFaceResult(cellColors->resultVariable());
bool isPerCellFaceResult = RiaDefines::isPerCellFaceResult(cellColors->resultVariable());
if (isPerCellFaceResult)
{
propertyAction->setEnabled(false);