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

#1755 Use namespace RiaDefines instead of class

Browse Source
This commit is contained in:
Magne Sjaastad
2017-08-11 14:05:59 +02:00
parent 8f3a7a5867
commit 89684c243f
49 changed files with 507 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
ApplicationCode/Application/RiaDefines.cpp
View File

@@ -100,3 +100,211 @@ bool RiaDefines::isPerCellFaceResult(const QString& resultName)
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::undefinedResultName()
{
return "None";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::undefinedGridFaultName()
{
return "Undefined Grid Faults";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::undefinedGridFaultWithInactiveName()
{
return "Undefined Grid Faults With Inactive";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::combinedTransmissibilityResultName()
{
return "TRANXYZ";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::ternarySaturationResultName()
{
return "TERNARY";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::combinedMultResultName()
{
return "MULTXYZ";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::riTranXResultName()
{
return "riTRANX";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::riTranYResultName()
{
return "riTRANY";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::riTranZResultName()
{
return "riTRANZ";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::combinedRiTranResultName()
{
return "riTRANXYZ";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::riMultXResultName()
{
return "riMULTX";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::riMultYResultName()
{
return "riMULTY";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::riMultZResultName()
{
return "riMULTZ";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::combinedRiMultResultName()
{
return "riMULTXYZ";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::riAreaNormTranXResultName()
{
return "riTRANXbyArea";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::riAreaNormTranYResultName()
{
return "riTRANYbyArea";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::riAreaNormTranZResultName()
{
return "riTRANZbyArea";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::combinedRiAreaNormTranResultName()
{
return "riTRANXYZbyArea";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::completionTypeResultName()
{
return "Completion Type";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::mockModelBasic()
{
return "Result Mock Debug Model Simple";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::mockModelBasicWithResults()
{
return "Result Mock Debug Model With Results";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::mockModelLargeWithResults()
{
return "Result Mock Debug Model Large With Results";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::mockModelCustomized()
{
return "Result Mock Debug Model Customized";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::mockModelBasicInputCase()
{
return "Input Mock Debug Model Simple";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RiaDefines::minimumDefaultValuePlot()
{
return -10.0;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RiaDefines::maximumDefaultValuePlot()
{
return 100.0;
}

58
ApplicationCode/Application/RiaDefines.h
View File

@@ -22,10 +22,8 @@
#include <QString>
class RiaDefines
namespace RiaDefines
{
public:
enum ResultCatType
{
DYNAMIC_NATIVE,
@@ -43,38 +41,38 @@ public:
FISHBONES
};
static bool isPerCellFaceResult(const QString& resultName);
bool isPerCellFaceResult(const QString& resultName);
static QString undefinedResultName() { return "None"; }
static QString undefinedGridFaultName() { return "Undefined Grid Faults"; }
static QString undefinedGridFaultWithInactiveName() { return "Undefined Grid Faults With Inactive"; }
static QString combinedTransmissibilityResultName() { return "TRANXYZ"; }
static QString ternarySaturationResultName() { return "TERNARY"; }
static QString combinedMultResultName() { return "MULTXYZ"; }
QString undefinedResultName();
QString undefinedGridFaultName();
QString undefinedGridFaultWithInactiveName();
QString combinedTransmissibilityResultName();
QString ternarySaturationResultName();
QString combinedMultResultName();
static QString riTranXResultName() { return "riTRANX"; }
static QString riTranYResultName() { return "riTRANY"; }
static QString riTranZResultName() { return "riTRANZ"; }
static QString combinedRiTranResultName() { return "riTRANXYZ"; }
QString riTranXResultName();
QString riTranYResultName();
QString riTranZResultName();
QString combinedRiTranResultName();
static QString riMultXResultName() { return "riMULTX"; }
static QString riMultYResultName() { return "riMULTY"; }
static QString riMultZResultName() { return "riMULTZ"; }
static QString combinedRiMultResultName() { return "riMULTXYZ"; }
QString riMultXResultName();
QString riMultYResultName();
QString riMultZResultName();
QString combinedRiMultResultName();
static QString riAreaNormTranXResultName() { return "riTRANXbyArea"; }
static QString riAreaNormTranYResultName() { return "riTRANYbyArea"; }
static QString riAreaNormTranZResultName() { return "riTRANZbyArea"; }
static QString combinedRiAreaNormTranResultName() { return "riTRANXYZbyArea"; }
QString riAreaNormTranXResultName();
QString riAreaNormTranYResultName();
QString riAreaNormTranZResultName();
QString combinedRiAreaNormTranResultName();
static QString completionTypeResultName() { return "Completion Type"; }
QString completionTypeResultName();
// Mock model text identifiers
static QString mockModelBasic() { return "Result Mock Debug Model Simple"; }
static QString mockModelBasicWithResults() { return "Result Mock Debug Model With Results"; }
static QString mockModelLargeWithResults() { return "Result Mock Debug Model Large With Results"; }
static QString mockModelCustomized() { return "Result Mock Debug Model Customized"; }
static QString mockModelBasicInputCase() { return "Input Mock Debug Model Simple"; }
QString mockModelBasic();
QString mockModelBasicWithResults();
QString mockModelLargeWithResults();
QString mockModelCustomized();
QString mockModelBasicInputCase();
//Units and conversions
@@ -94,7 +92,7 @@ public:
PLOT_AXIS_RIGHT
};
static double minimumDefaultValuePlot() { return - 10.0; }
static double maximumDefaultValuePlot() { return 100.0; }
double minimumDefaultValuePlot();
double maximumDefaultValuePlot();
};

8
ApplicationCode/Application/RiaPorosityModel.cpp
View File

@@ -22,10 +22,10 @@
template<>
void caf::AppEnum< RiaPorosityModel::PorosityModelType >::setUp()
void caf::AppEnum< RiaDefines::PorosityModelType >::setUp()
{
addItem(RiaPorosityModel::MATRIX_MODEL, "MATRIX_MODEL", "Matrix");
addItem(RiaPorosityModel::FRACTURE_MODEL, "FRACTURE_MODEL", "Fracture");
addItem(RiaDefines::MATRIX_MODEL, "MATRIX_MODEL", "Matrix");
addItem(RiaDefines::FRACTURE_MODEL, "FRACTURE_MODEL", "Fracture");
setDefault(RiaPorosityModel::MATRIX_MODEL);
setDefault(RiaDefines::MATRIX_MODEL);
}

4
ApplicationCode/Application/RiaPorosityModel.h
View File

@@ -21,9 +21,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
class RiaPorosityModel
{
public:
namespace RiaDefines {
enum PorosityModelType
{
MATRIX_MODEL,

2
ApplicationCode/Commands/CompletionCommands/RicFishbonesTransmissibilityCalculationFeatureImp.cpp
View File

@@ -86,7 +86,7 @@ std::vector<RigCompletionData> RicFishbonesTransmissibilityCalculationFeatureImp
std::vector<RigCompletionData> completionData;
RigMainGrid* grid = settings.caseToApply->eclipseCaseData()->mainGrid();
const RigActiveCellInfo* activeCellInfo = settings.caseToApply->eclipseCaseData()->activeCellInfo(RiaPorosityModel::MATRIX_MODEL);
const RigActiveCellInfo* activeCellInfo = settings.caseToApply->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL);
for (auto cellAndWellBoreParts : wellBorePartsInCells)
{

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

@@ -582,7 +582,7 @@ std::vector<RigCompletionData> RicWellPathExportCompletionDataFeature::generateP
RiaEclipseUnitTools::UnitSystem unitSystem = settings.caseToApply->eclipseCaseData()->unitsType();
std::vector<RigCompletionData> completionData;
const RigActiveCellInfo* activeCellInfo = settings.caseToApply->eclipseCaseData()->activeCellInfo(RiaPorosityModel::MATRIX_MODEL);
const RigActiveCellInfo* activeCellInfo = settings.caseToApply->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL);
for (const RimPerforationInterval* interval : wellPath->perforationIntervalCollection()->perforations())
@@ -813,12 +813,12 @@ CellDirection RicWellPathExportCompletionDataFeature::calculateDirectionInCell(R
{
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DX");
cvf::ref<RigResultAccessor> dxAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "DX");
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DY");
cvf::ref<RigResultAccessor> dyAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "DY");
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DZ");
cvf::ref<RigResultAccessor> dzAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "DZ");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DX");
cvf::ref<RigResultAccessor> dxAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DX");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DY");
cvf::ref<RigResultAccessor> dyAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DY");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DZ");
cvf::ref<RigResultAccessor> dzAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DZ");
double xLengthFraction = abs(lengthsInCell.x() / dxAccessObject->cellScalarGlobIdx(cellIndex));
double yLengthFraction = abs(lengthsInCell.y() / dyAccessObject->cellScalarGlobIdx(cellIndex));
@@ -852,19 +852,19 @@ double RicWellPathExportCompletionDataFeature::calculateTransmissibility(RimEcli
{
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DX");
cvf::ref<RigResultAccessor> dxAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "DX");
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DY");
cvf::ref<RigResultAccessor> dyAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "DY");
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DZ");
cvf::ref<RigResultAccessor> dzAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "DZ");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DX");
cvf::ref<RigResultAccessor> dxAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DX");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DY");
cvf::ref<RigResultAccessor> dyAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DY");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DZ");
cvf::ref<RigResultAccessor> dzAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DZ");
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMX");
cvf::ref<RigResultAccessor> permxAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "PERMX");
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMY");
cvf::ref<RigResultAccessor> permyAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "PERMY");
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMZ");
cvf::ref<RigResultAccessor> permzAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "PERMZ");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMX");
cvf::ref<RigResultAccessor> permxAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMX");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMY");
cvf::ref<RigResultAccessor> permyAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMY");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMZ");
cvf::ref<RigResultAccessor> permzAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMZ");
double dx = dxAccessObject->cellScalarGlobIdx(cellIndex);
double dy = dyAccessObject->cellScalarGlobIdx(cellIndex);
@@ -901,19 +901,19 @@ double RicWellPathExportCompletionDataFeature::calculateTransmissibilityAsEclips
{
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DX");
cvf::ref<RigResultAccessor> dxAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "DX");
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DY");
cvf::ref<RigResultAccessor> dyAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "DY");
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DZ");
cvf::ref<RigResultAccessor> dzAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "DZ");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DX");
cvf::ref<RigResultAccessor> dxAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DX");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DY");
cvf::ref<RigResultAccessor> dyAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DY");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "DZ");
cvf::ref<RigResultAccessor> dzAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "DZ");
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMX");
cvf::ref<RigResultAccessor> permxAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "PERMX");
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMY");
cvf::ref<RigResultAccessor> permyAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "PERMY");
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMZ");
cvf::ref<RigResultAccessor> permzAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaPorosityModel::MATRIX_MODEL, 0, "PERMZ");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMX");
cvf::ref<RigResultAccessor> permxAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMX");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMY");
cvf::ref<RigResultAccessor> permyAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMY");
eclipseCase->results(RiaDefines::MATRIX_MODEL)->findOrLoadScalarResult(RiaDefines::STATIC_NATIVE, "PERMZ");
cvf::ref<RigResultAccessor> permzAccessObject = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, 0, RiaDefines::MATRIX_MODEL, 0, "PERMZ");
double dx = dxAccessObject->cellScalarGlobIdx(cellIndex);
double dy = dyAccessObject->cellScalarGlobIdx(cellIndex);

2
ApplicationCode/Commands/ExportCommands/RicCellRangeUi.cpp
View File

@@ -260,7 +260,7 @@ RigActiveCellInfo* RicCellRangeUi::activeCellInfo() const
RimEclipseCase* rimEclipeCase = dynamic_cast<RimEclipseCase*>(m_case());
if (rimEclipeCase && rimEclipeCase->eclipseCaseData())
{
return rimEclipeCase->eclipseCaseData()->activeCellInfo(RiaPorosityModel::MATRIX_MODEL);
return rimEclipeCase->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL);
}
return nullptr;

14
ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp
View File

@@ -231,7 +231,7 @@ std::map<QString, QString> RifEclipseInputFileTools::readProperties(const QStrin
ecl_kw_type* eclipseKeywordData = ecl_kw_fscanf_alloc_current_grdecl__(gridFilePointer, false, ecl_type_create_from_type(ECL_FLOAT_TYPE));
if (eclipseKeywordData)
{
QString newResultName = caseData->results(RiaPorosityModel::MATRIX_MODEL)->makeResultNameUnique(fileKeywords[i].keyword);
QString newResultName = caseData->results(RiaDefines::MATRIX_MODEL)->makeResultNameUnique(fileKeywords[i].keyword);
if (readDataFromKeyword(eclipseKeywordData, caseData, newResultName))
{
newResults[newResultName] = fileKeywords[i].keyword;
@@ -290,7 +290,7 @@ bool RifEclipseInputFileTools::readDataFromKeyword(ecl_kw_type* eclipseKeywordDa
{
mathingItemCount = true;
}
if (itemCount == caseData->activeCellInfo(RiaPorosityModel::MATRIX_MODEL)->reservoirActiveCellCount())
if (itemCount == caseData->activeCellInfo(RiaDefines::MATRIX_MODEL)->reservoirActiveCellCount())
{
mathingItemCount = true;
}
@@ -301,7 +301,7 @@ bool RifEclipseInputFileTools::readDataFromKeyword(ecl_kw_type* eclipseKeywordDa
size_t resultIndex = RifEclipseInputFileTools::findOrCreateResult(resultName, caseData);
if (resultIndex == cvf::UNDEFINED_SIZE_T) return false;
std::vector< std::vector<double> >& newPropertyData = caseData->results(RiaPorosityModel::MATRIX_MODEL)->cellScalarResults(resultIndex);
std::vector< std::vector<double> >& newPropertyData = caseData->results(RiaDefines::MATRIX_MODEL)->cellScalarResults(resultIndex);
newPropertyData.push_back(std::vector<double>());
newPropertyData[0].resize(ecl_kw_get_size(eclipseKeywordData), HUGE_VAL);
ecl_kw_get_data_as_double(eclipseKeywordData, newPropertyData[0].data());
@@ -446,7 +446,7 @@ bool RifEclipseInputFileTools::writePropertyToTextFile(const QString& fileName,
{
CVF_ASSERT(eclipseCase);
size_t resultIndex = eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->findScalarResultIndex(resultName);
size_t resultIndex = eclipseCase->results(RiaDefines::MATRIX_MODEL)->findScalarResultIndex(resultName);
if (resultIndex == cvf::UNDEFINED_SIZE_T)
{
return false;
@@ -458,7 +458,7 @@ bool RifEclipseInputFileTools::writePropertyToTextFile(const QString& fileName,
return false;
}
std::vector< std::vector<double> >& resultData = eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->cellScalarResults(resultIndex);
std::vector< std::vector<double> >& resultData = eclipseCase->results(RiaDefines::MATRIX_MODEL)->cellScalarResults(resultIndex);
if (resultData.size() == 0)
{
return false;
@@ -717,10 +717,10 @@ qint64 RifEclipseInputFileTools::findKeyword(const QString& keyword, QFile& file
//--------------------------------------------------------------------------------------------------
size_t RifEclipseInputFileTools::findOrCreateResult(const QString& newResultName, RigEclipseCaseData* reservoir)
{
size_t resultIndex = reservoir->results(RiaPorosityModel::MATRIX_MODEL)->findScalarResultIndex(newResultName);
size_t resultIndex = reservoir->results(RiaDefines::MATRIX_MODEL)->findScalarResultIndex(newResultName);
if (resultIndex == cvf::UNDEFINED_SIZE_T)
{
resultIndex = reservoir->results(RiaPorosityModel::MATRIX_MODEL)->addEmptyScalarResult(RiaDefines::INPUT_PROPERTY, newResultName, false);
resultIndex = reservoir->results(RiaDefines::MATRIX_MODEL)->addEmptyScalarResult(RiaDefines::INPUT_PROPERTY, newResultName, false);
}
return resultIndex;

4
ApplicationCode/FileInterface/RifReaderEclipseInput.h
View File

@@ -38,6 +38,6 @@ public:
virtual void close() {}
virtual bool staticResult(const QString& result, RiaPorosityModel::PorosityModelType matrixOrFracture, std::vector<double>* values ) { return false; }
virtual bool dynamicResult(const QString& result, RiaPorosityModel::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values ) { return false; }
virtual bool staticResult(const QString& result, RiaDefines::PorosityModelType matrixOrFracture, std::vector<double>* values ) { return false; }
virtual bool dynamicResult(const QString& result, RiaDefines::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values ) { return false; }
};

58
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@@ -242,8 +242,8 @@ bool RifReaderEclipseOutput::transferGeometry(const ecl_grid_type* mainEclGrid,
return false;
}
RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo(RiaPorosityModel::MATRIX_MODEL);
RigActiveCellInfo* fractureActiveCellInfo = eclipseCase->activeCellInfo(RiaPorosityModel::FRACTURE_MODEL);
RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL);
RigActiveCellInfo* fractureActiveCellInfo = eclipseCase->activeCellInfo(RiaDefines::FRACTURE_MODEL);
CVF_ASSERT(activeCellInfo && fractureActiveCellInfo);
@@ -580,8 +580,8 @@ bool RifReaderEclipseOutput::readActiveCellInfo()
return false;
}
RigActiveCellInfo* activeCellInfo = m_eclipseCase->activeCellInfo(RiaPorosityModel::MATRIX_MODEL);
RigActiveCellInfo* fractureActiveCellInfo = m_eclipseCase->activeCellInfo(RiaPorosityModel::FRACTURE_MODEL);
RigActiveCellInfo* activeCellInfo = m_eclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL);
RigActiveCellInfo* fractureActiveCellInfo = m_eclipseCase->activeCellInfo(RiaDefines::FRACTURE_MODEL);
activeCellInfo->setReservoirCellCount(reservoirCellCount);
fractureActiveCellInfo->setReservoirCellCount(reservoirCellCount);
@@ -644,8 +644,8 @@ void RifReaderEclipseOutput::buildMetaData()
progInfo.setNextProgressIncrement(m_filesWithSameBaseName.size());
RigCaseCellResultsData* matrixModelResults = m_eclipseCase->results(RiaPorosityModel::MATRIX_MODEL);
RigCaseCellResultsData* fractureModelResults = m_eclipseCase->results(RiaPorosityModel::FRACTURE_MODEL);
RigCaseCellResultsData* matrixModelResults = m_eclipseCase->results(RiaDefines::MATRIX_MODEL);
RigCaseCellResultsData* fractureModelResults = m_eclipseCase->results(RiaDefines::FRACTURE_MODEL);
std::vector<RigTimeStepInfo> timeStepInfos;
@@ -665,9 +665,9 @@ void RifReaderEclipseOutput::buildMetaData()
{
QStringList matrixResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo(RiaPorosityModel::MATRIX_MODEL),
m_eclipseCase->activeCellInfo(RiaPorosityModel::FRACTURE_MODEL),
RiaPorosityModel::MATRIX_MODEL, m_dynamicResultsAccess->timeStepCount());
m_eclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL),
m_eclipseCase->activeCellInfo(RiaDefines::FRACTURE_MODEL),
RiaDefines::MATRIX_MODEL, m_dynamicResultsAccess->timeStepCount());
for (int i = 0; i < matrixResultNames.size(); ++i)
{
@@ -678,9 +678,9 @@ void RifReaderEclipseOutput::buildMetaData()
{
QStringList fractureResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo(RiaPorosityModel::MATRIX_MODEL),
m_eclipseCase->activeCellInfo(RiaPorosityModel::FRACTURE_MODEL),
RiaPorosityModel::FRACTURE_MODEL, m_dynamicResultsAccess->timeStepCount());
m_eclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL),
m_eclipseCase->activeCellInfo(RiaDefines::FRACTURE_MODEL),
RiaDefines::FRACTURE_MODEL, m_dynamicResultsAccess->timeStepCount());
for (int i = 0; i < fractureResultNames.size(); ++i)
{
@@ -729,9 +729,9 @@ void RifReaderEclipseOutput::buildMetaData()
{
QStringList matrixResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo(RiaPorosityModel::MATRIX_MODEL),
m_eclipseCase->activeCellInfo(RiaPorosityModel::FRACTURE_MODEL),
RiaPorosityModel::MATRIX_MODEL, 1);
m_eclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL),
m_eclipseCase->activeCellInfo(RiaDefines::FRACTURE_MODEL),
RiaDefines::MATRIX_MODEL, 1);
// Add ACTNUM
matrixResultNames += "ACTNUM";
@@ -745,9 +745,9 @@ void RifReaderEclipseOutput::buildMetaData()
{
QStringList fractureResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo(RiaPorosityModel::MATRIX_MODEL),
m_eclipseCase->activeCellInfo(RiaPorosityModel::FRACTURE_MODEL),
RiaPorosityModel::FRACTURE_MODEL, 1);
m_eclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL),
m_eclipseCase->activeCellInfo(RiaDefines::FRACTURE_MODEL),
RiaDefines::FRACTURE_MODEL, 1);
// Add ACTNUM
fractureResultNames += "ACTNUM";
@@ -791,7 +791,7 @@ RifEclipseRestartDataAccess* RifReaderEclipseOutput::createDynamicResultsAccess(
//--------------------------------------------------------------------------------------------------
/// Get all values of a given static result as doubles
//--------------------------------------------------------------------------------------------------
bool RifReaderEclipseOutput::staticResult(const QString& result, RiaPorosityModel::PorosityModelType matrixOrFracture, std::vector<double>* values)
bool RifReaderEclipseOutput::staticResult(const QString& result, RiaDefines::PorosityModelType matrixOrFracture, std::vector<double>* values)
{
CVF_ASSERT(values);
@@ -827,7 +827,7 @@ bool RifReaderEclipseOutput::staticResult(const QString& result, RiaPorosityMode
//--------------------------------------------------------------------------------------------------
/// Get dynamic result at given step index. Will concatenate values for the main grid and all sub grids.
//--------------------------------------------------------------------------------------------------
bool RifReaderEclipseOutput::dynamicResult(const QString& result, RiaPorosityModel::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values)
bool RifReaderEclipseOutput::dynamicResult(const QString& result, RiaDefines::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values)
{
if (m_dynamicResultsAccess.isNull())
{
@@ -1666,7 +1666,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel(const QStringL
const std::vector<size_t>& keywordDataItemCounts,
const RigActiveCellInfo* matrixActiveCellInfo,
const RigActiveCellInfo* fractureActiveCellInfo,
RiaPorosityModel::PorosityModelType porosityModel,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepCount) const
{
CVF_ASSERT(matrixActiveCellInfo);
@@ -1676,7 +1676,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel(const QStringL
return QStringList();
}
if (porosityModel == RiaPorosityModel::FRACTURE_MODEL)
if (porosityModel == RiaDefines::FRACTURE_MODEL)
{
if (fractureActiveCellInfo->reservoirActiveCellCount() == 0)
{
@@ -1712,14 +1712,14 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel(const QStringL
size_t sumFractureMatrixActiveCellCount = matrixActiveCellInfo->reservoirActiveCellCount() + fractureActiveCellInfo->reservoirActiveCellCount();
size_t timeStepsMatrixAndFractureRest = keywordDataItemCount % sumFractureMatrixActiveCellCount;
if (porosityModel == RiaPorosityModel::MATRIX_MODEL && timeStepsMatrixRest == 0)
if (porosityModel == RiaDefines::MATRIX_MODEL && timeStepsMatrixRest == 0)
{
if (keywordDataItemCount <= timeStepCount * std::max(matrixActiveCellInfo->reservoirActiveCellCount(), sumFractureMatrixActiveCellCount))
{
validKeyword = true;
}
}
else if (porosityModel == RiaPorosityModel::FRACTURE_MODEL && fractureActiveCellInfo->reservoirActiveCellCount() > 0 && timeStepsFractureRest == 0)
else if (porosityModel == RiaDefines::FRACTURE_MODEL && fractureActiveCellInfo->reservoirActiveCellCount() > 0 && timeStepsFractureRest == 0)
{
if (keywordDataItemCount <= timeStepCount * std::max(fractureActiveCellInfo->reservoirActiveCellCount(), sumFractureMatrixActiveCellCount))
{
@@ -1793,19 +1793,19 @@ std::vector<RigTimeStepInfo> RifReaderEclipseOutput::createFilteredTimeStepInfos
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel(RiaPorosityModel::PorosityModelType matrixOrFracture, std::vector<double>* destinationResultValues, const std::vector<double>& sourceResultValues)
void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel(RiaDefines::PorosityModelType matrixOrFracture, std::vector<double>* destinationResultValues, const std::vector<double>& sourceResultValues)
{
if (sourceResultValues.size() == 0) return;
RigActiveCellInfo* fracActCellInfo = m_eclipseCase->activeCellInfo(RiaPorosityModel::FRACTURE_MODEL);
RigActiveCellInfo* fracActCellInfo = m_eclipseCase->activeCellInfo(RiaDefines::FRACTURE_MODEL);
if (matrixOrFracture == RiaPorosityModel::MATRIX_MODEL && fracActCellInfo->reservoirActiveCellCount() == 0)
if (matrixOrFracture == RiaDefines::MATRIX_MODEL && fracActCellInfo->reservoirActiveCellCount() == 0)
{
destinationResultValues->insert(destinationResultValues->end(), sourceResultValues.begin(), sourceResultValues.end());
}
else
{
RigActiveCellInfo* actCellInfo = m_eclipseCase->activeCellInfo(RiaPorosityModel::MATRIX_MODEL);
RigActiveCellInfo* actCellInfo = m_eclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL);
size_t sourceStartPosition = 0;
@@ -1817,7 +1817,7 @@ void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel(RiaPorosity
actCellInfo->gridActiveCellCounts(i, matrixActiveCellCount);
fracActCellInfo->gridActiveCellCounts(i, fractureActiveCellCount);
if (matrixOrFracture == RiaPorosityModel::MATRIX_MODEL)
if (matrixOrFracture == RiaDefines::MATRIX_MODEL)
{
destinationResultValues->insert(destinationResultValues->end(),
sourceResultValues.begin() + sourceStartPosition,

8
ApplicationCode/FileInterface/RifReaderEclipseOutput.h
View File

@@ -54,8 +54,8 @@ public:
virtual bool openAndReadActiveCellData(const QString& fileName, const std::vector<QDateTime>& mainCaseTimeSteps, RigEclipseCaseData* eclipseCase);
void close();
bool staticResult(const QString& result, RiaPorosityModel::PorosityModelType matrixOrFracture, std::vector<double>* values);
bool dynamicResult(const QString& result, RiaPorosityModel::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values);
bool staticResult(const QString& result, RiaDefines::PorosityModelType matrixOrFracture, std::vector<double>* values);
bool dynamicResult(const QString& result, RiaDefines::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values);
static bool transferGeometry(const ecl_grid_type* mainEclGrid, RigEclipseCaseData* eclipseCase);
static void transferCoarseningInfo(const ecl_grid_type* eclGrid, RigGridBase* grid);
@@ -73,13 +73,13 @@ private:
void openInitFile();
void extractResultValuesBasedOnPorosityModel(RiaPorosityModel::PorosityModelType matrixOrFracture, std::vector<double>* values, const std::vector<double>& fileValues);
void extractResultValuesBasedOnPorosityModel(RiaDefines::PorosityModelType matrixOrFracture, std::vector<double>* values, const std::vector<double>& fileValues);
void transferNNCData( const ecl_grid_type * mainEclGrid , const ecl_file_type * init_file,
RigMainGrid * mainGrid);
RifEclipseRestartDataAccess* createDynamicResultsAccess();
QStringList validKeywordsForPorosityModel(const QStringList& keywords, const std::vector<size_t>& keywordDataItemCounts, const RigActiveCellInfo* activeCellInfo, const RigActiveCellInfo* fractureActiveCellInfo, RiaPorosityModel::PorosityModelType matrixOrFracture, size_t timeStepCount) const;
QStringList validKeywordsForPorosityModel(const QStringList& keywords, const std::vector<size_t>& keywordDataItemCounts, const RigActiveCellInfo* activeCellInfo, const RigActiveCellInfo* fractureActiveCellInfo, RiaDefines::PorosityModelType matrixOrFracture, size_t timeStepCount) const;
std::vector<RigTimeStepInfo> createFilteredTimeStepInfos();

4
ApplicationCode/FileInterface/RifReaderInterface.h
View File

@@ -59,8 +59,8 @@ public:
virtual bool open(const QString& fileName, RigEclipseCaseData* eclipseCase) = 0;
virtual void close() = 0;
virtual bool staticResult(const QString& result, RiaPorosityModel::PorosityModelType matrixOrFracture, std::vector<double>* values) = 0;
virtual bool dynamicResult(const QString& result, RiaPorosityModel::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values) = 0;
virtual bool staticResult(const QString& result, RiaDefines::PorosityModelType matrixOrFracture, std::vector<double>* values) = 0;
virtual bool dynamicResult(const QString& result, RiaDefines::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values) = 0;
void setFilenamesWithFaults(const std::vector<QString>& filenames) { m_filenamesWithFaults = filenames; }
std::vector<QString> filenamesWithFaults() { return m_filenamesWithFaults; }

6
ApplicationCode/FileInterface/RifReaderMockModel.cpp
View File

@@ -33,7 +33,7 @@ bool RifReaderMockModel::open(const QString& fileName, RigEclipseCaseData* eclip
m_reservoir = eclipseCase;
RigCaseCellResultsData* cellResults = eclipseCase->results(RiaPorosityModel::MATRIX_MODEL);
RigCaseCellResultsData* cellResults = eclipseCase->results(RiaDefines::MATRIX_MODEL);
std::vector<RigTimeStepInfo> timeStepInfos;
{
@@ -113,7 +113,7 @@ bool RifReaderMockModel::inputProperty(const QString& propertyName, std::vector<
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifReaderMockModel::staticResult(const QString& result, RiaPorosityModel::PorosityModelType matrixOrFracture, std::vector<double>* values)
bool RifReaderMockModel::staticResult(const QString& result, RiaDefines::PorosityModelType matrixOrFracture, std::vector<double>* values)
{
m_reservoirBuilder.staticResult(m_reservoir, result, values);
@@ -123,7 +123,7 @@ bool RifReaderMockModel::staticResult(const QString& result, RiaPorosityModel::P
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifReaderMockModel::dynamicResult(const QString& result, RiaPorosityModel::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values)
bool RifReaderMockModel::dynamicResult(const QString& result, RiaDefines::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values)
{
m_reservoirBuilder.dynamicResult(m_reservoir, result, stepIndex, values);

4
ApplicationCode/FileInterface/RifReaderMockModel.h
View File

@@ -39,8 +39,8 @@ public:
virtual bool open( const QString& fileName, RigEclipseCaseData* eclipseCase );
virtual void close();
virtual bool staticResult( const QString& result, RiaPorosityModel::PorosityModelType matrixOrFracture, std::vector<double>* values );
virtual bool dynamicResult( const QString& result, RiaPorosityModel::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values );
virtual bool staticResult( const QString& result, RiaDefines::PorosityModelType matrixOrFracture, std::vector<double>* values );
virtual bool dynamicResult( const QString& result, RiaDefines::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values );
private:
void populateReservoir(RigEclipseCaseData* eclipseCase);

2
ApplicationCode/ModelVisualization/RivCellEdgeGeometryUtils.cpp
View File

@@ -325,7 +325,7 @@ cvf::ref<RigResultAccessor> RivCellEdgeGeometryUtils::createCellEdgeResultAccess
adjustedTimeStep = 0;
}
RiaPorosityModel::PorosityModelType porosityModel = cellResultColors->porosityModel();
RiaDefines::PorosityModelType porosityModel = cellResultColors->porosityModel();
cvf::ref<RigResultAccessor> daObj = RigResultAccessorFactory::createFromResultIdx(eclipseCase, grid->gridIndex(), porosityModel, adjustedTimeStep, resultIndices[cubeFaceIdx]);
cellEdgeResultAccessor->setDataAccessObjectForFace(static_cast<cvf::StructGridInterface::FaceType>(cubeFaceIdx), daObj.p());
}

4
ApplicationCode/ModelVisualization/RivTernaryTextureCoordsCreator.cpp
View File

@@ -55,7 +55,7 @@ RivTernaryTextureCoordsCreator::RivTernaryTextureCoordsCreator(
if (cellResultColors->hasStaticResult()) resTimeStepIdx = 0;
RiaPorosityModel::PorosityModelType porosityModel = cellResultColors->porosityModel();
RiaDefines::PorosityModelType porosityModel = cellResultColors->porosityModel();
cvf::ref<RigResultAccessor> soil = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SOIL");
cvf::ref<RigResultAccessor> sgas = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SGAS");
@@ -89,7 +89,7 @@ RivTernaryTextureCoordsCreator::RivTernaryTextureCoordsCreator(
if (cellResultColors->hasStaticResult()) resTimeStepIdx = 0;
RiaPorosityModel::PorosityModelType porosityModel = cellResultColors->porosityModel();
RiaDefines::PorosityModelType porosityModel = cellResultColors->porosityModel();
size_t gridIndex = 0;
cvf::ref<RigResultAccessor> soil = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SOIL");

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

@@ -107,7 +107,7 @@ RigFlowDiagResults* RimFlowDiagSolution::flowDiagResults()
CVF_ASSERT(eclCase && eclCase->eclipseCaseData() );
timeStepCount = eclCase->eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL)->maxTimeStepCount();
timeStepCount = eclCase->eclipseCaseData()->results(RiaDefines::MATRIX_MODEL)->maxTimeStepCount();
}
@@ -171,7 +171,7 @@ std::map<std::string, std::vector<int> > RimFlowDiagSolution::allTracerActiveCel
{
const cvf::Collection<RigSingleWellResultsData>& wellResults = eclCase->eclipseCaseData()->wellResults();
RigMainGrid* mainGrid = eclCase->eclipseCaseData()->mainGrid();
RigActiveCellInfo* activeCellInfo = eclCase->eclipseCaseData()->activeCellInfo(RiaPorosityModel::MATRIX_MODEL); //Todo: Must come from the results definition
RigActiveCellInfo* activeCellInfo = eclCase->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL); //Todo: Must come from the results definition
for ( size_t wIdx = 0; wIdx < wellResults.size(); ++wIdx )
{

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

@@ -209,7 +209,7 @@ void RimWellAllocationPlot::updateFromWell()
{
bool isProducer = ( wellResults->wellProductionType(m_timeStep) == RigWellResultFrame::PRODUCER
|| wellResults->wellProductionType(m_timeStep) == RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE );
RigEclCellIndexCalculator cellIdxCalc(m_case->eclipseCaseData()->mainGrid(), m_case->eclipseCaseData()->activeCellInfo(RiaPorosityModel::MATRIX_MODEL));
RigEclCellIndexCalculator cellIdxCalc(m_case->eclipseCaseData()->mainGrid(), m_case->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL));
wfCalculator.reset(new RigAccWellFlowCalculator(pipeBranchesCLCoords,
pipeBranchesCellIds,
tracerFractionCellValues,

4
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

@@ -346,8 +346,8 @@ void Rim3dOverlayInfoConfig::updateEclipse3DInfo(RimEclipseView * eclipseView)
{
caseName = eclipseView->eclipseCase()->caseUserDescription();
totCellCount = QString::number(eclipseView->mainGrid()->globalCellArray().size());
size_t mxActCellCount = eclipseView->eclipseCase()->eclipseCaseData()->activeCellInfo(RiaPorosityModel::MATRIX_MODEL)->reservoirActiveCellCount();
size_t frActCellCount = eclipseView->eclipseCase()->eclipseCaseData()->activeCellInfo(RiaPorosityModel::FRACTURE_MODEL)->reservoirActiveCellCount();
size_t mxActCellCount = eclipseView->eclipseCase()->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL)->reservoirActiveCellCount();
size_t frActCellCount = eclipseView->eclipseCase()->eclipseCaseData()->activeCellInfo(RiaDefines::FRACTURE_MODEL)->reservoirActiveCellCount();
if (frActCellCount > 0) activeCellCountText += "Matrix : ";
activeCellCountText += QString::number(mxActCellCount);
if (frActCellCount > 0) activeCellCountText += " Fracture : " + QString::number(frActCellCount);

30
ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
View File

@@ -380,7 +380,7 @@ void RimEclipseCase::computeCachedData()
pInf.setNextProgressIncrement(17);
pInf.setProgressDescription("Calculating faults");
rigEclipseCase->mainGrid()->calculateFaults(rigEclipseCase->activeCellInfo(RiaPorosityModel::MATRIX_MODEL));
rigEclipseCase->mainGrid()->calculateFaults(rigEclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL));
pInf.incrementProgress();
pInf.setProgressDescription("Calculating Formation Names Result");
@@ -414,8 +414,8 @@ void RimEclipseCase::setReservoirData(RigEclipseCaseData* eclipseCase)
m_rigEclipseCase = eclipseCase;
if (this->eclipseCaseData())
{
m_fractureModelResults()->setCellResults(eclipseCaseData()->results(RiaPorosityModel::FRACTURE_MODEL));
m_matrixModelResults()->setCellResults(eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL));
m_fractureModelResults()->setCellResults(eclipseCaseData()->results(RiaDefines::FRACTURE_MODEL));
m_matrixModelResults()->setCellResults(eclipseCaseData()->results(RiaDefines::MATRIX_MODEL));
m_fractureModelResults()->setMainGrid(this->eclipseCaseData()->mainGrid());
m_matrixModelResults()->setMainGrid(this->eclipseCaseData()->mainGrid());
}
@@ -478,9 +478,9 @@ void RimEclipseCase::createTimeStepFormatString()
//--------------------------------------------------------------------------------------------------
cvf::BoundingBox RimEclipseCase::activeCellsBoundingBox() const
{
if (m_rigEclipseCase.notNull() && m_rigEclipseCase->activeCellInfo(RiaPorosityModel::MATRIX_MODEL))
if (m_rigEclipseCase.notNull() && m_rigEclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL))
{
return m_rigEclipseCase->activeCellInfo(RiaPorosityModel::MATRIX_MODEL)->geometryBoundingBox();
return m_rigEclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL)->geometryBoundingBox();
}
else
{
@@ -521,9 +521,9 @@ cvf::Vec3d RimEclipseCase::displayModelOffset() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimReservoirCellResultsStorage* RimEclipseCase::results(RiaPorosityModel::PorosityModelType porosityModel)
RimReservoirCellResultsStorage* RimEclipseCase::results(RiaDefines::PorosityModelType porosityModel)
{
if (porosityModel == RiaPorosityModel::MATRIX_MODEL)
if (porosityModel == RiaDefines::MATRIX_MODEL)
{
return m_matrixModelResults();
}
@@ -534,9 +534,9 @@ RimReservoirCellResultsStorage* RimEclipseCase::results(RiaPorosityModel::Porosi
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RimReservoirCellResultsStorage* RimEclipseCase::results(RiaPorosityModel::PorosityModelType porosityModel) const
const RimReservoirCellResultsStorage* RimEclipseCase::results(RiaDefines::PorosityModelType porosityModel) const
{
if (porosityModel == RiaPorosityModel::MATRIX_MODEL)
if (porosityModel == RiaDefines::MATRIX_MODEL)
{
return m_matrixModelResults();
}
@@ -592,7 +592,7 @@ bool RimEclipseCase::openReserviorCase()
}
{
RimReservoirCellResultsStorage* results = this->results(RiaPorosityModel::MATRIX_MODEL);
RimReservoirCellResultsStorage* results = this->results(RiaDefines::MATRIX_MODEL);
if (results->cellResults())
{
results->cellResults()->createPlaceholderResultEntries();
@@ -607,7 +607,7 @@ bool RimEclipseCase::openReserviorCase()
}
{
RimReservoirCellResultsStorage* results = this->results(RiaPorosityModel::FRACTURE_MODEL);
RimReservoirCellResultsStorage* results = this->results(RiaDefines::FRACTURE_MODEL);
if (results->cellResults()) results->cellResults()->createPlaceholderResultEntries();
}
@@ -636,7 +636,7 @@ QStringList RimEclipseCase::timeStepStrings() const
{
QStringList stringList;
int timeStepCount = static_cast<int>(results(RiaPorosityModel::MATRIX_MODEL)->cellResults()->maxTimeStepCount());
int timeStepCount = static_cast<int>(results(RiaDefines::MATRIX_MODEL)->cellResults()->maxTimeStepCount());
for (int i = 0; i < timeStepCount; i++)
{
stringList += this->timeStepName(i);
@@ -665,13 +665,13 @@ void RimEclipseCase::reloadDataAndUpdate()
{
if (this->eclipseCaseData())
{
RigCaseCellResultsData* matrixModelResults = eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL);
RigCaseCellResultsData* matrixModelResults = eclipseCaseData()->results(RiaDefines::MATRIX_MODEL);
if (matrixModelResults)
{
matrixModelResults->clearAllResults();
}
RigCaseCellResultsData* fractureModelResults = eclipseCaseData()->results(RiaPorosityModel::FRACTURE_MODEL);
RigCaseCellResultsData* fractureModelResults = eclipseCaseData()->results(RiaDefines::FRACTURE_MODEL);
if (fractureModelResults)
{
fractureModelResults->clearAllResults();
@@ -738,5 +738,5 @@ double RimEclipseCase::characteristicCellSize() const
//--------------------------------------------------------------------------------------------------
std::vector<QDateTime> RimEclipseCase::timeStepDates() const
{
return results(RiaPorosityModel::MATRIX_MODEL)->cellResults()->timeStepDates();
return results(RiaDefines::MATRIX_MODEL)->cellResults()->timeStepDates();
}

4
ApplicationCode/ProjectDataModel/RimEclipseCase.h
View File

@@ -73,8 +73,8 @@ public:
const RigEclipseCaseData* eclipseCaseData() const;
cvf::Color3f defaultWellColor(const QString& wellName);
RimReservoirCellResultsStorage* results(RiaPorosityModel::PorosityModelType porosityModel);
const RimReservoirCellResultsStorage* results(RiaPorosityModel::PorosityModelType porosityModel) const;
RimReservoirCellResultsStorage* results(RiaDefines::PorosityModelType porosityModel);
const RimReservoirCellResultsStorage* results(RiaDefines::PorosityModelType porosityModel) const;
RimEclipseView* createAndAddReservoirView();
RimEclipseView* createCopyAndAddView(const RimEclipseView* sourceView);

2
ApplicationCode/ProjectDataModel/RimEclipseCaseCollection.cpp
View File

@@ -171,7 +171,7 @@ RigMainGrid* RimEclipseCaseCollection::registerCaseInGridCollection(RigEclipseCa
// This is the first insertion of this grid, compute cached data
rigEclipseCase->mainGrid()->computeCachedData();
rigEclipseCase->mainGrid()->calculateFaults(rigEclipseCase->activeCellInfo(RiaPorosityModel::MATRIX_MODEL));
rigEclipseCase->mainGrid()->calculateFaults(rigEclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL));
equalGrid = rigEclipseCase->mainGrid();
}

18
ApplicationCode/ProjectDataModel/RimEclipseInputCase.cpp
View File

@@ -88,11 +88,11 @@ void RimEclipseInputCase::openDataFileSet(const QStringList& fileNames)
if (fileNames.contains(RiaDefines::mockModelBasicInputCase()))
{
cvf::ref<RifReaderInterface> readerInterface = this->createMockModel(fileNames[0]);
results(RiaPorosityModel::MATRIX_MODEL)->setReaderInterface(readerInterface.p());
results(RiaPorosityModel::FRACTURE_MODEL)->setReaderInterface(readerInterface.p());
results(RiaDefines::MATRIX_MODEL)->setReaderInterface(readerInterface.p());
results(RiaDefines::FRACTURE_MODEL)->setReaderInterface(readerInterface.p());
eclipseCaseData()->activeCellInfo(RiaPorosityModel::MATRIX_MODEL)->computeDerivedData();
eclipseCaseData()->activeCellInfo(RiaPorosityModel::FRACTURE_MODEL)->computeDerivedData();
eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL)->computeDerivedData();
eclipseCaseData()->activeCellInfo(RiaDefines::FRACTURE_MODEL)->computeDerivedData();
QFileInfo gridFileName(fileNames[0]);
QString caseName = gridFileName.completeBaseName();
@@ -206,8 +206,8 @@ bool RimEclipseInputCase::openEclipseGridFile()
CVF_ASSERT(this->eclipseCaseData());
CVF_ASSERT(readerInterface.notNull());
results(RiaPorosityModel::MATRIX_MODEL)->setReaderInterface(readerInterface.p());
results(RiaPorosityModel::FRACTURE_MODEL)->setReaderInterface(readerInterface.p());
results(RiaDefines::MATRIX_MODEL)->setReaderInterface(readerInterface.p());
results(RiaDefines::FRACTURE_MODEL)->setReaderInterface(readerInterface.p());
this->eclipseCaseData()->mainGrid()->setFlipAxis(flipXAxis, flipYAxis);
@@ -219,8 +219,8 @@ bool RimEclipseInputCase::openEclipseGridFile()
RiaApplication* app = RiaApplication::instance();
if (app->preferences()->autocomputeDepthRelatedProperties)
{
RimReservoirCellResultsStorage* matrixResults = results(RiaPorosityModel::MATRIX_MODEL);
RimReservoirCellResultsStorage* fractureResults = results(RiaPorosityModel::FRACTURE_MODEL);
RimReservoirCellResultsStorage* matrixResults = results(RiaDefines::MATRIX_MODEL);
RimReservoirCellResultsStorage* fractureResults = results(RiaDefines::FRACTURE_MODEL);
matrixResults->computeDepthRelatedResults();
fractureResults->computeDepthRelatedResults();
@@ -318,7 +318,7 @@ void RimEclipseInputCase::loadAndSyncronizeInputProperties()
for (const QString fileKeyword : fileKeywordSet)
{
{
QString resultName = this->eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL)->makeResultNameUnique(fileKeyword);
QString resultName = this->eclipseCaseData()->results(RiaDefines::MATRIX_MODEL)->makeResultNameUnique(fileKeyword);
if (RifEclipseInputFileTools::readProperty(filenames[i], this->eclipseCaseData(), fileKeyword, resultName))
{
RimEclipseInputProperty* inputProperty = new RimEclipseInputProperty;

4
ApplicationCode/ProjectDataModel/RimEclipseInputProperty.cpp
View File

@@ -91,7 +91,7 @@ void RimEclipseInputProperty::fieldChangedByUi(const caf::PdmFieldHandle* change
QString oldName = oldValue.toString();
QString newName = newValue.toString();
RigCaseCellResultsData* matrixResults = rimCase->eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL);
RigCaseCellResultsData* matrixResults = rimCase->eclipseCaseData()->results(RiaDefines::MATRIX_MODEL);
if (matrixResults)
{
if (matrixResults->updateResultName(RiaDefines::INPUT_PROPERTY, oldName, newName))
@@ -100,7 +100,7 @@ void RimEclipseInputProperty::fieldChangedByUi(const caf::PdmFieldHandle* change
}
}
RigCaseCellResultsData* fracResults = rimCase->eclipseCaseData()->results(RiaPorosityModel::FRACTURE_MODEL);
RigCaseCellResultsData* fracResults = rimCase->eclipseCaseData()->results(RiaDefines::FRACTURE_MODEL);
if (fracResults)
{
if (fracResults->updateResultName(RiaDefines::INPUT_PROPERTY, oldName, newName))

10
ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp
View File

@@ -128,8 +128,8 @@ bool RimEclipseResultCase::openEclipseGridFile()
this->setReservoirData( eclipseCase.p() );
}
results(RiaPorosityModel::MATRIX_MODEL)->setReaderInterface(readerInterface.p());
results(RiaPorosityModel::FRACTURE_MODEL)->setReaderInterface(readerInterface.p());
results(RiaDefines::MATRIX_MODEL)->setReaderInterface(readerInterface.p());
results(RiaDefines::FRACTURE_MODEL)->setReaderInterface(readerInterface.p());
progInfo.incrementProgress();
@@ -188,7 +188,7 @@ bool RimEclipseResultCase::openAndReadActiveCellData(RigEclipseCaseData* mainEcl
CVF_ASSERT(mainEclipseCase && mainEclipseCase->mainGrid());
eclipseCase->setMainGrid(mainEclipseCase->mainGrid());
std::vector<QDateTime> timeStepDates = mainEclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->timeStepDates();
std::vector<QDateTime> timeStepDates = mainEclipseCase->results(RiaDefines::MATRIX_MODEL)->timeStepDates();
if (timeStepDates.size() == 0)
{
return false;
@@ -207,8 +207,8 @@ bool RimEclipseResultCase::openAndReadActiveCellData(RigEclipseCaseData* mainEcl
readerInterface = readerEclipseOutput;
}
results(RiaPorosityModel::MATRIX_MODEL)->setReaderInterface(readerInterface.p());
results(RiaPorosityModel::FRACTURE_MODEL)->setReaderInterface(readerInterface.p());
results(RiaDefines::MATRIX_MODEL)->setReaderInterface(readerInterface.p());
results(RiaDefines::FRACTURE_MODEL)->setReaderInterface(readerInterface.p());
CVF_ASSERT(this->eclipseCaseData());
CVF_ASSERT(readerInterface.notNull());

6
ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp
View File

@@ -902,7 +902,7 @@ void RimEclipseResultDefinition::setResultType(RiaDefines::ResultCatType val)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseResultDefinition::setPorosityModel(RiaPorosityModel::PorosityModelType val)
void RimEclipseResultDefinition::setPorosityModel(RiaDefines::PorosityModelType val)
{
m_porosityModel = val;
m_porosityModelUiField = val;
@@ -991,8 +991,8 @@ bool RimEclipseResultDefinition::hasDualPorFractureResult()
{
if ( m_eclipseCase
&& m_eclipseCase->eclipseCaseData()
&& m_eclipseCase->eclipseCaseData()->activeCellInfo(RiaPorosityModel::FRACTURE_MODEL)
&& m_eclipseCase->eclipseCaseData()->activeCellInfo(RiaPorosityModel::FRACTURE_MODEL)->reservoirActiveCellCount() > 0 )
&& m_eclipseCase->eclipseCaseData()->activeCellInfo(RiaDefines::FRACTURE_MODEL)
&& m_eclipseCase->eclipseCaseData()->activeCellInfo(RiaDefines::FRACTURE_MODEL)->reservoirActiveCellCount() > 0 )
{
return true;
}

8
ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.h
View File

@@ -66,8 +66,8 @@ public:
RiaDefines::ResultCatType resultType() const { return m_resultType(); }
void setResultType(RiaDefines::ResultCatType val);
RiaPorosityModel::PorosityModelType porosityModel() const { return m_porosityModel(); }
void setPorosityModel(RiaPorosityModel::PorosityModelType 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);
@@ -108,7 +108,7 @@ protected:
protected:
caf::PdmField< caf::AppEnum< RiaDefines::ResultCatType > > m_resultType;
caf::PdmField< caf::AppEnum< RiaPorosityModel::PorosityModelType > > m_porosityModel;
caf::PdmField< caf::AppEnum< RiaDefines::PorosityModelType > > m_porosityModel;
caf::PdmField<QString> m_resultVariable;
caf::PdmPtrField<RimFlowDiagSolution*> m_flowSolution;
@@ -121,7 +121,7 @@ protected:
// User interface only fields, to support "filtering"-like behaviour etc.
caf::PdmField< caf::AppEnum< RiaDefines::ResultCatType > > m_resultTypeUiField;
caf::PdmField< caf::AppEnum< RiaPorosityModel::PorosityModelType > > m_porosityModelUiField;
caf::PdmField< caf::AppEnum< RiaDefines::PorosityModelType > > m_porosityModelUiField;
caf::PdmField<QString> m_resultVariableUiField;
caf::PdmField< caf::AppEnum< FlowTracerSelectionType > > m_flowTracerSelectionMode;

80
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.cpp
View File

@@ -159,8 +159,8 @@ bool RimEclipseStatisticsCase::openEclipseGridFile()
eclipseCase->setMainGrid(mainGrid);
eclipseCase->setActiveCellInfo(RiaPorosityModel::MATRIX_MODEL, gridCaseGroup->unionOfActiveCells(RiaPorosityModel::MATRIX_MODEL));
eclipseCase->setActiveCellInfo(RiaPorosityModel::FRACTURE_MODEL, gridCaseGroup->unionOfActiveCells(RiaPorosityModel::FRACTURE_MODEL));
eclipseCase->setActiveCellInfo(RiaDefines::MATRIX_MODEL, gridCaseGroup->unionOfActiveCells(RiaDefines::MATRIX_MODEL));
eclipseCase->setActiveCellInfo(RiaDefines::FRACTURE_MODEL, gridCaseGroup->unionOfActiveCells(RiaDefines::FRACTURE_MODEL));
this->setReservoirData( eclipseCase.p() );
@@ -218,15 +218,15 @@ void RimEclipseStatisticsCase::computeStatistics()
getSourceCases(sourceCases);
if (sourceCases.size() == 0
|| !sourceCases.at(0)->results(RiaPorosityModel::MATRIX_MODEL)
|| !sourceCases.at(0)->results(RiaPorosityModel::MATRIX_MODEL)->cellResults())
|| !sourceCases.at(0)->results(RiaDefines::MATRIX_MODEL)
|| !sourceCases.at(0)->results(RiaDefines::MATRIX_MODEL)->cellResults())
{
return;
}
// The first source has been read completely from disk, and contains grid and meta data
// Use this information for all cases in the case group
size_t timeStepCount = sourceCases.at(0)->results(RiaPorosityModel::MATRIX_MODEL)->cellResults()->maxTimeStepCount();
size_t timeStepCount = sourceCases.at(0)->results(RiaDefines::MATRIX_MODEL)->cellResults()->maxTimeStepCount();
RimStatisticsConfig statisticsConfig;
@@ -248,42 +248,42 @@ void RimEclipseStatisticsCase::computeStatistics()
for(size_t pIdx = 0; pIdx < m_selectedDynamicProperties().size(); ++pIdx)
{
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaPorosityModel::MATRIX_MODEL, RiaDefines::DYNAMIC_NATIVE, m_selectedDynamicProperties()[pIdx]));
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaDefines::MATRIX_MODEL, RiaDefines::DYNAMIC_NATIVE, m_selectedDynamicProperties()[pIdx]));
}
for(size_t pIdx = 0; pIdx < m_selectedStaticProperties().size(); ++pIdx)
{
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaPorosityModel::MATRIX_MODEL, RiaDefines::STATIC_NATIVE, m_selectedStaticProperties()[pIdx]));
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaDefines::MATRIX_MODEL, RiaDefines::STATIC_NATIVE, m_selectedStaticProperties()[pIdx]));
}
for(size_t pIdx = 0; pIdx < m_selectedGeneratedProperties().size(); ++pIdx)
{
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaPorosityModel::MATRIX_MODEL, RiaDefines::GENERATED, m_selectedGeneratedProperties()[pIdx]));
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaDefines::MATRIX_MODEL, RiaDefines::GENERATED, m_selectedGeneratedProperties()[pIdx]));
}
for(size_t pIdx = 0; pIdx < m_selectedInputProperties().size(); ++pIdx)
{
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaPorosityModel::MATRIX_MODEL, RiaDefines::INPUT_PROPERTY, m_selectedInputProperties()[pIdx]));
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaDefines::MATRIX_MODEL, RiaDefines::INPUT_PROPERTY, m_selectedInputProperties()[pIdx]));
}
for(size_t pIdx = 0; pIdx < m_selectedFractureDynamicProperties().size(); ++pIdx)
{
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaPorosityModel::FRACTURE_MODEL, RiaDefines::DYNAMIC_NATIVE, m_selectedFractureDynamicProperties()[pIdx]));
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaDefines::FRACTURE_MODEL, RiaDefines::DYNAMIC_NATIVE, m_selectedFractureDynamicProperties()[pIdx]));
}
for(size_t pIdx = 0; pIdx < m_selectedFractureStaticProperties().size(); ++pIdx)
{
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaPorosityModel::FRACTURE_MODEL, RiaDefines::STATIC_NATIVE, m_selectedFractureStaticProperties()[pIdx]));
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaDefines::FRACTURE_MODEL, RiaDefines::STATIC_NATIVE, m_selectedFractureStaticProperties()[pIdx]));
}
for(size_t pIdx = 0; pIdx < m_selectedFractureGeneratedProperties().size(); ++pIdx)
{
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaPorosityModel::FRACTURE_MODEL, RiaDefines::GENERATED, m_selectedFractureGeneratedProperties()[pIdx]));
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaDefines::FRACTURE_MODEL, RiaDefines::GENERATED, m_selectedFractureGeneratedProperties()[pIdx]));
}
for(size_t pIdx = 0; pIdx < m_selectedFractureInputProperties().size(); ++pIdx)
{
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaPorosityModel::FRACTURE_MODEL, RiaDefines::INPUT_PROPERTY, m_selectedFractureInputProperties()[pIdx]));
resultSpecification.append(RimEclipseStatisticsCaseEvaluator::ResSpec(RiaDefines::FRACTURE_MODEL, RiaDefines::INPUT_PROPERTY, m_selectedFractureInputProperties()[pIdx]));
}
RimEclipseStatisticsCaseEvaluator stat(sourceCases, timeStepIndices, statisticsConfig, resultCase, gridCaseGroup);
@@ -420,42 +420,42 @@ QList<caf::PdmOptionItemInfo> RimEclipseStatisticsCase::calculateValueOptions(co
if (&m_selectedDynamicProperties == fieldNeedingOptions)
{
QStringList varList = caseData->results(RiaPorosityModel::MATRIX_MODEL)->resultNames(RiaDefines::DYNAMIC_NATIVE);
QStringList varList = caseData->results(RiaDefines::MATRIX_MODEL)->resultNames(RiaDefines::DYNAMIC_NATIVE);
return toOptionList(varList);
}
else if (&m_selectedStaticProperties == fieldNeedingOptions)
{
QStringList varList = caseData->results(RiaPorosityModel::MATRIX_MODEL)->resultNames(RiaDefines::STATIC_NATIVE);
QStringList varList = caseData->results(RiaDefines::MATRIX_MODEL)->resultNames(RiaDefines::STATIC_NATIVE);
return toOptionList(varList);
}
else if (&m_selectedGeneratedProperties == fieldNeedingOptions)
{
QStringList varList = caseData->results(RiaPorosityModel::MATRIX_MODEL)->resultNames(RiaDefines::GENERATED);
QStringList varList = caseData->results(RiaDefines::MATRIX_MODEL)->resultNames(RiaDefines::GENERATED);
return toOptionList(varList);
}
else if (&m_selectedInputProperties == fieldNeedingOptions)
{
QStringList varList = caseData->results(RiaPorosityModel::MATRIX_MODEL)->resultNames(RiaDefines::INPUT_PROPERTY);
QStringList varList = caseData->results(RiaDefines::MATRIX_MODEL)->resultNames(RiaDefines::INPUT_PROPERTY);
return toOptionList(varList);
}
else if (&m_selectedFractureDynamicProperties == fieldNeedingOptions)
{
QStringList varList = caseData->results(RiaPorosityModel::FRACTURE_MODEL)->resultNames(RiaDefines::DYNAMIC_NATIVE);
QStringList varList = caseData->results(RiaDefines::FRACTURE_MODEL)->resultNames(RiaDefines::DYNAMIC_NATIVE);
return toOptionList(varList);
}
else if (&m_selectedFractureStaticProperties == fieldNeedingOptions)
{
QStringList varList = caseData->results(RiaPorosityModel::FRACTURE_MODEL)->resultNames(RiaDefines::STATIC_NATIVE);
QStringList varList = caseData->results(RiaDefines::FRACTURE_MODEL)->resultNames(RiaDefines::STATIC_NATIVE);
return toOptionList(varList);
}
else if (&m_selectedFractureGeneratedProperties == fieldNeedingOptions)
{
QStringList varList = caseData->results(RiaPorosityModel::FRACTURE_MODEL)->resultNames(RiaDefines::GENERATED);
QStringList varList = caseData->results(RiaDefines::FRACTURE_MODEL)->resultNames(RiaDefines::GENERATED);
return toOptionList(varList);
}
else if (&m_selectedFractureInputProperties == fieldNeedingOptions)
{
QStringList varList = caseData->results(RiaPorosityModel::FRACTURE_MODEL)->resultNames(RiaDefines::INPUT_PROPERTY);
QStringList varList = caseData->results(RiaDefines::FRACTURE_MODEL)->resultNames(RiaDefines::INPUT_PROPERTY);
return toOptionList(varList);
}
@@ -636,17 +636,17 @@ void RimEclipseStatisticsCase::updateSelectionListVisibilities()
{
bool isLocked = hasComputedStatistics();
m_resultType.uiCapability()->setUiHidden(isLocked);
m_porosityModel.uiCapability()->setUiHidden(isLocked ); // || !caseGroup()->mainCase()->reservoirData()->results(RiaPorosityModel::FRACTURE_MODEL)->resultCount()
m_porosityModel.uiCapability()->setUiHidden(isLocked ); // || !caseGroup()->mainCase()->reservoirData()->results(RiaDefines::FRACTURE_MODEL)->resultCount()
m_selectedDynamicProperties.uiCapability()->setUiHidden( isLocked || !(m_porosityModel() == RiaPorosityModel::MATRIX_MODEL && m_resultType() == RiaDefines::DYNAMIC_NATIVE));
m_selectedStaticProperties.uiCapability()->setUiHidden( isLocked || !(m_porosityModel() == RiaPorosityModel::MATRIX_MODEL && m_resultType() == RiaDefines::STATIC_NATIVE));
m_selectedGeneratedProperties.uiCapability()->setUiHidden( isLocked || !(m_porosityModel() == RiaPorosityModel::MATRIX_MODEL && m_resultType() == RiaDefines::GENERATED));
m_selectedInputProperties.uiCapability()->setUiHidden( isLocked || !(m_porosityModel() == RiaPorosityModel::MATRIX_MODEL && m_resultType() == RiaDefines::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() == RiaPorosityModel::FRACTURE_MODEL && m_resultType() == RiaDefines::DYNAMIC_NATIVE));
m_selectedFractureStaticProperties.uiCapability()->setUiHidden( isLocked || !(m_porosityModel() == RiaPorosityModel::FRACTURE_MODEL && m_resultType() == RiaDefines::STATIC_NATIVE));
m_selectedFractureGeneratedProperties.uiCapability()->setUiHidden( isLocked || !(m_porosityModel() == RiaPorosityModel::FRACTURE_MODEL && m_resultType() == RiaDefines::GENERATED));
m_selectedFractureInputProperties.uiCapability()->setUiHidden( isLocked || !(m_porosityModel() == RiaPorosityModel::FRACTURE_MODEL && m_resultType() == RiaDefines::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));
}
//--------------------------------------------------------------------------------------------------
@@ -668,8 +668,8 @@ void RimEclipseStatisticsCase::updatePercentileUiVisibility()
bool RimEclipseStatisticsCase::hasComputedStatistics() const
{
if ( eclipseCaseData()
&& ( eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL)->resultCount()
|| eclipseCaseData()->results(RiaPorosityModel::FRACTURE_MODEL)->resultCount()))
&& ( eclipseCaseData()->results(RiaDefines::MATRIX_MODEL)->resultCount()
|| eclipseCaseData()->results(RiaDefines::FRACTURE_MODEL)->resultCount()))
{
return true;
}
@@ -707,14 +707,14 @@ void RimEclipseStatisticsCase::updateConnectedEditorsAndReservoirViews()
//--------------------------------------------------------------------------------------------------
void RimEclipseStatisticsCase::clearComputedStatistics()
{
if (eclipseCaseData() && eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL))
if (eclipseCaseData() && eclipseCaseData()->results(RiaDefines::MATRIX_MODEL))
{
eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL)->clearAllResults();
eclipseCaseData()->results(RiaDefines::MATRIX_MODEL)->clearAllResults();
}
if (eclipseCaseData() && eclipseCaseData()->results(RiaPorosityModel::FRACTURE_MODEL))
if (eclipseCaseData() && eclipseCaseData()->results(RiaDefines::FRACTURE_MODEL))
{
eclipseCaseData()->results(RiaPorosityModel::FRACTURE_MODEL)->clearAllResults();
eclipseCaseData()->results(RiaDefines::FRACTURE_MODEL)->clearAllResults();
}
updateConnectedEditorsAndReservoirViews();
@@ -750,28 +750,28 @@ void RimEclipseStatisticsCase::populateResultSelection()
if (m_selectedDynamicProperties().size() == 0)
{
QStringList varList = caseData->results(RiaPorosityModel::MATRIX_MODEL)->resultNames(RiaDefines::DYNAMIC_NATIVE);
QStringList varList = caseData->results(RiaDefines::MATRIX_MODEL)->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(RiaPorosityModel::MATRIX_MODEL)->resultNames(RiaDefines::STATIC_NATIVE);
QStringList varList = caseData->results(RiaDefines::MATRIX_MODEL)->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(RiaPorosityModel::FRACTURE_MODEL)->resultNames(RiaDefines::DYNAMIC_NATIVE);
QStringList varList = caseData->results(RiaDefines::FRACTURE_MODEL)->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(RiaPorosityModel::FRACTURE_MODEL)->resultNames(RiaDefines::STATIC_NATIVE);
QStringList varList = caseData->results(RiaDefines::FRACTURE_MODEL)->resultNames(RiaDefines::STATIC_NATIVE);
if (varList.contains("PERMX")) m_selectedFractureStaticProperties.v().push_back("PERMX");
if (varList.contains("PORO")) m_selectedFractureStaticProperties.v().push_back("PORO");
}

2
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.h
View File

@@ -102,7 +102,7 @@ private:
// Fields
caf::PdmField< caf::AppEnum< RiaDefines::ResultCatType > > m_resultType;
caf::PdmField< caf::AppEnum< RiaPorosityModel::PorosityModelType > > m_porosityModel;
caf::PdmField< caf::AppEnum< RiaDefines::PorosityModelType > > m_porosityModel;
caf::PdmField<QString> m_selectionSummary;

14
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp
View File

@@ -44,7 +44,7 @@ void RimEclipseStatisticsCaseEvaluator::addNamedResult(RigCaseCellResultsData* d
// Use time step dates from first result in first source case
CVF_ASSERT(m_sourceCases.size() > 0);
std::vector<RigTimeStepInfo> sourceTimeStepInfos = m_sourceCases[0]->results(RiaPorosityModel::MATRIX_MODEL)->cellResults()->timeStepInfos(0);
std::vector<RigTimeStepInfo> sourceTimeStepInfos = m_sourceCases[0]->results(RiaDefines::MATRIX_MODEL)->cellResults()->timeStepInfos(0);
size_t destinationScalarResultIndex = destinationCellResults->addEmptyScalarResult(resultType, resultName, true);
CVF_ASSERT(destinationScalarResultIndex != cvf::UNDEFINED_SIZE_T);
@@ -82,7 +82,7 @@ void RimEclipseStatisticsCaseEvaluator::evaluateForResults(const QList<ResSpec>&
for (int i = 0; i < resultSpecification.size(); i++)
{
RiaPorosityModel::PorosityModelType poroModel = resultSpecification[i].m_poroModel;
RiaDefines::PorosityModelType poroModel = resultSpecification[i].m_poroModel;
RiaDefines::ResultCatType resultType = resultSpecification[i].m_resType;
QString resultName = resultSpecification[i].m_resVarName;
@@ -133,7 +133,7 @@ void RimEclipseStatisticsCaseEvaluator::evaluateForResults(const QList<ResSpec>&
for (int resSpecIdx = 0; resSpecIdx < resultSpecification.size(); resSpecIdx++)
{
RiaPorosityModel::PorosityModelType poroModel = resultSpecification[resSpecIdx].m_poroModel;
RiaDefines::PorosityModelType poroModel = resultSpecification[resSpecIdx].m_poroModel;
RiaDefines::ResultCatType resultType = resultSpecification[resSpecIdx].m_resType;
QString resultName = resultSpecification[resSpecIdx].m_resVarName;
@@ -301,13 +301,13 @@ void RimEclipseStatisticsCaseEvaluator::evaluateForResults(const QList<ResSpec>&
if (!eclipseCase->reservoirViews.size())
{
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->cellResults()->freeAllocatedResultsData();
eclipseCase->results(RiaPorosityModel::FRACTURE_MODEL)->cellResults()->freeAllocatedResultsData();
eclipseCase->results(RiaDefines::MATRIX_MODEL)->cellResults()->freeAllocatedResultsData();
eclipseCase->results(RiaDefines::FRACTURE_MODEL)->cellResults()->freeAllocatedResultsData();
}
// Todo : These calls really do nothing right now the access actually closes automatically in ert i belive ...
eclipseCase->results(RiaPorosityModel::MATRIX_MODEL)->readerInterface()->close();
eclipseCase->results(RiaPorosityModel::FRACTURE_MODEL)->readerInterface()->close();
eclipseCase->results(RiaDefines::MATRIX_MODEL)->readerInterface()->close();
eclipseCase->results(RiaDefines::FRACTURE_MODEL)->readerInterface()->close();
}
progressInfo.setProgress(timeIndicesIdx);

8
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.h
View File

@@ -64,12 +64,12 @@ public:
struct ResSpec
{
ResSpec() : m_resType(RiaDefines::DYNAMIC_NATIVE), m_poroModel(RiaPorosityModel::MATRIX_MODEL) {}
ResSpec( RiaPorosityModel::PorosityModelType poroModel,
ResSpec() : m_resType(RiaDefines::DYNAMIC_NATIVE), m_poroModel(RiaDefines::MATRIX_MODEL) {}
ResSpec( RiaDefines::PorosityModelType poroModel,
RiaDefines::ResultCatType resType,
QString resVarName) : m_poroModel(poroModel), m_resType(resType), m_resVarName(resVarName) {}
RiaPorosityModel::PorosityModelType m_poroModel;
RiaDefines::PorosityModelType m_poroModel;
RiaDefines::ResultCatType m_resType;
QString m_resVarName;
};
@@ -80,7 +80,7 @@ public:
private:
void addNamedResult(RigCaseCellResultsData* cellResults, RiaDefines::ResultCatType resultType, const QString& resultName, size_t activeCellCount);
void buildSourceMetaData(RiaPorosityModel::PorosityModelType poroModel, RiaDefines::ResultCatType resultType, const QString& resultName);
void buildSourceMetaData(RiaDefines::PorosityModelType poroModel, RiaDefines::ResultCatType resultType, const QString& resultName);
enum StatisticsParamType { MIN, MAX, SUM, RANGE, MEAN, STDEV, PMIN, PMID, PMAX, STAT_PARAM_COUNT };

24
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

@@ -184,7 +184,7 @@ void RimIdenticalGridCaseGroup::loadMainCaseAndActiveCellInfo()
RigEclipseCaseData* rigCaseData = mainCase->eclipseCaseData();
CVF_ASSERT(rigCaseData);
RiaPorosityModel::PorosityModelType poroModel = RiaPorosityModel::MATRIX_MODEL;
RiaDefines::PorosityModelType poroModel = RiaDefines::MATRIX_MODEL;
mainCase->results(poroModel)->cellResults()->createPlaceholderResultEntries();
@@ -217,8 +217,8 @@ void RimIdenticalGridCaseGroup::loadMainCaseAndActiveCellInfo()
RimEclipseCase* rimReservoir = statisticsCaseCollection()->reservoirs[i];
// Check if any results are stored in cache
if (rimReservoir->results(RiaPorosityModel::MATRIX_MODEL)->storedResultsCount() > 0 ||
rimReservoir->results(RiaPorosityModel::FRACTURE_MODEL)->storedResultsCount() > 0)
if (rimReservoir->results(RiaDefines::MATRIX_MODEL)->storedResultsCount() > 0 ||
rimReservoir->results(RiaDefines::FRACTURE_MODEL)->storedResultsCount() > 0)
{
foundResultsInCache = true;
break;
@@ -236,7 +236,7 @@ void RimIdenticalGridCaseGroup::loadMainCaseAndActiveCellInfo()
// for all cases
{
RiaPorosityModel::PorosityModelType poroModel = RiaPorosityModel::MATRIX_MODEL;
RiaDefines::PorosityModelType poroModel = RiaDefines::MATRIX_MODEL;
std::vector<RigTimeStepInfo> timeStepInfos = rigCaseData->results(poroModel)->timeStepInfos(0);
@@ -330,7 +330,7 @@ void RimIdenticalGridCaseGroup::computeUnionOfActiveCells()
if (activeM[gridLocalCellIndex] == 0)
{
if (caseCollection->reservoirs[caseIdx]->eclipseCaseData()->activeCellInfo(RiaPorosityModel::MATRIX_MODEL)->isActive(reservoirCellIndex))
if (caseCollection->reservoirs[caseIdx]->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL)->isActive(reservoirCellIndex))
{
activeM[gridLocalCellIndex] = 1;
}
@@ -338,7 +338,7 @@ void RimIdenticalGridCaseGroup::computeUnionOfActiveCells()
if (activeF[gridLocalCellIndex] == 0)
{
if (caseCollection->reservoirs[caseIdx]->eclipseCaseData()->activeCellInfo(RiaPorosityModel::FRACTURE_MODEL)->isActive(reservoirCellIndex))
if (caseCollection->reservoirs[caseIdx]->eclipseCaseData()->activeCellInfo(RiaDefines::FRACTURE_MODEL)->isActive(reservoirCellIndex))
{
activeF[gridLocalCellIndex] = 1;
}
@@ -422,13 +422,13 @@ void RimIdenticalGridCaseGroup::clearStatisticsResults()
RimEclipseCase* rimStaticsCase = statisticsCaseCollection->reservoirs[i];
if (!rimStaticsCase) continue;
if (rimStaticsCase->results(RiaPorosityModel::MATRIX_MODEL)->cellResults())
if (rimStaticsCase->results(RiaDefines::MATRIX_MODEL)->cellResults())
{
rimStaticsCase->results(RiaPorosityModel::MATRIX_MODEL)->cellResults()->clearAllResults();
rimStaticsCase->results(RiaDefines::MATRIX_MODEL)->cellResults()->clearAllResults();
}
if (rimStaticsCase->results(RiaPorosityModel::FRACTURE_MODEL)->cellResults())
if (rimStaticsCase->results(RiaDefines::FRACTURE_MODEL)->cellResults())
{
rimStaticsCase->results(RiaPorosityModel::FRACTURE_MODEL)->cellResults()->clearAllResults();
rimStaticsCase->results(RiaDefines::FRACTURE_MODEL)->cellResults()->clearAllResults();
}
for (size_t j = 0; j < rimStaticsCase->reservoirViews.size(); j++)
@@ -472,9 +472,9 @@ bool RimIdenticalGridCaseGroup::contains(RimEclipseCase* reservoir) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigActiveCellInfo* RimIdenticalGridCaseGroup::unionOfActiveCells(RiaPorosityModel::PorosityModelType porosityType)
RigActiveCellInfo* RimIdenticalGridCaseGroup::unionOfActiveCells(RiaDefines::PorosityModelType porosityType)
{
if (porosityType == RiaPorosityModel::MATRIX_MODEL)
if (porosityType == RiaDefines::MATRIX_MODEL)
{
return m_unionOfMatrixActiveCells.p();
}

2
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.h
View File

@@ -68,7 +68,7 @@ public:
RigMainGrid* mainGrid();
RigActiveCellInfo* unionOfActiveCells(RiaPorosityModel::PorosityModelType porosityType);
RigActiveCellInfo* unionOfActiveCells(RiaDefines::PorosityModelType porosityType);
void computeUnionOfActiveCells();
static bool isStatisticsCaseCollection(RimCaseCollection* rimCaseCollection);

8
ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp
View File

@@ -391,7 +391,7 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(RiaDefines::Result
for (i = 0; i < timeStepCount; i++)
{
std::vector<double>& values = m_cellResults->cellScalarResults(scalarResultIndex)[i];
if (!m_readerInterface->dynamicResult(resultName, RiaPorosityModel::MATRIX_MODEL, i, &values))
if (!m_readerInterface->dynamicResult(resultName, RiaDefines::MATRIX_MODEL, i, &values))
{
resultLoadingSucess = false;
}
@@ -402,7 +402,7 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(RiaDefines::Result
m_cellResults->cellScalarResults(scalarResultIndex).resize(1);
std::vector<double>& values = m_cellResults->cellScalarResults(scalarResultIndex)[0];
if (!m_readerInterface->staticResult(resultName, RiaPorosityModel::MATRIX_MODEL, &values))
if (!m_readerInterface->staticResult(resultName, RiaDefines::MATRIX_MODEL, &values))
{
resultLoadingSucess = false;
}
@@ -472,7 +472,7 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResultForTimeStep(RiaDefi
std::vector<double>& values = m_cellResults->cellScalarResults(scalarResultIndex)[timeStepIndex];
if (values.size() == 0)
{
if (!m_readerInterface->dynamicResult(resultName, RiaPorosityModel::MATRIX_MODEL, timeStepIndex, &values))
if (!m_readerInterface->dynamicResult(resultName, RiaDefines::MATRIX_MODEL, timeStepIndex, &values))
{
resultLoadingSucess = false;
}
@@ -483,7 +483,7 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResultForTimeStep(RiaDefi
m_cellResults->cellScalarResults(scalarResultIndex).resize(1);
std::vector<double>& values = m_cellResults->cellScalarResults(scalarResultIndex)[0];
if (!m_readerInterface->staticResult(resultName, RiaPorosityModel::MATRIX_MODEL, &values))
if (!m_readerInterface->staticResult(resultName, RiaDefines::MATRIX_MODEL, &values))
{
resultLoadingSucess = false;
}

20
ApplicationCode/ReservoirDataModel/RigEclipseCaseData.cpp
View File

@@ -434,9 +434,9 @@ void RigEclipseCaseData::computeActiveCellBoundingBoxes()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigActiveCellInfo* RigEclipseCaseData::activeCellInfo(RiaPorosityModel::PorosityModelType porosityModel)
RigActiveCellInfo* RigEclipseCaseData::activeCellInfo(RiaDefines::PorosityModelType porosityModel)
{
if (porosityModel == RiaPorosityModel::MATRIX_MODEL)
if (porosityModel == RiaDefines::MATRIX_MODEL)
{
return m_activeCellInfo.p();
}
@@ -447,9 +447,9 @@ RigActiveCellInfo* RigEclipseCaseData::activeCellInfo(RiaPorosityModel::Porosity
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigActiveCellInfo* RigEclipseCaseData::activeCellInfo(RiaPorosityModel::PorosityModelType porosityModel) const
const RigActiveCellInfo* RigEclipseCaseData::activeCellInfo(RiaDefines::PorosityModelType porosityModel) const
{
if (porosityModel == RiaPorosityModel::MATRIX_MODEL)
if (porosityModel == RiaDefines::MATRIX_MODEL)
{
return m_activeCellInfo.p();
}
@@ -460,9 +460,9 @@ const RigActiveCellInfo* RigEclipseCaseData::activeCellInfo(RiaPorosityModel::Po
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseCaseData::setActiveCellInfo(RiaPorosityModel::PorosityModelType porosityModel, RigActiveCellInfo* activeCellInfo)
void RigEclipseCaseData::setActiveCellInfo(RiaDefines::PorosityModelType porosityModel, RigActiveCellInfo* activeCellInfo)
{
if (porosityModel == RiaPorosityModel::MATRIX_MODEL)
if (porosityModel == RiaDefines::MATRIX_MODEL)
{
m_activeCellInfo = activeCellInfo;
m_matrixModelResults->setActiveCellInfo(m_activeCellInfo.p());
@@ -604,9 +604,9 @@ RigFormationNames* RigEclipseCaseData::activeFormationNames()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigCaseCellResultsData* RigEclipseCaseData::results(RiaPorosityModel::PorosityModelType porosityModel)
RigCaseCellResultsData* RigEclipseCaseData::results(RiaDefines::PorosityModelType porosityModel)
{
if (porosityModel == RiaPorosityModel::MATRIX_MODEL)
if (porosityModel == RiaDefines::MATRIX_MODEL)
{
return m_matrixModelResults.p();
}
@@ -617,9 +617,9 @@ RigCaseCellResultsData* RigEclipseCaseData::results(RiaPorosityModel::PorosityMo
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigCaseCellResultsData* RigEclipseCaseData::results(RiaPorosityModel::PorosityModelType porosityModel) const
const RigCaseCellResultsData* RigEclipseCaseData::results(RiaDefines::PorosityModelType porosityModel) const
{
if (porosityModel == RiaPorosityModel::MATRIX_MODEL)
if (porosityModel == RiaDefines::MATRIX_MODEL)
{
return m_matrixModelResults.p();
}

10
ApplicationCode/ReservoirDataModel/RigEclipseCaseData.h
View File

@@ -64,12 +64,12 @@ public:
RigGridBase* grid(size_t index);
size_t gridCount() const;
RigCaseCellResultsData* results(RiaPorosityModel::PorosityModelType porosityModel);
const RigCaseCellResultsData* results(RiaPorosityModel::PorosityModelType porosityModel) const;
RigCaseCellResultsData* results(RiaDefines::PorosityModelType porosityModel);
const RigCaseCellResultsData* results(RiaDefines::PorosityModelType porosityModel) const;
RigActiveCellInfo* activeCellInfo(RiaPorosityModel::PorosityModelType porosityModel);
const RigActiveCellInfo* activeCellInfo(RiaPorosityModel::PorosityModelType porosityModel) const;
void setActiveCellInfo(RiaPorosityModel::PorosityModelType porosityModel, RigActiveCellInfo* activeCellInfo);
RigActiveCellInfo* activeCellInfo(RiaDefines::PorosityModelType porosityModel);
const RigActiveCellInfo* activeCellInfo(RiaDefines::PorosityModelType porosityModel) const;
void setActiveCellInfo(RiaDefines::PorosityModelType porosityModel, RigActiveCellInfo* activeCellInfo);
void setActiveFormationNames(RigFormationNames* activeFormationNames);
RigFormationNames* activeFormationNames();

2
ApplicationCode/ReservoirDataModel/RigFlowDiagResults.cpp
View File

@@ -70,7 +70,7 @@ const RigActiveCellInfo * RigFlowDiagResults::activeCellInfo(const RigFlowDiagRe
RimEclipseResultCase* eclCase;
m_flowDiagSolution->firstAncestorOrThisOfType(eclCase);
return eclCase->eclipseCaseData()->activeCellInfo(RiaPorosityModel::MATRIX_MODEL); // Todo: base on resVarAddr member
return eclCase->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL); // Todo: base on resVarAddr member
}
//--------------------------------------------------------------------------------------------------

10
ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.cpp
View File

@@ -158,7 +158,7 @@ RigFlowDiagTimeStepResult RigFlowDiagSolverInterface::calculate(size_t timeStepI
{
using namespace Opm::FlowDiagnostics;
RigFlowDiagTimeStepResult result(m_eclipseCase->eclipseCaseData()->activeCellInfo(RiaPorosityModel::MATRIX_MODEL)->reservoirActiveCellCount());
RigFlowDiagTimeStepResult result(m_eclipseCase->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL)->reservoirActiveCellCount());
caf::ProgressInfo progressInfo(8, "Calculating Flow Diagnostics");
@@ -206,7 +206,7 @@ RigFlowDiagTimeStepResult RigFlowDiagSolverInterface::calculate(size_t timeStepI
QStringList restartFileNames = RifEclipseOutputFileTools::filterFileNamesOfType(m_filesWithSameBaseName, ECL_RESTART_FILE);
size_t restartFileCount = static_cast<size_t>(restartFileNames.size());
size_t maxTimeStepCount = m_eclipseCase->eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL)->maxTimeStepCount();
size_t maxTimeStepCount = m_eclipseCase->eclipseCaseData()->results(RiaDefines::MATRIX_MODEL)->maxTimeStepCount();
if (restartFileCount <= timeStepIndex && restartFileCount != maxTimeStepCount )
{
@@ -241,9 +241,9 @@ RigFlowDiagTimeStepResult RigFlowDiagSolverInterface::calculate(size_t timeStepI
CVF_ASSERT(currentRestartData);
size_t resultIndexWithMaxTimeSteps = cvf::UNDEFINED_SIZE_T;
m_eclipseCase->eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL)->maxTimeStepCount(&resultIndexWithMaxTimeSteps);
m_eclipseCase->eclipseCaseData()->results(RiaDefines::MATRIX_MODEL)->maxTimeStepCount(&resultIndexWithMaxTimeSteps);
int reportStepNumber = m_eclipseCase->eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL)->reportStepNumber(resultIndexWithMaxTimeSteps, timeStepIndex);
int reportStepNumber = m_eclipseCase->eclipseCaseData()->results(RiaDefines::MATRIX_MODEL)->reportStepNumber(resultIndexWithMaxTimeSteps, timeStepIndex);
if ( !currentRestartData->selectReportStep(reportStepNumber) )
{
@@ -256,7 +256,7 @@ RigFlowDiagTimeStepResult RigFlowDiagSolverInterface::calculate(size_t timeStepI
Opm::FlowDiagnostics::CellSetValues sumWellFluxPrCell;
{
if (m_eclipseCase->eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL)->hasFlowDiagUsableFluxes())
if (m_eclipseCase->eclipseCaseData()->results(RiaDefines::MATRIX_MODEL)->hasFlowDiagUsableFluxes())
{
Opm::FlowDiagnostics::ConnectionValues connectionsVals = RigFlowDiagInterfaceTools::extractFluxFieldFromRestartFile(*(m_opmFlowDiagStaticData->m_eclGraph),
*currentRestartData,

2
ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp
View File

@@ -250,7 +250,7 @@ void RigReservoirBuilderMock::populateReservoir(RigEclipseCaseData* eclipseCase)
addFaults(eclipseCase);
// Set all cells active
RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo(RiaPorosityModel::MATRIX_MODEL);
RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL);
activeCellInfo->setReservoirCellCount(eclipseCase->mainGrid()->globalCellArray().size());
for (size_t i = 0; i < eclipseCase->mainGrid()->globalCellArray().size(); i++)
{

8
ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.cpp
View File

@@ -41,7 +41,7 @@
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromUiResultName(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RiaPorosityModel::PorosityModelType porosityModel,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex,
const QString& uiResultName)
{
@@ -134,7 +134,7 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromUiResultName(Rig
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromNameAndType(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RiaPorosityModel::PorosityModelType porosityModel,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex,
const QString& uiResultName,
RiaDefines::ResultCatType resultType)
@@ -209,7 +209,7 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromResultDefinition
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createNativeFromUiResultName(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RiaPorosityModel::PorosityModelType porosityModel,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex,
const QString& uiResultName)
{
@@ -237,7 +237,7 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createNativeFromUiResultNa
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromResultIdx(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RiaPorosityModel::PorosityModelType porosityModel,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex,
size_t resultIndex)
{

8
ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.h
View File

@@ -41,14 +41,14 @@ public:
static cvf::ref<RigResultAccessor>
createFromUiResultName(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RiaPorosityModel::PorosityModelType porosityModel,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex,
const QString& uiResultName);
static cvf::ref<RigResultAccessor>
createFromNameAndType(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RiaPorosityModel::PorosityModelType porosityModel,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex,
const QString& uiResultName,
RiaDefines::ResultCatType resultType);
@@ -56,7 +56,7 @@ public:
static cvf::ref<RigResultAccessor>
createFromResultIdx(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RiaPorosityModel::PorosityModelType porosityModel,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex,
size_t resultIndex);
@@ -64,7 +64,7 @@ private:
static cvf::ref<RigResultAccessor>
createNativeFromUiResultName(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RiaPorosityModel::PorosityModelType porosityModel,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex,
const QString& resultName);

4
ApplicationCode/ReservoirDataModel/RigResultModifierFactory.cpp
View File

@@ -31,7 +31,7 @@
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultModifier> RigResultModifierFactory::createResultModifier(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RiaPorosityModel::PorosityModelType porosityModel,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex,
QString& uiResultName)
{
@@ -53,7 +53,7 @@ cvf::ref<RigResultModifier> RigResultModifierFactory::createResultModifier(RigEc
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultModifier> RigResultModifierFactory::createResultModifier(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RiaPorosityModel::PorosityModelType porosityModel,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex, size_t scalarResultIndex)
{
if ( !eclipseCase ) return NULL;

4
ApplicationCode/ReservoirDataModel/RigResultModifierFactory.h
View File

@@ -30,14 +30,14 @@ public:
static cvf::ref<RigResultModifier>
createResultModifier(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RiaPorosityModel::PorosityModelType porosityModel,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex,
QString& uiResultName);
static cvf::ref<RigResultModifier>
createResultModifier(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RiaPorosityModel::PorosityModelType porosityModel,
RiaDefines::PorosityModelType porosityModel,
size_t timeStepIndex,
size_t scalarResultIndex);
};

14
ApplicationCode/SocketInterface/RiaCaseInfoCommands.cpp
View File

@@ -95,14 +95,14 @@ public:
RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
if (!rimCase) return true;
RiaPorosityModel::PorosityModelType porosityModel = RiaPorosityModel::MATRIX_MODEL;
RiaDefines::PorosityModelType porosityModel = RiaDefines::MATRIX_MODEL;
if (args.size() > 2)
{
QString prorosityModelString = args[2];
if (prorosityModelString.toUpper() == "FRACTURE")
{
porosityModel = RiaPorosityModel::FRACTURE_MODEL;
porosityModel = RiaDefines::FRACTURE_MODEL;
}
}
@@ -144,7 +144,7 @@ public:
return true;
}
static void calculateMatrixModelActiveCellInfo(RimEclipseCase* reservoirCase, RiaPorosityModel::PorosityModelType porosityModel, std::vector<qint32>& gridNumber, std::vector<qint32>& cellI, std::vector<qint32>& cellJ, std::vector<qint32>& cellK, std::vector<qint32>& parentGridNumber, std::vector<qint32>& hostCellI, std::vector<qint32>& hostCellJ, std::vector<qint32>& hostCellK, std::vector<qint32>& globalCoarseningBoxIdx)
static void calculateMatrixModelActiveCellInfo(RimEclipseCase* reservoirCase, RiaDefines::PorosityModelType porosityModel, std::vector<qint32>& gridNumber, std::vector<qint32>& cellI, std::vector<qint32>& cellJ, std::vector<qint32>& cellK, std::vector<qint32>& parentGridNumber, std::vector<qint32>& hostCellI, std::vector<qint32>& hostCellJ, std::vector<qint32>& hostCellK, std::vector<qint32>& globalCoarseningBoxIdx)
{
gridNumber.clear();
cellI.clear();
@@ -412,7 +412,7 @@ public:
size_t scalarIndexWithMaxTimeStepCount = cvf::UNDEFINED_SIZE_T;
if (rimCase && rimCase->eclipseCaseData())
{
rimCase->eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL)->maxTimeStepCount(&scalarIndexWithMaxTimeStepCount);
rimCase->eclipseCaseData()->results(RiaDefines::MATRIX_MODEL)->maxTimeStepCount(&scalarIndexWithMaxTimeStepCount);
if (scalarIndexWithMaxTimeStepCount == cvf::UNDEFINED_SIZE_T)
{
canFetchData = false;
@@ -431,7 +431,7 @@ public:
return true;
}
std::vector<QDateTime> timeStepDates = rimCase->eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL)->timeStepDates(scalarIndexWithMaxTimeStepCount);
std::vector<QDateTime> timeStepDates = rimCase->eclipseCaseData()->results(RiaDefines::MATRIX_MODEL)->timeStepDates(scalarIndexWithMaxTimeStepCount);
quint64 timeStepCount = timeStepDates.size();
quint64 byteCount = sizeof(quint64) + 6 * timeStepCount * sizeof(qint32);
@@ -499,7 +499,7 @@ public:
size_t scalarIndexWithMaxTimeStepCount = cvf::UNDEFINED_SIZE_T;
if (rimCase && rimCase->eclipseCaseData())
{
rimCase->eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL)->maxTimeStepCount(&scalarIndexWithMaxTimeStepCount);
rimCase->eclipseCaseData()->results(RiaDefines::MATRIX_MODEL)->maxTimeStepCount(&scalarIndexWithMaxTimeStepCount);
if (scalarIndexWithMaxTimeStepCount == cvf::UNDEFINED_SIZE_T)
{
canFetchData = false;
@@ -518,7 +518,7 @@ public:
return true;
}
std::vector<double> daysSinceSimulationStart = rimCase->eclipseCaseData()->results(RiaPorosityModel::MATRIX_MODEL)->daysSinceSimulationStart(scalarIndexWithMaxTimeStepCount);
std::vector<double> daysSinceSimulationStart = rimCase->eclipseCaseData()->results(RiaDefines::MATRIX_MODEL)->daysSinceSimulationStart(scalarIndexWithMaxTimeStepCount);
quint64 timeStepCount = daysSinceSimulationStart.size();
quint64 byteCount = sizeof(quint64) + timeStepCount * sizeof(qint32);

8
ApplicationCode/SocketInterface/RiaGeometryCommands.cpp
View File

@@ -165,10 +165,10 @@ public:
QString porosityModelName;
porosityModelName = args[2];
RiaPorosityModel::PorosityModelType porosityModelEnum = RiaPorosityModel::MATRIX_MODEL;
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::MATRIX_MODEL;
if (porosityModelName.toUpper() == "FRACTURE")
{
porosityModelEnum = RiaPorosityModel::FRACTURE_MODEL;
porosityModelEnum = RiaDefines::FRACTURE_MODEL;
}
if (!rimCase || !rimCase->eclipseCaseData())
@@ -336,10 +336,10 @@ public:
QString porosityModelName;
porosityModelName = args[2];
RiaPorosityModel::PorosityModelType porosityModelEnum = RiaPorosityModel::MATRIX_MODEL;
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::MATRIX_MODEL;
if (porosityModelName.toUpper() == "FRACTURE")
{
porosityModelEnum = RiaPorosityModel::FRACTURE_MODEL;
porosityModelEnum = RiaDefines::FRACTURE_MODEL;
}
if (!rimCase || !rimCase->eclipseCaseData() )

24
ApplicationCode/SocketInterface/RiaPropertyDataCommands.cpp
View File

@@ -60,10 +60,10 @@ public:
QString propertyName = args[2];
QString porosityModelName = args[3];
RiaPorosityModel::PorosityModelType porosityModelEnum = RiaPorosityModel::MATRIX_MODEL;
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::MATRIX_MODEL;
if (porosityModelName == "Fracture")
{
porosityModelEnum = RiaPorosityModel::FRACTURE_MODEL;
porosityModelEnum = RiaDefines::FRACTURE_MODEL;
}
// Find the requested data
@@ -233,10 +233,10 @@ public:
return true;
}
RiaPorosityModel::PorosityModelType porosityModelEnum = RiaPorosityModel::MATRIX_MODEL;
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::MATRIX_MODEL;
if (porosityModelName == "Fracture")
{
porosityModelEnum = RiaPorosityModel::FRACTURE_MODEL;
porosityModelEnum = RiaDefines::FRACTURE_MODEL;
}
size_t scalarResultIndex = cvf::UNDEFINED_SIZE_T;
@@ -383,7 +383,7 @@ public:
m_bytesPerTimeStepToRead(0),
m_currentTimeStepNumberToRead(0),
m_invalidActiveCellCountDetected(false),
m_porosityModelEnum(RiaPorosityModel::MATRIX_MODEL)
m_porosityModelEnum(RiaDefines::MATRIX_MODEL)
{}
static QString commandName () { return QString("SetActiveCellProperty"); }
@@ -397,7 +397,7 @@ public:
if (porosityModelName == "Fracture")
{
m_porosityModelEnum = RiaPorosityModel::FRACTURE_MODEL;
m_porosityModelEnum = RiaDefines::FRACTURE_MODEL;
}
// Find the requested data, Or create a set if we are setting data and it is not found
@@ -697,7 +697,7 @@ private:
size_t m_currentScalarIndex;
QString m_currentPropertyName;
std::vector<size_t> m_requestedTimesteps;
RiaPorosityModel::PorosityModelType m_porosityModelEnum;
RiaDefines::PorosityModelType m_porosityModelEnum;
quint64 m_timeStepCountToRead;
quint64 m_bytesPerTimeStepToRead;
@@ -724,7 +724,7 @@ public:
m_bytesPerTimeStepToRead(0),
m_currentTimeStepNumberToRead(0),
m_invalidDataDetected(false),
m_porosityModelEnum(RiaPorosityModel::MATRIX_MODEL)
m_porosityModelEnum(RiaDefines::MATRIX_MODEL)
{}
static QString commandName () { return QString("SetGridProperty"); }
@@ -746,7 +746,7 @@ public:
if (porosityModelName == "Fracture")
{
m_porosityModelEnum = RiaPorosityModel::FRACTURE_MODEL;
m_porosityModelEnum = RiaDefines::FRACTURE_MODEL;
}
RigGridBase* grid = rimCase->eclipseCaseData()->grid(m_currentGridIndex);
@@ -1061,7 +1061,7 @@ private:
size_t m_currentScalarIndex;
QString m_currentPropertyName;
std::vector<size_t> m_requestedTimesteps;
RiaPorosityModel::PorosityModelType m_porosityModelEnum;
RiaDefines::PorosityModelType m_porosityModelEnum;
quint64 m_timeStepCountToRead;
quint64 m_bytesPerTimeStepToRead;
@@ -1092,11 +1092,11 @@ public:
}
QString porosityModelName = args[2];
RiaPorosityModel::PorosityModelType porosityModelEnum = RiaPorosityModel::MATRIX_MODEL;
RiaDefines::PorosityModelType porosityModelEnum = RiaDefines::MATRIX_MODEL;
if (porosityModelName == "Fracture")
{
porosityModelEnum = RiaPorosityModel::FRACTURE_MODEL;
porosityModelEnum = RiaDefines::FRACTURE_MODEL;
}
std::vector<QString> propNames;

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

@@ -260,7 +260,7 @@ TEST(RigReservoirTest, UnifiedTestFile)
void buildResultInfoString(RigReservoir* reservoir, RiaPorosityModel::PorosityModelType porosityModel, RiaDefines::ResultCatType resultType)
void buildResultInfoString(RigReservoir* reservoir, RiaDefines::PorosityModelType 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(), RiaPorosityModel::MATRIX_MODEL, RiaDefines::DYNAMIC_NATIVE);
buildResultInfoString(reservoir.p(), RiaDefines::MATRIX_MODEL, RiaDefines::DYNAMIC_NATIVE);
qDebug() << "\n\n" <<
"Matrix porosities, STATIC results" <<
"----------------------------------";
buildResultInfoString(reservoir.p(), RiaPorosityModel::MATRIX_MODEL, RiaDefines::STATIC_NATIVE);
buildResultInfoString(reservoir.p(), RiaDefines::MATRIX_MODEL, RiaDefines::STATIC_NATIVE);
qDebug() << "\n\n" <<
"Fracture porosities, DYNAMIC results" <<
"----------------------------------";
buildResultInfoString(reservoir.p(), RiaPorosityModel::FRACTURE_MODEL, RiaDefines::DYNAMIC_NATIVE);
buildResultInfoString(reservoir.p(), RiaDefines::FRACTURE_MODEL, RiaDefines::DYNAMIC_NATIVE);
qDebug() << "\n\n" <<
"Fracture porosities, STATIC results" <<
"----------------------------------";
buildResultInfoString(reservoir.p(), RiaPorosityModel::FRACTURE_MODEL, RiaDefines::STATIC_NATIVE);
buildResultInfoString(reservoir.p(), RiaDefines::FRACTURE_MODEL, RiaDefines::STATIC_NATIVE);
}

6
ApplicationCode/UserInterface/RiuResultTextBuilder.cpp
View File

@@ -374,7 +374,7 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigEclipseCaseData* eclips
return;
}
RiaPorosityModel::PorosityModelType porosityModel = resultColors->porosityModel();
RiaDefines::PorosityModelType porosityModel = resultColors->porosityModel();
if (resultColors->isTernarySaturationSelected())
{
RimReservoirCellResultsStorage* gridCellResults = resultColors->currentGridCellResults();
@@ -537,7 +537,7 @@ QString RiuResultTextBuilder::cellEdgeResultDetails()
adjustedTimeStep = 0;
}
RiaPorosityModel::PorosityModelType porosityModel = m_reservoirView->cellResult()->porosityModel();
RiaDefines::PorosityModelType porosityModel = m_reservoirView->cellResult()->porosityModel();
cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromResultIdx(m_reservoirView->eclipseCase()->eclipseCaseData(), m_gridIndex, porosityModel, adjustedTimeStep, resultIndex);
if (resultAccessor.notNull())
{
@@ -664,7 +664,7 @@ QString RiuResultTextBuilder::cellResultText(RimEclipseCellColors* resultColors)
size_t sgasScalarSetIndex = gridCellResults->findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "SGAS");
size_t swatScalarSetIndex = gridCellResults->findOrLoadScalarResult(RiaDefines::DYNAMIC_NATIVE, "SWAT");
RiaPorosityModel::PorosityModelType porosityModel = resultColors->porosityModel();
RiaDefines::PorosityModelType porosityModel = resultColors->porosityModel();
cvf::ref<RigResultAccessor> dataAccessObjectX = RigResultAccessorFactory::createFromResultIdx(eclipseCaseData, m_gridIndex, porosityModel, m_timeStepIndex, soilScalarSetIndex);
cvf::ref<RigResultAccessor> dataAccessObjectY = RigResultAccessorFactory::createFromResultIdx(eclipseCaseData, m_gridIndex, porosityModel, m_timeStepIndex, sgasScalarSetIndex);

2
ApplicationCode/UserInterface/RiuSelectionChangedHandler.cpp
View File

@@ -113,7 +113,7 @@ void RiuSelectionChangedHandler::addCurveFromSelectionItem(const RiuEclipseSelec
eclipseView->eclipseCase() &&
eclipseView->eclipseCase()->eclipseCaseData())
{
RiaPorosityModel::PorosityModelType porosityModel = eclipseView->cellResult()->porosityModel();
RiaDefines::PorosityModelType porosityModel = eclipseView->cellResult()->porosityModel();
std::vector<QDateTime> timeStepDates = eclipseView->eclipseCase()->eclipseCaseData()->results(porosityModel)->timeStepDates();