#1755 Remove porosity enum from RifReaderInterface

ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp

@@ -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(RifReaderInterface::MATRIX_RESULTS)->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(RifReaderInterface::MATRIX_RESULTS)->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(RifReaderInterface::MATRIX_RESULTS)->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(RifReaderInterface::MATRIX_RESULTS)->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(RifReaderInterface::MATRIX_RESULTS)->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(RifReaderInterface::MATRIX_RESULTS)->findScalarResultIndex(newResultName);
+    size_t resultIndex = reservoir->results(RiaDefines::MATRIX_MODEL)->findScalarResultIndex(newResultName);
     if (resultIndex == cvf::UNDEFINED_SIZE_T)
     {
-        resultIndex = reservoir->results(RifReaderInterface::MATRIX_RESULTS)->addEmptyScalarResult(RiaDefines::INPUT_PROPERTY, newResultName, false);
+        resultIndex = reservoir->results(RiaDefines::MATRIX_MODEL)->addEmptyScalarResult(RiaDefines::INPUT_PROPERTY, newResultName, false);
     }
 
     return resultIndex;

ApplicationCode/FileInterface/RifReaderEclipseInput.h

@@ -38,6 +38,6 @@ public:
 
     virtual void                close() {}
 
-    virtual bool                staticResult(const QString& result, PorosityModelResultType matrixOrFracture, std::vector<double>* values )                      { return false; }
-    virtual bool                dynamicResult(const QString& result, PorosityModelResultType 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; }
 };

ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp

@@ -242,8 +242,8 @@ bool RifReaderEclipseOutput::transferGeometry(const ecl_grid_type* mainEclGrid,
         return false;
     }
 
-    RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo(RifReaderInterface::MATRIX_RESULTS);
-    RigActiveCellInfo* fractureActiveCellInfo = eclipseCase->activeCellInfo(RifReaderInterface::FRACTURE_RESULTS);
+    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(RifReaderInterface::MATRIX_RESULTS);
-            RigActiveCellInfo* fractureActiveCellInfo = m_eclipseCase->activeCellInfo(RifReaderInterface::FRACTURE_RESULTS);
+            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(RifReaderInterface::MATRIX_RESULTS);
-    RigCaseCellResultsData* fractureModelResults = m_eclipseCase->results(RifReaderInterface::FRACTURE_RESULTS);
+    RigCaseCellResultsData* matrixModelResults = m_eclipseCase->results(RiaDefines::MATRIX_MODEL);
+    RigCaseCellResultsData* fractureModelResults = m_eclipseCase->results(RiaDefines::FRACTURE_MODEL);
 
     std::vector<RigTimeStepInfo> timeStepInfos;
 
@@ -681,9 +681,9 @@ void RifReaderEclipseOutput::buildMetaData()
 
         {
             QStringList matrixResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts, 
-                                                                            m_eclipseCase->activeCellInfo(RifReaderInterface::MATRIX_RESULTS),
-                                                                            m_eclipseCase->activeCellInfo(RifReaderInterface::FRACTURE_RESULTS), 
-                                                                            RifReaderInterface::MATRIX_RESULTS, 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)
             {
@@ -694,9 +694,9 @@ void RifReaderEclipseOutput::buildMetaData()
 
         {
             QStringList fractureResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts, 
-                                                                            m_eclipseCase->activeCellInfo(RifReaderInterface::MATRIX_RESULTS),
-                                                                            m_eclipseCase->activeCellInfo(RifReaderInterface::FRACTURE_RESULTS), 
-                                                                            RifReaderInterface::FRACTURE_RESULTS, 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)
             {
@@ -745,9 +745,9 @@ void RifReaderEclipseOutput::buildMetaData()
 
         {
             QStringList matrixResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts, 
-                                                                            m_eclipseCase->activeCellInfo(RifReaderInterface::MATRIX_RESULTS),
-                                                                            m_eclipseCase->activeCellInfo(RifReaderInterface::FRACTURE_RESULTS), 
-                                                                            RifReaderInterface::MATRIX_RESULTS, 1);
+                                                                            m_eclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL),
+                                                                            m_eclipseCase->activeCellInfo(RiaDefines::FRACTURE_MODEL), 
+                                                                            RiaDefines::MATRIX_MODEL, 1);
           
             // Add ACTNUM
             matrixResultNames += "ACTNUM";
