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

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