@@ -761,9 +761,9 @@ void RifReaderEclipseOutput::buildMetaData()
 
         {
             QStringList fractureResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts, 
-                                                                            m_eclipseCase->activeCellInfo(RifReaderInterface::MATRIX_RESULTS),
-                                                                            m_eclipseCase->activeCellInfo(RifReaderInterface::FRACTURE_RESULTS), 
-                                                                            RifReaderInterface::FRACTURE_RESULTS, 1);
+                                                                            m_eclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL),
+                                                                            m_eclipseCase->activeCellInfo(RiaDefines::FRACTURE_MODEL), 
+                                                                            RiaDefines::FRACTURE_MODEL, 1);
             // Add ACTNUM
             fractureResultNames += "ACTNUM";
 
@@ -807,7 +807,7 @@ RifEclipseRestartDataAccess* RifReaderEclipseOutput::createDynamicResultsAccess(
 //--------------------------------------------------------------------------------------------------
 /// Get all values of a given static result as doubles
 //--------------------------------------------------------------------------------------------------
-bool RifReaderEclipseOutput::staticResult(const QString& result, PorosityModelResultType matrixOrFracture, std::vector<double>* values)
+bool RifReaderEclipseOutput::staticResult(const QString& result, RiaDefines::PorosityModelType matrixOrFracture, std::vector<double>* values)
 {
     CVF_ASSERT(values);
 
@@ -843,7 +843,7 @@ bool RifReaderEclipseOutput::staticResult(const QString& result, PorosityModelRe
 //--------------------------------------------------------------------------------------------------
 /// Get dynamic result at given step index. Will concatenate values for the main grid and all sub grids.
 //--------------------------------------------------------------------------------------------------
-bool RifReaderEclipseOutput::dynamicResult(const QString& result, PorosityModelResultType 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())
     {
@@ -1673,7 +1673,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel(const QStringL
                                                                   const std::vector<size_t>& keywordDataItemCounts, 
                                                                   const RigActiveCellInfo* matrixActiveCellInfo, 
                                                                   const RigActiveCellInfo* fractureActiveCellInfo, 
-                                                                  PorosityModelResultType porosityModel, 
+                                                                  RiaDefines::PorosityModelType porosityModel, 
                                                                   size_t timeStepCount) const
 {
     CVF_ASSERT(matrixActiveCellInfo);
@@ -1683,7 +1683,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel(const QStringL
         return QStringList();
     }
 
-    if (porosityModel == RifReaderInterface::FRACTURE_RESULTS)
+    if (porosityModel == RiaDefines::FRACTURE_MODEL)
     {
         if (fractureActiveCellInfo->reservoirActiveCellCount() == 0)
         {
@@ -1719,14 +1719,14 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel(const QStringL
             size_t sumFractureMatrixActiveCellCount = matrixActiveCellInfo->reservoirActiveCellCount() + fractureActiveCellInfo->reservoirActiveCellCount();
             size_t timeStepsMatrixAndFractureRest = keywordDataItemCount % sumFractureMatrixActiveCellCount;
 
-            if (porosityModel == RifReaderInterface::MATRIX_RESULTS && timeStepsMatrixRest == 0)
+            if (porosityModel == RiaDefines::MATRIX_MODEL && timeStepsMatrixRest == 0)
             {
                 if (keywordDataItemCount <= timeStepCount * std::max(matrixActiveCellInfo->reservoirActiveCellCount(), sumFractureMatrixActiveCellCount))
                 {
                     validKeyword = true;
                 }
             }
-            else if (porosityModel == RifReaderInterface::FRACTURE_RESULTS && fractureActiveCellInfo->reservoirActiveCellCount() > 0 && timeStepsFractureRest == 0)
+            else if (porosityModel == RiaDefines::FRACTURE_MODEL && fractureActiveCellInfo->reservoirActiveCellCount() > 0 && timeStepsFractureRest == 0)
             {
                 if (keywordDataItemCount <= timeStepCount * std::max(fractureActiveCellInfo->reservoirActiveCellCount(), sumFractureMatrixActiveCellCount))
                 {
@@ -1772,19 +1772,19 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel(const QStringL
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel(PorosityModelResultType 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(RifReaderInterface::FRACTURE_RESULTS); 
+    RigActiveCellInfo* fracActCellInfo = m_eclipseCase->activeCellInfo(RiaDefines::FRACTURE_MODEL); 
 
-    if (matrixOrFracture == RifReaderInterface::MATRIX_RESULTS && 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(RifReaderInterface::MATRIX_RESULTS); 
+        RigActiveCellInfo* actCellInfo = m_eclipseCase->activeCellInfo(RiaDefines::MATRIX_MODEL); 
 
         size_t sourceStartPosition = 0;
 
@@ -1796,7 +1796,7 @@ void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel(PorosityMod
             actCellInfo->gridActiveCellCounts(i, matrixActiveCellCount);
             fracActCellInfo->gridActiveCellCounts(i, fractureActiveCellCount);
 
-            if (matrixOrFracture == RifReaderInterface::MATRIX_RESULTS)
+            if (matrixOrFracture == RiaDefines::MATRIX_MODEL)
             {
                 destinationResultValues->insert(destinationResultValues->end(), 
                                                 sourceResultValues.begin() + sourceStartPosition, 

ApplicationCode/FileInterface/RifReaderEclipseOutput.h

@@ -53,8 +53,8 @@ public:
     virtual bool            openAndReadActiveCellData(const QString& fileName, const std::vector<QDateTime>& mainCaseTimeSteps, RigEclipseCaseData* eclipseCase);
     void                    close();
 
-    bool                    staticResult(const QString& result, PorosityModelResultType matrixOrFracture, std::vector<double>* values);
-    bool                    dynamicResult(const QString& result, PorosityModelResultType 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);
@@ -72,13 +72,13 @@ private:
 
     void                    openInitFile();
 
-    void                    extractResultValuesBasedOnPorosityModel(PorosityModelResultType 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, PorosityModelResultType 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;
 
 private:
     QString                                 m_fileName;                 // Name of file used to start accessing Eclipse output files

ApplicationCode/FileInterface/RifReaderInterface.h

@@ -20,6 +20,8 @@
 
 #pragma once
 
+#include "RiaDefines.h"
+
 #include "cvfBase.h"
 #include "cvfObject.h"
 
@@ -43,13 +45,6 @@ class RifReaderSettings;
 //==================================================================================================
 class RifReaderInterface : public cvf::Object
 {
-public:
-    enum PorosityModelResultType
-    {
-        MATRIX_RESULTS,
-        FRACTURE_RESULTS
-    };
-
 public:
     RifReaderInterface()            { }
     virtual ~RifReaderInterface()   { }
@@ -64,8 +59,8 @@ public:
     virtual bool                open(const QString& fileName, RigEclipseCaseData* eclipseCase) = 0;
     virtual void                close() = 0;
    
-    virtual bool                staticResult(const QString& result, PorosityModelResultType matrixOrFracture, std::vector<double>* values) = 0;
-    virtual bool                dynamicResult(const QString& result, PorosityModelResultType 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; }

ApplicationCode/FileInterface/RifReaderMockModel.cpp

@@ -33,7 +33,7 @@ bool RifReaderMockModel::open(const QString& fileName, RigEclipseCaseData* eclip
   
     m_reservoir = eclipseCase;
 
-    RigCaseCellResultsData* cellResults = eclipseCase->results(RifReaderInterface::MATRIX_RESULTS);
+    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, RifReaderInterface::PorosityModelResultType 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, RifReaderInterface:
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RifReaderMockModel::dynamicResult(const QString& result, RifReaderInterface::PorosityModelResultType 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);
 

ApplicationCode/FileInterface/RifReaderMockModel.h

@@ -39,8 +39,8 @@ public:
     virtual bool            open( const QString& fileName, RigEclipseCaseData* eclipseCase );
     virtual void            close();
                             
-    virtual bool            staticResult( const QString& result, RifReaderInterface::PorosityModelResultType matrixOrFracture, std::vector<double>* values );
-    virtual bool            dynamicResult( const QString& result, RifReaderInterface::PorosityModelResultType 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);